From 46debe146ae9da2229b5a142b6c5a4a23af64630 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Mon, 9 Nov 2026 22:28:29 -0700 Subject: [PATCH 01/52] add tradespace module for trade studies of design spaces Add tatc.tradespace: hierarchical design spaces (Real, Integer, Categorical, Derived, Uncertain, Choice, Repeat) with enumeration, Latin hypercube sampling, and unit-hypercube encoding; trade studies evaluated in replicates with common random numbers, in parallel worker processes, with caches of analyses by satellite; Pareto fronts, ranks, tolerances, exact hypervolume, and the bootstrap probability of efficiency; screening with studies of increasing fidelity; and searches with Optuna and pymoo that use the violations of constraints. Port the RunOSSEMonsoon constellation trade to a design space (cached, parallel, with Pareto-efficient designs) and add the SearchTradeSpace example. Add the optional dependencies `tradespace` (joblib, Optuna, pymoo). --- CHANGELOG.md | 7 + README.md | 1 + docs/api_reference/index.rst | 1 + docs/api_reference/tradespace.rst | 98 +++ docs/examples/RunOSSEMonsoon.ipynb | 565 +++++++++---- docs/examples/SearchTradeSpace.ipynb | 1105 +++++++++++++++++++++++++ docs/examples/index.rst | 5 +- pyproject.toml | 5 + src/tatc/tradespace/__init__.py | 67 ++ src/tatc/tradespace/cache.py | 203 +++++ src/tatc/tradespace/nodes.py | 388 +++++++++ src/tatc/tradespace/optimization.py | 310 +++++++ src/tatc/tradespace/pareto.py | 296 +++++++ src/tatc/tradespace/screening.py | 131 +++ src/tatc/tradespace/space.py | 753 +++++++++++++++++ src/tatc/tradespace/study.py | 277 +++++++ src/tatc/tradespace/values.py | 165 ++++ tests/tradespace/__init__.py | 0 tests/tradespace/test_cache.py | 171 ++++ tests/tradespace/test_optimization.py | 307 +++++++ tests/tradespace/test_pareto.py | 169 ++++ tests/tradespace/test_screening.py | 105 +++ tests/tradespace/test_space.py | 233 ++++++ tests/tradespace/test_study.py | 170 ++++ 24 files changed, 5367 insertions(+), 165 deletions(-) create mode 100644 docs/api_reference/tradespace.rst create mode 100644 docs/examples/SearchTradeSpace.ipynb create mode 100644 src/tatc/tradespace/__init__.py create mode 100644 src/tatc/tradespace/cache.py create mode 100644 src/tatc/tradespace/nodes.py create mode 100644 src/tatc/tradespace/optimization.py create mode 100644 src/tatc/tradespace/pareto.py create mode 100644 src/tatc/tradespace/screening.py create mode 100644 src/tatc/tradespace/space.py create mode 100644 src/tatc/tradespace/study.py create mode 100644 src/tatc/tradespace/values.py create mode 100644 tests/tradespace/__init__.py create mode 100644 tests/tradespace/test_cache.py create mode 100644 tests/tradespace/test_optimization.py create mode 100644 tests/tradespace/test_pareto.py create mode 100644 tests/tradespace/test_screening.py create mode 100644 tests/tradespace/test_space.py create mode 100644 tests/tradespace/test_study.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 03528e43..fb03871a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,6 +10,13 @@ Added: - Field `type` of a catalog configuration's `attitude` (`attitude`, `glint`, or `target`), which builds an `Attitude`, `GlintAttitude`, or `TargetAttitude`, as for OCO-2's glint mode. - Field `blind_intervals` of `Attitude`: intervals of argument of latitude in which a space system's instruments do not observe, for example while the body or a mechanism moves. Observations in them are not valid, so point observations, ground tracks (`valid_obs`, and the swaths of `compute_ground_track`), orbit tracks, and ground pixels omit them, and the periods and swaths of region observations end at them. Method `is_observing` of attitudes, schedules, and instruments. - Field `type` (`instrument`, `pointed`, or `conical`) of `Instrument`, `PointedInstrument`, and `ConicalInstrument`, which identifies the instrument class in serialized data. Data without a `type` loads as the class its fields imply. + - Module `tradespace` (prototype) for trade studies. A `DesignSpace` declares design variables (`Real`, `Integer`, `Categorical`), fixed and `Derived` values, and `Uncertain` parameters (drawn per replicate, not searched), grouped hierarchically with `Choice` (one of several branches) and `Repeat` (a variable number of items, such as orbit planes, optionally unordered). Bounds, derived values, and constraints are callables of the values decided before them. `DesignSpace.enumerate` gives every feasible design (a full factorial design, including variables that exist only in some designs), and `sample` a Latin hypercube or random sample. A `Design` has a `key` from its decisions and `flat` values by path, and `realize` draws a replicate's uncertain parameters, with common random numbers between designs by default. `Study` builds and evaluates designs in replicates into a data frame, recording designs that fail validation as infeasible, in worker processes with `n_jobs` (or on an `executor`); `summarize` gives the mean, standard deviation, and standard error of metrics over replicates. + - Class `tradespace.SatelliteCache`, which caches an analysis of single satellites by their content (orbit, instruments, and attitude, not their name, see `get_satellite_key`), in memory or on disk, so that designs that share satellites compute their results once. + - Functions `tradespace.pareto_front`, `pareto_ranks` (both with optional tolerances of objectives, within which designs near the front are efficient), and `hypervolume` (exact) of designs with several objectives to minimize or maximize, and `pareto_probability`, the probability that each design is efficient given the uncertainty of its replicates (a bootstrap that resamples the same replicates for every design). + - Function `tradespace.screen` (and class `Screening`), which screens designs with studies of increasing fidelity, keeping whole fronts of the best designs of each stage for the next. + - Searches of design spaces with optional optimizers: `tradespace.optimize_optuna` suggests designs with Optuna trials (`DesignSpace.suggest`, define-by-run over the hierarchical space), and `optimize_pymoo` and `make_pymoo_problem` search the unit hypercube that encodes a design space (`DesignSpace.unit_paths`, `encode`, and `decode`) with pymoo. Each design is evaluated once, and the designs proposed together are evaluated together, in parallel if the study is. Constraints of a design space may return the amount of their violation (`Infeasible.violation`), which Optuna's trials record (`set_constraint`) for its constraint-aware samplers, and which is the constraint value of pymoo problems. Optional dependencies `tradespace` (joblib, Optuna, and pymoo). + - Example `SearchTradeSpace`, which searches a hierarchical trade space of constellations for the designs that sample points sufficiently: by evaluating every design, ranking them with the uncertainty of their replicates, screening, and searching with Optuna and pymoo. + - The `RunOSSEMonsoon` example declares its constellation trade as a design space, caches the looks of each satellite, evaluates its replicates in parallel, and finds its Pareto-efficient designs. Changed: - Instruments reject unknown fields, rather than ignoring them: a misspelled field in the data of a `PointedInstrument` previously gave an `Instrument` with a field of regard of 180 degrees. diff --git a/README.md b/README.md index faf53809..d1c58bf6 100644 --- a/README.md +++ b/README.md @@ -35,6 +35,7 @@ Note: the following optional dependencies are available with bracket notation: * `pip install -e ".[examples]"`: for running optional examples * `pip install -e ".[osse]"`: for running optional observing system simulation experiment (OSSE) examples * `pip install -e ".[preprocess]"`: for preprocessing functions (e.g., terrain masks) + * `pip install -e ".[tradespace]"`: for parallel trade studies and searches with optimizers (joblib, Optuna, and pymoo) * `pip install -e ".[validation]"`: for running validation notebooks (includes `examples` and `preprocess`) Multiple optional dependencies can be installed with a comma-separated list (e.g., `pip install -e ".[dev,examples]"`) diff --git a/docs/api_reference/index.rst b/docs/api_reference/index.rst index a09a2b7c..ec928186 100644 --- a/docs/api_reference/index.rst +++ b/docs/api_reference/index.rst @@ -11,5 +11,6 @@ The following provide documentation on the Python API to TAT-C. catalog generation/index analysis/index + tradespace preprocess/index utils/index diff --git a/docs/api_reference/tradespace.rst b/docs/api_reference/tradespace.rst new file mode 100644 index 00000000..018b7252 --- /dev/null +++ b/docs/api_reference/tradespace.rst @@ -0,0 +1,98 @@ +Trade Space +=========== + +.. automodule:: tatc.tradespace + +Design Spaces +------------- + +.. autoclass:: tatc.tradespace.DesignSpace + :members: enumerate, size, sample, design, suggest, unit_paths, encode, decode + +.. autoclass:: tatc.tradespace.Real + +.. autoclass:: tatc.tradespace.Integer + +.. autoclass:: tatc.tradespace.Categorical + +.. autoclass:: tatc.tradespace.Fixed + +.. autoclass:: tatc.tradespace.Derived + +.. autoclass:: tatc.tradespace.Uncertain + :members: uniform, normal, choice + +.. autoclass:: tatc.tradespace.Choice + +.. autoclass:: tatc.tradespace.Repeat + +.. autoexception:: tatc.tradespace.Infeasible + +Designs +------- + +.. autoclass:: tatc.tradespace.Design + :members: flat, realize, values + +.. autoclass:: tatc.tradespace.Values + +.. autoclass:: tatc.tradespace.ChoiceValues + :members: choice, value + +.. autoclass:: tatc.tradespace.RepeatValues + :members: count + +.. autoclass:: tatc.tradespace.Scope + +Trade Studies +------------- + +.. autoclass:: tatc.tradespace.Study + :members: run, workers + +.. autofunction:: tatc.tradespace.summarize + +Caches +------ + +.. automodule:: tatc.tradespace.cache + :no-members: + +.. autoclass:: tatc.tradespace.SatelliteCache + :members: get, clear, __call__ + +.. autofunction:: tatc.tradespace.get_satellite_key + +Pareto Efficiency +----------------- + +.. autofunction:: tatc.tradespace.pareto_front + +.. autofunction:: tatc.tradespace.pareto_ranks + +.. autofunction:: tatc.tradespace.hypervolume + +.. autofunction:: tatc.tradespace.pareto_probability + +Screening +--------- + +.. autofunction:: tatc.tradespace.screen + +.. autoclass:: tatc.tradespace.Screening + :members: final + +Optimizers +---------- + +.. automodule:: tatc.tradespace.optimization + :no-members: + +.. autofunction:: tatc.tradespace.optimize_optuna + +.. autofunction:: tatc.tradespace.optimize_pymoo + +.. autofunction:: tatc.tradespace.make_pymoo_problem + +.. autoclass:: tatc.tradespace.Evaluations + :members: evaluate, results diff --git a/docs/examples/RunOSSEMonsoon.ipynb b/docs/examples/RunOSSEMonsoon.ipynb index faeb1afe..5429f4af 100644 --- a/docs/examples/RunOSSEMonsoon.ipynb +++ b/docs/examples/RunOSSEMonsoon.ipynb @@ -2412,9 +2412,13 @@ "\n", "An OSSE is most useful for comparing designs that do not exist yet. The analysis above finds that the current sounders observe only 12 to 14% of the features, because all three satellites share one orbit plane, and that finer resolution helps only with the features that are observed. This section trades the two: how many satellites, in how many orbit planes, carrying heritage or future sensors.\n", "\n", - "Each design places satellites in sun-synchronous orbits at 830 km (the altitude at which the nominal resolutions of the sensors apply), in planes whose ascending equator crossing times are spread evenly over 12 hours from 13:30, so that `P` planes observe at `2P` evenly spaced local times. The satellites of a plane are evenly spaced in it, and each carries both swaths (ATMS and CrIS). Two strategies are compared for 1 to 6 satellites: all in one plane, like the current constellation, and one per plane. A design of 6 satellites in 2 planes (3 per plane) shows how much of the benefit of separate planes a single additional plane gives. Which passes cross the study region depends on the phase of the satellites in their planes, so each design is evaluated for `N_DRAWS` random phases and the results averaged.\n", + "The designs are declared as a design space (`tatc.tradespace.DesignSpace`): the number of orbit planes `P` (a repetition of planes, `Repeat`) and the number of satellites in each plane, for at most six satellites, which gives 14 designs. Each design places satellites in sun-synchronous orbits at 830 km (the altitude at which the nominal resolutions of the sensors apply), in planes whose ascending equator crossing times are spread evenly over 12 hours from 13:30 (a value `Derived` from the index of the plane), so that `P` planes observe at `2P` evenly spaced local times. The satellites of a plane are evenly spaced in it, and each carries both swaths (ATMS and CrIS). The designs include the two strategies of all satellites in one plane, like the current constellation, and one satellite per plane, and designs in between, such as 6 satellites in 2 planes (3 per plane), which shows how much of the benefit of separate planes a single additional plane gives.\n", "\n", - "Two days are too few to rank designs, so the trade uses two weeks of the Nature Run (`TRADE_DURATION`), downloaded once (about 120 MB, a few minutes). Evaluating the designs takes about three minutes." + "Which passes cross the study region depends on the phase of the satellites in their planes, which is not a design choice but an uncertain parameter (`Uncertain`). A trade study (`tatc.tradespace.Study`) builds and evaluates each design in `N_DRAWS` replicates, each with random phases, and the results are averaged. The replicates use common random numbers: the phase of a plane (the first plane, the second plane, and so on) is the same in the same replicate of every design, so that differences between designs are not differences between their draws.\n", + "\n", + "Designs share satellites: in the same replicate, the first satellite of the first plane is the same in every design, and so are others (such as the satellites of the planes of designs with the same number of planes). A cache of the looks of each satellite (`tatc.tradespace.SatelliteCache`), keyed by its orbit and instruments rather than its name, computes them once for the designs of a replicate: 32 satellites rather than 57. The replicates are evaluated in parallel, each by its own worker process (`n_jobs`).\n", + "\n", + "Two days are too few to rank designs, so the trade uses two weeks of the Nature Run (`TRADE_DURATION`), downloaded once (about 120 MB, a few minutes). Evaluating the designs takes about a minute with six processors." ] }, { @@ -2430,27 +2434,11 @@ } }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\Users\\paulg\\github\\tatc\\.venv\\Lib\\site-packages\\xarray\\coding\\times.py:215: SerializationWarning: Ambiguous reference date string: 1-1-1 00:00:0.0. The first value is assumed to be the year hence will be padded with zeros to remove the ambiguity (the padded reference date string is: 0001-1-1 00:00:0.0). To remove this message, remove the ambiguity by padding your reference date strings with zeros.\n", - " ref_date = _ensure_padded_year(ref_date)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\Users\\paulg\\github\\tatc\\.venv\\Lib\\site-packages\\xarray\\coding\\times.py:215: SerializationWarning: Ambiguous reference date string: 1-1-1 00:00:0.0. The first value is assumed to be the year hence will be padded with zeros to remove the ambiguity (the padded reference date string is: 0001-1-1 00:00:0.0). To remove this message, remove the ambiguity by padding your reference date strings with zeros.\n", - " ref_date = _ensure_padded_year(ref_date)\n" - ] - }, { "name": "stdout", "output_type": "stream", "text": [ - "1590 features in 14 days\n" + "14 designs, 1590 features in 14 days\n" ] }, { @@ -2497,50 +2485,50 @@ " \n", " 1\n", " 1 plane(s) x 1\n", - " 4.2\n", - " 3.5\n", - " 0.5\n", - " 2.2\n", - " 3.5\n", + " 4.4\n", " 3.4\n", + " 0.4\n", + " 1.9\n", + " 3.2\n", + " 3.3\n", " \n", " \n", " 2\n", " 1 plane(s) x 2\n", - " 8.4\n", - " 6.9\n", + " 8.5\n", + " 6.8\n", " 0.8\n", - " 4.2\n", - " 6.9\n", - " 6.9\n", + " 4.1\n", + " 6.8\n", + " 6.8\n", " \n", " \n", " 2 plane(s) x 1\n", - " 10.0\n", - " 8.0\n", - " 1.1\n", - " 4.5\n", - " 7.7\n", + " 10.1\n", " 7.9\n", + " 1.1\n", + " 4.3\n", + " 7.6\n", + " 7.8\n", " \n", " \n", " 3\n", " 1 plane(s) x 3\n", - " 12.6\n", - " 10.5\n", + " 13.0\n", + " 10.4\n", " 1.2\n", - " 6.1\n", + " 6.2\n", + " 10.1\n", " 10.3\n", - " 10.4\n", " \n", " \n", " 3 plane(s) x 1\n", - " 14.0\n", + " 14.2\n", " 11.3\n", " 1.6\n", - " 6.8\n", - " 11.3\n", - " 11.2\n", + " 6.6\n", + " 10.9\n", + " 11.1\n", " \n", " \n", " current (3 in the 13:30 plane)\n", @@ -2552,70 +2540,88 @@ " 9.6\n", " \n", " \n", - " 4\n", + " 4\n", " 1 plane(s) x 4\n", - " 14.8\n", - " 12.3\n", + " 14.7\n", + " 12.4\n", " 1.5\n", " 7.4\n", " 12.1\n", - " 12.1\n", + " 12.2\n", + " \n", + " \n", + " 2 plane(s) x 2\n", + " 19.6\n", + " 15.7\n", + " 2.4\n", + " 9.2\n", + " 15.4\n", + " 15.6\n", " \n", " \n", " 4 plane(s) x 1\n", - " 19.0\n", + " 19.4\n", " 15.6\n", - " 2.1\n", - " 8.9\n", + " 2.2\n", + " 9.0\n", " 15.2\n", - " 15.5\n", + " 15.4\n", " \n", " \n", " 5\n", " 1 plane(s) x 5\n", " 15.5\n", - " 13.3\n", - " 1.5\n", - " 7.9\n", - " 12.9\n", - " 13.1\n", + " 13.0\n", + " 1.7\n", + " 8.1\n", + " 12.7\n", + " 12.8\n", " \n", " \n", " 5 plane(s) x 1\n", - " 23.8\n", + " 24.4\n", + " 19.6\n", + " 2.6\n", + " 11.5\n", + " 19.4\n", " 19.4\n", - " 2.7\n", - " 11.4\n", - " 19.1\n", - " 19.2\n", " \n", " \n", - " 6\n", + " 6\n", " 1 plane(s) x 6\n", - " 15.5\n", - " 13.3\n", + " 15.8\n", + " 13.1\n", " 1.8\n", - " 8.3\n", - " 13.2\n", - " 13.2\n", + " 8.4\n", + " 13.1\n", + " 13.0\n", " \n", " \n", " 2 plane(s) x 3\n", - " 29.8\n", - " 24.0\n", - " 3.4\n", - " 14.2\n", - " 23.6\n", + " 29.7\n", + " 23.9\n", + " 3.6\n", + " 14.3\n", + " 23.3\n", " 23.7\n", " \n", " \n", + " 3 plane(s) x 2\n", + " 28.1\n", + " 22.7\n", + " 3.5\n", + " 13.8\n", + " 22.4\n", + " 22.5\n", + " \n", + " \n", " 6 plane(s) x 1\n", - " 29.3\n", + " 29.2\n", " 23.9\n", - " 3.6\n", - " 14.5\n", - " 23.3\n", - " 23.7\n", + " 3.5\n", + " 14.2\n", + " 23.0\n", + " 23.6\n", " \n", " \n", "\n", @@ -2624,83 +2630,93 @@ "text/plain": [ "sensor observed, ATMS swath \\\n", "satellites design \n", - "1 1 plane(s) x 1 4.2 \n", - "2 1 plane(s) x 2 8.4 \n", - " 2 plane(s) x 1 10.0 \n", - "3 1 plane(s) x 3 12.6 \n", - " 3 plane(s) x 1 14.0 \n", + "1 1 plane(s) x 1 4.4 \n", + "2 1 plane(s) x 2 8.5 \n", + " 2 plane(s) x 1 10.1 \n", + "3 1 plane(s) x 3 13.0 \n", + " 3 plane(s) x 1 14.2 \n", " current (3 in the 13:30 plane) 11.6 \n", - "4 1 plane(s) x 4 14.8 \n", - " 4 plane(s) x 1 19.0 \n", + "4 1 plane(s) x 4 14.7 \n", + " 2 plane(s) x 2 19.6 \n", + " 4 plane(s) x 1 19.4 \n", "5 1 plane(s) x 5 15.5 \n", - " 5 plane(s) x 1 23.8 \n", - "6 1 plane(s) x 6 15.5 \n", - " 2 plane(s) x 3 29.8 \n", - " 6 plane(s) x 1 29.3 \n", + " 5 plane(s) x 1 24.4 \n", + "6 1 plane(s) x 6 15.8 \n", + " 2 plane(s) x 3 29.7 \n", + " 3 plane(s) x 2 28.1 \n", + " 6 plane(s) x 1 29.2 \n", "\n", "sensor observed, CrIS swath \\\n", "satellites design \n", - "1 1 plane(s) x 1 3.5 \n", - "2 1 plane(s) x 2 6.9 \n", - " 2 plane(s) x 1 8.0 \n", - "3 1 plane(s) x 3 10.5 \n", + "1 1 plane(s) x 1 3.4 \n", + "2 1 plane(s) x 2 6.8 \n", + " 2 plane(s) x 1 7.9 \n", + "3 1 plane(s) x 3 10.4 \n", " 3 plane(s) x 1 11.3 \n", " current (3 in the 13:30 plane) 9.7 \n", - "4 1 plane(s) x 4 12.3 \n", + "4 1 plane(s) x 4 12.4 \n", + " 2 plane(s) x 2 15.7 \n", " 4 plane(s) x 1 15.6 \n", - "5 1 plane(s) x 5 13.3 \n", - " 5 plane(s) x 1 19.4 \n", - "6 1 plane(s) x 6 13.3 \n", - " 2 plane(s) x 3 24.0 \n", + "5 1 plane(s) x 5 13.0 \n", + " 5 plane(s) x 1 19.6 \n", + "6 1 plane(s) x 6 13.1 \n", + " 2 plane(s) x 3 23.9 \n", + " 3 plane(s) x 2 22.7 \n", " 6 plane(s) x 1 23.9 \n", "\n", "sensor resolved, ATMS resolved, CrIS \\\n", "satellites design \n", - "1 1 plane(s) x 1 0.5 2.2 \n", - "2 1 plane(s) x 2 0.8 4.2 \n", - " 2 plane(s) x 1 1.1 4.5 \n", - "3 1 plane(s) x 3 1.2 6.1 \n", - " 3 plane(s) x 1 1.6 6.8 \n", + "1 1 plane(s) x 1 0.4 1.9 \n", + "2 1 plane(s) x 2 0.8 4.1 \n", + " 2 plane(s) x 1 1.1 4.3 \n", + "3 1 plane(s) x 3 1.2 6.2 \n", + " 3 plane(s) x 1 1.6 6.6 \n", " current (3 in the 13:30 plane) 1.0 5.3 \n", "4 1 plane(s) x 4 1.5 7.4 \n", - " 4 plane(s) x 1 2.1 8.9 \n", - "5 1 plane(s) x 5 1.5 7.9 \n", - " 5 plane(s) x 1 2.7 11.4 \n", - "6 1 plane(s) x 6 1.8 8.3 \n", - " 2 plane(s) x 3 3.4 14.2 \n", - " 6 plane(s) x 1 3.6 14.5 \n", + " 2 plane(s) x 2 2.4 9.2 \n", + " 4 plane(s) x 1 2.2 9.0 \n", + "5 1 plane(s) x 5 1.7 8.1 \n", + " 5 plane(s) x 1 2.6 11.5 \n", + "6 1 plane(s) x 6 1.8 8.4 \n", + " 2 plane(s) x 3 3.6 14.3 \n", + " 3 plane(s) x 2 3.5 13.8 \n", + " 6 plane(s) x 1 3.5 14.2 \n", "\n", "sensor resolved, Future MW \\\n", "satellites design \n", - "1 1 plane(s) x 1 3.5 \n", - "2 1 plane(s) x 2 6.9 \n", - " 2 plane(s) x 1 7.7 \n", - "3 1 plane(s) x 3 10.3 \n", - " 3 plane(s) x 1 11.3 \n", + "1 1 plane(s) x 1 3.2 \n", + "2 1 plane(s) x 2 6.8 \n", + " 2 plane(s) x 1 7.6 \n", + "3 1 plane(s) x 3 10.1 \n", + " 3 plane(s) x 1 10.9 \n", " current (3 in the 13:30 plane) 9.6 \n", "4 1 plane(s) x 4 12.1 \n", + " 2 plane(s) x 2 15.4 \n", " 4 plane(s) x 1 15.2 \n", - "5 1 plane(s) x 5 12.9 \n", - " 5 plane(s) x 1 19.1 \n", - "6 1 plane(s) x 6 13.2 \n", - " 2 plane(s) x 3 23.6 \n", - " 6 plane(s) x 1 23.3 \n", + "5 1 plane(s) x 5 12.7 \n", + " 5 plane(s) x 1 19.4 \n", + "6 1 plane(s) x 6 13.1 \n", + " 2 plane(s) x 3 23.3 \n", + " 3 plane(s) x 2 22.4 \n", + " 6 plane(s) x 1 23.0 \n", "\n", "sensor resolved, Future IR \n", "satellites design \n", - "1 1 plane(s) x 1 3.4 \n", - "2 1 plane(s) x 2 6.9 \n", - " 2 plane(s) x 1 7.9 \n", - "3 1 plane(s) x 3 10.4 \n", - " 3 plane(s) x 1 11.2 \n", + "1 1 plane(s) x 1 3.3 \n", + "2 1 plane(s) x 2 6.8 \n", + " 2 plane(s) x 1 7.8 \n", + "3 1 plane(s) x 3 10.3 \n", + " 3 plane(s) x 1 11.1 \n", " current (3 in the 13:30 plane) 9.6 \n", - "4 1 plane(s) x 4 12.1 \n", - " 4 plane(s) x 1 15.5 \n", - "5 1 plane(s) x 5 13.1 \n", - " 5 plane(s) x 1 19.2 \n", - "6 1 plane(s) x 6 13.2 \n", + "4 1 plane(s) x 4 12.2 \n", + " 2 plane(s) x 2 15.6 \n", + " 4 plane(s) x 1 15.4 \n", + "5 1 plane(s) x 5 12.8 \n", + " 5 plane(s) x 1 19.4 \n", + "6 1 plane(s) x 6 13.0 \n", " 2 plane(s) x 3 23.7 \n", - " 6 plane(s) x 1 23.7 " + " 3 plane(s) x 2 22.5 \n", + " 6 plane(s) x 1 23.6 " ] }, "execution_count": 12, @@ -2712,38 +2728,58 @@ "from datetime import time as time_of_day\n", "\n", "from tatc.schemas import SunSynchronousOrbit\n", + "from tatc.tradespace import (\n", + " Derived,\n", + " DesignSpace,\n", + " Integer,\n", + " Repeat,\n", + " SatelliteCache,\n", + " Study,\n", + " Uncertain,\n", + ")\n", "\n", "TRADE_DURATION = timedelta(days=14)\n", - "N_DRAWS = 6 # random phases of the satellites in their planes, per design\n", - "# designs (planes, satellites per plane): all in one plane, one per plane, and 6 satellites in 2 planes\n", - "DESIGNS = [(1, n) for n in range(1, 7)] + [(n, 1) for n in range(2, 7)] + [(2, 3)]\n", + "N_DRAWS = 6 # replicates of each design: random phases of the satellites in their planes\n", + "\n", + "# the design space: P planes whose ascending equator crossing times are spread evenly over 12 hours from 13:30, each\n", + "# with the same number of satellites at a random phase, for at most 6 satellites\n", + "space = DesignSpace(\n", + " per_plane=Integer(1, 6),\n", + " planes=Repeat(\n", + " DesignSpace(\n", + " crossing=Derived(lambda d: (13.5 + 12 * d.index / d.planes.count) % 24),\n", + " phase=Uncertain.uniform(0, 360),\n", + " ),\n", + " count=Integer(1, 6),\n", + " ),\n", + " constraints=[lambda d: d.planes.count * d.per_plane <= 6],\n", + ")\n", "\n", "\n", - "def constellation(n_planes, per_plane, rng):\n", - " \"\"\"Satellites in n_planes sun-synchronous planes at 830 km, whose ascending equator crossing times are spread evenly\n", - " over 12 hours from 13:30, with per_plane satellites evenly spaced in each plane at a random phase.\n", - " \"\"\"\n", + "def build(design):\n", + " \"\"\"The satellites of a design: in sun-synchronous orbits at 830 km, evenly spaced in each plane from its phase.\"\"\"\n", " members = []\n", - " for p in range(n_planes):\n", - " hours = (13.5 + 12 * p / n_planes) % 24\n", - " crossing = time_of_day(int(hours), round(60 * (hours % 1)) % 60)\n", - " phase = rng.uniform(0, 360)\n", - " for s in range(per_plane):\n", + " for p, plane in enumerate(design.planes):\n", + " crossing = time_of_day(int(plane.crossing), round(60 * (plane.crossing % 1)) % 60)\n", + " for s in range(design.per_plane):\n", " orbit = SunSynchronousOrbit(\n", " altitude=830e3,\n", " equator_crossing_time=crossing,\n", " epoch=start,\n", - " true_anomaly=(phase + 360 * s / per_plane) % 360,\n", - " )\n", - " members.append(\n", - " sounder_satellite(f\"plane {p + 1} satellite {s + 1}\", orbit)\n", + " true_anomaly=(plane.phase + 360 * s / design.per_plane) % 360,\n", " )\n", + " members.append(sounder_satellite(f\"plane {p + 1} satellite {s + 1}\", orbit))\n", " return members\n", "\n", "\n", - "def evaluate(members, features):\n", - " \"\"\"The share (%) of the features that each sensor observes and resolves, flown on the members.\"\"\"\n", - " looks = collect_looks(members, TRADE_DURATION, features)\n", + "def evaluate(members, features, cache=None):\n", + " \"\"\"The share (%) of the features that each sensor observes and resolves, flown on the members, with their looks\n", + " from a cache of the looks of each satellite (in the order of the features and times, as for all members), if any.\n", + " \"\"\"\n", + " if cache is None:\n", + " looks = collect_looks(members, TRADE_DURATION, features)\n", + " else:\n", + " looks = cache(members).sort_values([\"feature\", \"time\"], kind=\"stable\", ignore_index=True)\n", " return (\n", " assess(looks, features, members)\n", " .groupby(\"sensor\")[[\"observed\", \"resolved\"]]\n", @@ -2753,16 +2789,21 @@ "\n", "\n", "trade_features = find_features(load_nature(TRADE_DURATION))\n", - "rng = np.random.default_rng(0)\n", - "trade = pd.concat(\n", - " [\n", - " evaluate(constellation(n_planes, per_plane, rng), trade_features).assign(\n", - " planes=n_planes, per_plane=per_plane, draw=draw\n", - " )\n", - " for n_planes, per_plane in DESIGNS\n", - " for draw in range(N_DRAWS)\n", - " ]\n", - ").reset_index()\n", + "# the looks of each satellite, cached by its orbit and instruments (not its name): designs of the same replicate\n", + "# share satellites, such as the first satellite of the first plane\n", + "trade_looks = SatelliteCache(lambda satellite: collect_looks([satellite], TRADE_DURATION, trade_features))\n", + "# common random numbers: the phase of a plane is the same in the same replicate of every design; each replicate is\n", + "# evaluated by its own worker process, whose cache its designs share\n", + "study = Study(\n", + " space,\n", + " build,\n", + " lambda members: evaluate(members, trade_features, trade_looks),\n", + " replicates=N_DRAWS,\n", + " n_jobs=N_DRAWS,\n", + " chunks_per_job=1,\n", + ")\n", + "trade = study.run()\n", + "trade[\"planes\"] = trade[\"planes.count\"]\n", "trade[\"satellites\"] = trade.planes * trade.per_plane\n", "trade[\"design\"] = (\n", " trade.planes.astype(str) + \" plane(s) x \" + trade.per_plane.astype(str)\n", @@ -2772,7 +2813,7 @@ " satellites=3, design=\"current (3 in the 13:30 plane)\"\n", ")\n", "\n", - "# features observed (by each swath) and resolved (by each sensor), % of all features, averaged over the draws\n", + "# features observed (by each swath) and resolved (by each sensor), % of all features, averaged over the replicates\n", "trade_summary = pd.concat([trade, current.reset_index()]).pivot_table(\n", " index=[\"satellites\", \"design\"], columns=\"sensor\", values=[\"observed\", \"resolved\"]\n", ")\n", @@ -2785,7 +2826,7 @@ " ],\n", " axis=1,\n", ")\n", - "print(f\"{len(trade_features)} features in {TRADE_DURATION.days} days\")\n", + "print(f\"{len(space.enumerate())} designs, {len(trade_features)} features in {TRADE_DURATION.days} days\")\n", "trade_summary.round(1)" ] }, @@ -2804,7 +2845,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2920,14 +2961,210 @@ "id": "8d240737", "metadata": {}, "source": [ - "Over the two weeks, the study region has 1,590 features. The current constellation observes 12% of them in the ATMS swath and 10% in the CrIS swath, and resolves 1% (ATMS), 5% (CrIS), and 10% (either future sensor), somewhat different from the two days above. Evenly spaced in its plane, a constellation of three satellites does slightly better (13% and 11% observed) than the current one, whose satellites are spaced unevenly.\n", + "Over the two weeks, the study region has 1,590 features. The current constellation observes 12% of them in the ATMS swath and 10% in the CrIS swath, and resolves 1% (ATMS), 5% (CrIS), and 10% (either future sensor), somewhat different from the two days above. Evenly spaced in its plane, a constellation of three satellites does slightly better (13% and 10% observed) than the current one, whose satellites are spaced unevenly.\n", "\n", "* **Satellites in one plane saturate.** Adding satellites to a single plane observes more features up to about four satellites, and then hardly any more (15 to 16% in the ATMS swath for four to six satellites), because they all observe at the same local times (near 13:30 and 01:30).\n", - "* **A second plane gives most of the benefit.** Six satellites in separate planes observe 29% of the features, almost twice as many as six in one plane. Six satellites in two planes (three in each) observe as many (30%): what matters is that the satellites do not duplicate each other's local times, not how many planes there are.\n", - "* **Planes and resolution trade against each other.** With heritage sensors, six satellites in separate planes resolve 14.5% of the features with CrIS, more than six satellites with a future infrared sounder in one plane (13.2%). Finer resolution pays off fully only with separate planes: a future sounder on six satellites in separate (or two) planes resolves 23 to 24% of the features: nearly all of those observed in the CrIS swath, and four fifths of those in the wider ATMS swath.\n", + "* **A second plane gives most of the benefit.** Six satellites in separate planes observe 29% of the features, almost twice as many as six in one plane. Six satellites in two planes (three in each) observe as many (30%), and in three planes (two in each) nearly as many (28%); likewise, four satellites in two planes observe as many as four in separate planes (19 to 20%). What matters is that the satellites do not duplicate each other's local times, not how many planes there are.\n", + "* **Planes and resolution trade against each other.** With heritage sensors, six satellites in separate planes resolve 14.2% of the features with CrIS, more than six satellites with a future infrared sounder in one plane (13.0%). Finer resolution pays off fully only with separate planes: a future sounder on six satellites in separate (or two or three) planes resolves 22 to 24% of the features: nearly all of those observed in the CrIS swath, and four fifths of those in the wider ATMS swath.\n", "* **ATMS is limited by resolution, not sampling.** More planes raise the share resolved by ATMS only from 2% to 4%, because its resolution element is larger than most features wherever they are observed.\n", "\n", - "The spread between the random phases (the shaded bands) is small compared with these differences. The trade holds the sensors and the altitude fixed; their swaths, altitudes, and resolutions, and orbits other than sun-synchronous ones, are further dimensions of a full trade study." + "The spread between the random phases (the shaded bands) is small compared with these differences. The trade holds the sensors and the altitude fixed; their swaths, altitudes, and resolutions, and orbits other than sun-synchronous ones, are further dimensions of a full trade study, which would add variables to the design space." + ] + }, + { + "cell_type": "markdown", + "id": "3f9c2a71", + "metadata": {}, + "source": [ + "### Pareto-efficient designs\n", + "\n", + "A design is Pareto-efficient if no other design is as good in every objective and better in one. With three objectives (the fewest satellites, the fewest orbit planes, each of which needs its own launch, and the most features resolved), the table gives the share of features resolved by each sensor's efficient designs (`tatc.tradespace.pareto_front`, from the means over the replicates by `tatc.tradespace.summarize`), blank where a design is not efficient for a sensor." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "8b41d5e0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sensorATMSCrISFuture MWFuture IR
satellitesplanesper_plane
1110.41.93.23.3
2120.84.16.86.8
211.14.37.67.8
3131.26.210.110.3
311.66.610.911.1
4141.57.412.112.2
222.49.215.415.6
5151.78.112.712.8
512.611.519.419.4
6161.88.413.113.0
233.614.323.323.7
\n", + "
" + ], + "text/plain": [ + "sensor ATMS CrIS Future MW Future IR\n", + "satellites planes per_plane \n", + "1 1 1 0.4 1.9 3.2 3.3\n", + "2 1 2 0.8 4.1 6.8 6.8\n", + " 2 1 1.1 4.3 7.6 7.8\n", + "3 1 3 1.2 6.2 10.1 10.3\n", + " 3 1 1.6 6.6 10.9 11.1\n", + "4 1 4 1.5 7.4 12.1 12.2\n", + " 2 2 2.4 9.2 15.4 15.6\n", + "5 1 5 1.7 8.1 12.7 12.8\n", + " 5 1 2.6 11.5 19.4 19.4\n", + "6 1 6 1.8 8.4 13.1 13.0\n", + " 2 3 3.6 14.3 23.3 23.7" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import pareto_front, summarize\n", + "\n", + "OBJECTIVES = {\"satellites\": \"min\", \"planes\": \"min\", \"resolved\": \"max\"}\n", + "# the mean shares over the replicates, by design and sensor, and the efficient designs of each sensor\n", + "trade_means = summarize(trade, [\"observed\", \"resolved\"], by=[\"sensor\"])\n", + "efficient = pd.concat(\n", + " [group[pareto_front(group, OBJECTIVES)] for _, group in trade_means.groupby(\"sensor\")]\n", + ")\n", + "efficient.pivot_table(\n", + " index=[\"satellites\", \"planes\", \"per_plane\"], columns=\"sensor\", values=\"resolved\"\n", + ")[sensors.index].round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "c7d05a94", + "metadata": {}, + "source": [ + "For every sensor, the efficient designs are those in one plane (the fewest launches) and those in two planes (the most features resolved for the number of satellites): two planes of two satellites resolve more features than four planes of one, and two planes of three about as many as six planes of one, with fewer launches. Designs with more than two planes are efficient only if their satellites cannot be divided evenly between two planes (three or five satellites, in separate planes). Some of these differences are smaller than the spread between the replicates (the standard errors of the means are given by `summarize`), so designs that are nearly efficient deserve as much attention as those that are." ] }, { diff --git a/docs/examples/SearchTradeSpace.ipynb b/docs/examples/SearchTradeSpace.ipynb new file mode 100644 index 00000000..848abd8b --- /dev/null +++ b/docs/examples/SearchTradeSpace.ipynb @@ -0,0 +1,1105 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a1f0c3d2", + "metadata": {}, + "source": [ + "# Search a Trade Space\n", + "\n", + "This example demonstrates how to search a trade space of constellation designs for Pareto-efficient designs with the `tatc.tradespace` module: declaring a hierarchical design space, evaluating designs in replicates (in parallel, with a cache of the analysis of each satellite), ranking them with the uncertainty of their replicates, screening them with a cheaper analysis, and searching the space with optimizers (Optuna and pymoo, installed with `pip install tatc[tradespace]`).\n", + "\n", + "The trade is a sampling problem of a pre-Phase A study: how many satellites, in how many orbit planes (each of which needs its own launch), sample the Earth sufficiently often? A point is **sufficiently sampled** if an imager observes it at least four times in a day, and the objective is the share of points that are. The points are a random sample of the Earth, so the share is a statistical estimate: each replicate of a design draws a different sample of points, which is the uncertainty of the estimate." + ] + }, + { + "cell_type": "markdown", + "id": "b2e1d4c3", + "metadata": {}, + "source": [ + "## Configure the Scenario\n", + "\n", + "The analysis covers one day, with 100 random points in each of five replicates. A design may have at most 10 satellites." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "c3d2e5f4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-10T05:21:06.335298Z", + "iopub.status.busy": "2026-11-10T05:21:06.335020Z", + "iopub.status.idle": "2026-11-10T05:21:07.046709Z", + "shell.execute_reply": "2026-11-10T05:21:07.045904Z" + } + }, + "outputs": [], + "source": [ + "from datetime import datetime, time as time_of_day, timedelta, timezone\n", + "from pathlib import Path\n", + "import tempfile\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "START = datetime(2026, 7, 1, tzinfo=timezone.utc)\n", + "DURATION = timedelta(days=1) # the period of the analysis\n", + "N_POINTS = 100 # random points sampled in each replicate\n", + "N_REPLICATES = 5 # replicates (samples of points) of each design\n", + "SAMPLES_PER_DAY = 4 # a point is sufficiently sampled if it is observed at least this often\n", + "MAX_SATELLITES = 10\n", + "\n", + "BLUE, ORANGE, AQUA, YELLOW, GRAY, INK = \"#2a78d6\", \"#eb6834\", \"#1baf7a\", \"#eda100\", \"#8a8a86\", \"#2b2b29\"" + ] + }, + { + "cell_type": "markdown", + "id": "d4e3f6a5", + "metadata": {}, + "source": [ + "## Define the Design Space\n", + "\n", + "A `DesignSpace` declares the design variables, in the order they are decided. Every design has an altitude and an imager's field of regard, and a layout that is one of two alternatives (a `Choice`):\n", + "\n", + "* a **Walker delta** constellation, with an inclination, a number of planes, a number of satellites in each plane, and the relative spacing of the satellites between planes (whose upper bound depends on the number of planes), or\n", + "* one or two **sun-synchronous** planes (a `Repeat` of planes), each with its own equator crossing time and number of satellites. The planes are unordered: two planes in either order are the same design. A constraint of the group requires the planes to have different crossing times (otherwise, they would be the same plane).\n", + "\n", + "The points sampled in each replicate are an `Uncertain` parameter (the seed of a random sample), drawn for each replicate rather than designed. The replicates use common random numbers: every design samples the same points in the same replicate, so that differences between designs are not differences between their samples.\n", + "\n", + "The constraint on the number of satellites returns the number in excess of the limit (a number that is not positive if the design satisfies it), rather than `True` or `False`, so that optimizers can tell how far an infeasible design is from a feasible one." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e5f4a7b6", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-10T05:21:07.048629Z", + "iopub.status.busy": "2026-11-10T05:21:07.048297Z", + "iopub.status.idle": "2026-11-10T05:21:08.187349Z", + "shell.execute_reply": "2026-11-10T05:21:08.186504Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1096 feasible designs of 12 decisions\n" + ] + } + ], + "source": [ + "from tatc.tradespace import Categorical, Choice, DesignSpace, Integer, Real, Repeat, Uncertain\n", + "\n", + "\n", + "def count_satellites(d):\n", + " \"\"\"The number of satellites of a design (or of the values decided so far).\"\"\"\n", + " if d.layout.choice == \"walker\":\n", + " return d.layout.planes * d.layout.per_plane\n", + " return sum(plane.satellites for plane in d.layout.planes)\n", + "\n", + "\n", + "def count_planes(d):\n", + " \"\"\"The number of orbit planes of a design.\"\"\"\n", + " return d.layout.planes if d.layout.choice == \"walker\" else d.layout.planes.count\n", + "\n", + "\n", + "space = DesignSpace(\n", + " altitude=Real(500e3, 800e3, step=100e3),\n", + " field_of_regard=Categorical([30, 60]),\n", + " layout=Choice(\n", + " walker=DesignSpace(\n", + " inclination=Real(45, 75, step=15),\n", + " planes=Integer(1, 4),\n", + " per_plane=Integer(1, 4),\n", + " relative_spacing=Integer(0, lambda d: d.planes - 1),\n", + " ),\n", + " sso=DesignSpace(\n", + " planes=Repeat(\n", + " DesignSpace(crossing=Real(6, 18, step=3), satellites=Integer(1, 2)),\n", + " count=Integer(1, 2),\n", + " ordered=False,\n", + " ),\n", + " # planes with the same crossing time would be the same plane\n", + " constraints=[lambda d: len({plane.crossing for plane in d.planes}) == d.planes.count],\n", + " ),\n", + " ),\n", + " points_seed=Uncertain(lambda rng: int(rng.integers(2**31)), nominal=None),\n", + " constraints=[lambda d: count_satellites(d) - MAX_SATELLITES],\n", + ")\n", + "designs = space.enumerate()\n", + "print(f\"{len(designs)} feasible designs of {len(space.unit_paths())} decisions\")" + ] + }, + { + "cell_type": "markdown", + "id": "f6a5b8c7", + "metadata": {}, + "source": [ + "## Define the Study\n", + "\n", + "A `Study` builds each design into its satellites (`build`) and evaluates them (`evaluate`) in each replicate. The evaluation collects the observations of the replicate's points by each satellite, from a `SatelliteCache`: designs share many satellites (the same orbit and imager, if not the same name), whose observations are computed once. The cache is kept on disk, where the parallel worker processes of the study (`n_jobs=-1`, one per processor) share it, and where it persists between sessions. Its namespace identifies the analysis: the points, the start, and the duration.\n", + "\n", + "`make_study` makes studies of other durations and numbers of replicates, as for screening (below). Each evaluation also reports its cost (`satellite_days`, the satellites times the days analyzed), which measures the computation independently of the cache." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a7b6c9d8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-10T05:21:08.189716Z", + "iopub.status.busy": "2026-11-10T05:21:08.189310Z", + "iopub.status.idle": "2026-11-10T05:21:08.196532Z", + "shell.execute_reply": "2026-11-10T05:21:08.195799Z" + } + }, + "outputs": [], + "source": [ + "from tatc.analysis import collect_observations\n", + "from tatc.generation import generate_points_random\n", + "from tatc.schemas import CircularOrbit, Instrument, Satellite, SunSynchronousOrbit, WalkerConstellation\n", + "from tatc.tradespace import SatelliteCache, Study\n", + "\n", + "CACHE_DIRECTORY = Path(tempfile.gettempdir()) / \"tatc-search-trade-space\"\n", + "caches = {}\n", + "\n", + "\n", + "def get_cache(seed, duration):\n", + " \"\"\"A cache of the observations by each satellite of the random points of a seed over a duration.\"\"\"\n", + " if (seed, duration) not in caches:\n", + " points = generate_points_random(N_POINTS, seed=seed)\n", + " caches[seed, duration] = SatelliteCache(\n", + " lambda satellite: collect_observations(points, satellite, START, START + duration),\n", + " directory=CACHE_DIRECTORY,\n", + " namespace=f\"{N_POINTS} points, seed {seed}, start {START.isoformat()}, duration {duration}\",\n", + " )\n", + " return caches[seed, duration]\n", + "\n", + "\n", + "def build(d):\n", + " \"\"\"The design and its satellites.\"\"\"\n", + " instrument = Instrument(name=\"imager\", field_of_regard=d.field_of_regard)\n", + " if d.layout.choice == \"walker\":\n", + " members = WalkerConstellation(\n", + " name=\"walker\",\n", + " orbit=CircularOrbit(altitude=d.altitude, inclination=d.layout.inclination, epoch=START),\n", + " instruments=[instrument],\n", + " number_planes=d.layout.planes,\n", + " number_satellites=d.layout.planes * d.layout.per_plane,\n", + " relative_spacing=d.layout.relative_spacing,\n", + " ).generate_members()\n", + " else:\n", + " members = [\n", + " Satellite(\n", + " name=f\"plane {p + 1} satellite {s + 1}\",\n", + " orbit=SunSynchronousOrbit(\n", + " altitude=d.altitude,\n", + " equator_crossing_time=time_of_day(int(plane.crossing)),\n", + " epoch=START,\n", + " true_anomaly=360 * s / plane.satellites,\n", + " ),\n", + " instruments=[instrument],\n", + " )\n", + " for p, plane in enumerate(d.layout.planes)\n", + " for s in range(plane.satellites)\n", + " ]\n", + " return d, members\n", + "\n", + "\n", + "def make_study(duration=DURATION, replicates=N_REPLICATES):\n", + " \"\"\"A study of the share (%) of points sampled sufficiently over a duration.\"\"\"\n", + " threshold = SAMPLES_PER_DAY * duration / timedelta(days=1)\n", + "\n", + " def evaluate(built):\n", + " d, members = built\n", + " samples = get_cache(d.points_seed, duration)(members).groupby(\"target_hash\").size()\n", + " return {\n", + " \"satellites\": len(members),\n", + " \"planes\": count_planes(d),\n", + " \"sufficient\": 100 * (samples >= threshold).sum() / N_POINTS,\n", + " \"satellite_days\": len(members) * duration / timedelta(days=1),\n", + " }\n", + "\n", + " return Study(space, build, evaluate, replicates=replicates, n_jobs=-1)\n", + "\n", + "\n", + "OBJECTIVES = {\"satellites\": \"min\", \"planes\": \"min\", \"sufficient\": \"max\"}\n", + "REFERENCE = {\"satellites\": MAX_SATELLITES + 1, \"planes\": 5, \"sufficient\": 0} # worse than every design, for hypervolumes" + ] + }, + { + "cell_type": "markdown", + "id": "b8c7d0e9", + "metadata": {}, + "source": [ + "## Evaluate Every Design\n", + "\n", + "The design space is small enough to evaluate every design, which gives the true Pareto front against which the screening and the searches below are compared. `summarize` gives the mean of each objective over the replicates (and its standard deviation and standard error), and `pareto_front` the designs that no other design is as good as in every objective and better than in one." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c9d8e1f0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-10T05:21:08.198273Z", + "iopub.status.busy": "2026-11-10T05:21:08.198033Z", + "iopub.status.idle": "2026-11-10T05:21:15.174003Z", + "shell.execute_reply": "2026-11-10T05:21:15.173012Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5480 evaluations: 1096 designs x 5 replicates\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanessufficientsufficient sem
1048800 km, 60 deg FOR, SSO: 1 at 09:001.01.04.20.7
960800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...2.01.013.81.0
963800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.028.61.1
961800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...3.01.037.01.8
962800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.066.42.2
1026800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.098.00.5
\n", + "
" + ], + "text/plain": [ + " description satellites planes \\\n", + "1048 800 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", + "960 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 1.0 \n", + "963 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", + "961 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 1.0 \n", + "962 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", + "1026 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "\n", + " sufficient sufficient sem \n", + "1048 4.2 0.7 \n", + "960 13.8 1.0 \n", + "963 28.6 1.1 \n", + "961 37.0 1.8 \n", + "962 66.4 2.2 \n", + "1026 98.0 0.5 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import hypervolume, pareto_front, summarize\n", + "\n", + "results = make_study().run(designs)\n", + "print(f\"{len(results)} evaluations: {len(designs)} designs x {N_REPLICATES} replicates\")\n", + "\n", + "# the values of each design, and the means of its objectives over the replicates\n", + "values = results.drop_duplicates(\"design\").set_index(\"design\").drop(columns=[\"replicate\", \"points_seed\", \"seconds\", \"sufficient\", \"feasible\"])\n", + "summary = summarize(results, list(OBJECTIVES), design_columns=[])\n", + "summary[\"pareto\"] = pareto_front(summary, OBJECTIVES)\n", + "exact_hypervolume = hypervolume(summary, OBJECTIVES, REFERENCE)\n", + "\n", + "\n", + "def describe(d):\n", + " \"\"\"A short description of a design.\"\"\"\n", + " if d.layout == \"walker\":\n", + " layout = (\n", + " f\"Walker {d['layout.walker.inclination']:.0f} deg: {d['layout.walker.planes']:.0f} x \"\n", + " f\"{d['layout.walker.per_plane']:.0f} (spacing {d['layout.walker.relative_spacing']:.0f})\"\n", + " )\n", + " else:\n", + " planes = [\n", + " f\"{d[f'layout.sso.planes[{k}].satellites']:.0f} at {d[f'layout.sso.planes[{k}].crossing']:02.0f}:00\"\n", + " for k in range(int(d['layout.sso.planes.count']))\n", + " ]\n", + " layout = \"SSO: \" + \", \".join(planes)\n", + " return f\"{d.altitude / 1e3:.0f} km, {d.field_of_regard} deg FOR, {layout}\"\n", + "\n", + "\n", + "summary[\"description\"] = [describe(values.loc[key]) for key in summary.design]\n", + "front = summary[summary.pareto].sort_values([\"satellites\", \"planes\"])\n", + "front[[\"description\", \"satellites\", \"planes\", \"sufficient\", \"sufficient sem\"]].round(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d0e9f2a1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-10T05:21:15.176165Z", + "iopub.status.busy": "2026-11-10T05:21:15.175970Z", + "iopub.status.idle": "2026-11-10T05:21:15.393143Z", + "shell.execute_reply": "2026-11-10T05:21:15.392292Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3oAAAG4CAYAAAAT7JXuAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjIsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvgI3uAAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQeYE+XXxc+kZwvb6b1KR5ooCiJYUGyIilhQQVGxF2zY+9/uJ3ZFLGAXBKQpSJOO9N6Xur2ll/me+2YnJNlkN7ubbdn788HslEwmk8nkPXPvPVeSZVkGwzAMwzAMwzAMEzWoanoHGIZhGIZhGIZhmMjCQo9hGIZhGIZhGCbKYKHHMAzDMAzDMAwTZbDQYxiGYRiGYRiGiTJY6DEMwzAMwzAMw0QZLPQYhmEYhmEYhmGiDBZ6DMMwDMMwDMMwUQYLPYZhGIZhGIZhmCiDhR7DMAzDMAzDMEyUwUKPYZiIMnnyZAwbNixi23vwwQcxYsSIiG2PYVq3bo0vvvgi5HRdYsWKFWjfvj0cDketPqY1cYxrwz5UhH379kGSJBw9ejTkOsuXL0e3bt2g1Wojfn3ctGmTeP2srKwq3S6duzRttVrDfk5Z0xXhwIEDaNSoEbKzsyu8DYaprbDQY5haxPPPPy9+tAL/xcXF1fSuMUyF+O6774Ke03l5eVF9RJs3b46vv/66yl+HboQ888wzYsBfl/a7ul6nvPtQG/YrHO677z5ceeWVQiTNmTOnpnen1rB+/fpyX1/atm2Lyy+/XPz+Mky0oanpHWAYxp9WrVrh0KFDfFiKee+99/hY1HHobvnJkydRW6mr37d//vlHRH+uv/561HZq4hgHvmZd/ZyDQZ/7gAEDoFarUVfo1asXZFmO6HMqss1gjB8/XmSivPzyy0hISKj09himtsARPYapQyxYsAA6na5EislTTz2Fnj17+kVRKK3HYDCItK7XXnsNLpfL70ftiiuuwD333IPk5GS0adMGixcvFtvOzMz02/bjjz+O3r17B90ft9uNJ598EikpKUhLS8O1116LjIyMEuuVtT/r1q3Deeedh/j4eCF06TUtFkvQ1E163qOPPur3mnfeeadfuqjy/u6//360bNkSSUlJuOmmm1BUVFSu403bufTSS3HbbbehRYsWIrJ66623CtEyduxYJCYmin2g41/e9/z66697o1s0sBg8eLA4DoGvX973QYMe2jYdR/o8u3btip9++qlazqFIEWrbFL14+OGH0bRpU8TGxqJ///5YtGiR33NTU1Px3HPPYejQoeK40uf26aeflvp6gSl9dO498sgj3s98+PDhYmCtQANs5bOjfaHzw/d40uDz2LFjYj6tQ8cw3P2nfe3YsSNiYmLE5+H72QUyY8YMXHjhhd7tl/X8qtzvsvA9xtV1fEpL3Qy2D5XZLzrvKCJ0/vnnw2g0iusWsWfPHnEu07WN1rnmmmtw5MgRv+f+/fff4ntK2+7Tpw8WLlwY8j1t27ZN7JvJZBLbpb/pu0r8+++/GDhwoNjvhg0b4t577/VeR31TJadNmya+0xqNRtwsCIdw3sf8+fPRuXNn7/v46KOP/FJQQ6VZ0nlM1xr6TPv164eNGzd6l5WVmum7nIQ8PZ+gayXNp5sg9LkH3jDcuXOnWL5lyxbvd4Ne/48//gjreDBMnUFmGKbW8Nxzz8mtWrUKudzpdMqNGzeWP/74Y+88t9stt27dWv7f//4npqdNmyY3adJE/uuvv2STySRv2LBB7tChg/zaa695nzNu3Di6BSo/++yzck5Ojnc77dq1k99++22/16Nt/d///V/Q/Xnvvffk1NRUefHixXJeXp7YB9ru0KFDveuEsz8tWrSQH3/8cTk/P18+fvy4/NZbb8lz584Vyx544AH5sssu86775ptvitdcsmSJeE3a38DXVN7fq6++Kufm5so7d+4Ux/WZZ57xrrN8+XKxzrp160Ieb2U79L7otdasWSPHxMTISUlJ8vvvvy/2l7aj0+nk+fPnl+s9+0KfwfPPPy+npaWJ1ynP+whkypQpcmJiojxv3jyxrU8++URWqVTyypUrq/wcCsa3334rq9VqsU/0b/DgwfKyZctCrl/atq+++mr54osvlnfv3i0XFRXJ06dPl41Go7xlyxbvOikpKbLBYJB/+ukn8fl89913slarlf/++2/vOnQMP//885DTI0aMkDt37iz/+++/ckFBgfhs6fMJhI7bvn375GHDhsnXXXed37JmzZrJU6dO9ZtX1v6vX79enEsLFiyQLRaLvG3bNnn06NHiMwtGly5d5Ndff907He7zI73f4RzTwOnqOD4V2YeKvn867xo0aCDPmTNHtlqtYt6pU6fkRo0ayS+++KKclZUlZ2ZmynfccYfcvXt32W63i3XoekfXFLr207lO31P67tH5n56eLodCr9fLs2fP9k6fPHlSjo+Plx977DE5Oztb3rhxo7ie33nnnSWuef379xfXEjoPgvHff/+J9Wh/w30ftK/0vaP3QdeqVatWiWPp+z4Ct6vsD33Xtm7d6t0uXZ/ouhPsOWVN0/WcpmkfFF544QWxr748+uijcp8+ffzmXXrppfL48eNDHnOGqYuw0GOYWgT9SNKPVOA/XxFDwufcc8/1TtOPJQ3kjx49Kqbbtm3rN5hRBu7t27f3G0h36tSpxOuToOjatat3+o8//hADilAD+ZYtW8pvvPGG37yzzjrLb3/L2h8aKND+L126NOhrBAq95s2bewWJwtlnn11C6J155pl+6zz11FPy+eefX26h17t3b795tC/nnHOO3zwSL5MnTw77PYeCBkazZs0q1/sIhAazNCDz5corrxT/quMcCmTmzJnyRx99JAaLx44dkx966CFZo9GIQXsogm2bBtWSJIntBA7CadDmO+CmwaIvN954o985VJoAoAEynRerV6+Ww4XOIRKTvoIjUDCEs/+//vqrEPsOhyOs1yVh8dVXX3mny/v8SO13JIReVRyfSAi98px3kyZN8luHvocDBw70m2ez2YQgWrFihZimmxkkdHyhmzDlFXr020HfT1/x9vvvv4ubLCTOfK95dAOjNALFUzjvg65/dOPBl08//TQsoafc1CNIwNOxVD6nSAg9en06Dsq1ns4fEq50U8yX2267TQh6hokmOHWTYWoZlHJXfBPG+++vv/7yLqfUvZUrV+Lw4cNi+vvvvxfpQs2aNUNubq5wEJswYYJIy6H6DZVKJdIMDx486Pc6Xbp0KfHalJa4e/durF27Vkx/9dVXuOqqq0QaTCCUOkSpO3379vWbr6TOEOHsD5lIUOolvQ6l6v38888oKCgIemzoNSkNiNKCfAncB6JDhw5+0/QeaH8Uzj33XHFsgz3XF0px8oXSNYPNU7Yd7meQnp6OMWPGiHQwWofSiChtLDAdqqz34YvZbBbnxVlnneU3/+yzz8aOHTuq5RwKhAwj7r77bpFKRu/1nXfeESly77//fqnPC9w2mSzQ50Xb8N2v33//XeyvL8HOSd/3Xxr//fefSH2j9LxQ0PeRUo2V9DDaPrlenjhxIuRzwtl/SjelVFVKSaT002XLlvmlywYSWJtU1vOrar8jQVUcn+raLwVKvwx8LqVT+j5Pr9eLVFDluXRelnYNDRfaDj2PPlff7z0dH7qml7afZRHO+9i1a1dY1+Vg+K5H373u3buH/X0NBzLYufjii8XvGTF37lzk5+eL6y/DRDss9BimjkE/ilSjMn36dDFII2FEA3elZo6YPXs2nE6n+JGneTRQoWlfqE4rkCZNmoiaNPpBpFo7+kEcN25cqfvjO7AIJNz9+fjjj0VdCg2mqJaCxG6w2hFlYBv4msGK8Uvbr/IQbDuReM833nijqJ+h90kCjZa3a9euxOdUnvcRypSA5vtupyrPoXCgepy9e/eWuk7gtmkfaBBos9lK7Nevv/4asc++LGMHEuNUq3T11VeLwS3ty9atW8WywONT3v2nmsLNmzeLGksaiN5yyy1i8BzKQZBqCH1Nbkp7flXudySoiuNTXftV2jk7atSoEs+jfzfffHNEr1XBzttQ18vyfm/DeR+B15hQ+xSMSF2ry6r7pVpAEqf0+zZy5Ehxg86XU6dOCVHIMNEECz2GqYOQSKAoDBW/U5SLCuMJMigh04558+ZVeNt33HEHfvjhB3z22WdC+NFd9GBQwT29VqCBiO90efaHxAf14KNIExmrfPjhhyXWIWMM+iGmO8y++Bbv1zThvGcaAK1evRoTJ04UgovujtMgQ4mwVRT6TEgkKxFZhTVr1giThOo6h8qCDCVI1JcHMgSiQVo45hHBzsnA91/W6wRuwzfiRxENMucgN1GKcAQebyVSrYjm8uw/nQtk9U43PCiqQVHUUPb5ZLwRuJ+hnl/V+11equP4lHcfKrNfwaDnUtSRbuSUFrkOvJ6FOvdKg6J09DxfcUXfe/qc6RpTGcJ5H/T92rBhQ4Wuy77vl4413YAI9/saiNJmJPBzpXOGBDvdVPzzzz9x++23B92PQYMGVeh1Gaa2wkKPYeogNEjfvn276J9Fd+kbNGjgXfbCCy8IZ7opU6YIRz1Ky6IB/QMPPBDWtslhkATVSy+9JFI5aXAYioceeghvvvmmGATRHXb6mwYXvpS1PxRpuO6668TzaCBB7obkiEbRrWDQ89566y0x8KDXpAEfpRWVF8WBLnCQFQnKes/0ujT4+vbbb8V7oPQniqiVFlkJl0mTJon0SIqQUgosuQxSdI7mV9c5FHjjgAZWlBJK2yGhQaKD+oCVhzPPPFOkgdL2yCGWxCmlpFEKH92p94WOq5ICTPtNzox0rob7OhTVpoEgnZOFhYXCqZSOCUGfG0Viabt0vi5ZsgRPP/10ie2Q4Kbn2+32sPef3BDpdSjaSREkZXBNfb6CMXr0aOHYqDgrlvb8qtzvilAdx6e8+xDp90+p6CS8brjhBrHP5Ja7atUqcVNFcTulFGkSq+TYSZFJWk7X3vJC6dF0s4hckHNycoQb5WOPPSYyMujmTWUI933s379f7Du9DzqG4b4P2k+6+UPOmeQwTOK0ommVdCOQfrPohqGv6KW0U0o/f+KJJ8Q6F1xwgd/z6KaH4mTKMFFFTRcJMgxTthmLb7G5rwEJzSfDlEB+/PFHYSJCBftkLnDLLbfI+/fv9zO7uP7660Me+qeffloYEBw8eLDUj8flcgkDAnKhJCfMa665Rhhh+BqjhLM/5JA4YMAA4T5Hy++9917ZbDYHNWMh44hHHnnE7zVvvvlm4ZhW2vsjt86ePXuW24wlcDtk7DF27Fi/eWR0MnHixHK9ZzL96Nevn1hOLntPPPGEfMYZZ8jvvvtuud5HIGTGQO6Y5GRKRhtkkED7EoyqPIcUyE1v5MiRwmCBPi86N+jYl0aobZNRw5NPPilMNch9kY7Xyy+/7HXoI+h1yOBiyJAhwqyE9p3MYMpj0kHbu//++4X7X1xcnDx8+HDhUqnw2WefeY9vt27dhEssHUff7ws5i5KxEe0nHcNw9r+wsFC4e5LDKbk60vN9zVaCQZ+Rsk5Zz6+q/Q7nmAZOV8fxqcg+VPT903k3Y8aMEvtA582oUaPE9YrOJTJBIpMUXxYuXCgMWeg9kfnShx9+WG4zFoIcO+k7Tcvou0bXJOU66nvNo/dTGoEGJ+G+D3L6JRMl5X0o51dGRkbQ7Sr78+WXX4pjTuYu5ITpe00urxkLQQZhdE2l3zDf68jevXvFusEcdOl3K/AazjDRgET/q2mxyTBM7YLMUSjK5GsCU5uhXmKdOnUKmu7J1C+oxxedBxTtqg9QZJoiFVR3p6StMR7IXIiyDNh0o2ag6DFFAymaX1pmSHVBmR9kRkS/bRS5VaBpMq6hDAe6fjBMNFHz3zyGYWoVlEJDP9DhprpVNzSgpZQgSvmktCFKU6SUKjJmYJj6BrnHUsocizx/qM6LUhkrWuvFlB9KD6c6PUqBpLRaSg0ms5baIPIoxZd+N8iExVfkEZT6S+cKizwmGqn5bx/DMLVq0EjW/ORQdtlll6E2Qu0GKBGB7sy2bt1aGMeQO2hpdvgMw9QfqG6X2oVQPSjV2DHVA9W23nvvvcLs57bbbhOR1LfffrvGDz/VKcfHxwsn6Xfffbemd4dhqhVO3WQYhmEYhmEYhokyOKLHMAzDMAzDMAwTZbDQYxiGYRiGYRiGiTJY6DEMwzAMwzAMw0QZLPSKIXMHaq7L3SYYhmEYhmEYhqnrsNArprCwEAkJCeKRYRiGYRiGYRimLsNCj2EYhmEYhmEYJspgoccwDMMwDMMwDBNlsNBjGIZhGIZhGIaJMljoMQzDMAzDMAzDRBks9BiGYRiGYRiGYaIMFnoMwzAMwzAMwzBRBgs9hmEYhmEYhmGYKIOFHsMwDMMwDMMwTJTBQo9hGIZhGIZhGCbKYKFXT9m+fTuee+65mt4NhmEYhmEYhmGqAE1VbJSpOgoLC3HbbbeJv2NjYzFt2rQKbSczMxNLly6N8N4xDMMwDMMwDFMbqBVCb/Xq1di1axcuueQSNG7cuMRyp9OJ5cuX49SpU+jevTu6du1aoXWqk3yLC1vTLcgzu5AYo0b3FkYkGNWV3q5er8fo0aNx8uRJTJ48OSL7yjAMwzAMwzBMdFGjQm/+/Pl44okn4HK5sG3bNixZsqSE0MvJycGFF14oHrt16yaiULfffjvee++9cq1TnWw/ZsG8LQWQ5dPzVu83YXiPBujazFipbet0OowaNQr79u0rU+ht2rQJc+fORadOncSx7ty5Mx544AFoNP4f+6FDh/Doo49CkiSkpaXhhhtuwHnnnee3DRLOc+bMQbt27fDwww8LwUkcOHAAn376qRDYAwYMwPjx40tsn2EYhmEYhmGYelSjRwLv66+/xrx580Ku89RTT8FisWDr1q2YPXs2Fi1ahA8++AALFiwo1zrVGckLFHkETdN8Wl5dUNTvjTfewB9//IFzzz0XM2fOxIMPPlhivaSkJBElvP7664Wgu+WWW7Bz507vNv73v/8JsTdo0CBxfGlaEYiXX345mjZtimHDhol1Hn/88Wp7fwzDMAzDMAzD1EKhd9lll6FXr14hl8uyjB9++EFE5+Li4sS8s846S/ybPn162OtUJ5SuGSjyFGg+La9OKEJHdXy33norfv31V3z11VfimPmSkJAAh8OBhQsX4p9//oFWq/Wr32vVqhU+//xzIQDJwGXVqlViPkXy1Gq1SJklEUnps7NmzarW98cwDMMwDMMwTElqdY5deno68vPzS9TbUXrmxo0bw14nGDabTfxTKCgoEI9ut1v8qyi5JmcJIeVLnslZqe0rKNsobVu0rHnz5mJ/6F9qaqpIz6T36vv8qVOnijTXu+66S6xjNpuF6YtyLJo0aeJd32g0iuU0ffz4cfTt21fUVioYDIaIvD+GYRiGYRiGqW+oVKr6IfRIwBGJiYl+85OTk73LwlknGK+99hpeeOGFEvMzMk7AYimq8D7LNifMJmfI5W6bFadOVXz7CllZp4R4O3XqeMh18vKyRY3djh1bkZKSgjVr1orjZDYXIjc3G3a7TTx/xYrlGDnyKowceSXsdjteeuklFBbmi2W0DWU9Iicnyzvdvn1bzJs3H88//4yIAiqUtk8MwzBMdELlGP/+u0pkfdDNQrrx16NHdwwdOhQxMTE1vXsMwzB1giZNmtcPoUfRI8JkMvnNpx8QZVk46wTjySefFKYiChTlatGiBRo2bIIGDRpUeJ/Pa+DCnpxsuIME9VQScF73lEq7b44bNw4nTpAgteDeex8QUbVgtXGJiSnC3GbMmJtFVG7t2rX4+OOP0ahRUyQlpUCn04u/r7/eU5+3bt0G7N+/X/wgx8cniGW0DWU9Ijk51Tv92GOPY+XKVRg0aAh69uwpTFjOPvtsv+PKMAzDRD/z5v2Jt99+CxkZGX7zqRzgyy+/wi23jMWECXdF9E41wzAMU4eFXsuWLUWkiEw/fKFpcn8Md51gkGuk4hzpC/0IVeaHKClWheE9E0oYskgShOtmUuzpyFdFGTlypEg7JYdLgkRcsH2meW3atBG1ihs2bECHDh3QunVrsYxaUFBEk9ah1Mv//vsPe/bsQY8ePYR7Kbl70rI+ffrgmWee8W6fUmSV59HdWnLzJBMcEohUo0epovxDzjAMU3+gOvmXX37Rm01z5ZVXid9m+i2ZM2c2Dh48iI8//kjcoHzppZdFCUF9Ze/evUIU33//AzW9KwzD1AMkubSCsmri6NGjIppG7RXOP//8EoYtlE5ITpoE2fiTOciHH37oFTrhrFMWFNEjUxJK96xMRC+wj16+2YWECPbRKw8kwqj2jh4ZhmEYJtJQa6QxY0aL2myK2j344EPiRqECDTFmzvwdzz//nEjtfPbZ53DdddcH3RbdLPztt1+xbt062GxWXHLJpbj00ksjsp+7d+/GokULce+991V4G5QVM2/eXBo64dJLL0O/fv0qtI2PPpqCr7+eVuH9YBiGqRMRPeoFt2LFCuTm5oppEiQUiSMnTsWNk9oDDBw4ENddd53o00bGIbRs7Nix3u2Es051Q6Lu3I4eF9Ca4swzz+Sm6gzDMExEEPeFbRZAb/RG5b777lsh8i666CI89tikEtE6mr766pHid/6dd97Gt99+g2uvvS5oVO+ZZyaL7BBq90M3Xtu0aRuxTy4nh2rW/6vw8//880/88svPGD58uCgNuffee/DBB/+Hs84aELF9ZCJ7bnrnO02AJrbkfJsFss4AyWUWywVB1mU8x8vk9BgYxmr0QY8PrWN22RGj1vHxq0XUaESPRN4XX3xRYv5VV10l/imQ+KO2ABSpo5RDitJR2qAv4axTnRE9hmEYhokWXDknYVs3H3JRHqS4ROj7XYIitRHnnz9ItOeZMeMHdOvQvsRAW4Hq6IcMGSxcm6dOnVYiGrZr1y7ceustWLjwrzJ/g6l0gQQj9Xt1OOwYOPBcUWtO2UH/+9/rIuJGKaQUdevfv794ztixN4sUUroJ3LZtOxF5LA95eXl+pm8vv/ySaOkUbDs7d+4QtYmtWrXGypUr0LZtWxHtpDITjuhV0bm5dj7c+VmQGqRA32cQ1Glt4So6DPvuL+CWzVBrEqHrMBbquFbec9ldcBBu9Q6oGqZCMiaIbUmyE5I+Fbo2N0ClT4GsjoFkt4Y8r6MZRbjl2syYdmgNNuQcAWSgb0or3NK6P5L0MV5Rd8ych9+Pbkau3YwkXQyubt4TzWISw34NFodRGtGjJt70ryyoruzFF1+s9DoMwzAMw5QPGowpIk9MF+WJ6SNNewuRl5aagnbHN8K8Z7FXBKqTG/ttIzY2FgMGnI3Fi//Gvn17Swi9zZs3oW/ffqKmj9yizzjjDIwZc2PQG7ZffvmFSBm94oorhHhq1szjUEc3a6k+kMjOzsazz07GlCkfoV279jj77HNQWFgklge6dIeD73MogkmvP378HUHXpdeeOvUrEeWkLCPqYXvs2DGRtspE/ty0Lv0ZjgNbILtygLh0OPO+g6p5JziPLobsKAScMiRNMzgOboVx0PtwbFgId2EuXM4NgMME14lCSPEeQz91Sn+4iw7AtGoCJENryJnZULm6QNWgTdDzOlpRhFuOzYRdBaeQ77CQxhOszDyA7XnH0alBIyTrY3FVsx6YeWyLEHkEPdJzJ3YYFFIc0+e2rzAT80/sQJ7DUi5xyESRGQvDMAzDMDUMpbgVizwFmnZaLeJvrdtZQgQaLxpbYpCn1O5RLV6wiNnGjRvQrFkzDBo0SKRJ7tixA2+99XaJdclxOj4+Hi1atBSCUK321L/TPJPJjLVr14gsHXr99evXC6FHztDr16/D0KHDKn04Xn31FRGlGzYs9LaSk1Pw0kuviH2giONFFw3D5MnPVPq1GX9kq9kj8ijqFncQsmyDK98Cl/sQ4MoCHFpSFZDt6XBb42Bb/StgdQGwA7JH3MkOM0D/JAmy7IA7fxdkpxnuPCckhwsuaQNQmBjyvI42SIQp0Tmn7Ea23YRsmwkN9Z5ypFO2Qrhkl1hG6/yUvhFFDpvfcaH5FpcDMZrT9bp+IjJ9Exaf2kPBd7SPSxPzyxKHTMVgn2OGYRiGYUJDaWtx/nfaabphU08k7VReATIKTrc4EqKPBt4+kBHLtm1bxd+NGjUq8RIpKalIS0vDk08+hREjLhciacmSxZ5aqgCoTQO5TU+e/DSGDDkff/zxh5hPkbNp0zw1+ldccaUQeJQqGiloX1588QVRo0fuoaXRuHEj74CV0kjpbxKoTBUhOSGrPDVkkF2AS/nbXbyCA5B1kC0OqIxUj6cDJE9dnqSN8fzTGD2i0GkGVHrAXnxDQghCe9DzOhoR6ZrF0TmNpEKM2uMW74Ys/hGUaknLCBJ58Vr/yDtF6IzFzwsmIjNshbC6nbC6nNhXlCnmK+KQiSws9BiGYRiGCQmJFEpbU8Sekp5J0bfevfvA5Zbx+/qdp9en9XT+A7/ly5eLGjqqvzvvvEElXoNq6Siqp/TETU9PF+sGu7uv1Mb9/vtMvP32O/j004/F/F27dgqROGrUtSIqePz4ce9zqJ2SzWav8KdM6ZokLEmsvfrqa94oYiio5pBSOAlyEaXUT0pfZSKLZIiBpm0PQBsLya0H1GpICY0haWIAieruiiNKcgxUmrOgbpAM3YARUMUnQa3pA8mQCnWTNlCnDRT/JKo506dCndQFkr74HBaCUBf0vI5GSMSRUCPo+9chviFaxSaL+fSP/m4fn3b6RoY+Fte2ONP7HCUNM9h3VxGRGkkNg8qTVEhij6KDocQhUzk4dbOeQj+4q1evxqhRo2p6VxiGYZhaDtUmUdqaiGiQU2HxIO6GG8aIlMtvVmxC9xYNMfDMHh5R6DPII7O0F17w1KeRA6fRaCyxfeq7N2LECFxxxQhhlrJ9+zZMnvxs0H35/PPPsHXrFrjdshB3FL0jLrjgAjz44ANYtWoVjh5N9xNWFN07ePAA7rzzDnTp0gW33nqbqOF7++13RZ0fQc+dPHkyUlM9qWS+/PjjD6J+kETqQw95euBR3R+9/2BQdHL8+HFISUnG9u3b8eKLL5VYh4Rt4D4w5YPOM+PgayEZ4+DObwS3ZjfUjdIAqQtcJw7CLedBtjqhNp4HTWJbb52duvhclrV6SC4LQMKQcJrhsmbBcWgG0FgDd0aWp0YvPqnEeR2tCKfc5j296ZstY5Nxf8fzvUKO5ik1eb61dZR2SRE5EmuhjpMiIum5JBapTo/SN9P0cSHFIRMFffRqA3XJdZOa0C5YsEB8IS6++GIkJSWVexvkCPb888+LR4ZhGIapaKTrscceEb9JFOW66KKLRfsEEm65uTkirZJ641GkrkOHDvjmm+9ELV1pDcUzMjLQqVPHoIKL2LJlMzIzM6HRaNG6dSvhbqlw/PgxHD58GB06dER+fp4QUC1btvL+du7YsV0IzW7dumPFiuUYMuQCqFQq4cj5xBOP4/vvp0OjKXkP/PDhQ6IllC8U0TzjjM4l1qXtfvvtt6K+kBw4qZaQUk0JajNBgpMioeQe6rsPTMURQ9kA4SbmWXIgG5Kgctr9blCEtT2nGbLaCMlhK9dzowU6BqGEW2nLysLPoVNrxCVNu6JdXGq9O77VBQu9Oib0KP2FWkf06dNH7CtZNf/777/iB7Q8sNBjGIZhIgG1OKAbh7NmzQy5DpmhfPDBh0hJSamVB/3ECUrzlLyCrDIoQu/TTz+LyL4xTLRRGaHIlA8WelUk9NymAjgPb4e7KB+quARoWnWFKrby292yZQuaN28uiruJMWPGoH379kFbS9Bdzf/++0/0FSSB2LlzZ5x11lklhB7dGf3+++/Fl43STS655BLv9pVtUHE7rduuXTucd9553tew2+3iTi71L6Rt02spUGooPZfuWvbo0UOk1TAMwzDRCblkUoojmajQbypFzvr06SsaoJ9zzsB6E7Wi2jyqMaTfTYZhmJqkflx1qxnn4Z2wLPgajp1r4ErfJR5pmuZXFhJMiggjyFGsadOmQdelZrIPPPAAbrjhBtGcnprQf/yxp2jdFxJrVENBqSuzZ88WP06UOqNs48EHH8RNN90kIofXX389vvnmG7GMnMfOOeccMU0W1ldeeSU+//xzsWzq1Km48cYbsXXrVrFtpSidYRiGiU6o9u2FF17EsmUrsGnTFqxatQYffjgF5557Xr0ReQRFLVnkMQxTG2AzlghDkTzbhkU+lr7FyG4xX5XaLCKRPYKicEeOHMHYsWNDrkNCcMmSJaIonRq8DhkyBHfffXeJOgMShBT1o/oB2ua8efO826UQ++LFi0UPpF9++UW87i233IIpU6aI+sCBAweK9aju4oMPPsAdd9whUkpvv/12PPnkk/XqB55hGIZhGIZhagM8Ao8wlK5ZQuQpyG7P8ggwffp0vP322yJtMpiDmULXrl29zmPdunUTwo9SanwhEdevXz+xrQMHDohUy6ysLO9ySvlUGt02btxYiEEl2keF+BSxo38OhwNXX321WEbCce7cueLOJs3bvHlzRN43wzAMwzAMwzBlwxG9CEM1eaUhm/xFVkX48ssv8eGHH2LRokVITU0tdV1yCXM6ncJFjOrtyBUtsAbx999/F5bSlKJJDB8+PGiT2kBatfI4mb333nsllp1xxhki1ZNSNr/77jvcfPPNor6QYRiGYRiGYZiqh4VehCHjFVcpy6VKpm3OnDlTpF4+/vjjQkApkbphw4YFXZ/q76g30bnnnosZM2bgoYceClr398Ybb4hGsJs2bcKGDRswdOjQMvfl3nvvFe6f1113nWh2S2KS3D8vu+wyUeu3f/9+EfFbtmyZMHFhGIZhGIZhGKZ6YKEX6QPaqiscu9YFT9+UVGJ5ZaA6uHvuuUcYodA/ojQ76N69e4toHUX/nn32WWGmQpBzp9Isndo1UHonOaaROxoZr8TFxYllrVu39qZjKvV8yvMaNmwo6v4ojZREHUUOExMTxTIyc6F0TuphRMKP3EEZhmEYhmGY6IUywswuu2iOzq0Tah5ur1AF7RXIXbOEIYukgr7PhdC0KtlctaqYP3++SKukR4ZhGIZhGIapKo6acvFT+kYUOWxI1sfi6uY90SzGEwBgagaO6FXFQW3VWbhrkvEK1eRRumak+uiVh8BoHMMwDMMwDMNUhch7fPMs5NrNMKg1aB+Xht+PbsbEDoM4sleDsNCrIkjU6bqcjZqEDFHoH8MwDMMwDMNUVbrmz+kbhcgjrC4n9hVlIk6jh8XlQIzG49zOVD/cXoFhGIZhGIZhmApBNXmFDhsMqtPxIxJ7cVo9jGotH9UahIUewzAMwzAMwzAVgoxXqCavfXyaV+wl6WJwXYvenLZZw3DqJsMwDMMwDMMwFYLcNcl4hWryKF0zXmvAtS3ORPPYJD6iNQy7blaB6ybDMAzDMAzD1LdaParJo3RNbq1QO+DUzXosbKlvHsMwDMMwDMNUFhJ3ZLzCIq/2wEKvjnL8+HHs2rVLNCmvCBs3bhSN1xmGYRiGYRiGiT64Rq8ORuJuv/12rFu3DlqtFg6HA3PmzEH37t1retcYhmEYhmEYhqklcESvisizW/DPqb34PX2zeKTpSJCRkYHx48fj8OHD2LdvH6644gpMmTIl6LpUb0hRP5fLJR6LioqCrmc2m7F69WqsWbMGBw4cEDnWgdtwu93iMS8vr8TzMzMzsW3bNlitVr/59Hr//fef2PbBgwcr/d4ZhmEYhmEYhgkPjuhVAVvyjuGPo1sh47RgWpG5H1c0744eic0qte327dujTZs2Qjzl5uZi7dq1eOSRR4Kuu2rVKjz++ONCuJFQO3bsGH755RcMHTrUbz2a/+CDD4q/T506hebNm+Ovv/6CXq8X23jiiSegVqtF9PDIkSOYPXs2zjvvPLHN2267DUuWLEFycrIQoT/88AMGDRqExYsX47rrrkPLli2h0+kwcuRITJo0qVLvnWEYhmEYhmGY8GChF2Eochco8giapvktY5KRqDNW6jUsFosQZidPnhRCioRVKPbu3YutW7eiXbt2mDlzJiZOnCgic7506NABK1asENE8Eo9PPvkk/vjjD1x77bViOYk72kazZs3w8ccf46OPPhJCb+rUqcjKysJPP/0k1qOIIAlLEoc076WXXsLdd99dqffKMAzDMAzDMEz5YaEXYTblHi0h8hRoPi0/v1GHSr1GXFyciOgRFCW79957RaQuGH379hUij7jqqqswZsyYEimcu3fvxsUXXyyidqmpqTh69CjS09O9y/v06SNEHkG1gIqw+/fff4VoVKKBBD2foAjeTTfdhN9++w3Dhg3DnXfeiaQk7qfCMAzDMEztQZSrOE2AJpbdIpmog2v0Ikyu3Vzq8jxH6cvLwmaz+U2fc845QpiFgurnfI1cKN3SaPSPKH766ae49dZbsX//fhGVu+CCC8R6CiQAfVFq+Kjf4KhRo4ToVP6RMQxx0UUX4dChQ3jooYewc+dOIfwYhmGYugdd82Wr2a9+uyLrMEyVnJuOIm+Jirsww2/8Utb56So6Auu2N2DZ/Lx4pOmyXieaofdnctpKvE+aLnJYxb9oPwbRBkf0IkySLqbU5Yna0peXxbfffovt27dj+PDhIs3y+eefx9ixY0OuT+mYVGNHUTVKuSTBFSjcqL7un3/+EbV2mzZtElG4nj17lrkv5P5JKZyNGjVC//79odFokJKSIlJB9+zZg5ycHCQmJoqaQhJ7DMMwTN3ClXMStnXzIRflQYpLhL7fJVAnNy7XOjQwNLvsiFFzfy0mgudm0RHYD06H25oJt7UQrpNHAbsJKkNDGM6aBG2jziJK5849FfT8JEFo2zcVsqNARPJkW5bYnr7rJMBmAdRuSNo4uE3pYj4tl/Sp0LUZA3Vcy6j7KI+Z8/D70c0iYEFj2aub90SzmEQxf9rBNViffRiQgD7JLXFrmwFimS/Bvudlfff52lD1sNCLML2SmgvjlWDpmxIksbwyjBs3Dp9//jneffddGAwGPPbYYyIaF4ohQ4agcePGePPNN9GlSxdRN6dE42iaoKgbGam88sorIk2TxGPTpk3FMhJqnTt39m7P93mUxkni8L333hPikHr6UTTw1VdfxZdffomlS5eKFhAdO3bE9OnTK/W+GYZhmOqFBmHKAFlMF+WJaeNFY/0GcqWtE2rwyDCVPTeFyCs6AGfeDrgytwFOF2BtDHfRKZiW3gJtx+FQG9LgTtcBFrXf+akfOAT2/V/DcXQ2JI0R6oTOkLQN4Mo/DPO8N+AqWAlonVC36A1J44Yke3oWK2LQ0O3xqErzpOOpfE8JeqTpe9qfh9/TNwmRZ3V7jsGGnCNooDHg3o6Dvccg2PecKO27z9eG6kGSOQbrTWtMSEgQ7QRIzETadZNEXiRcN8vD/PnzhQijR4ZhGIYpD5TqZp77WYn5MSMmQNIby1wHOgOm7F3mV9JAA76JHQZF1SCZqX4ojdK86Tm4stfCbS+EO3uPcEKAM06MuKCSoet8LSSVFs6D+6HWDvW7OaFuXwS3Mw/OzLWQnUWQNLFQp/aH6/ARyDYzIFloK5A1akhxFmjSBvids8aeL0DSxkbNR0/pmu/sWuw3j47T2DZn4Yv9/2JD7mnfBqJvcks80eUixGh0Yr0S33OtUYyA8xyWoN/9oM/ha0OVwBG9KoDEHLlrkvEK1eRRuiZF8irrtlleAqNxDMMwDBM2eqNIdVOidQRNk4ALZx1K2QqsW6dpi8shBogMU2HIOEXbALLTUmw3IQmdB8nlWS7rAEkDaDQiMgfY6WT1nJ+xRridRwFHIeC2QbZmQkYmVMaOcJGe0R0mcwJI+hjIBSZItiI4TVugbtIeKkOsSN+EpnJlOLUNSq0koaV8XwsdVhyz5OPrA6txoChLBCuU4IVBrUGaLhZu2e1NvQz8nmfYCsVnolWpS3z3jWotMm1FyLGZ/MQzXxuqBjZjqSJI1JG75lXNe4rH6hZ5xIABA0SKJ8MwDMOUFxqEUT2TEG7FAk5M+wzOSltHGTz6QtM00GPzFqYy0Pmla3erEF2SSgVoUwE5lkJwgBwDKaYdJK1WCBRNyz6Q4hqePj/7XwlJlwpX/k5AdkNlbAxVbEu4svIBdwIktx5wOSHnk5mdBEndFnDq4Tp5EJI+RdToRVtEmt4PpVbS95O+myTymhkToFKpRLoliTuDSiMeO8U3QoHTiv/tXIQpe5Yi1+ZJzfSloT4eaXqKrp6G1iFxR5G8T/Yux+7CDCEoA68NTGTh1M0qSN1kGIZhmGhBVHjYrSJK5zvAVcSaWaP2mC04bCXWCVaH08hiQe66eTCa8qGKSwpq8MIw4eAqOgz7/mlwFRyHKyMLkqMtpLg0qBrmQVLZvOYpqtgWfuewM28nzKsnQHaaIWlioIptD1f6QUjuQXBl7oGs3gm4CqBKaQuNcSAg0Y0MO2JG3AeVIbqieb7QdzrLVoSP9y4v8V2/u/15Qoi9v+cfUadHNXsk/vqmtMItrftj5rEtpdboXdWsh3cd36hhp/iGSNbHcv1uFcFCrxgWegzDMAwTHuS0eXDNbMy2ZCJXp0Vq884Y2aoPmiU2LhHtoEGikrJFwu/nJVM9gz+oMELWo1lcip/BC8OUvw+eGbLa6BFzKpcntdNlESmWodwerdteh9tyElBRFBBwHToICeeBVnc7HXBl7IemyRlQqSRvNLA+nKel1c9RLd8tq77xGrMQJPa+PXusSMdWvue+9ZDKPErxDFYHeE+HQUjRcw/DqoJTNxmGYRiGCRsxSF47zyPy4IZsKULGln/w0+KpMC/4WohAX0QaZ3FN3szDG5BjN0N2u5EDN+ZINriLcj0DdIapAHR+kTGKbD4K294PYN3yAmzb/we3LdtPcPj2wROpn21uhMrYRESlXelHAFs7uE8eEGYsmqSGiBsxEeoGSZ714xKh63uxaLsQ7R6G3jROrREOt1M80rRX4AbqXMn/ex6Y2q3MC5bKTZE8FnlVC5uxMAzDMAwTPjYLTKY85EpuYc/gNhWImqZcOGE25UEKaMGgQHf0s025wrhFpjRPtQY5sQ1gjW+MWF+DF4apYLsFan8Q2AYhVB88+kc98ywLP4fKbYZklCAbZEjGOBguvEXUp2nadBc3IVxFebCvX1BqP8loo1gS+zULi9XoRR89kbrpcoqaPZoOx1xJEZCBqdzRHiGtaVjoMQzDMAwTPnojYmMTkWS2IIdSuFxOIdqSoIEBMoqKcmGwWSAF1DIZVVo0OJWOHGMsZLdLPC/BVISEIf4GLwxTbpwmIeREtE12AJIWoGmHKaQAFJFAiiSbLN7zTzxaTZ56U3KUpVYAOoNX5IXqJxlNKD31qDUCuWbSI00rrRGoWTr10SPnTDJcGdmiV9jHgYxdaDuBKZ5M1cGpm/WUf/75B+eff35N7wbDMAxTx6DBmaH/cFxuTEOSpIak1SMlJgH9ocEXkhUf6p346PBaUY/n9zy7FSNsMpLVeqgapCAloRGuiGsKTbwnPY5hKowmFrKkEX31nBn/ikeapriUIvIUxLTT7NcexO88DWwhQumaPu1DxDZoOkrTjakOL8Na6JeiqrQ+UMQaNUunPnr06NsEPRyCpXgyVQdH9Ooo9AW88MILsXr1ahQVFdX07jAMwzD1CEpba3fJeDxos6CoIAuqDX/hc8tJYcyibtwGuQFRAIHeKIxX7ijKBXU/M1Jf67gk/0E1w1QKyf+RTFn0qX5iT0yTcYujSCynNEyK0PmmZfqJkHD6SUYJwiU3fRO25R0Xh7B9XBritYYSrQ98627Li9J7Tzj1stircljoVRFuWy6cWWshUzGwPgWa1P5Q6SN31/Kjjz5Cu3bthNBjGIZhmOpGpL4ZYtDA0BJFw8agcMciaFRqT7qbLIuogNlpR6xW79dzjwbVMaEG1QxTEZwmSLIT6tR+ZJkpnDRpmpw3qSbPt0ZP02iwMGvxTKdA13SkqMkL1h4k8LwNKQajKGWTbtK0j0/DvsJM7CvKxJCGHSNWSxes3Up5I4JM+eDUzSrAmb0B1m2vwXliEVw5G8WjmM7eEJHtHzhwAL/88gsmTZpU6nrz58/H4MGDMXr0aCQmJuLss8/Gvn37Sqy3adMmzw+2JKFhw4Z49NFHS2zj5ptvFtvo06ePeH2Fjz/+WAjOuLg4DBs2DAcPHhTz9+7dKxq26/V6sd277rorIu+dYRiGqX2QSUOysYG43lN/rE15R0VUYOqBVX4pnBQJpNqmmBETxGO0G1ow1URx5I4apEsqT6N0mqb2CmS6QjV5xp4vCPMV56mlQuS5rSbYdy9F0cJHYFk4DW5TfkgxUx/OW4qyKS0VKIrXK6k5uiU0xe1tz46IGPMKyeLXoEeajnYX05qGhV4VRPLsh34EZLf/Atkt5tPyyiCaVt59Nz788EOo1eoy11++fDmuv/56HD16FBdffDHGjRtXYp1evXp5rIdlGVu3bsXGjRuxcOFC73KKGt544404fvy4qOt7/fXXvSJw7ty5WLZsGbKysnD11Vfj3nvvFcvef/99XHLJJSgs9OR5f/LJJ5V63wzDMEztRXHUS9QaRRSArPooKqCkcPoO5sSNxWKjC4aJ1PlHkTsh7orTM8W0j8kKtWCQXGaPaQtkuE4eBOw2QDZBLsrwROxKER3Rft4Gtj8QN/8N8RVO0SxNSAar/WOqBhZ6EYbSNUuIPAXZ7VleCT744AMhtrp27RrW+n379hUCjCJukydPxpo1a2Cz2fzWycvLwzXXXIPk5GQ0btwYS5Yswc6dO73LKRJIoi0mJgZXXHEF9u/fL+b/8ccfQug1b94cRqNRiLzNmzeLZd27d8eMGTPw0ksvYenSpZV6zwzDMEzth+7639Z2gIgCUDSAogIED+aY6sA3ckePNB0q8gen0yPyhF1LjBB47sL63c/R2z+vWOxFuv1BsD56gbV/TORhoRdhqCav1OX2nEpt//fff8dTTz0lvnht2rSByWQSf5886d+gViGcL+g777yD2NhY7N69G263W0QMHY7Td1gMhtMFxxRFdLlcnvciyyK6p0QD6R9FDokJEybg22+/Fa//4IMP4vbbb6/U+2YYhmHqRgpnQ30cnLLLGx3hwRxTXXgjdyHGPkrkTxXbGNDpIUMFCVa47PPhkpbBZT9Vrz8spf3BI2cMFY+RrJ+raiHJBIeFXoShwt5Sl+uSK90WQRFVVA9HAo3+pkhcMNatW4eZM2cKZ86XX34ZZ511lqib88VisQgxR1E/StP88ccfw9oXiu5RhPHff/+Fk+6OBdC/f388//zzeO6559g0hmEYph5w3JKPfKcV2/JPYFPuUaglFQ/mmFoY+XsCMedNgaRPgiybIauOQ9YchHn1XXAVHQ76PBprucxFcJlOiJvi0UpVtj+oSiHJBIeFXoQhd01IIQ6rpPIsr0bOO+88/PDDD2jWrBkWLFiAL7/8ssQ69913nzBkSUtLwxNPPCHaNoTD8OHD8eKLL+K2224TQpEuCqNGjRLLrrrqKo9TlV6Pp59+Gu+9917E3xvDMAxTe1DMFtyyjF6JzdEtsSniNXo0NSbU9K4xjB80PtEkN4K6ZUtISSqo4htAUms8DdX3TytRq+fKOQnTnGdQ8FtfFMw6B4ULhsKRsYqPagXgPnrViySz3Y2goKAACQkJyM/PR4MGDSp1UMlds4Qhi6SCrvX10KT0QXVBZikksOiRYRiGYaoKGkpk2orwyd7lJSIBdPc+UoYODBPJc9ay+UU4js72zpPIpTO1H2J6vihSQJX1TPOnwpH9P2HcIlBroE7rhLihf0Kl4pgJE0V99OiE/++//4TTolKP1aJFCwwaNAhnnnlmVexjnYPEnCquraePnj1HpGtGuo8ewzAMw9QGlN5YOTYTdhdmoJkxwWvEwvV5TG1F1Ou1uxXOzFWennqaGKgSzoBKnybaMnixWSAXHT0t8giXE7I1E6BG7MaGNbL/DBPRiB4ZcHz++ed49913sWfPHrRs2RKNGjUSy06dOoUjR47gjDPOEMYb48ePD8v6P1ojegzDMAxTH6AhxJS9y7y26dRD75glH53iGyJZH8sNkZlaD9XkUbqm25EvRB6Ztfg6dnJEj6kXQo/s8sms44477sCIESNEY21fSOzNmTMHX3zxhXCC3LJlC+q70CNxTCF9dhRiGIZhohGT04Z3di32m0fDins6DEKKPrT7IcPUJsRQ2GkWkbxg5yzV6FlWfghH/i+AygZVUmvE9HkV2oZn18j+MkzEhd68efOE+Uak140moUfOlnPmzMZvv/2Kw4cPC8Gr0WiQlJQket9df/1onHFG54jvO8MwDMPUhoiekq5Jjnos8phoQbidO4rgdkqQYIJkSOPaPKZOwGYsERB6OTk5mDLlQ8ye/QfM5tM/dsHo2bMX7rxzAgYPHlzxT41hGIZhalmNHok9pTcW26Yz0YKr6AjsB6d76vj0qSVSOxkmaoVebm6u6M22fPlycbeDrPyfeeYZEcGqL0KPetndffcErzENNTGnyN25554ntmOz2XDo0EH8+uuv+OuvRd5+cw8++BDGjRvPdzwZhmGY6HAwdDlgVGv5d42JqvPauu0NIfIUSOwZuj3O5zkT/ULvsssuQ0xMjOijRkydOlU036Zavfog9I4dO4Ybb7wBWVlZaN68hWgOftZZA0J++bOyMvHJJ5/ghx9miOkHHngQd9xxZ0TfB8MwDMMwTP2rsTMBmsjWhVK6pmXz8yXmG3u+4G2/wDBRI/Q+++wzYcaifIni4+NFJIsEEpGXlyfcOEk0RbvQczjsuPbaUdi3bx86dOiIL774EikpKWG91tSpX+Htt98Sf//f/32IIUMuQH2BUluffPJJ0aCdevxRDeOzzz4r6hkXLlxY07vHMAzDVCPC0dBpE3/HavQcJWFqVWolR/SYuk65ujzOnTsXQ4YMEe0VCErVnDBhgjBfoX933XWXmBdpSAQsXrxYpD+uW7cupMMlpZD+8ssv2L17N6qaRYv+EiIvOTkZH3/8Sdgij7jtttsxZswY8fenn35artel93buueeKfxdffDGeeuopIU4jCR1LMo+pCuhmQXp6Ol566SW0bdsWDz30EM4++2y88MIL2LFjhzifyoLad1T2M6YoNH1+DMMwTM3V9r26YwFuWf0Nbln1DV7bsVDMY5hwcbvdsO+fCrctU0yT2BOir4wYhmKuUtZ6otdemzFCQIrpYiHJRkNMVDZMnzVrFn766SdcdNFFIrL31Vdf4Y033hB1eQSJjylTpkR0B0ngXXvttWjdurX4t2rVKjRt2lREf0hkKbWCJHpOnjyJrl27YsWKFUIwvPWWJ2pWFfz4oyf9cvToG9C4ceNyP/+uu+7Bzz//jG3btmLr1q2ifUU4FBYWCqH922+/CQH82muvic+CPpdIQRc+OoZVwc6dO3HVVVdh0KBB3mnad/os6b1NnDixzG3cd999aNasWaX247///hMuqQzDMEz1Q78zv6VvwoacI7C6PLXr67MPo4FGj4kdB/NAmgkrkmfbNxWOo7NPNzvXNvDU01GrhBCpleWNANIyqskrrf0CE/p7bnbZEaPW8XGrCxE94rrrrhOD5AMHDghxdcMNN2D9+vXiH6XilSeyFQ6PPvqoEJYbNmwQET0SBtSc/cMPP/Su8/TTT4vUy+3bt4vI4oIFC/DOO+9g0aJFqApIaNH+UFP4UaOurdA2SNhcfPElfqIxXHQ6nTeiR0JvyZIlYj5F92j+sGHDRKQsM9Nzh4sg4Tt79myMGzcODz/8sLf3ITW4p+3cfffd4rgqx5yiekrkkP6m6BdF0qhtxosvvgir1Rpy/6hOkyJ2l156KW688UasXbtWzH/33Xcxc+ZMvPLKK95tZ2RkiFpP+pu27XujgLZDZj+0HVpO9Y3E//3f/4n6yNJei7jlllvEuXDrrbfiyiuvFDcNCNoOvR+K6tF2KZLIMAzDVB80+Mu0FXlFHmF1O5FhKxKmLgxTloAQYs1RAEljhOw0w52/CzJkT/RNE1P684rNVcKNAJK4o5o8FnnhQ9F5ar1CfTbpkaP1dSCip0Cuml9++aUQGDSYvuSSS8TgPTY28oWpDocDLVq08E5THV1iYqLXvZK+nDNmzBAih2oGiXPOOQf9+/fH999/jwsvvDDi+7RkiUcwDB58fonG8eWBIpXUd08RIBWBat3S0tLE3zfffLMQPHTMSPDeeeed+P3338WyzZs3Y82aNXjuuefQoUMHIdRIWJF4u+KKK4Rwpelt27YJAURC+vXXX/fW1Slputdcc40Q0fv378e0adOC7hOJ/x49euCRRx4RNZz0PikSS2KLxHffvn2FeCdGjBgh9ikuLk4ILooS+x4f4t577xV1k8p5QO+Zon+lvRZFfTdu3CgE3RNPPIETJ06IZZQ2Su/z7bffxgMPPID27dv7nV8MwzBM1UN3+NP0cTCoNV6xZ1Bp0FAfJ5w7GaZUnCZPRE6SoE7oDFf+TiH2VNqE0lMri5/nS1kRQKb80NhcablC0CNNc3/NWi70KGr25ptvetP6aPC/bNkyMfDv2bOniLREulH6+++/L1IT9Xo9WrVqJYRCo0aNcP/994vlNHAnE5hu3br5PY9SIWmgHwpqe0D/fN+bku9N/8rqm0e0adO6zHVLo1Wr1t7XttvtwpikLOj1KFJHkShK3aTIKrmd0nwSeCSUDh06JIQciRzf/aMUWxJbBDmjUlP36dOne5eTeKPndu7c2SuYCRKLHTt2FKYpRK9evUQbiS+++EKIRxJSimgj4U8ik5xIFQFL+7ly5UohEkmUkrhStk3vmUQ5iXeVyhNgpn0+fvy4qLkkgWYwGPzev+86pb0WQTcglJ6FSiSPzhW6KUECkd6L73YZhmGY6knRuqpZDxQ4LNiQkw6Kp/RJboErm/Xw1E9V3BCcqQfIKiOgS/GINE08VMn9IGkToO36FCSVKuRvut/ziqEIoFtlgMTjgIhBBks5NpPfPJo2OWyI0egi90JRiqp4PFztQo8G8SQmKM2PoIgO/U0plRRZoejQd999JyJpkYJqscjJk9IOybyDxNvll18uIkCEYkQS2LuPUiNLMymhlEcyAAkkI+MELJbSa7fy8jxCj47FqVPHUVEo7VAhPf2QaFVRFjk5mSJy+eijD8NoNKJt2zbiWBw/ni6il3feeQcuueQisW933nmXd//IJVSv13qnDx7cj/bt24nt+CLLTu86ymN6+mEkJDTwTlMqJ/07fPgAUlISvdto2DANe/bs9O6fL/Ra9Hyr1YyCgjzvtuhiTMfcZjMjJydL7Cct27dvt4ji5efnIPBjpHXoOJjNhaW+ltNJ6T8u72upVJI4TmlpyeL4ZGdnVurzYxiGYYCTtkLMz96LPIcViVoDLknpgMZ6T4ZNWQOQ25K7YXRCJzEtevAVmnGq0BMFYJhSibsA6qKZgCMH0CbDlXoJkHmy/M9LuQDIOMEHO4LQjRqt3SmuCQp0bSjIykQh1ziWSZMmzVEjQo+iJlTHRdEXgtLvSIQRFNFbvXq1qNOLFCQCKBWRas4Ud0pK2aMoDNWpUfodiR0i0FiD1lOWBYMs/pVaNSWqRil8DRs2KbO9QlpaI/FINxwbNWpa4fdHNXIE1fq1bt0urLugycnHRYTriiuu8pufnZ0tonhPPPGkeN90vGh7yv5ptTokJ6d6p4cNuwjPP/8iOnXqjE6dPD+yvl9QirQlJCSL1xo8eAheffV1SJJGpKr+8MMPQnS3bdtBrN+pUxfvcyky6XkfKpESGojBEIMGDRK9+0F3LeiY0zmVnHxE7CctS0xMERHXrVt3iM/fF897SRMRudJeS6PRIiWlYcAxSBPTlAJM+1KZz49hGKa+Q78Xv+zbB4dOg1hdHOj22grbKdzToiPXMzFVTFPIrfoCLjOgLo9JSkWfx5SHmxrEYuaxLSJtM0kXIyL4jWM8+oGpPsol9CjFjmqhyNyCoJTBs846y7ucBAstjxRkuEGpiSNHjvTOowgOCcylS5eKaRJnWq1WpCH6QtMkRkJBqaD0LxASHmWFTBVxS8JWFOhW8CKxZs1q8di8eXNx7MJB2bfAfaSUyKFDh4r6OzLEoW0Gruf73sidlIxOqLUBHSeKJpLYUprdU3SQxDulydKxpno/Sumk9FlKmfzxxx+DHicShpQOStFfMslRIq3U9oLcSelYBR5jZdr3vZFY/frrr4XBCtXb0ed+0003iRYeyjplvVbge/adJgOa66+/Xrx3avnQpctpscowDMOEn6KV57D4/Q7StE12iTROhqly1GVHj4Mhq+KqpMk646FFXDLu7ThYmCuJaD0f49rfMJ3aF0yePNlbo0d1YlQDRWKgKqDoEKUlkimIb/SNrPlJzChGI1QXSNE/clgkqIaNxBjV95FAiXTDdFr3ggvOFxG0b775Fr1796nQ+xs9+nrRXuHBBx/C+PF3hPUcilyS82i/fv1KLKOPkgxN6JiRAKb6ORJyxJYtW0RdnWJY47s9chElwxUSzIpwp+NJLqZ0POhzJsghk2rmqF6vtGip8tnRdql+kqD9JWG9d+9eISgVAxnaRzJnIaFLUdiDBw+KSJ1veiv1zKP9pPdEQpOMZdq1a+dN3w31WuQOS9FKJSWWjgEJO+V5VK9HUVV6vcDjwjAMw5QN/e6Qo55iukDQ3Xs2XWDqa5N1hqmzQq8moDo66tVH5is0SKf+eRR1IhMYijAqA/iBAwcKMxASNmRIQqKFTDkoxTPSQo947rln8euvv2D48Evx5pvl79dH7pajR18n9vPvv5d4ewIyDMMwTF2CbNMVhz0SeVc374lmnKLF1FJo2Gvd9kYJQxbqlcdRJybaCNvWhWq+lJYGpUHrKPV0kYCs9+fOnSv+XrdunajPo+iNIvIIisiQ5T5FrCjaQ6mllG4YrsirCKNHjxaP8+fPw8KFnkhiuFB06tlnPU3mL7roYhZ5DMMwTJ2FRB1F8B45Y6h4ZJHH1GpKa7HAMPU1okfpkZRCRw23yfWSaryUujJyYCSB9ccff4i6KqrlItv7ukR5I3rEq6++gunTvxeC8o03/ocLL/T0hiuN3Nxc3Hffvdi06T+kpqZixowf0KQJG4IwDMMwDMNUNRzRY+oT5UrdJPFGffSoUTrVQJFQoadTHzOqkyIzEDJjiXQvvdoq9EjgPvroI1i0aKEI948YcbloM9G9u+IGeZr8/DzMnDkT3333rahzo9f44ouv2ASEYRiGYRimGuEaPaa+UKEaPTKw+Pfff0WzchI05PBINXJkvV9XqYjQU8Te66+/hhkzTjceJwfHgQPPFQYfJICpCTmJQaVBO7lIfvzxJ2jXrn2VvBeGYRiGiZbG6gxT2vkUyjlTNE23ZgCGhkFdwj3PNUNWGyHZrYDe6N1GsO2KeTaL33r1kXC/w6Wtx9eB6qPWm7HUdqGnsHXrFtFfbt68P4W4C0bHjp1ExO+yy0aE1RydYRiGYWo74Q7ajppyMfPwBuS47EjWx7JpC1NlUTlHxipYNr/gXWbs+Ry0Dc8uuY2ck7Ctmw+5KA9SXCL0/S4BdPYS24VdV2I9dbKnjVN9IlzjpdLWY/Om6oWFXoSEngJZ/M+ZMxtHjhxGQUGhSHGldgLnnz9EGMnU57tADMMwTHQR7qDNkXUc76yagSKHGZLOAHXjNkiJT8U9LftBMnDTaiZydXa0rOjvS0ssixv6p19kj9azLJwmxJuX2ASomp2EbMv2eW4K3McaA6b80/PiEmG8aGy9GtOF20qltPUIbsdSixumM2VDou6mm27mQ8UwDMNENTSgU0QeQY80HTjwo0je96tnYImzAHoA7ewWxKXvRobmILK3/YfYuKR6GyFhqsA501EYfBn9M/qUGNks/iKP1ivKgNt8CpL69PDYbToJuUgFSdL7rJcHFKd71hcoau8r3giapoboMRpdWOvJkMPaBlMD7RUYhmEYhmHCGdD5ikFK1yyyW6CXAasE7IELzvwsJNpsMBYPmkVaHFeSMOFCtXP6VL9ZYloTI2ryxN+y23+Z3mMgKDuKPOca1drF+UefpbiGkIyNIDsdnnVddsCQBMSmBayXCOgMUf950TEwOW3ikVKzKTKnzHe4nUjSGmFQabzrEL7rKdC0Ua0tdRlTNXBEj2EYhmGYcqMM2gJTtHwHbSQGs025Qsw1kp3YFKOHTa2BQavGcOgAWYLsckIurH8REqbiUMSYaucCa+lovjv3FFTWvnDk/wKobFAltRY1erL5KGwB61Mk2bf2TtuhN+y7FsGZtw1uHAS0TqhiGkGdeBYgtwEsam+NXrSnbQZLy6Z/0w6uwfqcw4AEdIx34fWdi+CS3X6p2/QY+FzleJW2jIk8XKMX4Ro9hmEYhqkvlFWjR86H7//5HrIt+djiNMMKGVpJjV76OKQ4XLgt/Rgkuw1SXAJixzwFTUqTGn0/TN3CzznTRY8xxXV3GXC7NZAkM6S4Zoi5+FbYtv8vaE2fwG6FrNXDuugbuAtz4bD9Bdm1HVAD6oRUSBojNE2Hw9DxQUj1wHUzVJ3dPe3PE/MzbUVQQ8Lm/GOADPRKai6OiW/NnqiBdDnEjZ9grpuhljE1FNGj2rPyGJIwDMMwDBPdkKijgV3goM1rRS/LGGGT8ZtaB5sGMMoy2kIDbZMOyNmzHmaHHZLegLjkRrCvXwB1PTO4YCoHnSsuW7Y3sie73HDkbAZkJyDFQ63p7jFRMWd7lpMqcTsgSxpIluOQHSaodHGeSLLVLCJ7bitFoA8BmkJAUkGO9dz8l61UuyfXi/MzVFp2tt2EPIcFWpUadpcTZqcdKkhwym5xA4fWMTlsMLsdSNXFhqy7o2PINXm1TOh9/fXX3r+3bt2K1157Dbfffjv69esn5q1btw5fffUVnnzyyarZU4ZhGIZhaiVGpxMoTtn0tawnF8OmKh3ucUuU6YVCuIXrpsoQA01sIn5on4A8lYRkqDCiKBvtOX2TKQd0Q8Er8mQZzoyVcFvTAVssoC2EW7cNqphecLmvgiyp4Tq1Am5HIeDMh2RoBNvu/4OuzY2etgwUqYtNhOvQNkCnA8iQRXJBNhdCSm4OydBYRA7hKAraty+aMKq0iNPoUOiwed8nRetSdLHi8YgpB3sLMpBlM0EjqWB1OYT4I+F357oZQgzSeg93ugB9UjwtLwLhXnq1OHVz8ODBePDBB3H11Vf7zf/999/x/vvv459//kFdg1M3GYZhGKZ8BPYh0/W9WETmfN0MZZUaKmM8jpmyMUcvoaBxSyTHpyJnzzq4HDbvejQwfODSB4M2t2aYYJCximXz8+Jvt9sGx745kJ12wE4RPTugdkBKaAOVPhXuQkC27wOQBahUkHTJ0DYbDnV8W5HCSYLGeeIgiqa/Crf9FGDYAcTmAyo1dB2vhv6MW+A8tTRo375oTMcmMXfMko9mxgS0jE32pmWTi+7jm2eJ6J0idfUqDYY07IB/Mvf5mTHRd/rbAbeU+E5zL71absby33//YejQoSXm07yxY8dGYr8YhmEYhqnF0H1ib+ROcc9cPRuyxQzfYIfkdsFw/nVoL0l4gOqg3E64ZTfeLswCTh4E7DZApxcCkJbFqNhmnSmf+6aovXNJgFsCJB0pD8q1BBXZUasEV94Bz3KZBIcacKtJJcKVtx2SLt7TlkEbC3Xj1tB2OQf2bcshWwYANheg1UEu6gvnqX+8/fXo9SiSqAjEaGyZEq81oJNGjzitXtTmKWItSR+DTvENRbomRfMI+vvyZt0x7+ROv+3RdnLsZqQa4oK+RmltWZjIUKHbZmRaQtG7QGheUlJSJPaLYRiGYZjaTLA+ZBYTVMZYv3kU6RMGFnqjGCxSbU6sRo+UBmnQtOoKTbue4pGm2WadqYj7Jok9SauFytAZKnVbSFJxHEPdQKwjudTFz3B6hB61XpBI8Nmg0iZ42jIUb0/f63xIFIWWVFBp46Bt3BGSOUv01wvaty+Ka/PoeJicdnEDxtdtN1kfK1I1xbGVJDQ0xKNFTFLQ1gnJAfPCacvC1HBE77nnnsP48eMxd+5cUaNH6nz9+vVC6H322WcR3D2GYRiGYWolxX3IfMWeKj7JL30zlBU9TbPNOhMJKH1SuGc6zXC1KRBRZlf+brjccyDFaESkTtLHQ3JqILuPQXa7AJUDkj7Zk4LZzt8ASET1up4DuSBbpG2KZbEJUMW4vRE9v7599axlSqjvrlqtFjV57+xe7J1P04Fpm+G8BlML2issX74c7733Hnbs2CGmu3TpgocffhgDBw5EXYRr9BiGYRimcjV6JOrUyY09rptkrKIzlJqOxTbrTKRRzj2X/RTs+7+B7MgHZAOQlQxX4RG43H8BBjVUMQ1h7PUidI3OCeu8hs5eom9fNNfohWqZUtZ3l1qqULomRfJC1dtyjV71wX30imGhxzAMwzDlJ1xRxzA11WePIm+ipnTLK3A78jztF1QaqPRpIevsgp3XvtuL5nO9Om7A8E2e6qFS1lbUXJyMWRiGYRiGqT/QIE2mvmOyp69YfWgizdQ9xLlJqZuiTs8Mmdoq0N8qLajhR2l1dsHOa9/tRTNKn7vKvk+6PpicNo9ArqLXYKpA6JHAGzVqlGii3rt3b+/8kSNHYs2aNXzMGYZhGCZKobQ2y8JpMM/9TDzSNMPUFYdOX6Kxzq62QOmZU/Yuwzu7FotHmmbqiNB74oknRKrj9u3b/ebfeeedePHFFyO1bwzDMAzD1BDB7sYHbalA0xUr92eYGnHoFNPFdXYcUYo8oVoo8HWijrhuzpo1C6tWrUKrVq385p911lki0scwDMMwTN0lpFlCsJYKNE21THpj2NunAR/ZrJMDHw+0mZpw6Iz2OruapLQWCpSuydTyiF5OTg5SUlLE375fEpPJxF8ahmEYhonWu/HFLRV8EdM6Q9jb55QuJtLnq+woCjtaVF/q7GoSpYWCL9xCoQ4JvT59+oioHuH7RXnzzTcxYMCAyO0dwzAMwzC15m68aChNffGKxV6oPnmh4JQuJpK4io7Auu0NWDY/Lx5pmql5lF57ithTsgJYXNeR1M1XX30VI0aMEL306KL9wgsvYMGCBdi4cSP++eefyO8lwzAMwzDVQlkNjalPnvGisRVqqcApXUykoPGn0tdOTNuyxHSodglM9dLUmIBb25wl3E3ZXbOORfQGDx4sBF1ubi7atGmDr7/+Gk2aNMHKlSs5oscwDMMwUXg3nqhsSwVO6WIihtPkFXkKpbVLYKoPJT373d1LMPXgahy35PPhryG4YXox3DCdYRiGYYI3NHbnnvK6bSrpmhTZi6jRC8OU8/ykdE1fsUdOmhWN6HmaoZs8bRg4Ilhh6DiSyAvMCJjYYRAf17qSuskwDMMwTHSjNDQO1VKB0jcrMiAmUUeDPkVE8qCaqej5Se0RlPTNyrRLoNq+wO2QQydTfjg9u44KvcaNw79zd/IkN09lGIZhmKggQi0VgolIhqkMqtgW0HeaSGdUhZ00udavemt8mVoq9N56662q3ROGYRiGYWofxS0VfMVeeVsqENw7j4kkEYvClVbrp42N3A7XsxrfwPRsjtzXDFyjVwzX6DEMwzBMcJzZJ5C7bh6Mpnyo4pLKXaPHdXlMba3Pi3StH3P6uHJ6dh2v0Vu1ahV27twp/u7SpQs7bjIMwzBMlCFEWvYe5DRrjGR1S1zVqg+axyaF/fxQvfPYnIGpMBGMwkWy1o/xP66cnl1Hhd6RI0dw3XXXYc2aNUhNTRXzsrKycPbZZ+Onn35C8+bNI72fDMMwDMNUM74ijQZuuW4HZh7bUi6RxuYMTMQhZ0x9aokoHDSeliDlhVI+KYInhKImhkUeU7/76N1xxx2Ii4vDgQMHkJmZKf7R3zExMRg/fnzk95JhGIZhmGrH5LQhx5zvsZ4vhkQfpWQFQusoffZ84d55TKRRonBC3BWLvMpG4URvyAoaujBMVNXoGY1G7NmzBy1atPCbn56ejo4dO8JisaCuwTV6DMPUFbKzs3Hq1CmoVCo0a9YM8fHxNb1LTBTiyjkJ69p5+Mx8Ark6LdSN20BliA3aE4vWLa3PHtfoMVWBp/dd5KNw3FOPqdepm02bNg25jAYdDMMwTGShgceKFcsxffp08ajco9PpdLj44ktw4403oVu3bnzYmYidbyTcYMrHCOgxx25D7smDSOnQz+ugJ85Bar2gM5TZZ4975zFVgTi/IuyMyT31GNT31M1x48aJFM3Dhw9759HfNJ/+MQzDMJHD5XLhxRdfwN1334Xly5eJAXZaWhqSk5Nht9sxe/YfuOGG6/Hdd9/yYQewc+cOuN1uPhYR6p3XFGrcIRtxn02De1r1F6KNIniWhdNgnvsZrH9+CVfWseB99oKYM3BqHFNbCdVTrwLJbwxTdyN6X3zxBQ4ePIg2bdqIwQZ9AahOj9i/fz++/PJL77r79u2L3N4yDMPUQ9555y38/PNPIlVzzJgbccMNN6BVq9bi2rtt21Z8/fVULFiwAK+//ppI47zyyqtK3Z7VahXXZrqGx8ZG7m74jh070Llz5woP5KnW22z2ODO2bdsGMTEV27dbbrkZS5cuq/DzmZK98yRIiI1LhKQ3eqN9yjK31QR3zklITdp6P/tgffa4jx5T6+GeekyUUSGhN2nSpMjvCcMwDBPU5XjatGni79dffwOXXnqZdxkNqrt374G33noHLVq8hy+++BxvvfUmLrlkOPR6fcijSev89tuv+OSTz9C/f/+IHfWbbhqDVavWlPrapfHVV19gz5692L9/Hz7//Av07t0nYvvGlA86t6jOLrDuTqRskuGKb/N0CVAlN4ZkjAOsJr91FbhGj6mPbp4MUyeF3l133RX5PWEYhmG8dU8ioiJJ+OmnH8VROe+88/xEni+03sSJ92LO7D9w8tQpLFy4AJdffsXpKIpdhlELSC4z1mzYCpPJhJYtW5Z6tCn1MT39CAoLi6DVatGpUycxf/fu3XA4HCISSK10aJkiSOm1KKpH8yiyp1ary/WJvvzyq+Lx8suDv09ftm/fjq5duwpTGno9SmNlIguZqVCdnUjB1BlOC7eAaJ9YN7UZDBfeAslh8183zD56gec9w9QE3FOPiTYq1TCdYRiGiRzBnAsXL/5bLBs16tpSn+dYNx+Xd2mOz0+dwl/z5gqhdzzPgbmb8uEoPIyu7ploFZeP9z/chI+mfIzb7nky5Pby8/MxduzNsNlsiI9vgJSUFHz88Sdi2XvvvStcP61Wi0iz/OijT4Tb8o8//gCn04nXXntFJPp9/fXXVZo6OWbMaAwbdiF27dopSgduvfU23HPPxCp7vfqKEF16Y1jRPkotDlw3nD56ZTl2Mkx1wj31GNR3oUd3g9977z2sWLECubm5JZavXr06EvvGMAxTbwise1KcC/PyPNOtW7cu83ktUxLEvLxjh0REjkRensmJHrbfATkb//t2D8Ze2hKG7Nml7st///2HJk2aesWdLzQvK8vTP/Xvv/8W9YGvvvoaHntsEmbMmI5vv/2+wqmb5YXSTt9++x1kZGRg1KiRuOyyy0TtIlOD0b4gKH30fMUeTRvV2pDnva9jJ8NEg5snw9QZoUeOmyTmrrnmGiQmJkZ+rxiGYeqxy6ECTVPfUurzqQi+0p6Xb/a4HOpVgLnIgjyzCxqYYZCzsftgLo5lmJHYwIDtu/bBZrPi0KGD6NChA5KSkvw22aNHD/zvf68LJ89+/foLc5d27dqJlM2HHnoQ//23EY0bNxaOn2lpDVFTXHbZCPHYsGFD9O3bFzt27GShV8PRvlDrUUsGJX2TRJ63RUNAvZ+fY2cY22YYhmEiLPTmzJmDTZs2iR9+hmEYJgIEqXui6d69e2PevHmYPXs2+vTpW+rz5m3eK2b16tAGMXFGJMZYkGeKgVVKQX7hKTidbrz17TZIkhYZGUX45ptpSE1NxQUXDPXbJNW7zZ49F1u2bMGaNatFGidN7927R0Tyli1bIerv5s+fhx9++OH0/lZzBIbEb1xcnPg7NzcPsbFsmFCdhOOiqazT1JggavIoXZMieaXV+wVz7GQYhmGqSejRD2tCgidFiGEYhqk8oeqerk/pJoTenDmzcdNNN6F9+w5Bn7do6v9h+7FMaNVqjJrwgKiXuqxXgkjf3O++Gv37Shh7SWvEN2gIXZsxuOame/HUU5ODum5SSv6xY8eEyYnyelR/R60bTp06iZUrV4jo3pQpHyIlJdX7PBKNZATTpk1bYcZCEcPU1DTv7wUZtpCJC9X8BYNek16bagMPHjwEnU5fahP4V199Bbfeeiu2bduGgwcPiKheIOTg6bsPTGQIx0Uz1Dok/kxOm1cghnL3ZBiGYWpA6FFT9GeeeQbvv/8+dDpdJXeBYRiGCVX31CepkUifXLduLcaNux0vvPASBg0a5DG+oMxNmw1//L0Mr0//U0xfN/oGNGzXWfzdNFGL8YNTYHEkw6A5E5LLImzCabsk4EL10KPUzE8++USsR+KN3DCpZyr9u+OOO/HVV1+hUaNGmDDhLmzYsN77vCeffArfffcdCgsLMXXqVHz22acYOfIanHXWALGcmr5fffXV3pTLQGbNmol//vkHiYlJwtyF+Omnn0OeHNRPkFpPkCD9/PMvveYvXbp0gUrlcfwM3Aem8oTroum7To7NhJ+ObMCo5mdi1vGt/uKvHPV+DMMwTPhIsvA0Lh90V7ZXr17iDm+LFi1KXJTp7mpdg2pg6I4vuc01aNCgpneHYRjGL0Vx3LjbRGsDonnzFiKlk67Bq1b96zXFuuCCC/D22+96Wx7UJqie7/nnn8Mrr7wakYF8z57dsWHDf9Bo2Dy6uqFo3Du7FpeY/8gZQ4WLZuA6hQ4r9hVmwupyoIHOiJYxSYjXelIzSez5CkSGYRgmclToF3Ls2LGi+H306NFsxsIwDBMBxD03p8nTsDdg0EumV9OmfYuPP56C33//HUePpot/CmSMMmbMjRg79tZy966rLij7g9w5IwX10GNxUDOU5qIZuA5F8oTIczuhVWuQb7dgn8uJXknNxefn22aBYRiGqQURPXKB27VrF1q1aoVogSN6DMPUFK6iI7AfnA7ZlgVJnypq6KiXUzAsFguWLFmCkydPiPRNqocbOHAgR7aYWlmjR+mai07uhkGtQfvYNOwzUWTPib7JLaFVqTmixzAMU9uEXtu2bUV7BYrqRQss9BiGqQnoEmzd9oYQeQok9gzdHueIFVPrz90SLpoBUD/H9/YsQZHDJtahNM5jlnx0im+IZH1sUIHIMAzDRAZPNX85GTNmDCZNmiTuLDMMwzCVwGnyE3mEmHaeTour7GBcdhR5UkMZJoKQcKOUy9JSaCnqfH3LPkLUES1jk/FGzyvxaOdhojaPRR7DMEwtjOgdPHgQBoMBTZs2LXGR37dvH+oaHNFjGCbaInrlSQllmJqO/jEMwzC1wIyFonkMwzBM5aFBLwmwQEFW2cEwDayVbYppW5aY5pRQpqaQwVFlhmGYWh/Ri0Y4oscwTM27bpq9fe4qvT1HESybny8x39jzBUja4P3zGKbC55ssw+yye5ugl9e4hWEYhok83ICIYRimFiAGx5EUYNSmQZ9aIiWUhCTDRJLShFxZzdVLE4gMwzBMDQm9TZs24bfffhPN06lpry/fffddJXeLYRiGqY0poQzjS1lCjkScb789ZR2q11PW5UgfwzBMLXLd/PXXX3H22Wdjy5YtmDZtmhB6a9aswffff4+ioqLI7yXDMAxTbsh4hWryKF2THtmIhYk0pQk538bpvtC0QaUJKhC5moRhGKaGhd6LL76Ib775BjNnzhTTP/zwg2igPnHiRCQkJERw9xiGYZjKQFEVqsnjSB5TFYQScuSuqZx/lMqprKOkdlrcnoheKIHIMEzdgm7SmJw2vlkTDWYs1FYhJycHMTEx0Gq1yM/PF39nZGSgc+fOyM7OrhKzlLVr14rX6d+/PzQa/6xTehvr16/HqVOn0K1bN7Ru3brc2yeRSu+lQYMGEd57hmEYholOwjFbCWyvQNNT9i7zE3v0XCXlk2GYugMbLkWZ0FMu0kSrVq1EZO/MM8/E0aNHccYZZ0Q8ffOTTz7BY489hh49egihR2KMXpN6+Cki7dJLL8X+/fvF65MgfOihh/Dyyy+H/Ros9BiGYRim+vrkBQ4Or2rWA0n6GDZmYZg6BN+0iXLXzauuugq33XYbRo8eLcTX+eefj0gyd+5ckRI6a9YsjBgxQszbunUrTCaTd53JkyeLSN7OnTuRmJiIpUuXiv244IILxD+GYRiGYaoOEncxGp3fvLIcNSnqRxE8Eog5NhNmHtvCxiwME0V1uoHXBKaO1OgtWrTI+/drr72GIUOGCJFH0bQvvvgikvuHV155BVdccYVX5BHdu3dHhw4dvD8k5PI5btw4IfKIwYMHo1+/fuz+yTBM1EPXQNlq5roIplZB0TpKzXxn12LxSNPBIAFIUUBF5BFszMIw0VOny9TBiN6wYcO8f1Mq5bvvvouqwGq1ijTMKVOmID09Xbh8Urpmz549oVJ5NCqli+bm5oq0Tl9omlpAhMJms4l/vqmbhNvtFv8YhmFqO66ck7CvXwC5KA9SXCJ0fS+GOrlxTe8WU8+hmw+/pW/yCjeK1tH0Pe3PCxrZIwMHWscXmjY5bBwRYJg6wJVNu/tF5Gla3IQsf3UYA3g1To0JPUqTJKfNBx54QEx//PHHeOONN9CuXTvhxtmsWbOI7ByZurhcLvz999949dVX0bVrVyH20tLSMHv2bDRv3lzU6xFJSUl+z01JSUFeXvA7iEok8oUXXigxPyPjBCwWbhHBMEwtR5ahWvkbYC70TFM6+5Kf4R44ksIkNb13TD3G7HLgaG6G3zyTqQiHTxwJepefBoNauxN5Dqt3XqLWgIKsTBTyucwwtacO1+2EUaUpccOGxMQ18e1gdTtF6xSp0IxThf7pnEz4NGnSHDUq9B555BFvKuXx48fx8MMP4/nnn8eqVavEMhKBkUCv14vHbdu2YceOHYiNjYXFYhE9/Oh1fvzxR+86ZrP/CUWGMOQOGoonn3xS7LdvRK9FixZo2LAJu24yDFProXRNi+QGYmN95rphTEqGpDfW4J4x9R0aEDY3HS7hqNmqScuQRi03NYj1iwiQMUvjAOdOhmFqBkq9Dvx+BjrrMrWTCgm9BQsW4MMPPxR/z58/HxdeeCEef/xxnDhxQqRVRorU1FTR8uCyyy4TIo8wGo1CZE6fPl1MkzijVgtHjhzxey5Nt23bNuS2SSAqIjEwXBrJkCnDMExVIBtjoYpPEmmbCpS+qTLEsD09U+OMbNGrRMsFtVodcv0Wccm4t+Pgcjt3MgxT9TduZh3fijyHRXwv6ZGmuRVK3aBCisbpdIr6OcWYZejQoV4RZrfbI7qDJPL27NnjN4+mKW2ToKgdmcH88ssvfimflO45fPjwiO4LwzBMbYF+cPX9LhHiTkzHJXqmeYDM1AIUR81HzhgqHsO5+684d/I5zDB1w1WTidI+euSCSRdicrek1gaUWknRM4ruffDBB/jzzz8jtoMHDhzAWWedhZEjR2LgwIFYs2aNcPak1yKBR2zcuBHnnXcerrvuOpHW+fnnn8PhcIh1g0XtgsF99BiGqW2Iy7PTBGhiQw5+xTp2K6Az8ACZYRiGifjvEDnnBqZic0QviiN65IJJ6Y3U1oCEnZIi+dlnn+HZZ5+N6A7Stv/77z+Rxrlw4UKRykmGLIrII3r37o0NGzYIQxbqoXfNNddg+fLlYYs8hmGY2oar6Ais296AZfPz4pGmg0ECkGrySouCCPczRxE7oDEMwzDlgn5bKPVaaaGgpGJz5D2KI3rRCEf0GIapLdBlmcSdbMvyzpP0qTB0e7zcP64kEO0Hp4tt0TZ0bcZAHdeyCvaaYRim7mRDMOU/plxDW0/MWBiGYZgqxGnyE3mEmHaaAa2vy2bZP8yKyFO2QdMVEYwMwzB1Ab65VTUoNbRM3YLtJRmGYWqQoGmVdBdanwLZ6YAMz3yKxkHjSZ2JiGBkmNpw7lvNnFLMRPScCnZzi5PXqhY6vianjY9zLYQjegzDMLXszrM79xTc6To48/cDWic0LftA32ZM+aNwQjCmlkgBLbdgZJgI48o5Cdu6+aI9iOIYq05uzMeZqRXZEEz5euwFtlLhHnt1PKJXWFgY+T1hGIaph3ee3dZMyG67eBTTbrcYAMOihlo7FGoMAXLaQxXbotyREBKGJB6FuCsWeWKa0zaZGoTOW0XkiemiPM80WwYwlaX45pYvfHOr6qDvrCLyCHqkaf4u1/GIXpMmTTBq1CjcfvvtGDRoUOT3imEYJtpxmuAuOgBX/k7ITgskjRFI6AyYs70DYI8g0wOmfE8LBb2x3JEQihBSTZ64o63hZupMLcBm8Z7jCmK6+BxnmIqi3NwKzJTgm1vV32OP6/nqcERv6tSpOHXqlGhx0KFDB7z22ms4fvx45PeOYRgmSpHVMSJ1k0SemHZaPNPGZG8TdAUxrTOUKxLiG/UTLRi07D7H1BKoHUiIc5xhKotyc8vY8wXxyC7DVUeMWudtu6BA00a1tgpflalyoXfttddi3rx5OHLkCG699VZ89dVXaNmyJS677DL8+uuvolk5wzAMExrJZYYqriWk4no5eqRpldsqonTKQFiJ2ok70iEiITLN90nlpKifZeE0mOd+Jh5pmmFqC3QuhzzHGSZC5xjf3Kp6gxXusVeP+uj93//9Hx599FHY7XakpaVh4sSJmDRpEozGupGGwX30GIapiV55blsm4HYCKg1U+jRv6wOq1UNhLhCfBJVKdbqP0cJpfmJPVqmhMsZDNnlSOXV9L4Z9/QK/dWi+8aKxPJBmahVi+EHpmjoDn5sMU4cNVrjHXpQKvby8PEyfPl1E9DZt2oRLLrkE48ePR0ZGBt555x20b98ec+bMQV2AhR7DMLXFdbO0OjzfZYhNACxFgNt1eqOGGMgWMwKDIzEjJkDi+ieGYRimFEgWTNm7zK/2jsTexA6D+IZMfTFj+euvv4S4+/3339G4cWNhyjJr1iw0a9bMu87IkSPRtGnTSO4rwzBMVBHMKCVoHd7a+XCffzNi9Soh+Cg6R5EQ2e2G5c/P/bYpW0xQGeMgW03eeVz/xDAMU35ELMRp8rh51pPU4vIarNAxoudQvV64x6giz2GqUehRLd6VV16JP/74A8OGDQv6IaWmpuKee+6p4G4xDMPUD4S4ozo96v+kiS1Rh1dkc+NA+gmsth9FXINYXNYrAU0TtR53QjJaiUv0W18Vn+SXvsn1TwzDMJHLuKgvBiuBEb1gBisV6aHHfffqQOpmVlaWEHLRBKduMgxTOwYTN8C2conHZEUGth61IF+Kx9b2o0gVIjFGjfGDU7w32EKleQrXTZsFULkgaePEuma7jBidxHdQGYaJWsSwlq595O5awWiRUkPt23ydrs9KDXW0E44YK0+KpxLBM6q0+Gjfck4Lre0RvWgTeQzDMDXZNF0ZTNCj/eAM6PqOFRE5R36uEHkHmg0WIo/IM7tgcXgEG+GbyulrauE2pXu3XehOwuKcoTjqao3EWM3pqCDDMEwUUd4+oyGhDAsfkUeIaUqz18Yi2iFRR4KN0jUpkhdM3Iab4nnUlIuf0jeiyGFDnFaPk5YCxGtPt1Lhvnu1ROhRLV64nDzJVt4MwzAVHUyoGzQQ4s1gsyB9lQkmi7t4oYwUnQOGgCu3+BH2MVrxFZBuSxHy9mxCD+syJDlH4ECz8zF3E/yiggzDMHWdUH1GK+Q4TDV5+tQSET2qpa4v0DErrel5OCmeJPIe3zxLrGNQa9AuNhXHrQXopNF7PxPuu1dLhN5bb71VtXvCMAxT3wgYTMiQoVInQFYboaI+UIYYXHamFnM35cORdQJdM5fjjAQrrIuSS79TXSwgaXv2E4cAuw0aFWC0Z6PtsaXYahzlFxVkGIap84ToMyqyHcrpOEwihGryAmv0+OaY/zGilM7AFE/lGJHw/jl9o1cIWl1O7DdloX1smojoFTltJZ7D1KDQu+mmm7x/v/zyy5g8eXLQ9WgZwzAMU77BhCv/MNwZWZBdXWDN+MYr5CjFctygZBTOmw11mh2SpCr7TrUiIE0noHLaoFYBNmcMZGhhsBcgRe+EUcs/rEz01FQxjDh/AsypKuM4HMwVmQk/xZNSOwsdNhhUGlipV2yx2Gsc0wAPdDxfzAuVFspEDk8X3nLyzDPPVGgZwzAMU3Iwoe86CVJRL6jc50BSJXmFnOKVJdmt0Fjz/Xrjee9UlyIgVbGNIWn1SDDGwmLvSiFDMfC5pE9D/nFlak1NlWXhNJjnfiYeaZphwkEYTlnNp6+TkiRukAlxVyzyxHQlhAQ9V9LWn9YKlUnxDDxGlNqZrI9F+/g0IfYIiuBd16I3VCpV0OcwtcSMJRS7d+9moxaGYZhyQkIOJovfj55fylEF7lSTgNQ2vRWOzXaodq9FG9cuSKnNEXfR5dAlha67YJg6WVPF1CtCma6EMqdiaja1M06jF+ma17Y4E81jk/jjqK1Cr3nz5kH/JtxuNzIzMzF+/PjI7R3DMEx9oAwhp9ypDhzYlDaIoUG0ZenPcO7aADicgEoFyWmDc+9GaNt25wEQE1U1VUz9oawbBIHmVEztdu9kapHQU+rvbrvtthK1eFqtFq1bt8bAgQMju4cMwzBRTjhCrrx3qimlybl/E2S7zTPD7YY7PxPu/CweSDNRWVPF1BP4BkFUuXcytUjo3Xrrrd4+eiNGjKiqfWIYhql3hCPkyn2nWlJBUqkhu12nZ8Um8ECaqRVUJFLNMHyDgGGquEbPV+Q5nc6SG9VEtPSPYRimXhDJlCNqzaBr1xN2pwPIy4QsAaqUZtB2GyhSn3gwzdQGuKaKKS98g4BhwkeSFbuicnDgwAFMnDgRK1euRGFhYYnlFdhkjVNQUICEhATk5+ejQYMGNb07DMPUQyJtMy8MC9bOhys/E7LdCldGujB+keISEHPZHdC27RGR/WbqB3R+kmU6uenxjQKmVlwv2XSlVsHXiCgRekOGDIFarRZiLymppHvO+eefj7oGCz2GYWqji1xloUu822pG4edPAKZ873wSe/ET3xc21wxTFsfMeSUaI5PRQnnPRRaKTKThPozRc41gIk+FcizXrVsnonoNGzaM/B4xDMPUcxc5d2EurGtmwnjxnWUKMTHIcZo8TdJD1PVJdoufyBPPK8oH6PUaJEf43TDRBp1jygCOoEeaJje9cCN7PAhkIn1O0nXPVVAI+/oFEb9BxkT+GsE3euqQ0GvatKlop8AwDMNE1kVOdufC5dwA5Jpg25IJXfuxoideMFxFR2A/OB2yLQuSPlU0SQ+6bnyyiOAJcVcMTaO4sTDDlAZF4ZQBnAJNk2V6OG56kRCKDBN43XPbMuE6cgQqVxdIqiTuw1iLrxF8o6fmqFDOzoQJE/D444/DYrFEfo8YhmHqq828LHtEnmwCdHq4nXkeISfLnn9Ws7cGmh4VkSembVnedQOhqCDV5AlxVyzyaJrTNplwoJo8SsXyhaapL1ZZ0PloMuUjx2YKOghkmPLgd91zOiFbs8Q103tdVPowlrEN2VFUJ/0k6uI1ItSNHj7+tTii99FHH4nUzR9//BHNmjUrcUdu3759kdo/hmGYeuMiR+maFMkjkadu3AYSJDGgcWUehP2/ZX7pSar4OK/IU/AMfsyANrbEa5DxCtXkiXTNuEQWeUy5zk+qtwmsvykrGqfUnaIoF/F6GQWNW0JliC2XUGQYP5ym09c9cnjX6QE73USw0x2zMvswhp0FwUTsGmFy2iqVEcDUgNB77LHHKvmyDMMwTAmb+YvvFOmaFMkjkUdI+hTYNi711tiR2KPBs+HCW8RAxVfs0TQ0/ndVfRERPK7JYyoAmSpQqiUNzkiglSXyfOtO6VweYXNjzskjKGx1BpL1sWEJRYYpAdUiF1/36LyiG2LujCzArSuzD2OoLAhDt8f5XKzCa4QS7fMVe3yjp5YLvbvuuivye8IwDFPPjQUkTayoyfO749z0alj3zPNbVy48JdKT6G504N1pHjwzVQWdWzSAC8s506fulGgKNe6wyZDaDkRMTAM+T5kKn4O+1z11QisYez0BlbahiOSVek76RgOLoTo/2ZoBGBr6mYaUZnDFlP75BEbpKpoRwNRgewUF6jlHKZxnnnkm6jrcXoFhmJogWCqRKraFJwWzODpnWThNDJq9Ri1aJ3SdBkPX5ka/dfmHk6lKymOoQEML5bxVoIiL8aKxfJ4ylcYjxsp33aPnWLe94RV7bkcB3EVHoE7sCpUhTVx7CU7trBrENSHMjACmhs1YSOCNGjUKiYmJ6N27t3f+yJEjsWbNmgjuHsMwTPQSKpWIkLSeu8lK/R5iE7wiT92oNdymk7Af/N5v3XBej00ImIqeq+UxVFDOW1EzVSzySkurY5jyIK6NYV73fJ8jsh4o9ROyR+TFtRTz6dprO/C9uKaGY3DFVDzax9eAOpC6+cQTT4gI2Pbt29G1a1fv/DvvvBMvvvgi5s6dG8l9ZBiGiU6CpBIFM1QR9XsXjILlv82Q7Va4Th0C7DZAtxvaRtdDndamzFQjNiFgqrvFgjhvLxrrcUEsK62OYaoBEnZUk0fpmpZt//M7J2XrCchU+afShmVwxTBRK/RmzZqFVatWoVWrVn7zzzrrLBHpYxiGYcpnLFCWoYqkjYMqphHs6Us9Io9waGBZ+yvUzc2QnQVQ6dOCushR31P73q/hduV7nTzZhIApD4qhgmiT4HICao0wVSnLOVMMpPVGPthMrUGck4aGIl3T79praAJaJNuywza4YpioTN3MyclBSkqK+Nv3bojJZOI7dgzDMBVIJRLTpRiqiHWbjhTizjMjFpKqHZx5X8KR/gdcWevgKjrgaSTsdsNkc3v68uWchGXBZ7DvXALnoe1wW03+d6oZJsxz9Yq4pog/vAvOA1vEI01zlI6Jlmuvvu2Nou45nOsxw0R1RK9Pnz4iqnfjjTf6fQHefPNNDBgwIJL7xzAMUy9SicIxFlAld4Qm6RrIRRmQZS1cjoWAykYFUJCdZrjzd8HsisWMf9KRbTUg0ajC5flzEee0CGFI/aZcJw9Cat1VRP/4TjUTLnTTIHXrStxhk2BBLIw2QLV1JeQm7XkgzNQIlXXHDHbtpW3q298HqOVy1wAyTNQIvVdffRUjRozA8uXLxZfihRdewIIFC7Bx40b8888/kd9LhmGYKEYMJsKoAaH1DP2Hi/5kbmqxoJWhMjaiYj+xnMTe3gwVsnU6ka9RVGjCwUMZ6N7cCLWmj8fMxW6CSpPId6qZ8lHcLoFSf5VENuGoSfV3nJrJVDORqjn2vfZS9oO392OxeRDVmXK7BabepW4OHjxYCLrc3Fy0adMGX3/9NZo0aYKVK1dyRI9hGKYKUQwuYkbcB/0Z50OT0gOSxgjZ5YSr0AYcVKH7/l8Ra86AU21AvhQPp1uGpEqCWjsUmuTR0Pd4ukKDIqZ+QgNdk1olnF99EY6aOkON7RdTPwnlVlwZd0x6riLyxHRRnph2FR0WLRksm58XjyQwGabe9NGLJriPHsMwtYHy3D1W7mq7rBlwHTkIydkd208YYXPIsOoaYGv7UWiCHIxUr4Vs8r9LzTDl7Z2X6HRh+IkTaGI28bnE1BjUIoaEVyDGni+IdMsKbdNqhnnuZ/7zZBnq9kWQnfneeRQ9pHRPTukM45jKsnDrJSMnPl51LHWTYRiGqf50pEAR6LUKN2XBfPg7SBoJbRu6cSDDBtgLkKJ34oK+HWBM6MwW90y5ofPtt/RNyLQVQSOpkKdRY37bDrinVX9IeiMP3pha71YcNnQ+xyV6I3pim7FGuJ1HRbqyArdbKP8NInLrvbp5TzSL8fTUZGqp0Gvc2HMH+OTJk96/Q0HrMAzDMJVPR1LuHntE4PeiUboqtrFwh1Oa/SI2Far4JDFIidOrRE2ey5iAQRc0hUpVnKHPdVRMOdlXlIklGXtgdTlhUGvQPi5NzLdqNIhhkwqmhh0zA2+KVSZqRM+lbAffGj1d34vhOD4tsoKynvyWKSKPoMff0zfh1rYDEKvR8w2iaiZsoffWW28F/ZthGIap2ubpsiYG1h2fwnlkg7dRuttShJh+L4sfzcBBiio+EcZ+l5wWeQxTgcHaguM7gOLiDhJ7JPyGNOxYZu88hqlNbsXlrX8WBkM6g+faqo+soKwPULqmIvKIArsF67MP45S1EI2MDTi6V1uF3k033RT0b4ZhGKZq05GoJsUr8gi7TUzLvUyQdHEhBykMU6nBmsOC9vFp2FeYCavbKUTf8CZd+Nxi6pRbcbm36ZP9UBWCMtqhmjxK1ySxV2i3YnnmfjhlN9SSCja3U0T7JnYYxMeymqjQ7V5qxrt3794S82keLWMYhmEi2DzdpTrdKF2Bpt3+l3DPHeiya6coWkPikb24mLIGa/FaA3olNUff5Ja4oFFHtIv3pG8yTLQSeH0U11XuqRc2dLyoJi9Ra8TuolNC5CXqjOJmEWUF5NhMsLgcVfcBMpU3Y3nnnXdw6tQp0SDdl88++0y0WXj44YcrslmGYZh6Tai7x5IhBpqEIXDmLwFkk2h+TtMk6mqq/xRTPwZrSq1NQ328mOaIBlPXEQLOZvEYsATcFOPrY2Qg45Xb2g5AprUQKngieUoKeJxWz+nftb29QqtWrbBixQq0aNHCb/6RI0cwZMgQ7N+/H3UNbq/AMExthpr5WtfOg1yUASmuoWicXt42CXS5p15QgemhbBfOlHbO0N13qstjkcfUdUI1RSf4+hhZ6HhO2bsMR0w53vRvyhJ4o+eVaB6bFOFXYyIa0cvMzIROpysxX6/X4/jx4xXZJMMwDFMKNBiJufjWEjV4pfXdK7GsFMOXSNe6MNEBnTcxGl2ZPbK4ZxZTWwh1TQzVFN1w4S2Q7FbIKleZ18fy9Dmt7/hmBcRp9CIN/NoWZ7LIqwtCr0+fPvjkk0/w3HPP+c2fMmWKWMYwDMNENqUomFFAaWlGwZapYltEvv8Ug/reI+vslDZYlX2Qe2YxNU6pqZc2i1+fPLF+1jFY5n0JWE1AbAKQrIeksgW9PnJaZ8VSOMl4hbMC6ljq5tKlS3HhhRfi/PPPx6BBg8TgZNmyZWL+okWLMHjwYNQ1OHWTYZiaxJl9Ara1syCbLKInnm9KkS/KHWVZHQPb9v8FTcMkQqVouk3pXKPHVDodS7FPp+ndhRnoFN/Qe3OCxB+76jHVTVmplyINeeG00xE9GXCd2A91k7anb6wZXVC1sEO2ZfsJRU7rZOpVRI+EHNXovfHGG/jyyy/FF+TMM88U8/r37x/5vWQYholiXEWHYV76KGRrljBaQUEfkVJE7RJ8I3u+d5ShiYfbcgwqbYOSaUaQQ6YgsV04E8keWeSoR9P0qJXUYh5N0x38YCmfDFNllJGa7ttv1F2YC0mvgZTUyD97wqKGvsMDkNSyfzsFTnsPmrLNRKnQI0jQ/frrr5HdG4ZhmHoG/XDa904TIk+kV7gL4XJuAAoTPfV4xamaYj1F5NG0owDuoiOQkrpCglQizai0FM2q6D/F1L8eWYRGUolpelSgaW6qztSmXqSi9Zc1A1JiQ+gHDoF93zdwO/IAxxHIri6QVB5zEDJoCdqippRt19eUbaq/o9RMJgr76DEMwzARwmmC25UPWVLBXZANd14WXPlHhDEAma74ruc3yJAkEZ2TNA0gu+2ALsXbd6/UnnwMEwGDBRroEcn6WDzc6QLxSCgDQD7XmOom1HXPmbkaRX9fisLFI8SjZesbkJ35Yn1Vw1S41TvEjTTFhTNUfXR9vqbS8VFEHkGPNM29WKMoovfoo4+Kx7feesv7dyhoHYZhGCaMxrxOCZIutTgm50FyGyAhIO1NEyvEnGw9AUjFVve6ZEBF65G481+dUzSZ6jRY6J3cgg0XmBon8Lon6vJW3QnZliFiG/ToLNgFTYuRUKlUUBliIbWMgbHzzZBiUkoVbvX5mhqYsh1OijanedYxobdt2zbv32+//TYuvvjiqtonhmGYetXPSdZKkJ1qqBqkQIIRkrov4LZAtllEs3SCTFRkRz5cOZtEDZ469RzPhuzZkFRaYR5AqZ2+PfE4RZOprrYLodowMEx143vdc2ZvgCtvGyA7AUkDSZ8MmZp3u62AynNtVenThMgjZKs5pOtx4LajHV+hFpiyXVaKNqd51kGhN3nyZJx77rne6fnz51fVPjEMw0Q1gf2cYNcDeR2hbtwCkCmVcyNcaidse93Qth4DlT4Z9oPfQ5KdUKf2A9xOSHS32lFAIw/PNuk/0wnIDhMkXVzNvkGGYZgaRtQ1H1sISaWB7HIKsSfbcqCKaw3J2AyyIwcqdQJ0bW6AO/dUyEbq9ZFgQk3piec7L5ggDpXmyU68tby9gmJNG/h3tMDtFRiGqS7orrF57md+89xWE1QJaXAW/gFonVA3bgNJ7RJOm6qEDnDnbIYq4QyvyyYJO0mTADgLxHNdJw8CDg3U8ZfDcPYV0KQ0Cbs/H8MwTLQhO4pg2fw83ObjcGb+C7fTBMnthKbJhZCM7YGsOMBihCouCW5LISS3y/tcEnuBrsf1tYWKb8sUoqyeeCanDe/sWlxi/iNnDOWof202Y4mLi8ORI0dQk2RmZmLOnDnYsWNH0OVbt27FX3/9hePHj1f7vjEMw4QNCa44f7cydWozGC4cDU3b9tC07gpJHwNX/k6PAYsbkN0uuGna480p0o107cZC0qcIkSdb3HCfjIdz60qYpr8q+vIpKaLUO4qEpWXBNBSePB51N+oYhmECoV6j1IZGMjaBusXVUMW3g5TQBVJsc7jSN8JV8K9Yz52fBeeBLX7XRZFtQa7HvvXUjqJ6ce0srR5PSdFWRB4dDxJ2vsdFSfP0hZ1460Dq5vXXX49u3bqhRYsWYpr+DqeeL1KQNS7tw/LlyzFx4kS899573mVFRUW48sorsXnzZnTo0AGbNm3C008/LdJNGYZhahu+/Zx8U4VUunioYhoLcSfLdshOi7hMu9L3Qra74VZlQhWTD1VSe28jX1X7++HcJcGZsQ+S3S62Lxflw756DlTDx3lfo8jmxoH0E8jf/RsOdLkOV/VNRNMkrqliGCY6EGLDaRLGVVTTTDXL1GuU2tCoYppApdJCndAZcLkAuw0A/bMDar1nAxTRU3uGxeJGXLHrsW//Ut8m6tFKuPV4oerwFGfecNI8mVok9D7//HOMGjUK+/btw3333Yfx48ejOnn55ZeRlJSErl27llj2zDPP4ODBg9i9ezdSUlKwaNEiXHTRRRg0aJD4xzAMU9ug+g9KDRJ3jXUG748gDSLEoMKa6enblGcFHDZIkgGQOwCmvtCfe6dwjCPIrEUVk+wVeZ6N6OG2mICiXI/ZiwwcyLCh0OpGoTkH/+7MxqZ0K567ujGasdhjGKaO4y/GUuC254uaZkp1F71GNQ0gxXWA5MjxZEXo9CLVXZZ1Ip1T3bo7YNRCNluhik/ytlko0b/UllXC9CraCEeolVWHF8yZl6nlQu/JJ5/E66+/Lv4moffggw+iulixYgW+/PJLbNy4EUOHDvVbRifbt99+i4cffliIPOLCCy9E79698c0337DQYxim1iJ+/Iobogez8HYVpMO0kNrZmAApFhpNH0hmKySHzfs8ER0ccDmcB7aKSB4NYNSNW0MVnwjEJYk70478XFgdMvLNLuRL8bBLetjNLszakI+7h6byjzDDMHWWQDHmtpyAK+c/qFP6e/qKUvMaZyH07cfDkT4TsGVB07IP5HQdnId2QFYVQdXEBHXDplA3bQZd+5FQxzUO2r9UvB5NU4uFKHbfLEuohdNugZ1465jQ+9///ofXXnut2gcEOTk5uOmmm4TQU4ScL8eOHUN2djZ69uzpN79Xr14ilTMUNptN/PM1Y1FSROkfwzBMjaI2QkrsAHXiSMhF1ANK53HYjE2Am2okfK5TqqRGiBn9BOxr5opIHok8bZ+LxDJ6lNctgFZtQZ4Uh3UJAyFLgEEjodDqhMnmQowu7HJthmGYWgXVzrmtmaenJYrUUV2zA1B50g0pO0KK7wBdl8cAlxmyyghr9jdQNTPC7V4K2W2G6+QhwBAD24Hp0Hed5InoqYye/qU+Yo+25VYZ/K7B0YqBHEupPjGgNtEgaZCoNQpxR8ucshtp+jjoJTWPoSOAkrFTrUKPavOmT5+Oc87x9G46dOhQyHVbt24dmb0DMG7cOFxzzTUYNmxY0OV5eR578uTkZL/5JAqVZcEg0frCCy+UmJ+RcQIWS1Gl95thGCYitDkTqq3LAHMhEBMPd+teKMjwGK2UoPdwkeYJLaUluYFTxcZUPYchvoUZK5YBBRQMdDvQJE4FrexCQc4JFHJaDcMwdRVZhtqhAxw5p+fF9ACcMYAzF9Amw5VyAeB73bSfhCqDro82qJDvmedwQC4sAMwm5J/YD5CZCxF3AdRFMz3bD7atespAXUPMyNmCHaZMcQ+yR1xjbEnfg8b6+JretTpPkybNq1/oUY3cHXfcAYuFzAGANm3ahFw3Uq5Ev/zyC5YsWSIieuS2qUTeqB6Ppi+77DLodJ4QsdnsH0KmaWVZqFRUSvdUoO2SmG3YsAkaNPDYlzMMw9Q4jZpC7tCjRC1fuTfTGHiliR2zNhagyOZCUqwGl/VsgMaJwRveMgzD1BXc8RNgPzjDxzDlBkgxLUT0jgRb4HWTxqnWRs3gLsyF25kIWTZB0uqhjm8gHI31Tdr5PKcp5FZ9Q26rPkJGLCvy92KfIx8arRYd4xvCoDVghe0U7mnRkY9RLSJsoXfzzTcL10tqXUAib+/evVW7ZwCMRqNo0j516lTvPErTpDYKn3zyCS699FK0bNkSarUaR48e9Xtuenp6qWJUr9eLf8HCpZEMmTIMw0QEY+XrQZqnGHDPMD0sDhlGrcQ/xgzDRAWq+NZQd3/CUzun8RFj6pLRJRJ5kt0qDFfs6xdAKugDt3oHVA1ToTY09LhqqtUlXyTItqIZOk5Ui0cunIFGLLOOb0WW3QRbce/B/UVZ6JXUHHkOC2yySzyHqWNCj6AIGaVlzpgxA+3bt0dVQxE7+hdYe3f++ed72ysYDAYMHjwYv/32G8aOHSvmUcrm33//7TWPYRimZiksLBQ3iWTZjUaNGgsHXSayduJl3WX2bZrONXkMw0Qb4hpYhkEK9RX1bWuj63sx1HGJkLV6SC6Lv0isx4RqneBrxKKRVDCoNbC6nLC6naJOr6E+vkQbBqYOCT2F0aNHozZB9XbURuHuu+/G2WefLaJ9JEipvo9hmJpj69Yt+O6777Bw4QI4HA4xjyLmdHNmzJgbcfbZnppfpnTxJorhrWZvOwWaX1pvp8BtBA5u6E42tXdgGIapL9B1UbkOiumiPBHRozY3KrrWqqLXRbM8lNU6wbfPXvu4NOwrygR1rGioj+N+edEi9BITPao+FKWZoFQWEnSBvfT69++PtWvXCoE3a9Ys0UOP2j9Q6ifDMDXDV199iXfeeds7TYZJJPKysrJE7a2n/vZmTJr0eL1PlyZzq8aNG0PrzCgh3mDXwbr0ZzgObBHHUdO2B/TnXQPnsalwOwqEdbhvbyelUbBvrYpt3RK/wQ0Ndmhww3euGYapN9gs3uuggpim+ueANjf1mbJaJ/j22SOGNOyI4U26oF18Gv+mRIvQ++KLL/ymqR0B1ey98847eOihh1CVfPDBB0Hn9+jRAx999FGVvjbDMOHx888/eUXe8OGX4pZbxqJ79+5iev/+/Zg+/Xv8+OMP+O67bxETE4P7738g5LZcLheOHk1HamoaYmMje8eVjJ2aNGkiUsArwokTx5Gf73Fso+0kJJR+EywUkyY9hmeffRbt5LkBjXm/hyu9ERwHNgB2lxB1jkP/wun6G5LhKCRNDFQJZ4imwLS+7DCVbO67dxrchfH+NRY8uGEYpr6hN4qMBl+xR9NkcsWcxjdip0DTvimZ3BA9yoXeqFGjgs7v168f3nrrrcruE8MwdRhyvFVE3t1334OJE+/1W96uXTs888yz6NatG555ZjK++OJzXHvtdUIoBbJo0SK8/vqrQgyeOnUKY8feWmJ7leHRRx/GK6+8ijPO6Fyh5//6669YsmSx6Of56KOTQl4bw8Jpgez0b8zrytsLZ+4/kEnU6fRwW1pD0hyCbI2DFKOH7DTDnb8LUmo/4RRH+TOBzX3drnxIcY0Ak8cxmeDBDcMw9Q262UVp64Fp7JzZUPI4KRE73xq9wOPEDdHrBhG1lxw4cKBIoWQYpv7y559/CvMValdCQi8w999kc4vHq68eiX79+ouMgF9++TnotvLz8/DbbzMxe/Zc/PLLr/jkk49hNptCvvbJkyexa9cu7Nq109u09ciRI2Kaond2u927bmZmJmw2Gw4ePCSWK61jysO9996HX3/9XaSPlwW9Pr0etXKh1w5EdkmQ9Cmnp2UZbutxSDoJUKshq2xAzH7IWgdU+hiok7pA0hiF2FNpE0Sap6SNE+mavgir8H5XeMRdscjjwQ3DMNGEUsdcVnsvqk2mtPWYERPEI9cqB0eJ2D1yxlDxqBixMPUkoheK2bNnIyEhIZKbZBimjrF48d/icdSoa/1q747nOTB3Uz7yzC4kxqhxWa8EEclbt26teM59991fYlu0jRMnToh2KWvWrEaXLl1hNBY3sfWBRN3EiXdj586dSEnxiKXvv58hUjKnTv0KW7ZsFmYwVD/82mtviJtSCxbMF9ueMuX/RKsVmt+xY8cqOy4PPfQAOnToiE2b/kNRURHOP38IXnvtdWGU4i7Igm3lTLjbJwOpekgqGyRtA6jIXEUnQ3Y64M4nceiGKqEF1E1aQaWNhZTSH5I2Afruk73HmgRfSZOWJlBfNLbSvfgYhmFqG+U1mxLXP67JK5OqitiFatvA1CKhN2DAgBLzcnNzRZ3ehx9+GIn9YhimjkJROKJVq9Z+F3ZF5BH0SNPntGpVpoHTzJm/iyhhdnYWnn32uaA/DFTDR4YmS5YsLbH8ueeeFxHGU6dOYtu2bULYkdAjI5jff/+tUqmb5SUpKRGLFv0Nk8mEG2+8AUuXLkU/60HKr/SsYFEDOe1huOBauAoKYFn2ANzWLEhqLbRn9Ic6oSW07W6Gc/+3IiVTZUgTQs5XUJPzJpmyUD8pWW2ExQHEUN8oHtwwtQzflh884GMi5aRZEbOpUOdieVrYMGULu+OW/JBtG5haJPRGjBhRYh71xaLm5j179ozEfjEMU0dR3G59xZvZLntFHl30HXAg16RFhipXzCvNDIXSP+nfgQMHMGbMaHTv3gPNmjXzW6dJk6biGjRqlCcdlPpv0nrEm2++gV9++QWNGjUSTXCr0hW4LEaMuFw8kqnMBRcMxfbN/6Gv/1sBTPmAWwXHhoWAuTXkgsNwyya484ugPfdaOFYt9ZirxDWCtt8VIloXCA1Ijpt0mLspxy+C2jSR+xsxtQNu+cHUFifNUOdiaS1smAr049Make+0wl2cXhvYtoGpRUJv8uTJkd8ThmGigl69zsTq1asxZ85srzlJjE4SYuOIKQ+73bthlS3ibt7xOX+J5b179wm6LUq31Gq1Qhw2atlMtGg4efJECaFH61Cq5o4dO7B27RpMnDgRn376qXDq/OOPP7B48T9CXO3Zswd33HG6v2Z1/7hQfZ4CuXVSHaMUF1DgTrV0VJ9XmAf3KRqwdIIkOSG71bAunAVNkzYAuZ+ZLKIHlEjJJHzuOoeKoI4fnMI/qEzURGEYprJOmqHORcOFt5R0MC5uYcPnaMX68WXYCrEt/wR6JTb3HkPftg1MLTJjIfe7999/3zv98ccfiwblQ4cOFe5zDMPUX6iujiJn69evw8qVK8U8uqhf2rMBjqj3CJGn16oQYz6KJYs8Qm/06NH+hi1Om3i888478MOc3/HM7KkY+8xDyC4qQEKrpkGdPnfv3gW1WoUuXbogPj4ORUUmUXtHYnHFiuWixu/VV1/2e15KSiqWL1/uNWM5fvyY6POnQKYpZPASiuzsbPHcwsIiIUDpb1/Dl0D+7//+D6tXrxLic968P3HBBReIu8dQqT3HKS4R2S16IbvIBEmvhmy3ipYKkkyROAmuk4fg2L8ZzsPb4baaxKDEnbsX1m1vwLL5efFId6F9I6gKNG1xlG5UwDA1HoVhmAo4aVbYbCrUuWjOLuFgLKad/v3lmPD78WkktWis7pQ9RmnB2jYwtUToPfLIIyINijh+/Dgefvhh3H333YiPjxfLGIapfygCja4N5KhJPPjg/aLGzuGwIzFeRrtmQM8WBiSf3Ie1b34Ol8OJs84+G926dfemeUzZuwzv7FosHsc9dJ8Qeium/QK72Yrzn70b83P2lnBWO3LkMJ5++ilMnvy0iORR3z5q99KgQQO88MKLmDFjOr7//juMGXMjOnTo4H0eRf7Wr18vnkeGLz/++CP++ecf7/LPP/9M9AQMxbJlS8XrFhTkizYL9HcwR02FG2+8CdOnT8fs2X/gzTffQsuWrUSKUNsefZF44RgR0fhp9kz8Nf1JyInbgZT9kNUmyFodjWggaTSApALsNiH6EJMA+7FfS9x1NmqBRKMKGqdFRAcJiqgatRwtYWpPFMYXbvnBVMhp01EEVVKjMp00lXUDfztkivzFGPzmi3MxJqWEg7GY1pQ0A2NK78fnPX6ShL4prZCmjxPTodo2MJFFksvyog1CWlqaMF5JTEzEV199hZkzZ4o71ORgRzV6GRkZqGtQShU5hlI6FQ0OGYapYB6+LgaXNeyMN56YjBUrVojl5IQ5YMDZ2GvOwrFte2DKzBHz09q1xO/TfhDXEroUkbjzvQMYp9Gh0GEr8UNAls/VkepBwu2pp56OSKP2q666Am+++baf0AyEjgFF5RTh5rYUwXUqA5LjLLiP74MqsSHceRlC6EGnR+z1D8JxcmqJ7eha3oOsf5fg4KEM5EvxyGp/AS4Y2IFr9JhaA9foMZU6f8pRPxdqXWW+K/8w3BlZkJxdoI5pDt3ZI6BJacI1elUwNiBh19SYINI1KZLHIq+W1ug5nU5YrVZvQ2NK2VRMGEpLW2IYJvrz8OlxbsZOfPDBh6K1wQ8/zBBRrrlz53ifo4s1ovOwgXjhoSeEyAuW5kGQyIvT6mFy2msk1YMcOSNFmzZtRSppqThNfulCKmMcpNaxMJxxO2wr5kI25UGVkCpcOqUGKVA37Qxnbqp4jkw5MW4HJEMT2DYuRbyrEN2bG+F0O6BTr4UxoXqcRRkmHJR+Ztzyg6nIb0649XOh1tV3neSdrzLEAmkyXKe2ApYEUfss9bsEqqQW0Le/D1DLkKidDUeeKtyPL1DYcU1eLRd65513HiZMmIDBgwdj1qxZeOWVV8R8MmA455xzIr2PDMPUYoIJNJp2qoAJE+7C7bePw/Lly0T7A/rRbdKkCQacdy6S4hr4/XAaVdoSEbxkfSyuatYDM49t8bsjWBd/cN99972yVyIzFb1HuPk2PFfFpkLf/xJhEgByhmuQCl3PweI40N1p6+6P4Mr8l4YxUCdp4C4ogKRqKJZr1ZIQiOVxoWOY6oBbfjAVIuCGmF/9nDY2vHWtmafFH0jkHRKZEpLOIWr0rEt/BoxxwgU5nN58TPX342OqUOhNmTIF999/P7777jt88MEHaNu2rZj/2Wef4dlnn63IJhmGqeN5+L5izzfqRo6Y1EqgtEapSnrHCUsBjlny0cyYgJaxyd4eO8HuCEYjinALTDOi+UoExHXqMGyblsD27ywxANH1vVg0TVcnnwm30wxX7jq4XKcgOTtAo+0LSZXE9U8Mw0QPQW6IhayfC7WuIe30fKfTkw4vkUjUibJm54Et0LToBEmtYVdYpv7V6EUjXKPHMJHNww9sghpqncDaPJqmdM0HOw7xawRen3C73cL1jQwBfI8BHRvLwmli4CGu3C4npPg4oOFesdyVtQ4yNUp30cAlFZLTAE3SNTD0H853oxmGiRoiUaPnLDwM+/6v4Xbkw52eDpWri7gxJjudcB7dDU2rLn43FsnsReKsCKY+RPQYhmF8KSvqFqyOT2mUGpj6Sc+lmjyr24kYVf1L9yjVpKLYCpxaKwjXTbsNsk4HXVIKoLYIkUeo9PFQNe0Bye2G8cxrodJ5XM4YJpKI+8Q2i8dFM4oj7Uztg4Qa1eSJdE1NTKnnX7B1Sfw5Ds2A7CyAWpcIXf8b4Ny+XVxfqQ5ao9NDcp9uUcOusExdhYUewzBVnocfqo5PNEotI/WzPlFmI2kaUMcmwnVouyfVSHTXkyDnpEHVwgFJpC7JUJPxiiRBpUtmO3CmSmDXTKamEdfEwJq8MNb1NWgR109HAVy5f8Nw4SRIDnI0NsCde6rEDTe+mcHURepnXhTDMDXaT8dXzNGPJ6VxKsvrsuFKVTeSFjV8PQefXqjTQ924NSSrBoaODyBmwGfQNL0UsksN15EjcO1zwbroGzEoZ5iqviHBlSBMnSCEQYvksojUTN+a6NJ68zFMXYAjegzDVDmKmAus0VPEXH0yXAmnkbSf2ItNgEw1e7LsGYA0bg1t13MgF2QDKrWYR8+hAYrGcAZUDR6HecFnkOwFgEbrHYQbLrwFkotSl9gmnKnCGxJ6Y0jTJYapS2Yu7ApbOvw9j2IzllOnTuGHH37AAw88IKY//vhjvPHGG2jXrh2++eYbNGvWDHUNNmNhmKq/0Aszkfou5sqREieTkKOZ1DfPp16vtLQ554mDKJr+qrepuoj46exQd9BAduaXaVzAMGXhawqkQOchRT6OW/LLNGZimLpk5sJUzICNqcNC76abbsKIESMwevRoHD9+XAi8559/HqtWrYLBYBAisK7BQo9hygdf6KsOuizLNgus//zk6YEXMJgmkSwu3RRB0Rm8olkMwBdMg337Sm8NH5m1qFrnQdOqlahHEdvRpwZtLsww4RLsZoMqqRGm7FmKDFshNJIn2kyDQIrW87nG1DZTIPG8MsxcfLctcJrqfVZEoFM2wd/z2kuFUjcXLFiADz/8UPw9f/58XHjhhXj88cdx4sQJ9OzZM9L7yDBMLaM0F00e0FUer3DzEXmB6XFB04oopc6UJ6J4iisn4IQ6Nckr8kptLswwYaLUMPnebNhbkIHFp/YIx1yDSoP28WliXWG6xA2TmWq44UB9RdUN4sMSY2WZufhuG0YXkJoDSWWr9xHAUs3V+HseHWYsTqcTVqvHHGDRokUYOtTTDNloNMJut0d2DxmGqVMXeiay9Xq+lGnxXfwclSEWmlZdoWnXA7oug6FObuu/nVDNhRmmHIj60OKbDnTzZ/6JHWQDKyCxt68wE0laY7100GWq3xTIXXAQ5qX3w7z5OVi3vSHSM2kdt70QboupXGZBvtumv535S+A8sgEy/WfL8qR91tM21KWZqzFRIvTOO+88TJgwAe+88w5mzZqFyy+/XMxfvXo1zjnnnEjvI8MwtQy+0Fc9NHgWlt7FYi8ci2/f59BqUoMU6PsMEvUnQtwVizwxzWmbTIRv/uQ5LGgflwaDujhZSAIuadqVzzWmyk2BSHS5nBsgW7MAl0uIMevuj2Ba+zQK/7gWhTOvh3neO+E7EPsZDtkpvcKTIeFy+WdF1EMCnbITtUZc3LhzubZBn5fJaau3YrnW1+ilp6fj/vvvx+HDh3HPPfdg/PjxYv7IkSMxadIkDBgwAHUNrtFjmKqp0WNnrsoRrBavrPoUMejJ2QP7kR8hu/Kh0qdB2/oGqA2eSB6LPKYq63ZEBER2I00fh3s7DubzjalyUyBZtsFlny8MqDStu4rlrqy1cBfqITmKG59LsdAkXYOYi28tvSaP2i+oY0RrGiWi53L8DWidYtuUBs91zp5jtb8oC/OPb0euwyLGAVc164EkfUypBm1c318HhN7LL7+MyZMnl3tZbYaFHsOUn7JcNPmCXrWEct90Zp8QKUzi7rZw3mwDdUIrNmBhqpTyfN/5BhATyWuguzAXbtW/UDVMhaSPgewywZm9BcjzFxxq3SWIvfx+kXJclhOnJnkYHNu2cY1emKYshQ4rjlny0Sm+IeK1elzbojeaxyaV+hyCjVxqodDzOr6Vc1lthoUew0QWvqDXjMU99cuzLPgMztwfPevRfI0WmjbdEdPrRUhswMJU9XlZRgsVvgHEVEXWg9uRAevuj+HKXOmZDxXkAkByqsqM6InzduvrkK0nAMlz7pLY03ed5MmoULk8Bi8uC2dFFEOpl+/sWuw9fpvyjqLAYUWsRgeH2y0E3Bs9r/QTe77P8eWRM4aykUtdaJi+e/dupKZ66kAYpq5SVFSEuXPnYNeunXA4HEhJScWll16GTp061fSu1SnYmauGmlYX5UI2WcSgRnbmwW0q8NSVqOLgalsATQo7bTJVBw2QS3PeY8depirOOUpdV+laQqVLAJJ7AyoNZEchXPJeyEU6SE4tNAlDYOg/POgNCHf+LjiP/wnZaYGkMUKd4Kk5kwv2wJ4+07/fHt8s86vVp+gcpWpbnQ4UOWzQSWr6UMT8n9I34qFOF3iPue9zFNjIpRYJvebNmwf9m3C73cjMzPTW6zFMXcPhsOO9997DTz/9CIvF4rfsyy+/wJln9sbkyc+w4AsTvqBXMcUOm4ERPcQlQRWfBDm/D5y58wDZBUmKhcrdDfb1C6Au7sPHMDUB3wBiqgyqrbNlQ1J53B8lbQNIab1hGDwJkire6xAb7OaDEHMy/e2C7DAD+TuhanwJbId+EIJRZKsVu21yD1J/UxZK186xmdBAZ4BddgmRR5ApEwk/37YLvs/xTfHm36RaIvSo/o647bbbvH8raLVatG7dGgMHDozsHjJMNYm8++67FytWrBDTbdq0xUUXXSRahuzYsR2LFy/Gf/9txC233ITPP/8CPXrU736RP//8Ezp06IhevXqFXIcv6FXb/Fdx2CzRtFql8sz/dzac+Z0g6dRQN2oPlTrOrw8fw9QEfAOIqTIotVKf6nHELIaMqFTGhqULCacJ7qKDgNsG2ZopZrnlFKhsJ+HIXOWN8JFw5B6k/lANLvXPJTGXbS3CE1v+EAKORB458CbrY0u0XfB9Tmkp3kwNCL1bb71VPFJ65ogRIyK0CwxT87z//vtC5JGwe/XV1zFs2DC/i09GRgYmTXoM69evw733TsTcufMQHx9fYjsulwtz587F1q1bRNT7mmtGIS4uLmL7+cMPP6BLl84VFpqR2r/169fDYDAIoVeaqQJf0CNjrhJu02rCZHMjJqkRDJeOg5t6PllyIEn68PrwMUwVwzeAmKo8tyi10tdQJZxWMuSwSUYskN1QGRuLR9lZBFnSQNLEQHaa4crfCXVKf6gMadyDNMhxp4hdTFyyqMmjdE2K5JHICxWtKyvFm6nhGj1fkUfN00tsVBPR0j+GqfKaPErXJEjkXXjhhX7LScikNYjDlClTcN1114q2In/8MQs33nhTiW099NCDQjh169YNy5cvw+zZf+Cnn34RUZZIQEKzQYMGFRZ6kd6/cEwV+IJesea/9EjTJOTKiuxRhO54ngNzN+Ujz+xCYowal3XIQ0LqXrjStwIOjahPKasPH8NUB8FuAIUbyWaY0lDHtfQYqJizgZiUsH7bJJcZqriWcLvMQtRJGgMgO6GiW2UJZ4j6PTFfm8A9SMuAjFeoJo+jdbWHCimyAwcOYOLEiVi5ciUKCwtLLK+LrptM/YWMV8xms0jXpEheaRGWMVdfidfe+0AIw2BC76mnnkbjxp4IzLXXXoezzz4Lx44dQ4sWLUqse/ToUfz2268iWkjfmXvumYhmzZoJ8bV69WqRDt2qVSuxHRJnGzduEJG4rKxMrFy5Atdccw169+5Trvdanv2bMWO6SM+k16T62+HDh6N79x7e5fQ1V0QeQY80TQM4HqhF0FwljFRLOn8UkUc4Cg4hb8UkxMYWQIo3QhXXEaoEO1RJjSqyZwwTcXxvAJU3ks0woajQuaSJhTquLSRtPOB2kk0xXHnbxaOK6vxS+0GlTYC+++SI3bSNZvjmbu2iQmfsuHHjhBvhtGnTsGTJkhL/GKYuQe6aBNXk+QqUYBGWwYmegfT+/fvFdyAQRUQRR44cgV6vR+PGwQfXd9wxTpgY9enTB/369UNsrMcNkcQdTXfr1h2HDh0SUTglZTo5ORlt27YTyyvicFue/Vu7di2eeGKSMKahNNUJE+4UzroKdtnp55xF0DTdyaNjJ1s9jZOZ8pmr+BJuqqXZLntFHinwDrafoHblwE3mAk4L3EV74aa6Faf/58UwtTWSzdcOprrOJSXlk+r5yMiF0jONPZ/zpGkW1/np2nlaMsiOIj43meiP6K1bt05E9Ro2bBj5PWKYakYRbFSfV1aExUBuXN7n2UXULRi5ubl49NFH8OKLL0GrLZmHTj88FA3v0aMH+vc/y69OrnXrNti0aRMOHjwoUqM3bFgv9rFly1Zo1qw5+vbth0svvbRS77ms/VMYOfIaEWkk6Efu119/EVFBQidpgtok6/KzYVm/gO/Ol5NQ5iqlRUfFAMZpglEbI9I1SexpYIaOmkepjFBJnnOb0o7ojjQ0MeXdLYaptZFshgk8l6hxOmCnXyiPMAvzXKKUT3LTFDfDNDHiuZq0Ad5ptykd1m1v+LdZiGvJHwATnRG9pk2bikgEw0QDqameu3bkrllWhGVXrlU8xsTEwGgMPmim1Mrx42/HnXdOwNCh/qmgCvQj8tZbb+PHH3/EsGEXiGhZVpbHKeyBB+7Hli1b0KnTGSJyR+sGtnuoDOHsn4JvSmfLli2RnX3azYz0B9XkkbgjwZGk0uLKpt2FhX/gHVW6XlCjVOXOKkf8TiOORfFdYsVcJWbEBPFYWsoRmQfQwMOy+XnYtv8Pl3XMF2LPiRhAn4akxl2FW5z4rGhg0o7bKjDRFclmGF/czky4Vf/CZZ8Pl+NvyO7ccp1Lokm6NtZ7c02ZJhSDF0JpsxBtUWd6P/Q7Hfh7Xdb60XYcoo0KRfQmTJiAxx9/HJ988knJKAjD1DGGD78UX3zxuWihQPVySqQ6WITl96V7xTJqoB4s0nLy5ElMmHAH7r77HlxyyfBSX3fAgLPFP4raPfnkE8Lg5fbbx2Hz5k1YtmyFiPLt2LEDNpvN+xydThc0ZTRcyrN/irvm5ZdfIf5et26tqGMMNFW4K6Uj8tbNg8GUD+ngAbjyMqEynG7KfawoGwt2LUau2yFE4RVxTZG6dWXIiF99MmUgsRboECfuEodRkxc48EjK/hnjBk2C1Qno7eNhPzgDbmuCx0Cg3Vio41pV07timKqNZDNM8GviDKgapsJ1shCwm+BW74Ch712VP5dEf74s/9dTUuGjpHm6Yqx2xJSDY5Z8NDMmoGVsclCDtXCN2Jg6LPQ++ugjkbpJ0Qgyjwj8Eu3bty9S+8cwVU6nTp3Qu3dvbNy4UbRQoPM7Jia2hH39zD/nYcFiTw3q9ddfH3RbDz30AOx2O5YvXy7+ERMm3CWiYb6YzSa88sorxX+bhZvmLbfcIqbPPfc83HzzTaIvJTl8+t5M6dq1Kz755COsWbMao0aNEimYOTk5wliFIMMWeh/jx99Rqf1T2LlzJ26//Tbx99Gj6Zgxw+NO6vvjunDqh8jJzsLVfTtDtpjgyj4BuWFLWDQaxEjAHL2EQpddXCeoqeovu//AjXYJsZAAH2dJwnniIOwb/4LbaoI1LgFJ/YZDk9IE0UgwsRZuM16KALpNJ8jiGBIdR5+Bh5EmY0umITFMTVBa+5VQbUL4fGUqKsboJqPUuiv1EgLUaqgbNKiS/nw0HS2p8PQdVZqe7yvKhNXlhMVpR5xGH9RgTVmfjdiiWOg99thjkd8ThqlBnn76GdEMnQTXtdeOwk033YwLL7wIMTFGbN++Az/8MAMLFswX644deys6d+4SdDu33z4eJlOR37xgfeo0Gq1IyyRiY+Pw9NNPe1NI33nnXfz770rh7nXmmb2xdOlSGI2e1BNy+qSUTnLKJDMWSiFNTDx9F23ZsmWi/UIowt0/hfHjx6Np02bIyDglagOVbV933XVo2LCRiLw1MUhokObZB9lmxnG7GX8WHcX/t3ce4HGVV/p/b5m5UzUz6pLlIveCC5jQm2nG9JYECAvZUJKQsmmb/g/JphCyu+kJIZ0OCwkEMKaEGsDGNNu4d7mpa0bT59b/c77RjCVZLrIFtkbnx2M0986dok937nzvd855T1RRECyrRGfFOJT12KdHM3G8bcTRLrlQDRkXOhrqkzFYrU3IvP44jHf+iV2KhKdHjUa3U4HyxQ/gw/P+XVg2lxwHsEo8UHSTXOWySxfBjG4CXCaU2kZIHh9gOciu/RWgd3INCXNEMJhV/0KbEIY5VDEmFr8UdcjE2MH25xsu0EIMfUZNxxYij8japtguGKz17nlXOL43Ax3HHBlIDifXCuLxOEKhELq7u/c5UWZKlxUrlotm6BQh2xsk8r785a8csRbL1PLkhBNOgKIoh/xc5PZJLRXOPXf+XlfnKZc/+9SfRAQOcGA0rcafwj7EgmE4qW7xmE0VVWioHItNuQS2Z7uh5DI4yVYQgIyQLeFT/nzETn/vX7Dad+Ivo2oR09yQPEHIoQpUT5yLzxw1/4gd84OFxrJQ3F+AJhCFiN5ANuHUHiHz7F1iH9WfWObbcJCB5IoAehRwu4TwE6vavZ6LYYbifO392d9fijXd/5sNr+xh1sTtV5gPPBX+ICmYXQkRWTjnSzBLovBZpYjestgOIfY8soo5kQbR9HygiB5/tocPLPR6YKHHEOSESX3sHnroQdFCgaCoGdXkXXXVVZg6ddqIGShqr9DQMEpE9Iqr89uXoSsTR7m3DBcHR4laO6tjJ+yuFkihSiQ7duKOhjrY6TjQszKYCoaww9IR83gQlYCwJwBvNoeGbhM6NJweOhvndSyEsvFNdJhZ3DVmNCRZgaR5ALcXcjCC//DVI3Lc+SXXW2tvExP6Ii0IOoK2Jb8XntOvRXbRH4uPJ6FtblsBZdREOPbz+Z1uDeq4GWJV2zv7e0UzAYYZqsjc/upsCTJp+OnaF/Z4ri9PPYtX/Zn3jaESY0MtGkdSjd6BpGszR6DQK/TfIjOH3r24BoKOGW6w0GP6Q+0TyPiE3DVH+sWKLhO/Xr4Q7TvWAHoOcGkImyZutj1CUIjLiOYXPdx+r7ehs7st/0BJhs92kJIc2OFKrJFs5BQFnVIItXYVvHIZZuEonPTe7XgrmEVMlrDRq6E2pyMgu6CU16Bc1XCTQ02/I6KOp9T+FgNNTKgHYXrh7/O3eyJ3cFJwTZsHp9kPZPIRW8c0YO5YD2XMdNjm8+IYQp0wG7KvNl+nR4wQcxtm6Om/ek+LC56mtbhFlyD3GHeT2Ov/2Rzsqv9IMmFihne2RakiFhgtQ0TzKHXTq7j2296Hju99HJu0DOMavf/5n/8Z8DbDlCrUX25fPeZGErQ6XxR5opYsg85kFOnAaPgppSWXhtW0GkpVAxYkOvGkYiIKCxFHwvyWFjzZMBoZScEESNhoWSINU5I15KBjqb0Yi8eWY6KRhD+bQp1pozlYhgmqDxFFE3V8QkyWaG8t8QXZK+om2i2ICF4YdnK3yKNInWN1A5U5oGsiQC6noUq4yDrctiCpc/PHukzIvhqxAm1HW/dI/yy1qCjz/tK7HidhZLGxuxVpMw5IblzueFAPZcDPJp3XtMrff9V/oInjQGnKfJ4yh40R4LI5EPTZLNTY+WT3oI4n2KRlmAu9a6+9dsDbDMOUPj7TQkQ3QK1oBbKMiGXDa1twZBlWy1axW/KVocEbxA1Nq6hyDFFLx6LKSrSqClphog4KzlD8yHrPxrvZTcghC0uSEXe7sNUXxqxgBbyWg7Ch4uh2PxrsNMqqyaRhZPTW6j3hdWQFkK2iyBOmK2QyIOfgOfPDkBwFjktDqq0FyrJnASoliVwB7ZjToVQ1iufLvNYr/bOXw2kpr0ozQwulX5FIKzryORY0WUXScvCklCtG2wf6bFIqF0Xw+q/694Ymh4VzXmzzecocbkrcZfP9gk1ajkzkoahporRHhmFKF3J1vMhbhUjPJaMcMi4pb4RcVlmsxVNqx+UbzFJ0KZuG17axKBxAzOdDwHYw0bBQHY/hhmQOV6VfhYr8xM7rUhGKVIiUTlOW0WW4kfZORLT6JMQRxOa2nIhulXpvrf4TXhpHeMtFuibV3BV6E9KEg+rumjMq/vRKF373joL7tAvQfeon4Jv/cajV4/PjlMsUn6v4GoXIC8McIIXIXMCl5U0aFBcm10yA5NYQhY2sP7TPz2Zh1X+vn10+T5kjjILLphB3PdfcUnLZPFj21yC9sCjUG9qmRR5mmLVXEPU6v/41br/9dmHzTlA/PWqi/tnPfnbEfxgYptSgL7jG4y/CzUsXIZ2KwecPw3PcAuECSWmcmZceEqmEdG2wbQeOnkNGdSGm9rh/0kTPE0DapUF3/Ki2kjhOTaCrYYroApe1G7DTF4DqKUd6axYLmlswKrMJWXcQK2rPwax5R0PRDt1J9EhFpGvGO2EnYug9l5DScWhjr4K+8+99TAGIhcu6EU1ZMC0H0bSNhat13Hh6ryelWqdAuI/YGwlRUWboocjcFybPExFlSt8UDoT+MMoVN8qnntnHEXfQRgx8njJHIGS8wr1Id3MgtXeDSddmjnChd9ttt+G///u/8eUvf1lYudMfcfHixfjOd74jInzf/OY3h/6dMgxzWKGaGYoY+fo1NaZoH4m+zMsPw9y8ArBscb8XkkjvjLrdkD1ewMyhXFJRqOI5IWHidztNRC1DfCF8afYFmFJRhreW/gnI5E1FPHoc09pfg0c9GqWermknorCaN0Mur90dvQuEIUcmwRPp2/w8lbOxo8vA5vYccoYDzSVhfJWGjOHA5+75u0iSiLT0r33iL13mYCAx95ExxxQncWS7TpO43iLvYIwY+Dxlhkv99EhlMLV3B5KuzQyD9gpjxozBH//4R5x77rl99j/zzDO46aabsG3bNgw32HWTYQZPwSnPcXuQffZu2PEOQFZgNq0W97WNnoSFqomY242IpODCXP5y8wRyWJuRECubiQnyBESkCCJ+FTcc70X7o3eKdE07k0JFegfKNQv+o0+D58SLSs6goX8bBepHSK0qlLoJkIN7N6Ug58NP/XUHYmmruC/sU/C7jzfs0W9Q/I36iXOGOaRzdoBJ3MH21up9DZGMHJ+nDHOEwa1SRmBEj9onUCSvP7SvtbV1KN4XwxwxsO33/o1D4PHBjrUXI1FUr0cGLaMkBZ/0V8Oeeza8siqO/326GZ2qC51SDQxkscnZjGOluUK0ZGQPghXlmOmOQt+yCZLPhuT2wMkkS9NIpFd9knDaVN2QaxvhO/c6IBCGZKXz+3ua9TpGErBkpCUP6sIqMoZdjOjltx345GSxwS8hHkvpmuQk12s/wxwsDpwBJ4Nd6W5AUYvnGIm+tKnDZ1kDtk0Y0G2zxFx1GWa4U6i967+Iw7V3JSz0Jk+ejIceekhE73rz4IMPYtKkSUP13hjmsMO23wOzh1NeJh+JkuomiBozEnzKjJPhOeMjkHpN8LJnXY3E6uegyQrkHVnAsJF1MjAdA7VuMmaR4FC64etPQDb1HrfJvMlLSbZX6KlPoqbzwrlUz0EKhGDGN8Fqer5Yl6fWnA5965Mwt70NGCrUsnmYpC2Av6Ecpg2oMlCvtUBefxcyuc4+DX5HWuNf5v1jb6mZdJ2Uli5CMN2MqNslHGLpGhA2LeD5+5GmViD92iaw2ybDDA+49m4Epm4+8sgjuOqqq3DhhRfiuOOOE/veeOMNLFy4UIi9K6+8EsMNTt1k9pdWt7fGwCOR3g29C1DaoRKuhpNN7bUXVu/0rmTWwuZ2HVrawI1tHZgWyolonqgjC1cjs+hPIpJXjEyV6Nibnc1I3f8jOMluIWzlmrGAbzmUMWOKzeit2Co4dBpSahsh+ZHxXIonwpcglrER9sq4OPB7BKViAwwh6rQZX0Vu1U9GXONfZujZW2rmLRNPRfa5u8V1chcs0XKBxF7VpA9hweYNqEvn6237f4YHuoYQvgs/KRaHGIYZHmnbTAlG9EjIvfbaa8KQ5Z577hF/8OnTp4t9xx9//NC/S4Y5HOzL9nukT0QGcMpTKkfBc851+6yzoX2XjpqFh7e/A0fL4bTx5Th7w3qMrjIgSXKfHlpUkzcSjEQUf0jU5ME2AZkuyTlY2Q7AGiXS4OAYcLJtcIwAJPQ4jzopBKxO3HCiH1nZAw9SyK7YLfLEISTusu0jsvEv8wH2yErHgZ7rADVPp756mRxQXnMUsiuX7f36yW6bDDOs6N8g/VAZtEMv88EIvTvvvBOPP/64+ANdcsklIrrHMCUJT0QG7ZQnjED2IYJ3pKL4v21vI55JoswbxKVVk1FOk0Fpz8kgRQNJ8JW8kYjmFcYru2v1qBVFJaD0iDrJBclTDWT7RvSkQLWIfPhE/V5g4Aa/nipu/MsMeZ2OSASyTJR7y+D1lSHba9GHotB+qi8tK99new9222SYkcvBOPQyH0DD9J/+9Ke45ZZbkM1mkcvlxO2f/exnB/nSDHNkU5iIiMlJzySlVKNKB0NBiFGqFf0cKE2T0rMK2eEk8r725v/h2fWv492t72LHxrfw6LZ3AH+oz+P6TwZ71/iNhPNMDkbgPf5rkLWq/LanCt7Zt0IdO1ekdpLIU0PzREuL3oYrhQa/ZJQhKWVwN14thDc3/mWG6jylyRjV3ZlNqxDcvBLnbd4AJ9aWP3/9YTimKX4WFn32d/3c3zWEYZiR067hICrJmKGu0Zs2bZrolXf11VeL7XvvvRc//OEPsWbNGgx3uEaP2RtsT3/oJjbuY+fjl22r8ez61wA73xJAc4BZLj++ctxHob71jDB0IZGzt5YCI+08E9s9vfPE/SSaFRuSrexV/FK9X+7Nx+Ek033GsvdzlbJoZt4fCilWXtkl6pbTqZjoh0nRu8LnO7t0EZxoK6RIDbzHn9/HdOVAo/LscMwcbvgcfP/hdg1HsNDzeDyIxWLiJ5HJZBCJRESEb7jDQo9hhtbExk7ERHoX1ZllAmX4bU0F3tn6DnqSDwXzDOAzvlFANg3Z64f7hAuhVtTxn+IgnF/ZPIh531OsZBfmr1kuavF2n3f0z4a1bY1wjaWoszp+FvyXfnZAYbe3uhx2OGYOt4jjc/CD4WB7bjIfQOompWsWRB7h9XrFPoZhmN0XioxoF0DpXebmFeKn1rkL5ZofE1QftJ7Dwo6EizqiALl0ShSxSkGnyF6/taf+KaAjib1Z0A84FvsyD2KYIUix6rJ0/F0DbNjFYySPD2bT6rzII/Sc+Nw7NKEeQDTSBO+na18QP2l70Oc5wxwEJOJENHrh78VP2u5/rvM5+MGmgZO4Iwo1eizyjhAzls9+9rP73ffrX//60N4VwzDDdrXUdmmip17viZ/T1YpLxxyDx/QsAtvXwG/ouFyNoDbU16a5v6vpiF9hHYzzK5sHMe+j02bCyGJjoh0ZjwrJMXGZbmFUoAKumafBWPemaKGekSR4Hae3t9J+63JoFZ8djpn3CzrvbD2BzJJHgXS22JO14O5c/P5hl+0PFDJeoc8+t2s4woTe3LlzsWTJkv3uG2ooarh69WqoqiqatWtaISbQlw0bNqC1tRVTp05FZWXl+/qeGGYksrfUl96CDB4fJF8ZHBIjPalccnktGlxefHb2BUhNP1vc5/UEoD/9F9F/r/BUvY1YuKHy4MQbuxgy75fTZlcuJURe1jbh1bzIVI/CM6qGW6aeKc679vEz8I+uLYjCRgQyLilvRKjfQsTe2jOkTR2OIkMiU6ZU937Pc4Y5UKzkNmTX/RZmyyuwunZBksfD5T4VkhzZc8GMF8qGfbsGZgiE3ltvvYUPEprokfnL73//e4waNQrpdBrRaBR33HEHLr/88uJxtL/Q22/8+PFYu3Ytvv/97+MrX/nKB/p+GaaU2Vt0jT6nwoihuyPf9y2TgpOOQxkzHZJjAbIijEFo0rYr0y1W8Tvj7Shr2Ybz4ynUdrYJIShX1MM96/TdL0jRwUQMpu1AkQDJNuEkoiOqj+Fgxdu+WlKwyQBzMOcfpVRRSxQSeR5FxcRAlXDUjNpGXvgpLjzdOBFx1YCsZxB3e/H06In47D7aMxSQJQl/2bwYUSODcG0VFjSbosE6Oxwzhwpd7/Qt98FseQF2ehfFpOHYy2DogEu7qPiddLDXWoYp6YbpH+QHlaJ3FKkrKysT+2677TZ87GMfw6ZNm1BfXy/23XrrrVi1apU4rrq6Gk899RQuuOACnHTSSeIfwzCH/lnsXb9AAiz3+hPwnH8D7NYmGKteL0bvlJqxkEKVonYH6XjxC5MgkUfRAatlC6J6Dk95FNxY1yj8+4jc6/8oHt+KCDa1SJDj7ajI7ES5ZkELhWElY1BLROgdiPgi8UaN6JHuBHwVYpKdd9FMAap/j8eJ7X7jQyK9IMbpb0OtGUaisylzcClW/zF5nkjNTBq54vlGoo1EHkXqYqoCddyMvKOurCAmSSIlq/dqfUE0FtI3wy4vEmZOiDyCnuPp8ZNwy9jjSr6lCvMBYKZgpXfBTm6HQ4sLtOhoG3CcjYDfO6CI29tC2b6ut8yhwU3TR7jQownNt7/97T77PvGJT+Cb3/wmli1bVhR6d911Fz73uc8JkUecf/75mDNnDv7617+y0GOYoaBX/QKlWlotW4Wws2n6V6jFo4t2Jglj7VLAH4Yc64ASroLcI+KKqVvkxNnzGEr1ommeu2k1pNFTICmqeJ3MSw9jQ4sMNd6G2q6VsGQXuhDAqEitMGxRetdWDFMOtP6Q0o/0LfeLZujUJ0+tOR1m68vFbeqTpwTG7PV1hBvnyw8Lg4yCGKe/095cERlmoO/ij46Zi79vX4b2XBJVWqBontAnUkcR/V4isP8krnddju3Y+Nm6F4vnqOlY6NLTyKoqfHxeMoe6SEaizF0Bx8gCDpkHSYDsAlQNnjOvgaLlgwf96b9Q1v/6u7/rLXPgcNP0D4YjWugNRKEecNKkSeLnzp070d7ejmOOOabPcbRNYnBfdX+9HUOpvQJh27b4xzCDodTT4hyXJhqbUyTPat4Ch1b2XRqseBTOjnWQ68bDat0Ku7tDjIVMTpmpGMxcGo7LA3vJU9BOuxJh1YMu+ny5NPEcEUeCx6RJnwNHUoRXez7lZiXgjIGpuKErPtiyirbARNS4vJASUdjZtFj1H64U010LLoOJqNimyF3/dMvc5vvEJIOws20wln8Pcmh63lQg2y7u12Z8da/nnZ1Jwdy0XIy3QM+KbYv6FlLUlWEOAPG92PP5pJ+9vysvqZ+Jx3auyLdgcPvE9o5UtM++S0fNEkKP8MiqeB6K6m1LdWFjsh1ZU0e5FkBHJoEGf4T/Jsw+F8mEQ3OvPq0DLZK5Gj4CfdU9cJC/fkIKQcYYwJL3O88Tbs9GErnN9wK5zvy+A7jeMgcGjS8tHBUdfXMpsX3LxFN5bJFfXBuRQq+lpUU4fF577bVFoUc1e0R5eXmfYysqKor3DQSlgH7ve9/bY39bWzMymeSQv3emhOluh/zeK0A6AfiCsGeeBoSqUHKMmwN52QuQ0klAdcPxBiGRIOtuAxU+OBX1kFJxQHHDNgyRJoNMG4yeurpU0zqcUlmNx2trkPVHUN7VhjPTJjIeP1AzHkin8q9jmZBMHVBt6AagSwpUMwfJziKXdaD7ypCIdtHSK4YtegZy686++1IpxHds6WtAYaagRLfu3rYNyKlm2Gp9fnWaSCfR3bwJUPYi2nJpKLoOmMbufY6E9rbmEVPryBz6pOze5ncRo+gIgB2ZDO5NvYrr644WkzKaSFwRnJCv45NVIJ7CXb2OT6WSuDe5+/gCJ7ur8fK2FUgmOqHZNsqlKO7Ds7i+8RSe7DF7Oxkhv/b3/Pdt/uQCXnwY9smX7/md4AQhu66FnP0XecICTgCG+2RkYlFA6utm3IfMTigtjwG5VsiJVbD9EwE1cGDX2xJAZIFQ/a2svm+fw7RlYEe0rc8+uk40NW8T2QAjnbq6hpEn9Lq6unDeeeehsbERd955Z3G/2+0uNm/vDRm0FO4biG984xv40pe+1CeiN3r0aFRX1xXrARlmf9E6EZlZ/hwcyQb8fpqJQ9q6bI/ITElQUw974kxkn/4z7HQS9rbVcGjRKVIjhB+SXZAiNZAj1SK10+5sFvU6hT5urdkoXrA90Lc0o9wfweXeSjSedA7kmrGwo63FFVqKHDrhckzJGNjcpqPLGQt3og2648HaVASTTr0QdbWjMJwR503NqD3cND0NjXtG9KLjihE9Bw5ssw6yP1w8jtKJtLoJ+Qhfv3O10IMwM+VYWFtWFCOxyvhZ8I0eX3rnKPO+kDJzMDpV+N09k10AtGxQVlk1oGvegR7vN8ox7b0sDKhQZUquk5Dp2oHgsZXwUxYBw/RDXM+K37cFbHgj5QNmeVhnfRK5N8fCSbZBClTvNUW+TxSv/XnApcNRw7CybkDfBqXsQ+L87H29LdV0yr1F4ocSGuuGVNMeTdPH1o0p2bE9XAwLoUeRubPPPhuBQEAYrfh8u1dSSJxRiHPHjh19HkPb48aN2+tzksnLQG0a6LmGMmTKoKTrqOhLhyzB+1yYUt2QTX1YpxbuDfpseE+6WBix6IYOye2BUjsOkuYTRgzaqVfAWPGyqIlwYu1iDOxMQlinL/S5EEt3i+NSsLAw14mbV7wM3/yPQ6mshzr/48UieBJ+yptPY6Y7irdbvFg2+aPQPSGYioYN21Tc2CgN+y8DMkTZ49xSlD5ijcZbG/+xYo2IrFVBm/1hUaNn59phqpUIjL9GHEfiOrf8pfz5GAjDNekYGBveyT+/rEAdPxswc5DLKqEdl38thjkQAi4PyjX/HpMyEmMDfQ4P9PiA7aDcNBHt1XkvYhjwU9SGv4eZAXC8fuGY2X+RjNLQBzoXZfpuOe/fB3Qi7k2hFs/O7ILVtQxyaCpkVxmk8DRY3WuEg7TsrYO78WrIdqYkjVnou+cfu95DzMiI341+0jbV1Q7F79q7Zpc+35ePnlM0Zyo0TefvpREo9Aoij8TdokWLhNjrjdfrxamnnorHHnsM1113ndiXSCTw/PPP4wc/+MFhetdMKXBAfdxGYO8d4QJ5/g2U/SdMPYqRpVAl1Npx4p+TyyDz0kNwujthbl+LtGkg5lbzrnxk2CDJwoglnYrB19MuoXcRPL0G1V0kXn0CyLRjQvMr2DzqdJi+asTSFjKGA597eH/JDuTwNvDCwhh4jvoaYKYBNT+ZaXfNxdPvNqMzo6FuZxfONv4Mz6Z8/bIQ3vSFuvAPUMTKM7WmsESk1HvGDexoyAya/o6ZhUnZ3iZ/B3o8OfNe5K3CE5n2Yg8+2i7FRTJmaDiYNggDORH3Jl8Xnl9Mg0Rpgw7s7rWQKj8EyVUGtf58eKZ+DnauE/qWB0rWmGVvvS77O+gOpfEKN01//zmihZ6u65g/f76IzlG65htvvFG8b/r06UXXzR/96EeYN28evvjFL+LEE0/Eb37zG9F378YbbzyM754pJafJAv2brI7U3jtClBw3H8rbzxcjSL1/b5rA0Xb0zUXQzHHwdbWi3BdGNJeC5PWL9Xua1Pn8A4ti8cX71jNwGWlobhnQ4xi/82W8N/FKhP0qvK7SGN/eE5D9Liy4/MXjFi6PI5alcXNQufEFbLWimKLnxLhSZE8ZNQlOkqKnZtEJsRB5LvVzk3l/GOykrHA8NUQnh02/ZYtzt/fj6Hbj8Rfh5qWL8os+vjC0OWfwn5DZJ/vqF3pQmKliejw9lxLKR/Ho+imJKN41kFx+GOt+vTuNPtchxCEtwpXKNXWgXpcFB91DgT73BZFH0E/aLkQKuWn6CBZ62WxW1MvNnDkTv/71r/vc9+Uvf7ko9KhXHjVL/+1vfytaLZDYo2bp/j453AwzSA4wWjfkXzpHOH1W5hobcWnNVIwK1fT5vcUxnevRNaoW5WPG4JIxx+Cjpo6/b30LHTvWIKIbYuWe0hcHqntMpbqBZFTcN75aw+a2nBB7FZqJ8+ZUlOYYH8DCApHWHRHVJFQrC48eRxYyHNWdN7GhFgok6AIhgIwxesZU8nuFe2oJjhzzATHYSdmuTDf+vv5VtPf6zJOw653+TrcpfVtrbUJu2Yt9emlyr0dmX+fikJlJURqmVrlb7PWK4pHAE/XORrJ4fwGxTZkWPYtwIy1yfyRECpn9IzmiIIQhM5ZQKITu7m42Y2EG3etspECXi99seGWPFb/eOfz7OoagFX6vZQ2YQlgQkWS1HGxaiwtzDupBdWuA5Q0huOD6kq3dEU5nz961x8JCn1ThnuP++HJnXuw5DmZufBhhpxPTK1TYbU3iGNeMk+CePFfU6NnxLbCV1ZAqy6EEKuCedDPU4N7rlxlmf+dp7954+zruN+tfRtuGN4t9MymKf7OvTgi7/uf0gZz7DPN+sb9+ecJAa+XtfcQeHVdKEb0+n8cDjNwP1byBGaERPYY53Iy0aN1QrMzt7xj6l7Yd+PaR3kHjHK8dgydbtuGmnCOK770fOq9kRd5g0oBp+4I5ISxc1g0j0YSyUZsxwVwNx3HBNXUetLlXQKkZm09BGncUcit+CCfugtX+LMyWDPSmR+A76a9w15x02H5XpvQbHNN1oCsTL4o8on9d7mCj2QxzKIi4hpka0EiFRF3/Wuje0DaJv/5isBTnBEOdTvl+RQqZA4OFHsN8kCkiIyCHf1/H7IoZQqBQNCrsU3DB7DLUeU0xvv0FouzxIzF2KqTxJ8PrKxsRXwoHurBQH3bhhtPKkVzxBygmid+jAMuC7NOLIo+QrDQsIwqrfTEcK9+CxjHiyC6/FerZz5S0cGaGlv3V2fSHrgPl3jK0ubU+Eb0B63JHoKkV88G0QDrQiB3RuxZ6IPYnBpm9w8Yrhw/+lmcYZtArcyTciIjLi0urJu/7mJ7VO2LhuzEk40mRcmh0NGPDg39E6snfi7Qtrbur+JgCZNHu9QbzK/4jJMtcGKbsY8JS6I1HK9Oq2Znv7UT/KSqcXGd+ElJA9UNWPEWRl38BFWYuCifb/gH8NkypsK9IfbG21swVP6fiOjB6DqoapgFureioOVBdbiGaTc6wKTji50gwtWKGpryCvj/SC/PfI7S9T1fNXkYqB/OdIq7PPXV7zMFFCnnsPli4Rq8HrtFjmAOHviCTHTsgv/1P4e5I0Tf3iRfm6xd7VlaJ3nn+iZZdeO2hv+fNQ1xBuM0UZMfGnLFeuBQyDwmj65RL+jRrvThQj8r3XuMayQFqRmkyjPKNkOTcPmtGzMRWJP95rojkWVAQN8NISDVYWvMgLjgmIqKDDHModTZkurK3lE5R07ePutw+aaHbl6EzE0dQ8+EjY+aiwR/hPwxz6HXNRhKZ5d/d4/He2d8Too1hShmO6DHMEFCIsoyUqBOhvPM87M5dMJtWQX/vX0jedStSj/46H6Fb+EchSgqrdzQuyrJnEXIS4rG+XBTV0TXQVAmq3GPikoxhlOoRE8cvTz0Lt0w8tSjyCvcLkTNCxlicU+T01vP79m+/QO0S0FEOSasQm3urGSHjFarJU8JHIWZVCZH3ru/LiGUdkUY7UsaTOTT2FakfKKWzd2SPGqXvraF177TQbekolida8M/W9fja8n9gRyrKfzZm7+yrtnMAV80+5zNtq/0rxRmm9OAaPYY5yJz/Ee3MmcvATsREzzaqvxGipG0HjGwGEtXkGDr0LSsgffQrKKsak/9CTsVEq4RNbVnEDRlVsoTxlYpo6N27JqeQ3iGE8wg1aBionkRWK/cYD2QUaJP+A5Li7LNmhIxXcqc+jUXPr0UWFUBPbV6pNJ9nPhinzXpvaI9eepSuuS/zpd4uncRAjp20rzObxLpEK3SK/EmSeI6Ht7+LL0yZx6lezMAcYG3n3oxUxLlNafAH8D3PMMMVFnoMcwjCbb9NrksVzSvSNYuOeiT06Ee8E3JZOVpcLizUbMSXPIiqKceLOr6Irwwxsw2vjLYRp0bf0hRc7I0gkE6JcXYfOz8v7noarvf+EhfC2zIhhSpL3qBhb/Uk2oyvDjip2Vc6XG8CHgWeQC2yPT34CDLEKZXm88z7cy7ujLXgsbZ1iBoZEcW7dNQsRDTfAZkv9XbplKm2CRIsx94jvTOaS2NNogVNqShUSUbY7UWZ6kHCyHKvLeaQnYoHMlKxo63IvHbXHt/z+3LmZJjhCAs9ZkTTP3JXEG6dLc3Y3B6FaW1Hxa42zLr+KwM7FI5QW3CxQnrihTC2rBA1etA8kKUK2IlOOJKEhSEfom43pGwa7evewMPLX8I5O3fh+xU+xGwXvB4/JtdNwNORetwy9jjYqW5kX3kE5uYV4vnVxpnwnHiREH+997vcHvEFXdIRUzM1YGNeycoUJzV2IioaoNP47CsdrveEpXdbhqLr6ZwQT2aYvS54ZZcuwsPpZkRdLtg1Y7DNyIqUyinBamGUVBBrBet06n8ZcGlCDBIFkUfn4tvR7aBVnDmRhmJ6J6Vn0zX0sR3LMcZXjq3JLmRtE0kjh6PDDXkzpl6OvgxzKC2QCq6ae1ug1U6eB33LA/t05mSY4QYLPWbEpmIOFLlbuXkb/vLnR/Dimi2w7N21S+P//jKuuvoaXHnlh+F29+ovM4JtwdWKOviv+SZyS56Ek0kCsgpz63tI6zkh8mRfGZxsCo6ioiPWikeQQsyhtE4bWdWNTXoSQUrxUhTgzafzYk7PwTZ16G8/K7ZdR50sJofq6Cni+WFbpR8x7akn6d+Yl1ahlXJ/fjKy8W7Y5g4Yu+6CpO05GdmblTgZr9x4eoVI16RIXsmOIXNIFCbCqVQM2yULm8wccs3rEPN4hZCbEKjs016BxB6JO0q1pCgcGSrNr5tWjPKZjo2sZRZvuyQFnfF2dD37V7HI06aZ8Nc24rTqiViXaINhmajzhbjXFvP+tEAaYIGWFs/ouuqY3X0yKUqxITozsmChx5Q8Awk6OVKzx4reg7/8MW7/+z9h27bY11BeBq/Lhe1d3di8ZQt+9KMf4tlnn8GvfvUbBIPBQaeOlBLr1q1DeXk5qqrqoJx/Y3E1lcZaXfwEKnLtiKkqIAGObcGX7EZSlqGRUFMUONkkMmZOTBq9pol0d0dR5Nlkj21ZcKgvXPMW2F3NUMdOL9bylXrEdF+NefNpnQ+IyQilwQ00Gdlb6mfhGFEDyTV5zAFMhL1wsAsWKEHbti1kqZWCBCj0v161eBR1I3GXNHPF+rpndq1G2OVFzMiIdEyPouYXbSRZnKNlLdvgyeWfJ6IbiLZsQWDsDMyNjEbQ5cF/TD6D+zwy7w8DLdD6vWLxjK6rBcQ1lFI92ZmTGcaw0GNKmv4pGrRql138ODzzrulzkX9pzRbc9shz4va5887AdUePxQTNFKIj7SvH01u6cOdzS/DWW2/hi1/8An7/+z8UJyH9U0eSySQ2vPM26utHobZ2aFMM165di8rKClRWVh3U43fs2IGtW7eI26NGNaCxsfGgnufPf/4TTjnlFFx00cV9VlNFlO+Cm/BhquvZtRLtm5chlErg3J278HRtDRpTaWwJBJCTHURkFz4y+hhRjydq71xu2N3tQuRBOHFKsDp3ISNJ8BgG3C4ycBgZEdNCPYljpOCYefFXSMUcKK2zz2TkQI5hmAOYCGeSUdRDRsbJL9B4FBcCqgYLjrDsLtTikZkKpW2ajgVVIoMlSdT0XT1mLp5uWSOE39zyMbtr9GQX5uccSD3G3xc6Gp7Uc0jYlmiyTqmgA6bKM8wQMNACLaXBU4bEQJkUDDOcYaHHlDa9UjTsbKroEikcP2RFpALatoNfPfuGOObqq6/BN7/5rXx/nkV/gqT5UCZJ+MjREcwaNwqfuvNhLFmyGK+99ipOOeXUvumgmhf33nuPEEEkojZt2oiPfOSj+MIXvjhkv84f//gHnHnmWTj//PMP6vErV76HRx99FE1NW3HWWWfjP//zqxhqqIau4s1n8O/JKDKyGy41AtMGFrS0YlF9HfyOg6Cs4mNzryz2yaImynYyCqt9JxxFEc6drZFyPBHQsNVbCVfWwtkdKRw3uhZVIyBiSgizgJcf3l2fOH4WtNOu3GtaZ9/UzwrYqRZAVfPN1HnCwhzERNhZugij0xn4XR44NWORU13YlY2LqFzBUEWIulxapFySoPPIKiYGqzDGX44JwSp8JlhVjPoRdJuOyW7fUbw210PBzb46YPq53FCZOWy1fZQGvzuTogLu0ZfwX4MZ9rDQY0bEyjRF8ooiz63lLZUVBbI/jKXL38OOrjgCfj+++MUv5UUECbhsqo+gmBrx4IrLLsO999+PB+75K+amNkOPR+EqC0ObfQaU2nHw+/146qmn4fF4sH37dlx44fn42MeuRVXVwBG4DRs2oK2tDQ41Dp9zNAKBADZt2oTm5l1wuVwYM2YM6urqxbGtra3o6OjAunVrUVYWxKRJk1FTUzOo4TjvvAXi389+9lOYZr5mZm+sXbtGRA4Nw0BHRzumTp0Kl2t3fWLOdIQg7tOYtlcElQSGz3YgBSLQrv4GRj15Jz7R2omsL4jKSz4DT7Cyz5eu//IvQPYEYHU2w2rfjoVlGnZBQ1twAgzVh/vLXWgJnoibIgcXzRxO0DiSEYaxaTmQy9LMG8bmFZC8QWinXC3SN+1cO2QlBHfj1X3+BiQQ7e1umN2bAJcJdcxcaAP012OYfUGfSd/8j+PD3a14rHWtiNDVun34jynziiYphUgzpW2O8oaQsXRRi7cz043PTz6jeM5Rm4UC9Di6/hpHz4P6zguiH2QxpZ6Oo8U5trtnDvK6ORjHzP61fYVMCqt7HfRtjyK3kRZ72ZSFGd6w0GNGxMo0pWsWRB4JMvEdYFvwnPERLH17uzj2/AsuhM/n26fJyhUfvkAIvdeWLMW70yYKMViZeheRZa/BP+dkXHz6AiiefFphRUU5FEWB2z2wa9xXvvJlrF69Cg0No8X7HD16tBB6b765FC+++CIsyxSi75prPoabbrpZ3Ka0y0QiLlI4r7/+44MWeoPhzjvvRCKRQHt7m9hWFBV//etdaNNlbGzNoXtVAtFIp3BuJJOPvbqQpmLwzvso3HPPBqKtQKRGjEt/KFXLc9LFQihm/EHEVAM7rDoh8oi0ZKAjo4+Mvm/Up7C1CU7HLlHjKFH02R+CHe+A7KqGq/565N58HFYyjVzbiyLtSCkLwlF8Yvyov57iOguADnRVQ/aPPty/ETMMoetSQ7gWnwnV9Omd1xtK26RIHtXVzQk3CLMViviRGOwP1fBueeMJPJFpR9TtQmXDNFw+bgFGhWryEexn97S7Z5gDYW8GVAeDsf0xQO8Ut9mUhRnusNBjSh4yXqGaPErXpJXk3g26yfEttuE9sV2VahETEZpc7M1kpcEbEsdato1sPIbx3aug0Cp2WoGndVsfR8jbb78dV155JUKhfK+o/iuPL7/8El5++RX4fH0nRFdddTXmzTsTTU1N6O6O4dZbvyOE3kknnYRjj/3QIaVuDpZQKIQ//vFP4vZnv/R5fOHXP0Li6OPQYnYg4GSETT/Z9ZOTY2F1tNj7Dg7Ic8/vz9fUKXR/ZT46ub90Gk8ug9qmpVi/uUu4dEq2CU0OoNKnjYi+bw4Z23RTq4qebdsCcilIwQo4Lg36W88AqYwYczu+BemXPg9lVH0+ZTNOwjDSMyHXRMSklM1rmPcfYeDTKyrXm9599Og4ctQs1O4NFKUWIg+2WHjr2LEGj3kDuKWsemT2I2WGhP0ZUA0KrnFmSgwWesyIcdwUNXkUSaIISU/xNU2YfXK+jUJHZ2efycVAOfzt27aJY+mrozq7S4g8wrEBo3UbZH9IHP/jn/0cqVQK3/nOrQO+L3ouatUwf/65mDVrNs455xxcfPElIqr1m9/8Gg8++AAmTJgATfMgnU6LyFrB6fOD5PTTzyh+kSrTR2PXknfhPupYWLDQ7DRjhuMIsVeIshUEMq3aP55uR6fLhZraKlyR6S42Rx6o1UX/sSGDlstHz0Ey9gq2bFiFQDaHk61ynDgrXxNUqgjH12wbHASgVNTCScdhx9pp1PIpsEfPg6Rnd0+IHQdmdrGox7OzbZDcXsByQ5HmFcdpJJjXMIcPOs8KffRI7BWaqu+RgpnLiHYNUSnvaizQc+jKJpBJx4ER2I+UGSKGUpzto70NwwxHWOgxI8ZxkwQe1eRRuqZEk4eeNMO5jfV4eOkqPPveJnz2nE4RTRL0Mlkp8I9/PCZ+jmmcBpns7ckZzpFgeIKQLUMIlO/d9mMh8m6//ScDpigW+NrXvo5PfvJTwsnzzjvvEJP8yy+/Anfd9VcsWvQMKioqhMA75ZST8uKoJ70x7yTzwVBI26T0rI72dmgBL9yuvBue4RgwYaLK5+kTZaMI6sP1E/DujhCyloz1zTpS0jv4+qx5eeG95Ak4mRTkYGSP9KzeIrDeG8Lno51IeTxwuTW4ZBvyuufhjC3NVX6jbTEyy79XTD2Sy46F2jAZlqzAMXRIvjLApfWNmjp63nSFkGTAyMGRDEh+H5DOjJh2H8zhhRZxqJ8epXe6uzuhv/oPpPunYGpeEd2PpDP5iB7h1lDuCcLrK0N2hPYjZYaAIRRn+2pvwzDDERZ6TOmyl3qxQi8xsdocCOPUKWNRVeZHezyFe19/D58oewhOvBNSqAL2nPkI1NSJ47dt2yYibcT1x02AkmtFyh0BaZxQQIXsDeInr23A2ytW4j+/+jUsXvy6OHb27Dl7ROPI4OSNN5aI29SfSpJkUQNHkHHLfffdK8xPHnnkkT5fMFSTR/V79HyTJ09BLpdFJpPFlClTioYtbW2tmDlz1oBD0tnZiTVrVos2CyQsX331X5g2bboQlQPxwAP3o6ysTAiwdU+8hJO/8u/wVLmxU6RouUQq5ZzKbqxf31l8Dykzh3d2xZCz8oIwZ9hiO167Dfi//4GT7C7WSvaOoPbvd+iedbpIO/TT769IJb3KT3+Lgsgj6KelvAY7Oh2SZULyeEWEjyLQNF7FtOKuNsB2QQp4it2fJHjhOePa/KJATySaYd5v6DyjdM3MW8/sNQWT3HUv6lWjV9UwDZeNniPO1ZHYj5QZGoZanBVMWUREUPXxecgMa1joMaVLP0MVChbJHr+ocRJd2nrSDPHm07jx9Lm47YlXcOfzSxFr2YErJ1ZCkj3YtbIVG+Zcj0hqOX73ix+ju7sbUxtqMH9KLaSESzghOkYOyPpgRyqRWfc2amQJ9/zyvyGHKiG5NNFPr7/Qy+VyuOeee8TtQMCPK664AhdffLHY/tnPfoG//OXPQrRdf/314rEqNR8ngXn99bjjjjtw//334d/+7Xp0dnagvb29KLKeffZZrFq1Ej/+8cBCj5xAC69L0O1Pf/qWvQq9T33q09iyZYtwBv3W976LnWP9Ij1r+lHjcf6HTsSlp1fgycdexnuxbkyePDkvrh03JMMNyU7CkfPvm7btJU9DIpFH6DnhgkrtK0i4UU0a1e9QahetwTqJKHJvPwfHVwaJ0rpKfZWf0jX7pR7B6oZSUwOpulGcvJLqKgpdipBoJ88DNtwFe0MAjt4Kx4lAkiughuZBpt6EPElmjoTFtV6LM3TeTjjvRvxHLoOMovRppTBQqjzDHC5xJh7PfUeZEkByCjlhI5x4PC6MJ2giTxEMpjQoRImsjp2i+blcXgulYhTcs0/vcd+UYHTsQvLVJ/GXRc/jz6/ljVkogDQ14ofbpWJ91oVUd34SPmH8ePzy8pNQEfDBbFoFPZ1GtqsDWcmDgBGDS9OgaB5Ik4+DVtMA7/wPNs3wjjt+iw9/+MMH3VC9N9QYfsGCBTj33PnFfaK/YI/7Hrnk9a5/pAuJZFtwJAUv7ErhJU8WMZcbemACjgnMxM2JZ2A2rc67n/bgmnUqfOffiJ2xFjz84l9ESlfYNLGguRl16QzUSUcDiiqetxSd+Ap24LbsReqFC/ZIPZLiC2BtXVl0jKVeer5LPyvuz668XRwv+kM2bwFMCUr4w/Aef35JjREzfBDXhx7nzAL0uWVTFYZhmMMDR/SYkoYmvJ5zris2P3dyaeirXoO+8lWoUz+E+PTzsOWJhxBqW4WLyoHGWUE81JTBym4Tq7pSxefR/CFc9ZErcfONN8K15FHYsQ44eg7daQuabSFgdkGxDWEtnjMsdK9bj3iXgrHHJFBf/cEtHFB0bqig1NHKyt297nq771GqYe71J4TIIApNvZUx02FtW4ETTAeVRiPipg1fohkTr74E8lsRIa4L/QylQAjaCReKxz3Wtk6kcjm5HDqTMTzpUXGDriJFtiSegGjPQHWVpbTK39cOvALahOuQ23R3MfXIO/s7yL32dp/HFFflSBzm2gHTFOe1Ojof0fUe8xHI7sAer7U/AxyGGQr25lbM5xzDMMzhgYUeU/KQSyH1u6PqJYp8CCfDdBL28n8htvRNlJMtOBxYjoQTyl04OeRgQ0rC+rSDTimMV8bfgAVnn4pPnZ2v1bNoIrP0adiqGxSbIjtxEckSfi9Ub2cIN84EvFi4Kocbq/o2FR8ukFHM3qKk1JfQeO/VfK1dZcPuKB2lseo5kBH7UeUmzLbtkBI6tCX3wDXteHGIpPkhe/1wn3Ah1Io6JI0sujJxyOFq0SCc/j7bZRm/C6hIJbejwo7jw5luNJBgKRGh0tsO3DbisDuWChkn154HrWEB5MhsSOlOwHoD6tjpwkhIuMZaJpxEFyxKfd22DXayGU4mCckbgByogz0pAbmir9DrU/voD/eJZjPMUMMpmAzDMEcOLPSYEVOrZ7c0waIG1Jkk2VfC8QYhZ3VoRhI5d0iIPaqFsiFjdJkXNWUqomo51oyZhfmze/rEFaKE516H5oYT8d7f/4EZqRgqkIAk/nNgQUHOHcDG0WcilbFLqsF30ck0kxIiT9TatW/Pu0HSr0g/3Zo4zm7fDtnUAZcbdjIGY/07YtwkEoM9NTgkQqSlixBINaMz0Q7HMETPuBavhkBOF0YkneluPPzq/bhZlyFTi4FSSN/ssQOnXoN291o4VFciFiXaoDf9H+TmZ2CTCJS3QbamA3IYdjYKO9qF1DN3w27ZDPhqYMdWwpEykJI5SNIJwqxF6dV7rLfzrEjx3LpKRLRdM04SxhjDfhyZI5L+bsX94QgzwzDMBwMLPWZE4Jp5GvR1P9ud/EZ1X5kE4K5CRlZFXZlq68Ki3pYlET1RJRk+j4yTJvnRWLW7WfCumIEn343hX+s15EKXorprDXRVQZmdhCLZyMlevDrjM9DdZQh75dJq8N1jtiD6DPZKw+xdSyePnwXbNGBtXAaHHE5NA+bm94QAdM85A2rtuD4ihJw1z0wDj0W7kJaBgK6jlv4G1FPOIwOWhaieQgZB+EqlkXLBDjyza7fIU71woMBufw0oPwaS7IJcXQmr5S04OsSxUrgKsMqEcLZbooAxGpAsOI4C2+6C7Y3CiXcBZeX58en5e1HmZuFvRZCrbEmMIzPs6O+uWxILNwzDMEcoLPSYkWHGEm2HnU1CbpwJe9sawKBG5w4iY8dhY9qPhO1B2IoiIqUhWTpsw6b2eJDdHiw4tqZPhGThsm50JC3kDAeqY6JNrYJXNhF3XKLfW7NUjok7nkOZYqKxsQZ29ILSmcj0cjIlB1Np7HSRNuhdcEN+jHoc84Qpw1N/grF2KRwjK0SbRMJu2YtQ5n+8KELsRAy7rBweyGXhkMgzDFzQ0o7naqsQ19z510rHEYGCQnygFFos7LYDvw9QvHAcC7JvIuW+ihRjSCoMy4Gq+SAF4lAC02A0UcViBqb5Dhyljnp05NM5bQkSmeFk07B2bkT6ubtFj0L3sfMhk2upPwyHzIT0nIggwq3AkeSSGEfmyKZ/5K5/b9NC+wVRR20b8Cm7XTgZhmGYQ4eFHlOyFCYV5LhpNW+FE20F4p1QRk2EvXMjHMuCJ9OFD114BYyGGfBko0g/cSesli1Qc1nYLg/K6xsR8Pc096XG4bqDWNqCKgOaS0LW1tCm1gCKD14YqPQBU2KrEMx1QiU78ZRTUpGT/mYLhabn+UbueSFYPG7u2cL0xqaehBRIVVTYnbuK4sJKdcNs3oTH3Daytgy3JCOmubGovhYLmlvx/Oh6JDQfyl0eXGS7RWJsKbVYIDtwEntWbCuM7S/CpDRWbSpyFUdhy44scqYNj2JivNuBR7YBZzucXDdA/QmlEyC5NVHv6ORSALWpMHXIFfX5lNiOnUjd/yModePFuFNKreMxAG0TpKAbttkBOTSvJMaROTIxO5vRtfQpOOluBPwRkSpMCw/92y/sTHbimbUvIGobiLh9uKxhtmjAzjAMwxw6LPSY0kVEjKJC5Fl6FrIvBDvVDWvnBkjhGrhqxkDylsFc8wa8jUdBcldAqRoFyeMHbBOQVcjBvqKCau3CPkWIvfFVbmxu17GrfAaO7fwbwk4SvmgKfq8LKgkfo2+vuFKJnByo2YJcMxaSLwjZskj5iYgetbigPoaUS0j1ZNnyGnTrncjqBjaEypBRXNAsCx9Ka/hU/XRkzvw0ynMxGG8/W3IufgVDFqu1CRJGAbIFGDI2ra9DojILD7oQs6uxQfdgRvcyOHZOuGw6IoK3AfL4K+CqHgs7kxCij851Mrnpk6ZJbSkokuIrg+v40bB2UrpnDnCZQGXX4R4CpkTZkYriT6/fi3fMpAhQH5NO42NvPIHx82/o29sUDp7UJCQsXZyn1KPz0R3L8ZlJp5XEZ5xhGOZww0KPKV00L5LworszBdtxoMoSQsEqUYvn1E8BzAysptWwjJxI0/SceNF+rcHp9gVzQiJ9kzh1kg/nR3cg1DgNZi4HZ9sqgFw9KVWRDshlRWpjqUVO9mW2QAImbenwGiaUijoxviJt0K0JYRckgdiTthXw+FHhkbDcySFlWLBkFYpiYfGUKmzXzkTXK3FE/G5ccNw1qPNZpdVImVokpFryrSbEDgWWk4KRsLC67iZAtWHCh5C1AdOst/MCTdYgWWWidtGJ7oDn6m+IaCqJ5+yzd8OKtQOWAYdSYTU3bKQg2UFIqXYgnIVS1yCiz5LLBYk8Y6k+kJsCM0MIff4f3fqWEHmiIlQC3nEMBDNt+IKe7XONzfhDiFeWQe71mSaxR706qY0LwzAMc2iw0GNKluaYgZ+1HYsLjbdE/Z3mpJBNWULo6R1dUCQHHk2FGqkSTpyFFMv9Ravqwy7ceHqFcNP0WBlknsq7eLo8XpiaF7aehZOOCQdJyeuHa+rxpSNO9sPOdEysyNNkLeLy4rzyatRqfuyydTypmIhpLlQ3LcWlDbNRTimYyRjOgoaXZR1enwa3P4K6ZByvZjMYFXsKln8iGjEXC5dDjHlJjaPqh+yvBdzriiYpiuwHAlUwVY+IghJScCrcofnI7aC0TdGWHpKtics3jQf1F6RIqdXVDGP1YjjUW88fh1SxC1bOACQ/oMyCs+kVwE4JsahWnQRX/YmA6jvMg8AMR/blmkmLPG1mFjlRP2qJfTkJaFddyCgK/L0yArwuDRUb/yWuFwUofdOruD7w34lhGKYU6SmsYZjSm4g89nY3NugR/Dr472i3gzAMGzlbggEFipGBpGcQT1vC9IImzwVzisLkeV+igp4/lbHykTt/vp6EDqd0RTg2ZH8ESlUDXJPmwtz4Tn5iNBJW8ntEHhE1MlhUVwf4y7BQzYs8pbZR7H9s5wphFkJR0wlQcLqrDMfWTsasdBrNti4MN11WDnJyI9aaaxBNmUJYlxIFQxa1YWa+LYXjhVo2D5MWXIywP78GR66tF8xUoU26Hkp4Qo+zqQaYU+AaP1ucpzTu2aWLYDVvhuQPQSoLAzWb4dhJ4TFrORkY2YXI5GwYlgTHSMHc+TKMrQpsqltlmEEaXKWf+SvaF94pftJ2b8hQpcYThDdYnjcLouQKRUVdw7RilK5wjaVoNNXkkbgjCjV6JbWgwzAMcxjhiB5TkpBpSjJnIZWzIclB7FDrEbCTkOGgEt0wocKRFcSVIKykCZ9lQgpX5uvHsukBV6oLLNuWxn0L12BKyyuokJKYPc6Paj85JUpQItWQJs0VNVNU40dPMVLcDWklv/fKPBFTFaTPuBKJ9S9DlZXimNJxeqiiuLL/ETOLx5rexk6qnwRQZUnYojnQ5Qx0ZyuO9kyB11WDUsJKboO+5QHYRgKO5IGsTKcCSNSU5SPG6VgT5B0PwNnaCUOrhPeU/wd9xdvQY3FokSp4jl+Qr7/LpouumqKTo6IDMtXh+WAHKtDanUUVdBhWALKpinPfRfPvVLqkjIKY9x9aVNjyxhN4ItOOqGQjks7gojeewITzbiy6atJ1gCL2cTOHt9QmsfA1t2Isrhh/4oDnGRmvUE0epWtSJI/PRYZhmKGDhR5TkpBpSkBT4NcUdFseRJUIDMUDL3RYlgIoCmJKBLbigi7LMAMV8E86Btnn7h6wv1MhVcl2afjtc+04ruUVBKy4qPOLrlyHSI0G17TjYR59Plwr/gkntdtZrlRcIvcHreTTinz/NKxKLYByb9mA6VmFWr8GzYtbpp6JzqYm3J1pxos+A4ZJzesVKIoMVO4AMAmlQsGIxc61w2reAkdPwZaXQ0pUIrv4cXjOuwHyjgdhZzsAx4CdbUN8+0I87v4Usr5O+OUAzpPKUU9PRosSocpiA3vYHhEdhCIjmgFytgsW3PkWkj1BUcf2wpECI2YRghkaaFFBiDzknYjpJ23/Ry4j0rOLadtuH64bdxz+Y/IZ4jiK5O1PwHlNE+CUTYZhmCGFhR5TktCk4tK5ISzbloFLlbDJfwamZkyUx9cglZWQhhsd3lFApA6ZxuMwdf6HoD9/7x79nSjaQeltdJtcDTOSD1rXNATMbnjNBKakVsMFA3q7C5vsrejY9Bg6JszD2coSePQ43GX59gMjYZWafkdKu+o92aPtQnrWo9uXoSsTF6JvoPQsOq78+AtwzpJ/4JXcLvg8LmiBckwpr4el5ErLoMFMwcl1wO7eBTu+XPTPcxwVdkyFbIYAJwc7sBJOtgl2LgEnlUY66cFJ5mtQ5Bwsy4utW05F9YdvgFpRJ6zrnXQS5sZlkNQ04B8HR22ClmtFyq5CZ/NMVIY2QlENOJYGKTUVTnwdnAmzRsQiBDM0pFUFUberWFNK0HZalvHotl5p23papGcfiHsmN1BnGIZ5/2Chx5Qs9RE3br2sFv94uxvJnBedzsU4OhsB0t1Y3e1DwjcODdkmHJ9bDP3plbC620QT8AIk9uxsGrnXn4AVa4PVuhWqnsW1Xa/DsmxU6a3w2mmYslv0PNNiO6FF/NiS8eE78bMxtdJBUPPjAjmcj7yMAPaWhlWbzeLft2xBOhWDzx+GVjkFKbd3jwbJFEE96rybcPbaF9BuZIrpniVn0KD6AXc5zNbHAcnKR9pMA460Fo7rFOQSOqTEckh+F5xUNxzTgKZ2QUmbop40o0UQsv6F5OJ6hC7493zE2aNCGj0ZUJdAqZkKaB9Cy/YoyttWIhEdjZ0d9SiXWhBwDDhuGba7FU42dbhHghlG+FUNVQ3T0L5jTV7sufPblG/dP237QNwz99ZAndOJGYZhhgYWekxJMyrixqfPqkRatyG9+DQcKQtbMXFMbjmslmchh2ughhthZ2XhXCjVjS8KD6rhyz5/H/QV/xJNf0V/PVnFWLShFQFxDB3rkS202mGY2Sx2pN14r8WG5TjIVHlhZWzRiqHkHCN7UajLKYg2+td7cleYzCHVDR8k7Ep14cnFDyAxdirKNf8eDZIpsnf5uGP3iAyW0vgJI5aa85Bb8UfA5QZ0C06O6kZ1bDYjyDW1Yow/B082BklPQIIKRTJh2zogqaIPoaamISd2wWh7B5lXbwNynbDI5dDcAmeHCqW8AeO8NbCdTridMkguHd7y7ZAUAw6iQGI0rKY1cHIZSB5232QO7Ly9fPIpeNQbQFc2gXJPEJeNniME4EBp2/tdnMllhLijfnr0SHEWcjoxwzDMkMFCjyl5hPBwciKaVGgmTZNbx9Dh6Bnou7ZAa5wBubw23/OOohz+EJBOQk8lAdUFh/rAkWFLoFykgo6JeGBJAch6CslYNxxHQlIO4AXvqdjaacKvyVi7K4fx1XnBQ46RVDdYSpCA2xlrwaOta9Gup1ClBXD56Dl9RJs4LpuGTf3dFFWs/D8p5RDVbai2tdcGySPBoEGumgPZewycXBtsUFSvGYauQou3wWcbMF0BZGMSvKYNx7ag+CxIZgY5VxAqLJSZSZjRx5D6511wLBKA5YCzlc42OKYGO+uHK90qjF5Unw7UrYUkZwBbgWTS32In7HhgRDjCMkOH+GxOPn2Pz+ZAadv7/dxqXjT7/MW6vwhkXOStwgROJ2YYhhkSWOgxIwMyrAiE4cQ6oGey6E7bkA0ViU4TLlcKCSWFcePrUL3g3yEZOTRHc2h68A7kDAd+1GOs0g7F0iG53JBCVeKnVjMO+vb1sKQUZLcHzVojknre8aLMKyNnOtjcruPUyX54XaUlVKiuJvPGU/hjagfedUnQ/WXwal7EzSy+OX1+cYJndjYjt/gJGNvXiX3Z2rGIku+HcCVVoFsGWjNxpJKU0hmC1GMMMlBksNSgyKXvhK8jveTHQHw9HDWMeOdoqFYOmpFAW+44jJZeoD7qcBwZyGqQ/Um4FBN2WkFWluEJAko2KtI+4ersuaIrgCzB0buEMYsUPgOy9DIcVQdsKX+MkoLkuIBgsCRFNPP+MtBn82AXZ6gFS3QHmQLlRL0fbX/2fXrfDMMwIw0WesyIgCYdZIpC/ca6cgpMyGh2j0fAiCJnSojJIfxTPQHXUKRP82LhmiRGS0F4EEdK8qEpPBuTXO1QRk+FpKqiBYBjWVD8ZeiURyEp+1HlAOemFuOflZcIp0gjb0yHs2aUlcxkWvQPNHNwXv4/xLesxDs1QWRNBZJtIqtU4+2ubUgZORG5c7VsR/rh/8nXgckK0pIEb0sTIlOmYVdlLVZ1bEFzOgaXoUNevQRXdSXQEKqBHKqCe+bJUMZME2KolHGNOhaBBX9F+olfArIH8UwXfNEmyLaJQCIBMzMaLqSA6mZILsBIa4j7qoX7q6TYkEgg+2RSjYCUAyw571xoB+BkHSBbCYXSN2vqAIr6GUmR9in+aRG4xp4g+pkxzFAw2MUZSvmmFizq2Bn55uqygpgklZbxEsMwzGGEhR4zYiCjD+eM6/Bm6yhMW/cwgplWxKUA/hG6CKMrGjFn04uIpw3AH4aRORabR52Gidufhz/TAVe2A/aEBrh8AWgnXJh/rngX0s/djdG6g81tOaRzNsJOEm7oyNoa3IqMOWO8GF9VGhOWnemYSM3qSnfD17UJ82xTCDrqbi56uTk2cpaF3733NGKbl6Fsx0Ys2LlDpL4+PbYRMa8PFf4ITj76fHx/3UtYG2+HZBnwmwaW6Bn4cp34xLurhGjMvHA/lIZJ8F/6WRhjp+5h2lJKyF4/lHA97EQMY50WdEsW0p5KqI4FjVI6bVvU1cGi398FTU9DQgp2jvo0GnDSHsBtwFEUWNQp0rIhIQ5FqYTLexqcWBRyZQCOVAcbzYCRyDdnr7oIvjM+UrLjygyzliyU2n2gtX0MwzDMAcFCjxlRUJ3c6NQGbFZGIaPVwHRkTM5tQmjzVoTKslAdFcjEMHvnIiQcL9xGCoFMK/RgLdz+AIxUEtKbz8A7/3pIZeWQgxGgs0sESEj0pJQgdMktGleXUjCKInmF+hu6HZWB5wNuzOqKYnnAJ9II5Vg7tFA1YjvXwe7ciZgi46nafB/CmJWDmXXQAQcvvv0kOmyZOuTBY5IFg4M2zY0ORUU2l4JXUgBJxo7uVjzzr7uRTp81oGlLyRjZ6A60Y+dDX/wkXHYOFRUuoLIBaGsB0jVwUlE4ZgskleLQJhTHQNI1Ck5XGF7vchEFkfRRyOppyJ44JHdOmHhmdAvuoBdKXQO0k29C+vXvQ4YGqBpk+RgowXGQI6XVhJ4pjZYsvPjAMAwzNLDQKwF0Xcdzzz2Ld955B5lMBuFwGGeeeRbmzp3LX5j9oBqwScEs2ltkqC4XHMtBjdyNgJ5FY7YL5maqdXJjUk7HRm0SDMeBz0qj0mjGe9t9yJmA5spi7DEJ1FeXwTX3XKx86FHIZgZZVxkWqyfApcqYVu+BS5FgO6VhxEIpVjQRs7Mp0eCbfrGYkcVl25qAujq8G4kAyW5kyDTPAryWDVOS0a5posfWdr8POZcbHk8Ao40UVMOCopEg3k3I0OGxLAoRiujUovIQuqleTc8iKkkDmrYMZ3bFDOHIGktbCPtcuODoM+BL/w3Q14t2C47PB0maDps6IGRGwQm2QVZMKDrQZc2BHI6gIgpIqSxsqRuu+l1wXDrFCAFDgdtJwOxYCFftxyF56mAZJ8HlMiDRQgSNYaqbm6Uzh52RYLzEMAxzuGChN8yjAXfd9Vf86U9/RDQa7XPf3XffhYkTJ+KrX/06TjrpJIxUhKNgLlM0+KCf4apy1LXlYBiGsKpPu8oxNr4KLluHI0swMmlkYt3IVU2CpgKhoAfdCeqXlwUUDd1SGRauyuECl47Hlrnwkr0AQb+OUdVBpDsN6IYjBIzLyiIQLA0jFpFi5fKibetKwMhBCoQQ6u7AmFQKHtvB9EQCVLm4SnVhtScANeCnFuAo03UYioKcogCaD0lZwjIYlGAoQqC2JEG1bYxKZ3Hhzl1IKwp8lo20oqJNVSGrGlyqm+xFDqgv13A6Lwsij4ilTGx48y7M9kbhGKTyTMDTAcdZBYRTkFymSLd0usfAbQQwdVYdVFWF2S3BdpdDLtsFS5JpRIVVvWihoFNPyCzSm97ByqYkvLEmGMFqjBkVQUCThDkRN0tnjgRK3XiJYRjmcMFCbxhPFH/wg+/joYceFNs1NbU4//zzRTRv69atePrpRdi4cSM+/elP4vbbf4LzzluAkQY5Q+aWPg09HsXr2zrgmnQ0Zpx+CV5PTkRjdDECmTgsbxl2TbkSkVwbkNwOt2PAkFxQFB+q4+uh2Ca6HQuKkUKVtR5ZLYRl9Vcjmrbw2DvUiN2G5paRMDRs6TTQWOlGpq0Zx2x5HSEnicZx1bCjF4iavuE+Ebu0egr+b+Vr6DRyCCdiOKYrhj80NuKVqkpojoPGdBqNuokXfCoiiht+I4OqbA6bgwG4TAvZbBpxlwK/A0zL2dhIZjWGjpPa2nByZzsW1dWiw63Ba1tIKgpeK4/AcrtRs/UdHFUzEWPLR5VM7Q6laxZEHqEiDTPdjHYpBxshqIqDkKsTstMBydAAk9wyDcg1KUj6VBGNTlkqmj3j4U7vQtivQ5XDoPCfouiU+QpHsWBnckh2xqGXG3B8IfgSrdjc6sPsaXXCnIijJwzDMAxTurDQG6b87W+PCJFHroRf+9rX8dGPXiVW+At89atfww9/+AM8+eQT+MY3vo4pU6aisbFxj+dZuXIlHnjgfnF72rRpuPbafxvS9/ncc8/B5VJxxhnzDurxB/v+SAi3v7IQW7a2iRYJ/1qxCeGmFmwNnobRO5cjERoLKWhBUVWMSqxH3FsDXfHCsU10JB1MdTWJ6AihGinoWgit4SlwZBW1nSuRqpmOZNYGBQnHV2nY3J4Tr1NbpuJyZRk8uglV9kKyEqJZuPfc64f9pFqOGTj3vW1QE9vgsW08NKYGKdmBZlvIKSq2BIKY6i2HGz7IMqWyOtgUdMGGjZmJGOKqircqIkjIMrbKEibEOiDZCj66sxP3ja3GinAIOVlC1OUSkb6gYSLhcqHN1rG9bQs+f1TpCBNK5Q37lLzYcxw4BtCSq0Ct5oEqZWE5DrKGAp/mhuyuhZNKAJYFuboS3jk3wFz/Hrasb4M3m0DMNw6Sqw1lxg74PH44dlLUPUr01EYOXqsJY5WtMLxu6MEyvF1zNWbNOw2KRnFShmEYhmFKlRKyiyhNhJ19zu7T1Ni2bfzlL38Wtz//+f/Axz52bR+RRwSDQfzwhz/CCSecIFIU77//vgGfv7w8gg996ENiAr106RtD/v7XrFmNdevWHfTjD/b9kQtkQeQRpu2gK5pCJtoFjx4XaYOOpIixsRIxNNWdKKJ15PyWVX2I+uvREZ6M9vAkmJ4yRPwKNBeFSYCwFcWlM91iHxHwyJjZ4MUZ0wK4+WQvArkoVJn6wPW8lyT1iMpiOEPn3Iann0TcFYHXcpCVgA7VJRrMN2ayIqKXk2VEcmmE052Q7JyIhtqSDb9loDKXRbPXA9WGEHC65GCHz41y3YDlWD0iTwb5RVKaJwk8xQEimRzKHQmNpo1yMmkpEeh8vmBOCHVOJ2ZufATHbX4IlTE/opgOCx4Ykhdd5kRAbhTpq3KoEkp1A1xTz4C5eQ2MdBI5S0LKW4VIvAm+7RZcmTQc6qdn+IFkFZDWIAUScDVuhMe/HR6ri/KJMVF9Hh4rw43SGYZhGKbE4YjesDFrUPITw5CKf732BpqamuD3+3HNNdcUnfsoStA74qEoCm644UYsWbIEjz/+D3zpS1+G19u3Z1Z9/ShceullME0Lr7zy0j7fT1dXFx5++P+wY8cOMfH/6Ec/ilmzZuO1117DU08tFNHFUaNG4YorrkRVVRWamrbipZdeEj3ltm3bJqJ655xzzqDGYDDv75lnnoamaWhtbcW6DZtQFuvGnJrdLo267IZaFkHWXYZgugWhQqqmVoZ1ihvvTbxSNKu2FTfGbHsUSMagal6EQn64VQnTqySYLVsg2xLcyx7DBVPPwsKtXvH3IdF3wbgMcq88CXNHXtgqteMge/wlUQuVTqaFYNVdQaS0CGBGEdJ1pGRAkxXMSKQA2xR/J6uqEklVhc+RUWbmMDadwsU7d6FLc2NcKo0twSDSiltEss5r2QmfRRYuZMFCK08OVNuBLOcFOp3NXkdCteaH1xtEKUGf5cuVpdDrDKiyB+/tALrbj8aL9V/H1i4DPj2FqxPPYlJgMdweC+qYufCMugLZDYugSIDHlW/j4c1FkXVVQm5Xobg2Q5J0QPMDvjZIiguyY4ioquruhumbjenZN5F56jeQgzUifXO4pxUzDMMwDDMwLPSGi1lD2sIDi7tQ5lXw2tNviX1zjzsZMd2N+5Z27haDs8sQ8qlF0XfCCSeirKwM8XhcCLRJkyYd9Hv6+te/hrq6Ohx99NFC1JWXV4j9tbU1IupG4m/z5s248cZP4G9/exSBQBD19fUi2kj3NzSMwvvJ6tWr8eijj+Kiiy7EmIZ63LFwIawTT8LcmjBsSUY6Mg6XHhvBC7l5qF36S2iOgVDIB6dqFGa0v4qlYy5HoMwvBHX1CZchuXgRlGQHIE8XkT5r63uQZQlKzTjY3R0Ir30eN5x7HbLkm6EC2efuhpPqFgLPatkq/ikzTi6JWihfwCcEa3umEy+OCiENL3KSjSavhoyiIGQYaEiToyMQNA24HRsuWcVRiSTCuSzKDQsVuolut4QpKYriZVGVy2JSMopmr1ekFnSSCydFTA0dNVkbKhzYsoa57iCuOOai0muensvAScWEOysxvlrDptYktrbb0BU/GkaV4zXtRqx1X4/rTw9DdgXyj/M+Cbv7RUwoTyCaBJROG4oahsdXASluAoEdkFxqT+P0MCRvDi7K45QVjHXHIJkaALcQ7qWSVswwDMMwzJ6w0DvCzRooY9O0HCgysGJnVtj225YpjmlPy33E4I4uA999tAUTayitUC1GADWPF4jHRRuGQyEa7cJZZ50lInPl5eXF/Q0No0VrB0rRpPYO7e3tQlSOGzcOkydPFlE2isp9EJDD6H/+59fEbZe/Ag/fdw/O9ncjnG5BDXYUvl8AACElSURBVLpRFV2La86agHh6qmhITQKO5rhzHR3HnhbMCxpJgtUlQdVTMLevo2onSPUTIIWqIGk+WK1bAT0HuDW455wBX+24fMNwStGkqBRF8cZOB2wLnjM+Atnjw3CHRNbEk47Hc/+6GxlLh+SY2BQqg+TYmBXLO76uC5ZhRnc3GpMpbAkEkFNlBBUXLujugisYxgXROBZVVSBKhizJDE7vysFUffj7uLHIuT2QZQW2bSFgmPj+ylWi3YJVVovqE6bA6/aLMS66p5YC9LsEwsXzJqDJmD6pFhNsMmORi6m/nYYbOfjhk6R8umVlF5xkAqq1HZVhG5hkIRCtgmwF4GA0JM80+K7/EfR3fwRr5wo4ejccuROyPwSkNCjq7rYrxbRirW+kn2EYhmGY4Q8LvSMUisjJEvB2UwaGZYtVf8uGqP3yBvMia1fTeuyK6vC687VLBUMQ0waiKQv3vNoFVe9AR3u7uN9yhw7pPX3/+z/E7353B37xi58LY5f/+q8fYMKECfjRj36InTt34swzz4TP5xO1dMkkGUJ88IwePbp4e+aUsfhbdBsavB54qY+dkUHqid8j+NlfwB2KFCfYNHmWvH54fB5RD+mx0ki8/hSkzSvg5NKwujsAaitAuKleqgqylhdvuWUvQpn/8eKk3U7EhDC3HQdaoGzYp2wWoDFy71qOjkAYWtqCbCSQkanpeT69ktIt6T9qnO63LBHJC5oybomMh5WWIBlZ1OeSuMlfj3RXM7RYh0jdTAe8WF4WgCPLqDBtYR5CRiwU1aNaQMRaoL/1LMy3noVr8lwoVaNKJt2QxBb9LhRVo3ORzp/AsfNR9Z6rjyMnReqLLTrMFCBlIZXZkIwIPQkcD9Xb7YTTORlyIAzfBTfB5Q1DmfVZ6MH7YKdbIXmr4R5zGXJLluT75xXeQwmkFTMMwzAMMzAs9I5QmmMGVmzLiJ9EVUCG20XTagejp58MxaWhu2WziKSVNRyFMRVuIfI0l4SsbmNLu44dUQPSur/BcWzUNM7CGzs9mDnROeiIyNSpU/Hzn/9CTPpJ7N1zz9347ne/h+XLl+G2236MadOmi2geuX0WcLvd+X51HxDvvPN2XrhJEt589RWMCahALg0nFRfCwtyyEsayl+A+dj70t56B1bETdlcLsv5qLPvV/yCV0ZFJG2g0tsDvZFHmJIF0QkTnRNUYRe7MFkhjpkKtHScmzU4uI8RObPKZWPnE48i27ECF0QapvA7jzb+g6rTh316B0gzVRAw+U0KnJ4gOLxDVXKIHHok7svOnsrqNwYAY+9mpLOYp5VjZrsBwxsLyqziqMg1/pBz+RBfsQAipTEKYuUgiJZNcIk0xjoWzk1xPKZUTnbuE+DO3vAfJ4y+pdEM6L+h3EVE1t6fHpGXP2tzi76r6IbnKADMjRB4h+yogH30svBO+CCk8qpjiqgTGwHPU1wEzDaj5SLV0XKSPsCyFtGKGYRiGYQaGhd4RCNW6/d/SGNKGjXKfDIMcI1MWAhqwrjmHhnIfwpNOR+fqZ7Ht+Z8jcs4PkNWrEfYrqAu5sKVDR8awobesQPzdv4nnnHLipWLimDHypi0FyLiERNvWpia0tbbgW9/6JhYsWIBTTjl1j/f1/e//F7LZrEgBpajdt7/9/8R+OvaLX/wCZsw4CuvXrxc1gQVmzJiBb3/7Wz0Rv7OEScuSJYvxqU99WtxPhi0PPfSQaAcxEPT+fvnLXwjzmZaW5n2+PyKRSOCaa64S9YPLl72Lnx0ThNO+A7BIbEqAmcMbv78Ny/2N+NSXvw7n3edFLdP2rVHUty2BZRiIymGYkgNZSiJn5kT7gN2ep9TLOgfb1GFagCrJ6H7uQSAdw/pODS9nJ+I8/R14rBTMzm3Ytl5GmedpeOcPc2GieaGVleP01jR+HzaQc1TRI4/Y4vfDa9kYm0rDb1tIuDWsr65DsisKyd0F3V8G1YxjSTqJyym6FKnEk0ENMVcNKsrrMdnKYYOjI+Nk4DYNzI51w2OR/6YwOYVE6YoinbYFqmWUXLqhOC96/S71YRduPL1CfFYpktf7vKHb7gkfh9m+GE6uA5LqgxyaCsVTDTnSsMc5JrZd1Dh978KSYRiGYZjShIXeEei0+ehbMby0JoHWbhO0OG9YDlyKjOqQjMm1brhVGbXH/xvi25bBiO9C+8IvITn5fEyefwHciCC2awNiaxahe+0/hROiu+F4hCee3DcFrIduXUWmbDqCU6aiZqaMSWO8qK0dOPp0zDHHiOicx+MRbR0KaZJf+cp/4rTTTkMqlcKcOUdjxYoVaGhoEPedeupp+O1vf4fNmzcJMxYyaKHIX4G3334b6XR6r+NBLqFk5EL/Cuzt/RHnnjsf8+bNE6YwXzt9OvzvPQ+nI4pTKvLpraYjwWsbqOxuQexPt0JJdYqIZ30mk48oORYC6BYOkKbsETVjvUUe4UBGVyyDeKoJG+TRgN0F2bGQ1CXM05fCZadhKzJUS4c7tg16vBzeYS5MRJrhcedhZvQBTOtsgkVmK7YhonFZxxGtEFwUSVVc2Eb1eWYO9WYaaynC5yQwI5NCtyLhCTqwezu6NQ8kVwDd4UoEO3fhVFNGWyKBilQK83fshCW5ITs5qo7seQMyrYCIXnJSuKrk0w1pvHsvyPRGDY6F/8Q7oW+6C7bRDVmrgrvxmgMWbf2FJcMwDMMwpQkLvSPQaTOZtUStGDk86qYN2wFkycHYCreYpKV1G6qvAmMu/hG2PvldWPEdSK+4H/9YkW8s3hv3mJNQduIX0Npt4xOn+fd4vZc3OaifdW5xn+FTMGFC3k2zPxdccOFe3/txxx1fvH366af3uY+ievRvoDq6ceMaMX/+eXt9XooODtbIZcKEiRg/qh6pfyxHNks1TRImBRQh2Ei4jfK4ENbcsNqahPU83S87cv52TxSJPhiqnUYO1PBbErb/NI22ISMpB9AcnISulA0t1YoKKwqXYyAHBV47ixzccNORqgwNOly+QEkIEzlSg6qAFzVxF6LkDqTnhUW9pAiBF1MVmGYOOVUVffVoHMnY35Ek6JDgBtDhmIDmgZvGw7ZgNa2GHa7G1VubgEwKGkXrFA2IlImok6NnkZYAr2lC9gUgl+dbAoz0SJQSGAvPrP/XJy2TYRiGYRimNyz0jkCnTTJd8WsKTNuCLElQKG3NcbChNQevW8bs0R4cM86Ld1CPsvN+CnPHYpibFiHTulY8j6y44G44DhVHXSjq93TTwab2HL7zaAuObfTjo8eHEfYqSOm2MG3pPUccKL3z/YSihEMFRfNcLld+g8xRfCHA1OHIKhzhVErSw0FKKYMnF4VMPfN64nU0xv2hPZqQKhIsKFBgidskYRqaX8cEmyJONky40C6XQ5YUVDgxdEoh+KwsdNuNVqUKuTFnYWYpTMSpFjGXwYVZCwu9EqIuDeFMGhdaEtQps7CoIoK2pvcQMdKo1XVIsgZ3j0kLBfJMxYXaXBxwuRHXelwfjRyqKsfAt2EDJFkFKkZBrqgTrSlaq+vxeLoNMVlC2HLw4VOuRvnRZ7Oo2UtaJsMwDMMwTG9Y6B1BkLii9EoSX0GvDPJeURUFluUgmraLE1wyW7jq+DCCHhkvUSJh9dmom7cA725NwjR01Ff6YdlS3qIdDjqSpnisYTp4Y1MSy5rSom0DTcBJSDZWaQh48gYOA6V3Dhd6Rw1FLdPcs5F45TEYOTL5yJ/qQrQZuojW0e18QicNxu4EzUJtWGEPjaEBGUbP0R6b4nwiViX6v0kwUGl3IiEFkZApVdFB0ElBclLYqpfhoX9uwIyjxg3/PnCaF3IwgobKMbihZSsy5IzpCyJw1ZeFMc1nHQdd0QQ6k5143J3FBsfEpGw3dMUDyw2EdR3nd8WgBMvxlMcWUcGI4sZlM8+BFs/CjlPPQvo7ObCTUTwVLkMiEoBimUh6/Fjod+Ezh3sMGIZhGIZhhgks9I4g8o57IZG+Ob5KE46bVUEF27oMnDTKC80li/YKpmWLOj0ybDhrRhmeXxXHi2uSMBwZ4aAfpk09uJxilJAIefMipS1OvfksVAYVIfIkycaumI5JNR5E/P0c/oY5cs1Y/Mt3Ehoyy1BvtQgBl4QXG6QGfAjUWiGfXlhAV3yQbUOkYdKxZHBfqBGjxE2dEjIlBV4n07OH/nOgioROHbLTjbTlE1FASvU0JBc8Thanb/s/dCXOQGWIGlWXRjsA6ifo9gagnXAh1Iq64v2R486H782n8alEFK/rLuwKnoHazpWQjG54vQFMvOKj0F97FDd0diMbDKFiwXVwBytgHde7zUAEmP1xxNa9AIn6FXr9UGobETUyyFgGfColgTIMwzAMwzAjRuht375duDRSk+7ezo/DCXLcu+G0clH/FfFJIo3yrlejSOUs4fKYyFrY3qnjzhfaUR1yCWF25vQgXlyTEDV3sbSJkEeBqko4frJHRAVf35gW0Tz6Z1n52r+ClnMcCeMq3bjh9AqU+5WSEXlEV8rBc2Xn4KPdG2HYefmVlPwISxkYcIuETBJkBP1sc9WIfnveZBtcdlbcS6ShCTMQS3KhWwqgwcr2SMB83R5BP91CGtJ9eRQnn+pZ5iTg1ql3WTWGO/tzbex9/8y0gm3L41gZmYYKzcR5c6vhjbihzTkDSMYQCoR3twLo97xkFVJtJ9CVTVAucl5Eun3wKj2puQzDMAzDMEzpCz2y/P/Yxz6GRYsWYezYscKK//bbb8fnPvc5DEfXzUIPLRISliOhvdvA6l1ZWLaD9gTVmkFsN0TciGcsYd6ytd1A1rB7mqXbIK+MrOGgzCsjmbXRGjeEqQtFBD0uSuOk246o+asM5NNDC/3nSoUK6j1YFsYubQy8ZgoRK4YwEgg7KXS7IpCNHDTJgK1oSATrRR9CDzKIlY3FZtQJ0RE0Y+hQK2G7/bDIdCQTRxlS8Nsp+JxMT0xQAtw+2IYukjtNEojUs4/q+iRACYbhLx/Y4GY4sj/XxsL99RoGbBMgxF1Z+X6f97LRc/DojuWI6mkh8i5rmF1S5yfDMAzDMMz7SUkIve9973tYunQpNm3ahLq6Ojz22GO47LLLcNxxx+H443e7QQ4X100SeYmMhcUbUzAtR0TgfG6gPW6KqB7NdUkE7ojqeGtLPh2TUjXtnlIzag1AgmNn1EBLjCbWPSVokoRyv4y0QQ3ZdTH5rgio+OeqBJ5dmRQRvc+cU4U5Y3woBUhQ3HjOKLy+NUS2pYBD7pmADhVJNYSN3kbUBxwomgc5LYRVEy5HpZpGm+lH2K9i3kQFz6zW0dmdxoYuSQjBMkVHtDyLqTufx+j2t1GR3gFZdUFSVZi2g5ziw66ySaiMboAMG77ycpRf/kkoSj51dqSxrzYB+2OUL4zPTDpNpGtSJI9FHsMwDMMwzAgTen/5y1/w6U9/Wog84tJLL8VRRx0l9g8noVdw3STBt6lNF9s5wxYirTsNZPLu/8IlhJw5XeQgmbVFVI+ifXmDlTw6ZRGK6FJPsVnPA7d1WXDJEOYrEZ+MrZ26iAK6FAntCRk/W9SGv9w0Zvgbh/Qwqc6HJUedisCKFbBMCQlbxU61ATURF04eXYu29m50S0F0TDwTV59chbqQ2icC5QtShFWFx28ioCm4ZG5IpNem9Zlwd21D9sWHYKx6HbBMKLXj0KY1wnDcaK6ehDGnnIZpM48asSJvKBB/A67JYxiGYRiGGXlCb9euXaIub+7cuX32UzTv3Xff3evjcrmc+Fegu5tqqIBYLAabGjMfBkjgue2UcMlMJdLIpk0RpRPvV3dEpK7P8QbgjZDhh4VEzoZh9TGP3Cuk+3yShOYskMnm68wkBUjkJGzOydiy04+KYGnUQtGY5gIV2BCaIVoqOFDgc8kYN7EGnjOvQkTPIiNp8LnJoTSFntMAes/jKbZ55WwFGUPuEX/p4jGGNwJnwSfhzPs3QM/BFQxjEqgdXAZev1eI5UQicdh+d4ZhGIZhGGZ4QfPHYDA4JJlMw17odXV1iZ8VFX1roGi7cN9A3HbbbSLlsz9U4zecWP0+POfE72OE8NnD/QYYhmEYhmEYpg9tbW2oqqoCRrrQKzTIJkOW3mQyGbjde7dh/8Y3voEvfelLxW2K4pEwJIE4XGuB4vE4Ro8eLdxHh6vr6JEEjyeP55EMn588nkcyfH7yWB6p8LnJ4zkczs99aZgRJfRoMCjEuXPnzj77aXvMmDF7fZymaeJfb8LhMEoBEnks9Hg8j1T4/OTxPJLh85PH80iFz00ezyMZPj+HlqEKOg17xw2fz4eTTjoJjz/+eHFfKpXCP//5T5xzzjmH9b0xDMMwDMMwDMMcDoZ9RI/4wQ9+IEQdpWOeeOKJ+NWvfoXq6mrcfPPNh/utMQzDMAzDMAzDfOAM+4gecfrpp+PFF18UjdJ/8YtfYMaMGXj11VcRCAQwkqBU1FtvvXWPlFSGx/NIgM9PHs8jGT4/eTyPVPjc5PE8kuHz88geT8kh/3mGYRiGYRiGYRimZCiJiB7DMAzDMAzDMAyzGxZ6DMMwDMMwDMMwJQYLPYZhGIZhGIZhmBKjJFw3md29A7ds2YLZs2cjGAzysBwCuVwO69atQygUEv0Yh6qfyUhF13WsXbtWtENpbGyEoiiH+y2VBCtXrkQsFsMJJ5wAVeXL+WBJJBJYvnz5HvvnzJkz4sy8hppNmzYhm81i2rRpotctM3jefPNN8V3Un8rKSkydOpWH9CCwLAubN28Wn/1x48ahvLycx/EQoPNz48aN4jZ/1gdPZ2cn1qxZgylTpqCqqmrAY1paWrB9+3aMHz8eFRUVg38RMmNhhjdLlixxLrnkEqeyspKMdZzFixcf7rc0bInH487nP/95JxKJOLNmzXJqamqco446ynnnnXcO91sblhiG4Xzzm98U5+acOXOc+vp6Z+zYsc5zzz13uN/asOeNN95wNE0Tn/n29vbD/XaGJXStpPE78cQTnZNPPrn4b+3atYf7rQ1b3n33XWfmzJlOdXW1M3fuXGfGjBnOsmXLDvfbGpZcdtllfc5LOk/pfP30pz99uN/asOSVV15xxo0b5zQ0NDhHH3204/V6nU984hOOaZqH+60NS+6++26nvLzcmTp1qtPY2OhMmDCBP+sHCH3HXHfddU5dXZ34TN9zzz17HGNZlnPzzTeL7/np06eLnzSfGiy8zFYCvPfee7j++uvxr3/963C/lWFPe3s7JkyYIKKjtNJPqyhHHXUULr30UloUOdxvb1iu9tEq1bZt2/Duu+9ix44duPDCC/GRj3wEtm0f7rc3bOnu7sbHPvYxfO5znzvcb6UkePbZZ0VLnsI/Wl1lBk9rayvOPvtsnHLKKdi1axfeeust/OMf/0BzczMP50Hw97//vc95+f/+3/8T+z/+8Y/zeB4ENG6nnnqqaMX1zjvvYOnSpbj77rvxwAMP8HgOklWrVuETn/gEbr/9dhGRoijp1Vdfjcsuu0xk8DD7hsZs3rx5IvNhb9xxxx146KGHsGzZMjHe1Ebuv//7v8V1YTCw0CsBbrzxRvHh4tStQ4dC45///Ofh9XrFtsvlEuNLQoVEHzM4/H4/vvCFLxTHk1Jgqe8lpRumUikezoPk5ptvxpVXXinGkjl0NmzYIL5M+Zw8NKiPLaVl/+xnPyumZ9PC2Xnnncen6RDwpz/9CbNmzcJxxx3H43mQC7nHH398MZWYFnHD4bDYzwyOV155Rcw5b7jhhuK+W265RZQP/fOf/+Th3A8UPKCFh8LcaCD+/Oc/48Mf/nAxTfvEE0/EWWedJfYPBhZ6DHMAdRJUW1ZXV8djdZBQDj9FnO+77z58+9vfxje+8Q2uIz1I/vCHP4hVwP/6r//i83GIuOSSS3DVVVeJep0vfelLoo6HGTzPP/88zjnnHDGRpgg+Tfo4cj80kBh5/PHHcdNNN/GpeZD86Ec/wv/+7//i3nvvxXPPPScWzOh7/brrruMxHSR0raSMnY6OjuI+yoQi3n77bR7PQ4S+gyhbb+7cuX320yIPXVsHA1fvM8x+zC5++MMf4utf/7qI7jEHx9/+9jeRwkXpHQ0NDWKVihk8q1evxje/+U2RxsXn49BMVl544QWRQkMsWbJEpB5SujEtRjCDg9I1R40aJSIltFJNJgJkHnD//fcLkzDm4LnnnntElPTaa6/lYTxIqGzgsccew9e+9jXxGacsHRJ/B2VwMcKhsaRoPWWTffWrXxXGSzRXoiyerq6uw/32hj2JRAKGYexxbtL2YMeXI3oMsxcoakIpRxdddBG+9a1v8TgdAvTF+vrrr4sVP0o9OOOMM4TbFDM4KNWDUj5odZ/EHgk/4o033hB1J8zgmDx5clHkEeReSmP84IMP8lAeBLT4sHDhQhG5p1RYSnmnMaZoKXPoaZu0QEaphszgoegTfdZJnNB5SecnZZn853/+J/74xz/ykA4SEnSLFy/Gaaedht/97nfimvnLX/5SLJ7tKx2ROTAKC7kkoHuTyWTgdrsxGFjoMcwAUOSJvhTIVIBWUtkefGigFWlKjSMzEfqSYAYHpRlRETdFmOnfXXfdJfZ///vfx6JFi3g4h4CamppiChIzOMiu/thjjxX/CJqQkGEDtVbpneLFDA6KNNOiDqdtHlp2ztatW/GpT32qWD86ffp08T1PKbHM4KE2HxQRfeqpp4RBCLVXKBjYMYcupCl61/+7iLap5ddgYKHHMP2gLwO6+FPhK+Xyc8+3g2cgc4tCzx1Olxk8lP7a24WPHM+IJ598UkxgmEM/P6l2hycqB8f8+fOFw2bvujxy2iXBV1ZWxqfnQUIRJ3KCJcdI5uAo9Cij87E3tL23/mXMvqHoUn+XyEgkIrKgmEOH6p2feOKJPnV7lDFB+wcD1+iVAFQHQZPngvJfsWIFTNMUq6tUD8UMzh6cRB5NSshBilZSC3Aj+sHz9NNPC4coaqdAtTvUhJ7ECaXEUpocwxxOqLaEnGDPPPNMEbWn6D21BCCxxwweumaSWRCZW1AtGaXIUUuAL37xi4NON2J2L0aQxfp3v/tdHpJDgKIgZLr0mc98RpQN1NbW4pFHHhHzJUo9ZAbPNddcI+ZLFBklp82f//znIoUzGAzycO4Hymois5UC69evF4u3dF5OnDhR7KNrJ5mvfPKTnxQ1kfT9RLV7X/7ylzEYJGqmN6hHMEfkKj/11ujPpz/9adFrizlwyM1ob73Jfv/734sLGjM4qA6CehVRDRldxBYsWCCEH0dKDx2qeySxQqt8oVCIT81BQiuklP5KCxK0Ok2pR/T5Hz16NI/lQdLW1oaf/OQnogaKUrsKjqYkqJnBQ2ZBt956q0iN48jToUH93eh7/OWXX0Y8Hhf1ejRPmjlzJp+aBwGZgtx2223is97Y2CgWeubMmcNjeQDQgiK1nuoPRUPJ06AAicGf/vSnYtFs0qRJ4vue2oANBhZ6DMMwDMMwDMMwJQbX6DEMwzAMwzAMw5QYLPQYhmEYhmEYhmFKDBZ6DMMwDMMwDMMwJQYLPYZhGIZhGIZhmBKDhR7DMAzDMAzDMEyJwUKPYRiGYRiGYRimxGChxzAMwzAMwzAMU2Kw0GMYhmGYIWLLli14/PHHD3ibYRiGYd4vWOgxDMMwJcfatWvx5JNP4vXXX0c6nR704zdv3ownnnhi0I97+eWXccsttxzw9sG+DsMwDMPsDxZ6DMMwTMmQSCRwzjnn4KSTTsIdd9yBb3zjG5g2bRp+/vOfD+p5XnjhBXzuc58b8vfX2NiISy655H1/HYZhGIZReQgYhmGYUuF73/seNm7cKCJl4XBY7Ovu7u6TLtnS0oKXXnpJ3PZ6vZgyZQqmTp1avH/nzp148803kUql8OCDD4p9s2fPFoKRaGpqwrJly1BRUYFjjjkGPp/vgN/fmDFjMH/+/CF5nc7OTrz99ttQVRXHHnssysrKDnrcGIZhmNKDhR7DMAxTMqxcuRJz584tijwiFArh3/7t34rbra2teOyxx8RtElmvvfYaFixYgHvvvReSJKG5uRnvvvuuSPksHEcii8TgF77wBXHcCSecgI6ODnHs3/72N3zoQx86oPdHqZvf/va3cfHFFx/S69Dx1113nfhd3W43Nm3ahDvvvBNnnXXWkI4nwzAMM3xhoccwDMOUDCSMfvKTn4i0TUqRrK+v3+MYipoVImgECalZs2bh73//O6644goRHbv55pvxgx/8oM9xf/jDH7Bw4UKsX79eRNmIH/7wh0JwrVmzZtDv9VBeh7YpLZX+EV1dXXjvvfcG/R4YhmGY0oWFHsMwDFMykPDJZrO49dZbhelJQ0MDzjvvPHzrW9/CuHHjiscZhiHSHnft2gVd1zF69GgsXbpUCL298Ze//EUIwhdffBGO44h/gUBAGL9QxK2urm5IfocDeR1KOSUhSL+rx+NBeXk5Tj/99CF5fYZhGKY0YKHHMAzDlAyapuHHP/4xbrvtNqxatQqvvvoqfvrTn4pUx9WrV6OqqkpEvs4///xifZ7f7xfpnG1tbft87q1btwpR+Mgjj/TZ/9GPflTsHyoO5HV+9atf4aabbhK/DxnPUCrojTfeKH5/hmEYhiFY6DEMwzAlB9XaHXXUUeIfuXBOnDgRzz33HK655hoR3TvzzDNx1113FY+nqB9FzvYFmZ3Q4yg19P3kQF6H0k8pAkkRvueff16Y0FCt4f333/++vjeGYRhm+MDtFRiGYZiSgaJh/aH0RqJg0EKumxTJK0DbJJJ6Q6mShcf1FoP33XefaOHQG3LPPFgO9nUKtymN89prr8XnP/95LFmy5KDfB8MwDFN6cESPYRiGKRkoCka1d+SiSTV5FPEiN8oTTzyx6Eh56aWX4n//939FbRu1JqA0SPrZG2pn0N7eLoxSKBpIEbTvfOc7InpGzpeUNkkOmW+88YZo5fDKK68c1Ps92Ne5/PLLMWPGDBx//PHIZDIiPfXqq68eghFkGIZhSgUWegzDMEzJ8Nvf/lYIPXKtpFYGkUhE1OyRyYrL5RLHfP3rXxcmLXQ/1bT94he/wJYtWyDLu5NcJk+ejKeeekr036NaPxJb1N+O0iWp7QEJLxKKZ599Nq666qq9NkTf3/bBvg7VHlLUb/HixaK9Av0OvZ+XYRiGYSRnf0UJDMMwDMMwDMMwzLCCa/QYhmEYhmEYhmFKDBZ6DMMwDMMwDMMwJQYLPYZhGIZhGIZhmBKDhR7DMAzDMAzDMEyJwUKPYRiGYRiGYRimxGChxzAMwzAMwzAMU2Kw0GMYhmEYhmEYhikxWOgxDMMwDMMwDMOUGCz0GIZhGIZhGIZhSgwWegzDMAzDMAzDMCUGCz2GYRiGYRiGYZgSg4UewzAMwzAMwzAMSov/D4NpasP6kfX4AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(9, 4.5))\n", + "PLANE_COLORS = {1: BLUE, 2: ORANGE, 3: AQUA, 4: YELLOW}\n", + "jitter = np.random.default_rng(0).uniform(-0.18, 0.18, len(summary))\n", + "for planes, color in PLANE_COLORS.items():\n", + " selected = summary.planes == planes\n", + " ax.scatter(\n", + " summary.satellites[selected] + jitter[selected],\n", + " summary.sufficient[selected],\n", + " s=14,\n", + " color=color,\n", + " alpha=0.55,\n", + " lw=0,\n", + " label=f\"{planes} plane{'s' if planes > 1 else ''}\",\n", + " )\n", + "# the efficient designs, ringed and labeled\n", + "ax.scatter(front.satellites, front.sufficient, s=70, facecolor=\"none\", edgecolor=INK, lw=1.5, label=\"Pareto-efficient\")\n", + "for _, row in front.iterrows():\n", + " ax.annotate(\n", + " f\"{row.satellites:.0f} sat., {row.planes:.0f} pl.\",\n", + " (row.satellites, row.sufficient),\n", + " xytext=(8, -3),\n", + " textcoords=\"offset points\",\n", + " fontsize=8,\n", + " color=INK,\n", + " )\n", + "ax.set(\n", + " xlabel=\"Satellites\",\n", + " ylabel=\"Points sufficiently sampled (%)\",\n", + " xticks=range(1, MAX_SATELLITES + 1),\n", + " ylim=(0, 105),\n", + ")\n", + "ax.grid(axis=\"y\", color=\"#e6e6e3\", lw=0.8)\n", + "ax.set_axisbelow(True)\n", + "for side in (\"top\", \"right\"):\n", + " ax.spines[side].set_visible(False)\n", + "ax.legend(loc=\"upper left\", fontsize=8, frameon=False, markerscale=1.6)\n", + "ax.set_title(\"Every design: mean over 5 replicates (satellites jittered for legibility)\", fontsize=10)\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "e1f0a3b2", + "metadata": {}, + "source": [ + "Of the 1,096 feasible designs, six are Pareto-efficient (ringed in the figure). All of them fly at the highest altitude (800 km) with the wider field of regard (60 degrees), which observe the most points per satellite, so the trade is in the number of satellites and planes. One satellite samples only 4% of the points sufficiently (at least four times a day), and the share rises steeply with the number of satellites: two satellites in two planes (29%) sample twice as many points as two in one plane (14%), and six satellites in two inclined planes sample 98%. No design with more than six satellites is efficient, because six already sample nearly every point. Designs with the same number of satellites differ widely: their layout (inclination, planes, and phasing) matters as much as their number." + ] + }, + { + "cell_type": "markdown", + "id": "f2a1b4c3", + "metadata": {}, + "source": [ + "## Rank Designs with the Uncertainty of Replicates\n", + "\n", + "The means of five replicates are uncertain, and so is the front of the means: a design just behind another in the means may be ahead of it in other samples of points. `pareto_probability` estimates the probability that each design is efficient by a bootstrap: it resamples the replicates (the same replicates for every design, which keeps the correlation between designs of common random numbers) and counts how often each design is on the front of the resampled means." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a3b2c5d4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-10T05:21:15.395014Z", + "iopub.status.busy": "2026-11-10T05:21:15.394834Z", + "iopub.status.idle": "2026-11-10T05:22:06.536751Z", + "shell.execute_reply": "2026-11-10T05:22:06.535728Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanessufficientparetopareto_probability
91800 km, 60 deg FOR, SSO: 1 at 15:001.01.04.0False0.25
107800 km, 60 deg FOR, SSO: 1 at 18:001.01.04.0False0.42
827800 km, 60 deg FOR, SSO: 1 at 09:001.01.04.2True0.74
162800 km, 60 deg FOR, SSO: 2 at 12:002.01.012.2False0.22
1057800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...2.01.013.8True0.78
235800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.028.6True1.00
919800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...3.01.037.0True1.00
1038800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac...3.03.035.4False0.29
747700 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...3.03.035.8False0.28
125800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.066.4True1.00
498800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.066.2False0.15
599800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.066.4False0.32
568800 km, 60 deg FOR, Walker 45 deg: 4 x 1 (spac...4.04.066.4False0.40
499800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.8False0.32
290800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.098.0True1.00
\n", + "
" + ], + "text/plain": [ + " description satellites planes \\\n", + "91 800 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", + "107 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", + "827 800 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", + "162 800 km, 60 deg FOR, SSO: 2 at 12:00 2.0 1.0 \n", + "1057 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 1.0 \n", + "235 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", + "919 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 1.0 \n", + "1038 800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac... 3.0 3.0 \n", + "747 700 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", + "125 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", + "498 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", + "599 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", + "568 800 km, 60 deg FOR, Walker 45 deg: 4 x 1 (spac... 4.0 4.0 \n", + "499 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "290 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "\n", + " sufficient pareto pareto_probability \n", + "91 4.0 False 0.25 \n", + "107 4.0 False 0.42 \n", + "827 4.2 True 0.74 \n", + "162 12.2 False 0.22 \n", + "1057 13.8 True 0.78 \n", + "235 28.6 True 1.00 \n", + "919 37.0 True 1.00 \n", + "1038 35.4 False 0.29 \n", + "747 35.8 False 0.28 \n", + "125 66.4 True 1.00 \n", + "498 66.2 False 0.15 \n", + "599 66.4 False 0.32 \n", + "568 66.4 False 0.40 \n", + "499 97.8 False 0.32 \n", + "290 98.0 True 1.00 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import pareto_probability\n", + "\n", + "probability = pareto_probability(results, OBJECTIVES, n_resamples=1000)\n", + "probability[\"description\"] = [describe(values.loc[key]) for key in probability.design]\n", + "candidates = probability[probability.pareto_probability >= 0.1].sort_values([\"satellites\", \"planes\", \"sufficient\"])\n", + "candidates[[\"description\", \"satellites\", \"planes\", \"sufficient\", \"pareto\", \"pareto_probability\"]].round(2)" + ] + }, + { + "cell_type": "markdown", + "id": "b4c3d6e5", + "metadata": {}, + "source": [ + "Four of the six efficient designs are efficient in every resample: two satellites in two planes, three or four satellites in one plane, and six in two planes. The others are not settled by five replicates. One satellite in a sun-synchronous orbit crossing the equator at 09:00 (efficient in 74% of the resamples) samples about as many points as one crossing at 15:00 or 18:00 (25% and 42%), and six satellites in two planes with another relative spacing (32%) sample about as many as the efficient design. Designs that are efficient with a probability between 0 and 1 are equally good candidates, given the uncertainty of the estimates: more replicates (samples of points) would separate them, or a tolerance of the share (see `pareto_front`) would treat them as ties." + ] + }, + { + "cell_type": "markdown", + "id": "c5d4e7f6", + "metadata": {}, + "source": [ + "## Screen Designs with a Cheaper Analysis\n", + "\n", + "Evaluating every design is affordable here, but not for larger spaces or longer analyses. `screen` evaluates every design with a cheap study, keeps the best (whole fronts, until it keeps at least `keep` of them), and evaluates only those with the full study. A cheap study ranks designs less exactly, so a `tolerance` of an objective keeps designs that are within it of the front of the cheap study.\n", + "\n", + "The cheap study must rank designs as the full study would. Here, the screening study analyzes one replicate, rather than five, over a shorter period, with the threshold of sufficient sampling scaled to the period: 12 hours with two observations, or 6 hours with one. The table compares each screening's front with the true front (how many of its efficient designs it keeps, and its hypervolume), and its cost with that of evaluating every design." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d6e5f8a7", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-10T05:22:06.538911Z", + "iopub.status.busy": "2026-11-10T05:22:06.538543Z", + "iopub.status.idle": "2026-11-10T05:22:16.593345Z", + "shell.execute_reply": "2026-11-10T05:22:16.592274Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
screening studykeep (%)tolerance (%)designs keptefficient designs kepthypervolume (% of true front)cost (% of every design)
012 h, 1 replicate5.0NaN685 of 6100.016.0
112 h, 1 replicate10.05.02126 of 6100.023.7
26 h, 1 replicate5.0NaN551 of 679.010.2
36 h, 1 replicate20.0NaN2416 of 6100.024.8
\n", + "
" + ], + "text/plain": [ + " screening study keep (%) tolerance (%) designs kept \\\n", + "0 12 h, 1 replicate 5.0 NaN 68 \n", + "1 12 h, 1 replicate 10.0 5.0 212 \n", + "2 6 h, 1 replicate 5.0 NaN 55 \n", + "3 6 h, 1 replicate 20.0 NaN 241 \n", + "\n", + " efficient designs kept hypervolume (% of true front) \\\n", + "0 5 of 6 100.0 \n", + "1 6 of 6 100.0 \n", + "2 1 of 6 79.0 \n", + "3 6 of 6 100.0 \n", + "\n", + " cost (% of every design) \n", + "0 16.0 \n", + "1 23.7 \n", + "2 10.2 \n", + "3 24.8 " + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import screen\n", + "\n", + "full_cost = results.satellite_days.sum()\n", + "true_front = set(summary.design[summary.pareto])\n", + "screenings = []\n", + "for hours, keep, tolerance in [(12, 0.05, None), (12, 0.1, 5.0), (6, 0.05, None), (6, 0.2, None)]:\n", + " screening = screen(\n", + " designs,\n", + " [make_study(timedelta(hours=hours), replicates=1), make_study()],\n", + " OBJECTIVES,\n", + " keep=keep,\n", + " tolerance=None if tolerance is None else {\"sufficient\": tolerance},\n", + " )\n", + " screenings.append(\n", + " {\n", + " \"screening study\": f\"{hours} h, 1 replicate\",\n", + " \"keep (%)\": 100 * keep,\n", + " \"tolerance (%)\": tolerance,\n", + " \"designs kept\": len(screening.designs),\n", + " \"efficient designs kept\": f\"{len(true_front & {d.key for d in screening.designs})} of {len(true_front)}\",\n", + " \"hypervolume (% of true front)\": 100 * hypervolume(screening.final, OBJECTIVES, REFERENCE) / exact_hypervolume,\n", + " \"cost (% of every design)\": 100 * screening.results.satellite_days.sum() / full_cost,\n", + " }\n", + " )\n", + "pd.DataFrame(screenings).round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "e7f6a9b8", + "metadata": {}, + "source": [ + "The 12-hour screening study ranks designs nearly as the full study does. Keeping the best 5% of the designs finds a front with the hypervolume of the true front at 16% of the cost of evaluating every design, although it misses one efficient design, whose place a design with nearly the same objectives takes. Keeping 10%, with a tolerance of 5 percentage points, keeps every efficient design at 24% of the cost.\n", + "\n", + "The 6-hour screening study is cheaper, but ranks designs differently: one observation of a point in 6 hours separates designs less than four observations in a day do. Keeping 5% of the designs keeps only one of the six efficient ones (79% of the hypervolume), and it must keep 20% to keep them all, which costs as much as the 12-hour study. How many designs to keep depends on how well the cheap study ranks designs, which is worth checking on a sample of designs evaluated with both studies before screening a larger space." + ] + }, + { + "cell_type": "markdown", + "id": "f8a7b0c9", + "metadata": {}, + "source": [ + "## Search with Optimizers\n", + "\n", + "Larger design spaces cannot be enumerated or even screened, and an optimizer searches them for efficient designs instead. `optimize_optuna` suggests designs with Optuna's trials, which search the hierarchical design space directly (`DesignSpace.suggest`), and records the violation of the constraint of each infeasible design, which Optuna's samplers use to prefer feasible designs. `optimize_pymoo` searches the unit hypercube that encodes the design space (`DesignSpace.decode`) with a pymoo algorithm. Both evaluate each design once, however often it is proposed, and evaluate the designs proposed together in parallel.\n", + "\n", + "Each search below is given a budget of about 200 proposals, and is compared with a Latin hypercube sample of 200 designs (`DesignSpace.sample`). The designs evaluated (and the analyses of their satellites) are those of the evaluation of every design above, so they are retrieved from the cache." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "a9b8c1d0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-10T05:22:16.596081Z", + "iopub.status.busy": "2026-11-10T05:22:16.595673Z", + "iopub.status.idle": "2026-11-10T05:22:18.360695Z", + "shell.execute_reply": "2026-11-10T05:22:18.359673Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
designs evaluatedhypervolume (% of true front)
Optuna (NSGA-II)140.095.3
pymoo (NSGA-II)87.089.6
Latin hypercube sample176.080.3
\n", + "
" + ], + "text/plain": [ + " designs evaluated hypervolume (% of true front)\n", + "Optuna (NSGA-II) 140.0 95.3\n", + "pymoo (NSGA-II) 87.0 89.6\n", + "Latin hypercube sample 176.0 80.3" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import optuna\n", + "from pymoo.algorithms.moo.nsga2 import NSGA2\n", + "\n", + "from tatc.tradespace import optimize_optuna, optimize_pymoo\n", + "\n", + "optuna.logging.set_verbosity(optuna.logging.WARNING)\n", + "BUDGET = 200\n", + "study = make_study()\n", + "searches = {}\n", + "_, searches[\"Optuna (NSGA-II)\"] = optimize_optuna(\n", + " study,\n", + " OBJECTIVES,\n", + " n_trials=BUDGET,\n", + " sampler=optuna.samplers.NSGAIISampler(population_size=20, seed=1),\n", + " batch_size=20,\n", + ")\n", + "_, searches[\"pymoo (NSGA-II)\"] = optimize_pymoo(study, OBJECTIVES, NSGA2(pop_size=20), (\"n_gen\", BUDGET // 20), seed=1)\n", + "searches[\"Latin hypercube sample\"] = study.run(space.sample(BUDGET, method=\"lhs\", seed=1))\n", + "\n", + "\n", + "def get_progress(search_results):\n", + " \"\"\"The hypervolume (% of the true front's) of the designs evaluated, as designs are evaluated.\"\"\"\n", + " means = summarize(search_results, list(OBJECTIVES), design_columns=[]).set_index(\"design\")\n", + " order = search_results.design.drop_duplicates()\n", + " counts = np.arange(10, len(order) + 1, 10)\n", + " return pd.Series(\n", + " [100 * hypervolume(means.reindex(order[:n]).dropna(), OBJECTIVES, REFERENCE) / exact_hypervolume for n in counts],\n", + " index=counts,\n", + " )\n", + "\n", + "\n", + "progress = {name: get_progress(search_results) for name, search_results in searches.items()}\n", + "pd.DataFrame(\n", + " {\n", + " name: {\n", + " \"designs evaluated\": search_results.design.nunique(),\n", + " \"hypervolume (% of true front)\": progress[name].iloc[-1],\n", + " }\n", + " for name, search_results in searches.items()\n", + " }\n", + ").T.round(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b0c9d2e1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-10T05:22:18.362508Z", + "iopub.status.busy": "2026-11-10T05:22:18.362234Z", + "iopub.status.idle": "2026-11-10T05:22:18.507452Z", + "shell.execute_reply": "2026-11-10T05:22:18.506612Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(9, 4.2))\n", + "for (name, series), color in zip(progress.items(), (BLUE, ORANGE, AQUA)):\n", + " ax.plot(series.index, series.values, color=color, lw=2, label=name)\n", + " ax.annotate(name, (series.index[-1], series.values[-1]), xytext=(6, 0), textcoords=\"offset points\", va=\"center\", fontsize=8, color=INK)\n", + "ax.axhline(100, color=GRAY, lw=1, ls=\"--\")\n", + "ax.annotate(\"true front\", (0, 100), xytext=(2, 4), textcoords=\"offset points\", fontsize=8, color=GRAY)\n", + "ax.set(xlabel=\"Designs evaluated\", ylabel=\"Hypervolume (% of true front)\", xlim=(0, None))\n", + "ax.grid(axis=\"y\", color=\"#e6e6e3\", lw=0.8)\n", + "ax.set_axisbelow(True)\n", + "for side in (\"top\", \"right\"):\n", + " ax.spines[side].set_visible(False)\n", + "ax.legend(loc=\"lower right\", fontsize=8, frameon=False)\n", + "ax.set_title(\"Progress of the searches\", fontsize=10)\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c1d0e3f2", + "metadata": {}, + "source": [ + "Both optimizers find more of the hypervolume than a Latin hypercube sample of as many designs. Optuna (NSGA-II, searching the hierarchical space directly) finds 95% of the hypervolume of the true front with 140 designs, 13% of the space. pymoo (NSGA-II, searching the encoded space) finds 90% with 87 designs: its 200 proposals include many that encode the same design or that violate the constraints, which are not evaluated. The sample finds 80% with 176 designs. The searches stop at their budget of proposals, not at convergence: a larger budget, or screening, would bring them closer to the true front. Their results also depend on their seeds, so compare several seeds before relying on one." + ] + }, + { + "cell_type": "markdown", + "id": "d2e1f4a3", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "* A `DesignSpace` declares a hierarchical trade space, with choices between alternatives (`Choice`), repeated elements such as orbit planes (`Repeat`), bounds that depend on other variables, constraints that measure their violation, and uncertain parameters (`Uncertain`) drawn for each replicate.\n", + "* A `Study` evaluates designs in replicates, in parallel, with a `SatelliteCache` that analyzes each distinct satellite once. Every design of a space of about a thousand designs can be evaluated in minutes.\n", + "* The front of the means of the replicates is uncertain: `pareto_probability` finds the designs whose efficiency the replicates settle, and those that are equally good candidates.\n", + "* `screen` evaluates every design with a cheap study and the best with the full one, which finds the front at a fraction of the cost if the cheap study ranks designs as the full one does.\n", + "* `optimize_optuna` and `optimize_pymoo` search spaces too large to enumerate, and find most of the front with a fraction of the designs.\n", + "\n", + "The objectives here are geometric: the share of points observed at least four times a day, and the numbers of satellites and planes as proxies of cost. The uncertainty is that of the sample of points; other uncertainties (such as the phase of the satellites or the period of the analysis) are further `Uncertain` parameters of the design space." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/index.rst b/docs/examples/index.rst index bc8a476b..3d12fad0 100644 --- a/docs/examples/index.rst +++ b/docs/examples/index.rst @@ -22,9 +22,12 @@ The following provide examples of TAT-C use in a Jupyter notebook environment. CollectSpace.ipynb RunOSSEMonsoon.ipynb RunOSSEHurricane.ipynb + SearchTradeSpace.ipynb Note that running the above examples in a local Python environment requires additional dependencies which can be installed via:: pip install tatc[examples] -using the pip package manager. +using the pip package manager. The trade space example also requires:: + + pip install tatc[tradespace] diff --git a/pyproject.toml b/pyproject.toml index 4103a10d..81a83473 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -107,6 +107,11 @@ osse = [ preprocess = [ "rasterio" ] +tradespace = [ + "joblib", + "optuna", + "pymoo" +] validation = [ "tatc[examples,preprocess]", "awsgnssroutils", diff --git a/src/tatc/tradespace/__init__.py b/src/tatc/tradespace/__init__.py new file mode 100644 index 00000000..80c5c6ed --- /dev/null +++ b/src/tatc/tradespace/__init__.py @@ -0,0 +1,67 @@ +""" +Trade space analysis: design spaces of (hierarchical) design variables and +uncertain parameters, trade studies that evaluate their designs (with caches +of analyses by satellite, in parallel), Pareto efficiency (with the +uncertainty of replicates), screening with analyses of increasing fidelity, +and searches with optimizers (Optuna and pymoo, optional dependencies). + +@author: Paul T. Grogan +""" + +from .cache import SatelliteCache, get_satellite_key +from .optimization import ( + Evaluations, + make_pymoo_problem, + optimize_optuna, + optimize_pymoo, +) +from .pareto import hypervolume, pareto_front, pareto_probability, pareto_ranks +from .screening import Screening, screen +from .nodes import ( + Categorical, + Choice, + Derived, + Fixed, + Infeasible, + Integer, + Real, + Repeat, + Uncertain, + Variable, +) +from .space import Design, DesignSpace +from .study import Study, summarize +from .values import ChoiceValues, RepeatValues, Scope, Values + +__all__ = [ + "Categorical", + "Choice", + "ChoiceValues", + "Derived", + "Design", + "DesignSpace", + "Evaluations", + "Fixed", + "Infeasible", + "Integer", + "Real", + "Repeat", + "RepeatValues", + "SatelliteCache", + "Screening", + "Scope", + "Study", + "Uncertain", + "Values", + "Variable", + "get_satellite_key", + "hypervolume", + "make_pymoo_problem", + "optimize_optuna", + "optimize_pymoo", + "pareto_front", + "pareto_probability", + "pareto_ranks", + "screen", + "summarize", +] diff --git a/src/tatc/tradespace/cache.py b/src/tatc/tradespace/cache.py new file mode 100644 index 00000000..9f330318 --- /dev/null +++ b/src/tatc/tradespace/cache.py @@ -0,0 +1,203 @@ +""" +Caches of analyses by satellite, which designs of a trade study share. + +Most analyses of a constellation (such as `tatc.analysis.collect_observations` +or `tatc.analysis.collect_feature_observations`) compute the result of each +satellite independently of the others, then combine them. Designs in a +trade study often share satellites (the same orbit and instruments, if not +the same name), so caching the result of each satellite avoids computing it +again for every design that flies it. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +import hashlib +import json +import os +import pickle +import tempfile +import time +from collections.abc import Callable, Iterable +from pathlib import Path +from typing import Any + +import pandas as pd + +from ..schemas import Satellite + + +def get_satellite_key(satellite: Satellite) -> str: + """ + Gets a key of a satellite's content: its orbit, instruments, and + attitude, but not its name, so that satellites that differ only in their + names share a key. + + Args: + satellite (Satellite): The satellite. + + Returns: + str: the key + """ + data = satellite.model_dump(mode="json", exclude={"name"}) + text = json.dumps( + {"type": type(satellite).__name__, **data}, sort_keys=True, default=str + ) + return hashlib.sha1(text.encode()).hexdigest() + + +class SatelliteCache: + """ + A cache of an analysis of single satellites, keyed by their content (see + `get_satellite_key`), in memory and optionally on disk. + + The function computes the result of one satellite, with every other + argument fixed (for example, by a closure over the targets and the + analysis period): the cache assumes that its result depends on nothing + else. A result that is a data frame with a `satellite` column is + relabeled with the name of the satellite it is retrieved for. + + A cache on disk (`directory`) persists between sessions and is shared by + the parallel workers of a trade study (see `Study`), each of which + otherwise has its own cache in memory. Its `namespace` must identify the + analysis (the function and its fixed arguments), as results in the + directory are only keyed by the namespace and the satellite: change it + whenever the analysis changes. + + Args: + function (Callable): The analysis of one satellite. + directory (str | os.PathLike | None): A directory in which to store + results, or `None` to keep them in memory only. + namespace (str | None): An identifier of the analysis, required with + a `directory`. + """ + + def __init__( + self, + function: Callable[[Satellite], Any], + directory: str | os.PathLike | None = None, + namespace: str | None = None, + ): + if directory is not None and not namespace: + raise ValueError("a cache on disk requires a namespace") + self.function = function + self.directory = None if directory is None else Path(directory) + self.namespace = namespace + self.hits = 0 + """int: The number of results retrieved from the cache.""" + self.misses = 0 + """int: The number of results computed.""" + self._memory: dict[str, Any] = {} + if self.directory is not None: + self.directory.mkdir(parents=True, exist_ok=True) + + def __getstate__(self) -> dict: + # copies sent to parallel workers start with empty memories + state = self.__dict__.copy() + state["_memory"] = {} + return state + + def _path(self, key: str) -> Path: + name = hashlib.sha1(f"{self.namespace}/{key}".encode()).hexdigest() + return self.directory / f"{name}.pkl" + + def _load(self, key: str) -> Any: + if key in self._memory: + return self._memory[key] + if self.directory is not None: + path = self._path(key) + for attempt in range(5): + if not path.exists(): + break + try: + with open(path, "rb") as file: + result = pickle.load(file) + except (OSError, EOFError, pickle.UnpicklingError): + # on Windows, another worker may be replacing the file: + # try again, then compute the result instead + time.sleep(0.02 * (attempt + 1)) + continue + self._memory[key] = result + return result + raise KeyError(key) + + def _store(self, key: str, result: Any) -> None: + self._memory[key] = result + if self.directory is None: + return + path = self._path(key) + if path.exists(): + # another worker stored the (same) result + return + # write to a temporary file, then rename it, so that a parallel + # worker never reads a partial file + descriptor, temporary = tempfile.mkstemp(dir=self.directory, suffix=".tmp") + with os.fdopen(descriptor, "wb") as file: + pickle.dump(result, file) + try: + os.replace(temporary, path) + except PermissionError: + # on Windows, another worker is replacing or reading the file, + # which then holds the same result + os.remove(temporary) + if not path.exists(): + raise + + def get(self, satellite: Satellite) -> Any: + """ + Gets the result of a satellite, computing it if it is not cached. + + Args: + satellite (Satellite): The satellite. + + Returns: + Any: the result + """ + key = get_satellite_key(satellite) + try: + result = self._load(key) + self.hits += 1 + except KeyError: + result = self.function(satellite) + self.misses += 1 + self._store(key, result) + if isinstance(result, pd.DataFrame) and "satellite" in result.columns: + if len(result) > 0 and (result["satellite"] != satellite.name).any(): + result = result.copy() + result["satellite"] = satellite.name + return result + + def __call__(self, satellites: Satellite | Iterable[Satellite]) -> Any: + """ + Gets the results of satellites, concatenated if they are data frames + (or the list of results otherwise). + + Args: + satellites (Satellite | Iterable[Satellite]): The satellites. + + Returns: + Any: the concatenated data frame, or the list of results + """ + if isinstance(satellites, Satellite): + satellites = [satellites] + results = [self.get(satellite) for satellite in satellites] + if results and all(isinstance(result, pd.DataFrame) for result in results): + non_empty = [result for result in results if len(result) > 0] + if not non_empty: + return results[0] + return pd.concat(non_empty, ignore_index=True) + return results + + def clear(self) -> None: + """ + Clears the cache in memory (not on disk) and its statistics. + """ + self._memory.clear() + self.hits = self.misses = 0 + + def __repr__(self) -> str: + return ( + f"SatelliteCache({len(self._memory)} results, " + + f"{self.hits} hits, {self.misses} misses)" + ) diff --git a/src/tatc/tradespace/nodes.py b/src/tatc/tradespace/nodes.py new file mode 100644 index 00000000..f07902f1 --- /dev/null +++ b/src/tatc/tradespace/nodes.py @@ -0,0 +1,388 @@ +""" +Nodes of design spaces: design variables, fixed, derived, and uncertain +values, choices, and repetitions (see `tatc.tradespace.DesignSpace`). + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +import math +from collections.abc import Callable, Sequence +from dataclasses import dataclass +from typing import Any + +import numpy as np + +from .values import Scope + + +class Infeasible(Exception): + """ + Raised while deciding a design that violates a constraint of its design + space or has a variable without feasible values. + + Args: + message (str): The reason. + violation (float): The amount by which the design violates its + constraint (positive), as for constraint-aware optimizers: the + value of a constraint that gives one, or 1. + """ + + def __init__(self, message: str = "", violation: float = 1.0): + super().__init__(message) + self.violation = violation + + +# --------------------------------------------------------------------------- +# nodes +# --------------------------------------------------------------------------- + + +class Node: + """ + Base class of the nodes of a design space. + """ + + +Bound = float | Callable[[Scope], float] +"""A bound of a variable: a value, or a callable of the values decided so far.""" + + +def _resolve(bound: Any, scope: Scope) -> Any: + """ + Resolves a bound that may be a callable of the values decided so far. + """ + return bound(scope) if callable(bound) else bound + + +@dataclass(frozen=True) +class _Domain: + """ + The values a variable may take where it is decided: a finite list of + levels, or a continuous interval. The kind (`"real"`, `"integer"`, or + `"categorical"`) and the step between levels inform optimizers. + """ + + levels: list | None = None + low: float = 0.0 + high: float = 1.0 + log: bool = False + kind: str = "categorical" + step: float | None = None + + def from_unit(self, u: float) -> Any: + """ + Maps a value in [0, 1] to a value of the domain: a level (each + level spans an equal part of [0, 1]) or a point of the interval + (uniform, or uniform in its logarithm). + """ + u = min(max(float(u), 0.0), 1.0) + if self.levels is not None: + return self.levels[min(int(u * len(self.levels)), len(self.levels) - 1)] + if self.log: + return float( + math.exp( + math.log(self.low) + u * (math.log(self.high) - math.log(self.low)) + ) + ) + return float(self.low + u * (self.high - self.low)) + + def to_unit(self, value: Any) -> float: + """ + Maps a value of the domain to [0, 1] (the center of a level's part), + the inverse of `from_unit`. + """ + if self.levels is not None: + return (self.levels.index(value) + 0.5) / len(self.levels) + if self.high == self.low: + return 0.5 + if self.log: + return (math.log(value) - math.log(self.low)) / ( + math.log(self.high) - math.log(self.low) + ) + return (value - self.low) / (self.high - self.low) + + def suggest(self, trial: Any, name: str) -> Any: + """ + Suggests a value of the domain with an Optuna trial. + """ + if self.kind == "categorical": + return trial.suggest_categorical(name, self.levels) + if self.kind == "integer": + return trial.suggest_int( + name, self.levels[0], self.levels[-1], step=int(self.step) + ) + if self.levels is not None: + value = trial.suggest_float( + name, self.levels[0], self.levels[-1], step=self.step + ) + # the level nearest the suggestion, without rounding errors + index = round((value - self.levels[0]) / self.step) + return self.levels[min(max(index, 0), len(self.levels) - 1)] + return trial.suggest_float(name, self.low, self.high, log=self.log) + + +class Variable(Node): + """ + Base class of design variables: the leaves of a design space that are + searched by enumeration, sampling, or optimization. + """ + + def domain(self, scope: Scope) -> _Domain: + """ + Gets the values this variable may take, given the values decided so + far. + + Args: + scope (Scope): The values decided so far. + + Returns: + _Domain: the domain + """ + raise NotImplementedError + + +def _levels(low: float, high: float, step: float, integer: bool) -> list: + """ + Gets the levels from `low` to `high` (inclusive, within a small + tolerance) at intervals of `step`. + """ + if step <= 0: + raise ValueError("step must be positive") + count = math.floor((high - low) / step + 1e-9) + 1 + if integer: + return [int(low + k * step) for k in range(max(count, 0))] + return [round(low + k * step, 12) for k in range(max(count, 0))] + + +class Real(Variable): + """ + A real-valued design variable on `[low, high]`: continuous, or discrete + at intervals of `step` from `low`. A continuous variable cannot be + enumerated and makes every sampled design distinct, so give it a step + unless a search needs the continuum. + + Args: + low (float | Callable): The lower bound, or a callable of the values + decided so far. + high (float | Callable): The upper bound, or a callable of the values + decided so far. + step (float | None): The interval between levels, or `None` for a + continuous variable. + log (bool): `True` to sample a continuous variable uniformly in its + logarithm (requires a positive lower bound). + """ + + def __init__( + self, low: Bound, high: Bound, step: float | None = None, log: bool = False + ): + if step is not None and log: + raise ValueError("a discrete variable cannot be logarithmic") + self.low, self.high, self.step, self.log = low, high, step, log + + def domain(self, scope: Scope) -> _Domain: + low, high = float(_resolve(self.low, scope)), float(_resolve(self.high, scope)) + if high < low: + raise Infeasible(f"empty range [{low}, {high}]") + if self.step is not None: + levels = _levels(low, high, self.step, integer=False) + return _Domain(levels=levels, kind="real", step=self.step) + if self.log and low <= 0: + raise ValueError("a logarithmic variable requires a positive lower bound") + return _Domain(low=low, high=high, log=self.log, kind="real") + + def __repr__(self) -> str: + return f"Real({self.low!r}, {self.high!r}, step={self.step!r})" + + +class Integer(Variable): + """ + An integer design variable from `low` to `high` (inclusive) at intervals + of `step`. + + Args: + low (int | Callable): The lower bound, or a callable of the values + decided so far. + high (int | Callable): The upper bound, or a callable of the values + decided so far. + step (int): The interval between levels. + """ + + def __init__(self, low: Bound, high: Bound, step: int = 1): + self.low, self.high, self.step = low, high, step + + def domain(self, scope: Scope) -> _Domain: + low, high = int(_resolve(self.low, scope)), int(_resolve(self.high, scope)) + if high < low: + raise Infeasible(f"empty range [{low}, {high}]") + levels = _levels(low, high, self.step, integer=True) + return _Domain(levels=levels, kind="integer", step=self.step) + + def __repr__(self) -> str: + return f"Integer({self.low!r}, {self.high!r}, step={self.step!r})" + + +class Categorical(Variable): + """ + A design variable that takes one of a list of unordered options (for + example, the identifiers of instruments in the catalog). Options should + be numbers, strings, or booleans, which identify designs (see + `Design.key`). + + Args: + options (Sequence | Callable): The options, or a callable of the + values decided so far. + """ + + def __init__(self, options: Sequence | Callable[[Scope], Sequence]): + if not callable(options) and len(options) == 0: + raise ValueError("a categorical variable requires at least one option") + self.options = options if callable(options) else list(options) + + def domain(self, scope: Scope) -> _Domain: + options = list(_resolve(self.options, scope)) + if len(options) == 0: + raise Infeasible("no options") + return _Domain(levels=options) + + def __repr__(self) -> str: + return f"Categorical({self.options!r})" + + +class Fixed(Node): + """ + A fixed value. Plain values given as children of a design space are + wrapped as fixed values. + + Args: + value (Any): The value. + """ + + def __init__(self, value: Any): + self.value = value + + def __repr__(self) -> str: + return f"Fixed({self.value!r})" + + +class Derived(Node): + """ + A value computed from the values decided so far (for example, the + equator crossing time of an orbit plane from its index). Derived values + are not searched, and do not identify designs (see `Design.key`). A + derived value that depends on an uncertain parameter is computed from its + nominal value (`NaN` or `None`) until a design is realized (see + `Design.realize`). + + Args: + function (Callable): The function of the values decided so far. + """ + + def __init__(self, function: Callable[[Scope], Any]): + self.function = function + + def __repr__(self) -> str: + return f"Derived({self.function!r})" + + +class Uncertain(Node): + """ + An uncertain (nuisance) parameter: a value that is not designed but + changes the outcome of a design, such as the phase of satellites in + their orbit planes or the epoch of an analysis. It is drawn for each + replicate of a design (see `Design.realize`), does not identify designs + (see `Design.key`), and takes its nominal value until then. + + Args: + sampler (Callable): A function that draws a value from a + `numpy.random.Generator`. + nominal (Any): The value before a design is realized. + """ + + def __init__( + self, sampler: Callable[[np.random.Generator], Any], nominal: Any = math.nan + ): + self.sampler, self.nominal = sampler, nominal + + @classmethod + def uniform(cls, low: float, high: float) -> Uncertain: + """ + An uncertain parameter distributed uniformly on `[low, high)`. + """ + return cls(lambda rng: float(rng.uniform(low, high))) + + @classmethod + def normal(cls, mean: float, std: float) -> Uncertain: + """ + An uncertain parameter distributed normally. + """ + return cls(lambda rng: float(rng.normal(mean, std))) + + @classmethod + def choice(cls, options: Sequence, p: Sequence[float] | None = None) -> Uncertain: + """ + An uncertain parameter that takes one of `options` (with + probabilities `p`, or equally likely). + """ + options = list(options) + return cls(lambda rng: options[int(rng.choice(len(options), p=p))], None) + + def __repr__(self) -> str: + return f"Uncertain({self.sampler!r})" + + +def _as_node(value: Any) -> Node: + """ + Wraps a plain value as a fixed value. + """ + return value if isinstance(value, Node) else Fixed(value) + + +class Choice(Node): + """ + A choice of exactly one of several alternatives (branches), each a node + (typically a `DesignSpace`). The nodes of the other branches are + inactive. The value of a choice gives the name of the chosen branch as + `choice`, and the values of the branch as its attributes. + + Args: + **branches (Node): The alternatives, by name. + """ + + def __init__(self, **branches: Any): + if len(branches) == 0: + raise ValueError("a choice requires at least one branch") + self.branches = {name: _as_node(node) for name, node in branches.items()} + + def __repr__(self) -> str: + return f"Choice({', '.join(self.branches)})" + + +class Repeat(Node): + """ + A node repeated a (variable) number of times, such as the orbit planes of + a constellation, each with its own design. The value of a repetition is a + sequence of the values of its items, whose length is also given as + `count`. Within an item, `index` gives its position. + + The items of an unordered repetition (`ordered=False`) are exchangeable: + designs whose items are the same up to their order are the same design, + whose items are sorted by their decisions (so their values must not + depend on `index`). + + Args: + item (Node): The repeated node. + count (int | Integer): The number of items, fixed or a design variable. + ordered (bool): `False` if designs that differ only in the order of + their items are the same. + """ + + def __init__(self, item: Any, count: int | Integer, ordered: bool = True): + self.item = _as_node(item) + if isinstance(count, int) and count < 0: + raise ValueError("count must not be negative") + self.count, self.ordered = count, ordered + + def __repr__(self) -> str: + return f"Repeat({self.item!r}, count={self.count!r}, ordered={self.ordered})" diff --git a/src/tatc/tradespace/optimization.py b/src/tatc/tradespace/optimization.py new file mode 100644 index 00000000..cc98971d --- /dev/null +++ b/src/tatc/tradespace/optimization.py @@ -0,0 +1,310 @@ +""" +Searches of design spaces for Pareto-efficient designs with optimizers: +Optuna (which searches the hierarchical design space directly, see +`DesignSpace.suggest`) and pymoo (which searches the unit hypercube that +encodes it, see `DesignSpace.decode`). Both are optional dependencies. + +The objectives of a design are the means over its replicates of columns of +the results of its evaluations (see `Study.run`), which must have one record +per evaluation. Each design is evaluated once, however often an optimizer +proposes it, and designs proposed together are evaluated together, in +parallel if the study is (see `Study`). + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +from collections.abc import Mapping +from typing import Any + +import numpy as np +import pandas as pd + +from .space import Design, Infeasible +from .study import Study + + +class Evaluations: + """ + The evaluations of designs for a search: the objectives of each design + (by its key), and the records of the study's evaluations. + + Args: + study (Study): The study that evaluates designs. + objectives (Mapping[str, str]): The objectives: columns of the + results and their directions (`"min"` or `"max"`). + """ + + def __init__(self, study: Study, objectives: Mapping[str, str]): + if len(objectives) == 0: + raise ValueError("at least one objective is required") + for column, direction in objectives.items(): + if direction not in ("min", "max"): + raise ValueError( + f"direction of {column!r} must be 'min' or 'max', " + + f"not {direction!r}" + ) + self.study, self.objectives = study, dict(objectives) + self.values: dict[str, tuple[float, ...] | None] = {} + """dict: The objectives of each evaluated design (by key), or `None` + if it is infeasible.""" + self._records: list[pd.DataFrame] = [] + + @property + def results(self) -> pd.DataFrame: + """pandas.DataFrame: The results of every evaluation (see + `Study.run`).""" + if not self._records: + return pd.DataFrame() + return pd.concat(self._records, ignore_index=True) + + def evaluate(self, designs: list[Design]) -> list[tuple[float, ...] | None]: + """ + Gets the objectives of designs, evaluating those not yet evaluated + together. + + Args: + designs (list[Design]): The designs. + + Returns: + list[tuple[float, ...] | None]: the objectives of each design, in + the order of the objectives, or `None` if it is infeasible + """ + new = list({d.key: d for d in designs if d.key not in self.values}.values()) + if new: + records = self.study.run(new) + self._records.append(records) + for key, group in records.groupby("design", sort=False): + if not group["feasible"].all(): + self.values[key] = None + continue + if group["replicate"].duplicated().any(): + raise ValueError( + "objectives need one record per evaluation: make the " + + "study's evaluate function return a mapping of metrics" + ) + self.values[key] = tuple( + float(group[column].mean()) for column in self.objectives + ) + return [self.values[d.key] for d in designs] + + def worst(self) -> list[float]: + """ + Gets the worst value of each objective of the feasible designs + evaluated (0 if none is), as for infeasible designs. + + Returns: + list[float]: the worst values, in the order of the objectives + """ + feasible = [values for values in self.values.values() if values is not None] + if not feasible: + return [0.0] * len(self.objectives) + table = np.array(feasible) + return [ + float(table[:, i].max() if direction == "min" else table[:, i].min()) + for i, direction in enumerate(self.objectives.values()) + ] + + +def optimize_optuna( + study: Study, + objectives: Mapping[str, str], + n_trials: int, + sampler: Any = None, + optuna_study: Any = None, + batch_size: int | None = None, + constraints: bool = True, +) -> tuple[Any, pd.DataFrame]: + """ + Searches a study's design space with Optuna: each trial suggests a design + (see `DesignSpace.suggest`) and is told the means of its objectives over + its replicates. + + With `constraints`, each trial records the violation of the constraints + of its design (`trial.set_constraint`, under the name `"feasibility"`): + 0 for a feasible design, the amount by which it violates a constraint of + the design space (see `DesignSpace`), or 1 if the study finds it + infeasible. Optuna's constraint-aware samplers (such as TPE and NSGA-II) + then prefer feasible designs, and infeasible designs that violate their + constraints less. An infeasible trial is told the worst objectives of the + feasible designs evaluated before it, which these samplers do not use to + rank it. Without `constraints` (or with a version of Optuna before 5, + which lacks `set_constraint`), an infeasible design prunes its trial. + + Trials are asked in batches, whose designs are evaluated together (in + parallel, if the study is) before they are told. A batch defaults to one + trial per worker of the study. + + Args: + study (Study): The study that evaluates designs. + objectives (Mapping[str, str]): The objectives: columns of the + results and their directions (`"min"` or `"max"`). + n_trials (int): The number of trials. + sampler (optuna.samplers.BaseSampler | None): The sampler, if not + Optuna's default (TPE with one objective, NSGA-II with several); + ignored with an `optuna_study`. + optuna_study (optuna.Study | None): A study to continue, whose + directions are those of the objectives. + batch_size (int | None): The number of trials evaluated together. + constraints (bool): `True` to record the violations of constraints, + `False` to prune infeasible trials. + + Returns: + tuple[optuna.Study, pandas.DataFrame]: the Optuna study, and the + results of every evaluation (see `Study.run`) + """ + # pylint: disable=import-outside-toplevel + try: + import optuna + except ImportError as error: + raise ImportError( + "optimize_optuna requires optuna (pip install optuna)" + ) from error + evaluations = Evaluations(study, objectives) + directions = [ + "minimize" if direction == "min" else "maximize" + for direction in evaluations.objectives.values() + ] + if optuna_study is None: + optuna_study = optuna.create_study(directions=directions, sampler=sampler) + batch_size = batch_size or study.workers + constrained = constraints and hasattr(optuna.trial.Trial, "set_constraint") + + def infeasible(trial: Any, violation: float) -> None: + if constrained: + trial.set_constraint("feasibility", max(violation, 1e-9)) + optuna_study.tell(trial, evaluations.worst()) + else: + optuna_study.tell(trial, state=optuna.trial.TrialState.PRUNED) + + remaining = n_trials + while remaining > 0: + trials, designs = [], [] + for _ in range(min(batch_size, remaining)): + trial = optuna_study.ask() + try: + design = study.space.suggest(trial) + except Infeasible as error: + trial.set_user_attr("error", str(error)) + infeasible(trial, error.violation) + continue + trial.set_user_attr("design", design.key) + trials.append(trial) + designs.append(design) + remaining -= min(batch_size, remaining) + for trial, values in zip(trials, evaluations.evaluate(designs)): + if values is None: + infeasible(trial, 1.0) + else: + if constrained: + trial.set_constraint("feasibility", 0.0) + optuna_study.tell(trial, list(values)) + return optuna_study, evaluations.results + + +def make_pymoo_problem(study: Study, objectives: Mapping[str, str]) -> Any: + """ + Makes a pymoo problem of a study's design space: its variables are the + unit hypercube that encodes the design space (see `DesignSpace.decode` + and `DesignSpace.unit_paths`), its objectives are minimized (maximized + objectives are negated), and its constraint (`G <= 0`) is violated by + designs that violate a constraint of the design space (by the amount of + the violation, see `DesignSpace`) or that the study finds infeasible (by + 1). The designs of a population are evaluated together. + + The problem keeps its evaluations (`evaluations`, see `Evaluations`), + whose `results` are those of every evaluation (see `Study.run`). + + Args: + study (Study): The study that evaluates designs. + objectives (Mapping[str, str]): The objectives: columns of the + results and their directions (`"min"` or `"max"`). + + Returns: + pymoo.core.problem.Problem: the problem + """ + # pylint: disable=import-outside-toplevel + try: + from pymoo.core.problem import Problem + except ImportError as error: + raise ImportError( + "make_pymoo_problem requires pymoo (pip install pymoo)" + ) from error + + evaluations = Evaluations(study, objectives) + signs = np.array( + [1.0 if direction == "min" else -1.0 for direction in objectives.values()] + ) + n_var = len(study.space.unit_paths()) + + class DesignSpaceProblem(Problem): + """ + A pymoo problem of a design space (see `make_pymoo_problem`). + """ + + def __init__(self): + super().__init__( + n_var=n_var, n_obj=len(signs), n_ieq_constr=1, xl=0.0, xu=1.0 + ) + self.evaluations = evaluations + + def _evaluate(self, x, out, *args, **kwargs): + designs: list[Design | None] = [] + violation = np.ones(len(np.atleast_2d(x))) + for i, row in enumerate(np.atleast_2d(x)): + try: + designs.append(study.space.decode(row)) + except Infeasible as error: + designs.append(None) + violation[i] = max(error.violation, 1e-9) + feasible = [design for design in designs if design is not None] + values = iter(evaluations.evaluate(feasible)) + costs = np.zeros((len(designs), len(signs))) + for i, design in enumerate(designs): + value = None if design is None else next(values) + if value is not None: + costs[i] = signs * np.asarray(value) + violation[i] = 0.0 + out["F"] = costs + out["G"] = violation[:, None] + + return DesignSpaceProblem() + + +def optimize_pymoo( + study: Study, + objectives: Mapping[str, str], + algorithm: Any = None, + termination: Any = ("n_gen", 10), + seed: int | None = None, + **kwargs: Any, +) -> tuple[Any, pd.DataFrame]: + """ + Searches a study's design space with a pymoo algorithm (see + `make_pymoo_problem`). + + Args: + study (Study): The study that evaluates designs. + objectives (Mapping[str, str]): The objectives: columns of the + results and their directions (`"min"` or `"max"`). + algorithm (pymoo.core.algorithm.Algorithm | None): The algorithm, or + `None` for NSGA-II with populations of 20. + termination (Any): The termination criterion of `pymoo.optimize.minimize`. + seed (int | None): The seed of the algorithm. + **kwargs (Any): Other arguments of `pymoo.optimize.minimize`. + + Returns: + tuple[pymoo.core.result.Result, pandas.DataFrame]: the result of the + search, and the results of every evaluation (see `Study.run`) + """ + # pylint: disable=import-outside-toplevel + from pymoo.optimize import minimize + + if algorithm is None: + from pymoo.algorithms.moo.nsga2 import NSGA2 + + algorithm = NSGA2(pop_size=20) + problem = make_pymoo_problem(study, objectives) + result = minimize(problem, algorithm, termination, seed=seed, **kwargs) + return result, problem.evaluations.results diff --git a/src/tatc/tradespace/pareto.py b/src/tatc/tradespace/pareto.py new file mode 100644 index 00000000..cd203e3c --- /dev/null +++ b/src/tatc/tradespace/pareto.py @@ -0,0 +1,296 @@ +""" +Pareto efficiency of designs with several objectives: non-dominated +designs, Pareto ranks, and the hypervolume of a set of designs. + +Objectives are given as a mapping of the columns of a data frame (such as a +summary of a study, see `summarize`) to their directions, `"min"` or +`"max"`. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +from collections.abc import Mapping, Sequence + +import numpy as np +import pandas as pd + +Objectives = Mapping[str, str] +"""Objectives: columns and their directions (`"min"` or `"max"`).""" + + +def _get_costs(frame: pd.DataFrame, objectives: Objectives) -> np.ndarray: + """ + Gets the objectives of a data frame as costs (to minimize): maximized + objectives are negated. + """ + if len(objectives) == 0: + raise ValueError("at least one objective is required") + columns = [] + for column, direction in objectives.items(): + if direction not in ("min", "max"): + raise ValueError( + f"direction of {column!r} must be 'min' or 'max', not {direction!r}" + ) + values = frame[column].to_numpy(dtype=float) + columns.append(values if direction == "min" else -values) + costs = np.column_stack(columns) + if np.isnan(costs).any(): + raise ValueError("objectives must not be NaN") + return costs + + +def _get_tolerances( + objectives: Objectives, tolerance: Mapping[str, float] | None +) -> np.ndarray: + """ + Gets the tolerances of the objectives (zero if not given). + """ + tolerance = tolerance or {} + unknown = set(tolerance) - set(objectives) + if unknown: + raise ValueError(f"tolerances of columns that are not objectives: {unknown}") + values = np.array([float(tolerance.get(column, 0.0)) for column in objectives]) + if np.any(values < 0): + raise ValueError("tolerances must not be negative") + return values + + +def _dominated( + costs: np.ndarray, tolerances: np.ndarray | None = None, block: int = 512 +) -> np.ndarray: + """ + Finds the points (rows of costs) dominated by another, even if the other + is penalized by the tolerances: no worse in every cost, and better in at + least one, by at least its tolerance. + """ + n = len(costs) + tolerances = np.zeros(costs.shape[1]) if tolerances is None else tolerances + dominated = np.zeros(n, dtype=bool) + for start in range(0, n, block): + part = costs[start : start + block] + # [i, j]: point j dominates point i of the block + penalized = costs[None, :, :] + tolerances + no_worse = np.all(penalized <= part[:, None, :], axis=2) + better = np.any(penalized < part[:, None, :], axis=2) + dominated[start : start + block] = np.any(no_worse & better, axis=1) + return dominated + + +def pareto_front( + frame: pd.DataFrame, + objectives: Objectives, + tolerance: Mapping[str, float] | None = None, +) -> pd.Series: + """ + Finds the Pareto-efficient (non-dominated) rows of a data frame: those + that no other row dominates, being no worse in every objective and + better in at least one. Rows with the same objectives are all efficient + if any is. + + With a `tolerance` of an objective, a row dominates another only if it + would still dominate it if it were worse by the tolerance in that + objective. Rows within the tolerances of the front (that no other row is + clearly better than) are then efficient as well, which suits objectives + estimated with an uncertainty (such as a few standard errors of their + means, see `summarize`), or by a cheaper analysis (see `screen`). + + Args: + frame (pandas.DataFrame): The rows (such as designs). + objectives (Mapping[str, str]): The objectives: columns and their + directions (`"min"` or `"max"`). + tolerance (Mapping[str, float] | None): The tolerances of objectives + (by column, zero if not given). + + Returns: + pandas.Series: whether each row is efficient (boolean, with the + frame's index) + """ + if len(frame) == 0: + return pd.Series([], index=frame.index, dtype=bool) + costs = _get_costs(frame, objectives) + tolerances = _get_tolerances(objectives, tolerance) + return pd.Series(~_dominated(costs, tolerances), index=frame.index, name="pareto") + + +def pareto_ranks( + frame: pd.DataFrame, + objectives: Objectives, + tolerance: Mapping[str, float] | None = None, +) -> pd.Series: + """ + Ranks the rows of a data frame by non-dominated sorting: rank 0 is the + Pareto front, rank 1 the front of the others, and so on, optionally with + tolerances of the objectives (see `pareto_front`). + + Args: + frame (pandas.DataFrame): The rows (such as designs). + objectives (Mapping[str, str]): The objectives: columns and their + directions (`"min"` or `"max"`). + tolerance (Mapping[str, float] | None): The tolerances of objectives + (by column, zero if not given). + + Returns: + pandas.Series: the rank of each row (with the frame's index) + """ + ranks = np.full(len(frame), -1, dtype=int) + if len(frame) > 0: + costs = _get_costs(frame, objectives) + tolerances = _get_tolerances(objectives, tolerance) + remaining = np.arange(len(frame)) + rank = 0 + while len(remaining) > 0: + front = ~_dominated(costs[remaining], tolerances) + ranks[remaining[front]] = rank + remaining = remaining[~front] + rank += 1 + return pd.Series(ranks, index=frame.index, name="pareto_rank") + + +def _hypervolume(points: np.ndarray, reference: np.ndarray) -> float: + """ + Computes the hypervolume (to minimize) of points that are all better than + the reference in every dimension, by slicing the last dimension (exact, + for few dimensions). + """ + if len(points) == 0: + return 0.0 + if points.shape[1] == 1: + return float(reference[0] - points[:, 0].min()) + points = points[~_dominated(points)] + order = np.argsort(points[:, -1], kind="stable") + points = points[order] + if points.shape[1] == 2: + # sweep: by increasing second cost, the first cost decreases + x = points[:, 0] + upper = np.append(points[1:, 1], reference[1]) + return float(np.sum((reference[0] - x) * (upper - points[:, 1]))) + volume = 0.0 + for i in range(len(points)): + upper = points[i + 1, -1] if i + 1 < len(points) else reference[-1] + height = upper - points[i, -1] + if height > 0: + volume += height * _hypervolume(points[: i + 1, :-1], reference[:-1]) + return float(volume) + + +def hypervolume( + frame: pd.DataFrame, + objectives: Objectives, + reference: Mapping[str, float] | Sequence[float], +) -> float: + """ + Computes the hypervolume of the rows of a data frame: the volume of the + objective space that they dominate, up to a reference point that is + worse than every row of interest in every objective. Rows that are not + better than the reference in every objective add nothing. A larger + hypervolume is a better set of designs, which makes it a measure of the + progress of a search, or of how close a search comes to the true Pareto + front. + + The hypervolume is exact. Its computation slices the objectives in turn, + which takes long with many objectives and many efficient rows. + + Args: + frame (pandas.DataFrame): The rows (such as designs). + objectives (Mapping[str, str]): The objectives: columns and their + directions (`"min"` or `"max"`). + reference (Mapping[str, float] | Sequence[float]): The reference + point: the value of each objective (by column, or in order). + + Returns: + float: the hypervolume, in the product of the units of the objectives + """ + if isinstance(reference, Mapping): + reference = [reference[column] for column in objectives] + if len(reference) != len(objectives): + raise ValueError("the reference point needs a value for each objective") + signs = np.array([1.0 if d == "min" else -1.0 for d in objectives.values()]) + bound = signs * np.asarray(reference, dtype=float) + if len(frame) == 0: + return 0.0 + costs = _get_costs(frame, objectives) + costs = costs[np.all(costs < bound, axis=1)] + return _hypervolume(costs, bound) + + +def pareto_probability( + results: pd.DataFrame, + objectives: Objectives, + by: Sequence[str] = (), + n_resamples: int = 500, + seed: int = 0, +) -> pd.DataFrame: + """ + Estimates the probability that each design is Pareto-efficient, given the + uncertainty of the means of its objectives over replicates, by a + bootstrap: each resample draws replicates with replacement, the same + replicates for every design (which keeps the correlation between designs + of common random numbers, see `Design.realize`), and finds the front of + the means of the objectives over the drawn replicates. The probability + is the share of resamples in which a design is efficient. + + Designs that are efficient with a probability between 0 and 1 are those + whose efficiency the replicates do not settle: more replicates (or a + tolerance, see `pareto_front`) would settle it. With few replicates, + the bootstrap has few distinct resamples and understates the + uncertainty. + + Args: + results (pandas.DataFrame): The results of a study (see + `Study.run`), with a record per replicate of each design (and + group of `by`). Infeasible results are ignored. + objectives (Mapping[str, str]): The objectives: columns and their + directions (`"min"` or `"max"`). + by (Sequence[str]): Columns that group records of an evaluation (such + as a sensor), whose fronts are found separately. + n_resamples (int): The number of resamples. + seed (int): The seed of the resamples. + + Returns: + pandas.DataFrame: a row per design (and group): the means of the + objectives over every replicate, whether the design is efficient + by these means (`pareto`), and the probability that it is + (`pareto_probability`) + """ + feasible = results[results["feasible"]] if "feasible" in results else results + columns = list(objectives) + signs = _get_costs(pd.DataFrame({column: [1.0] for column in columns}), objectives)[ + 0 + ] + rng = np.random.default_rng(seed) + frames = [] + groups = feasible.groupby(list(by), sort=False) if by else [((), feasible)] + for key, group in groups: + # the costs of each objective, design (rows), and replicate (columns) + tables = [ + group.pivot_table(index="design", columns="replicate", values=column) + for column in columns + ] + designs, replicates = tables[0].index, tables[0].columns + costs = np.stack( + [ + sign * table.loc[designs, replicates].to_numpy(dtype=float) + for sign, table in zip(signs, tables) + ] + ) + means = np.nanmean(costs, axis=2).T + counts = np.zeros(len(designs)) + for _ in range(n_resamples): + drawn = rng.integers(0, len(replicates), len(replicates)) + sample = np.nanmean(costs[:, :, drawn], axis=2).T + # a design without a value in any drawn replicate is not ranked + valid = ~np.isnan(sample).any(axis=1) + front = np.zeros(len(designs), dtype=bool) + front[valid] = ~_dominated(sample[valid]) + counts += front + frame = pd.DataFrame({"design": designs}) + for name, value in zip(by, key if isinstance(key, tuple) else (key,)): + frame[name] = value + for i, column in enumerate(columns): + frame[column] = signs[i] * means[:, i] + frame["pareto"] = ~_dominated(means) + frame["pareto_probability"] = counts / n_resamples + frames.append(frame) + return pd.concat(frames, ignore_index=True) diff --git a/src/tatc/tradespace/screening.py b/src/tatc/tradespace/screening.py new file mode 100644 index 00000000..e9a7d65e --- /dev/null +++ b/src/tatc/tradespace/screening.py @@ -0,0 +1,131 @@ +""" +Screening of designs with analyses of increasing fidelity: cheap analyses +(such as shorter periods, fewer targets, or fewer replicates) rank many +designs, and only the best are analyzed with more expensive ones. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +import math +from collections.abc import Mapping, Sequence +from dataclasses import dataclass, field + +import pandas as pd + +from .pareto import pareto_ranks +from .space import Design +from .study import Study, summarize + + +@dataclass +class Screening: + """ + The outcome of a screening (see `screen`). + """ + + results: pd.DataFrame + """pandas.DataFrame: The results of every stage (see `Study.run`), with + the `stage` (0 for the first).""" + summaries: list[pd.DataFrame] = field(default_factory=list) + """list[pandas.DataFrame]: For each stage, the summary of its designs + (see `summarize`), with their Pareto rank (`pareto_rank`, -1 if + infeasible) and whether they were `kept` for the next stage.""" + designs: list[Design] = field(default_factory=list) + """list[Design]: The designs analyzed in the last stage.""" + + @property + def final(self) -> pd.DataFrame: + """pandas.DataFrame: The summary of the last stage.""" + return self.summaries[-1] + + +def _per_stage(value, count: int, name: str) -> list: + """ + Gets a value for each of `count` transitions between stages. + """ + if isinstance(value, Sequence) and not isinstance(value, str): + if len(value) != count: + raise ValueError(f"{name} needs a value for each of {count} transitions") + return list(value) + return [value] * count + + +def screen( + designs: Sequence[Design], + studies: Sequence[Study], + objectives: Mapping[str, str], + keep: float | int | Sequence[float | int] = 0.25, + tolerance: Mapping[str, float] | Sequence[Mapping[str, float] | None] | None = None, +) -> Screening: + """ + Screens designs with studies of increasing fidelity (and cost): each + study (stage) evaluates the designs kept by the one before, ranks them by + non-dominated sorting of the means of their objectives (see + `pareto_ranks`), and keeps whole fronts, best first, until it keeps at + least `keep` designs (a number, or a share of the feasible designs). + + A cheap analysis ranks designs less exactly than an expensive one, so a + design it ranks just behind another may be better: keep enough designs, + or give a `tolerance` of each objective (in the units of the stage's + analysis), within which differences do not separate fronts (see + `pareto_front`), so that nearly efficient designs are kept. Compare the + final front with one found without screening on a sample of designs to + check that screening does not lose efficient designs. + + Args: + designs (Sequence[Design]): The designs to screen. + studies (Sequence[Study]): The studies of each stage, in order of + increasing fidelity. + objectives (Mapping[str, str]): The objectives: columns of the + results and their directions (`"min"` or `"max"`). + keep (float | int | Sequence): The designs kept by each stage but the + last: a number (int), or a share of its feasible designs (float), + or a value for each stage. + tolerance (Mapping | Sequence | None): The tolerances of objectives + in each stage but the last (see `pareto_front`), or the same for + each stage. + + Returns: + Screening: the results and summaries of each stage + """ + if len(studies) == 0: + raise ValueError("at least one study is required") + transitions = len(studies) - 1 + keeps = _per_stage(keep, transitions, "keep") + if tolerance is None or isinstance(tolerance, Mapping): + tolerances = [tolerance] * transitions + else: + tolerances = _per_stage(tolerance, transitions, "tolerance") + current = list({design.key: design for design in designs}.values()) + screening = Screening(results=pd.DataFrame()) + frames = [] + for stage, study in enumerate(studies): + results = study.run(current).assign(stage=stage) + frames.append(results) + summary = summarize(results, list(objectives), design_columns=[]) + summary = summary.dropna(subset=list(objectives)).reset_index(drop=True) + summary["pareto_rank"] = pareto_ranks( + summary, + objectives, + tolerances[stage] if stage < transitions else None, + ) + if stage < transitions: + amount = keeps[stage] + count = ( + math.ceil(amount * len(summary)) + if isinstance(amount, float) + else min(int(amount), len(summary)) + ) + ranks = summary["pareto_rank"].sort_values(kind="stable") + last = ranks.iloc[count - 1] if count > 0 else -1 + summary["kept"] = summary["pareto_rank"] <= last + kept = set(summary.loc[summary["kept"], "design"]) + current = [design for design in current if design.key in kept] + else: + summary["kept"] = True + screening.summaries.append(summary.assign(stage=stage)) + screening.results = pd.concat(frames, ignore_index=True) + screening.designs = current + return screening diff --git a/src/tatc/tradespace/space.py b/src/tatc/tradespace/space.py new file mode 100644 index 00000000..1887915c --- /dev/null +++ b/src/tatc/tradespace/space.py @@ -0,0 +1,753 @@ +""" +Design spaces: declarative trees of design variables from which designs +(architectures) are enumerated or sampled for trade studies. + +A design space is a tree of nodes. Its leaves are design variables +(`Real`, `Integer`, `Categorical`), fixed values, values derived from other +values (`Derived`), and uncertain (nuisance) parameters (`Uncertain`), which +are drawn for each replicate of a design rather than searched. Its branches +group nodes (`DesignSpace`), choose one of several alternatives (`Choice`), +or repeat a node a variable number of times (`Repeat`), which makes the +space hierarchical: for example, a constellation of a variable number of +orbit planes, each with its own design. + +Nodes are decided in the order they are declared. A callable (a bound of a +variable, a derived value, or a constraint) is given a view of the values +decided so far, in which names resolve to the innermost enclosing group +that declares them (as in lexically scoped code), and `index` gives the +position of the innermost enclosing repeated item. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +import hashlib +import json +import zlib +from collections.abc import Callable, Sequence +from functools import partial +from typing import Any + +import numpy as np + +from .nodes import ( + Choice, + Derived, + Fixed, + Infeasible, + Integer, + Node, + Repeat, + Uncertain, + Variable, + _as_node, + _Domain, +) +from .values import ( + Scope, + Values, + _ChoiceValue, + _RepeatValue, +) + +_ABSENT = object() +"""Marker of a node that records no decision (fixed, derived, or uncertain).""" + +_RESERVED_NAMES = {"index", "count", "choice"} +"""Names that cannot be given to the children of a design space.""" + + +# --------------------------------------------------------------------------- +# deciding designs +# --------------------------------------------------------------------------- + + +def _decision_key(decision: Any) -> str: + """ + Gets a canonical string of a decision. + """ + return json.dumps(decision, sort_keys=True, default=str) + + +def _plain(value: Any) -> Any: + """ + Converts a numpy scalar to a plain Python value, for decisions. + """ + return value.item() if isinstance(value, np.generic) else value + + +class _Context: + """ + How a walk of a design space decides its nodes: `choose(path, domain)` + decides a variable, `draw(path, node)` draws an uncertain parameter (or + `None` for nominal values), and `check` enables constraints. If given, + `record(path, domain, value)` is called with every decision, chosen or + prescribed. + """ + + def __init__( + self, + choose: Callable[[str, _Domain], Any] | None = None, + draw: Callable[[str, Uncertain], Any] | None = None, + check: bool = True, + record: Callable[[str, _Domain, Any], None] | None = None, + ): + self.choose, self.draw, self.check = choose, draw, check + self.record = record + + def decide(self, path: str, domain: _Domain, prescribed: Any) -> Any: + """ + Decides a value of a domain: the prescribed value, or a chosen one. + """ + if prescribed is _ABSENT: + value = _plain(_choose(self, path, domain)) + else: + value = prescribed + if self.record is not None: + self.record(path, domain, value) + return value + + +def _join(path: str, name: str) -> str: + return f"{path}.{name}" if path else name + + +def _walk( + node: Node, + path: str, + scope: Scope, + ctx: _Context, + prescribed: Any = _ABSENT, + publish: Callable[[Any], None] | None = None, +) -> tuple[Any, Any]: + """ + Decides a node: returns its value and its decision (the values of its + design variables, or `_ABSENT` if it has none). A prescribed decision is + followed instead of choosing. A container publishes its (partial) value + as soon as it is created, so that its contents are visible to the + callables of later nodes within it. + """ + if isinstance(node, Variable): + if prescribed is not _ABSENT and ctx.record is None: + return prescribed, prescribed + value = ctx.decide(path, node.domain(scope), prescribed) + return value, value + if isinstance(node, Fixed): + return node.value, _ABSENT + if isinstance(node, Derived): + return node.function(scope), _ABSENT + if isinstance(node, Uncertain): + return (node.nominal if ctx.draw is None else ctx.draw(path, node)), _ABSENT + if isinstance(node, DesignSpace): + return _walk_group(node, path, scope, ctx, prescribed, publish) + if isinstance(node, Choice): + return _walk_choice(node, path, scope, ctx, prescribed, publish) + if isinstance(node, Repeat): + return _walk_repeat(node, path, scope, ctx, prescribed, publish) + raise TypeError(f"unknown node {node!r} at {path or 'the root'}") + + +def _choose(ctx: _Context, path: str, domain: _Domain) -> Any: + """ + Chooses a value of a domain, if the walk can choose. + """ + if ctx.choose is None: + raise ValueError(f"no decision for {path}") + return ctx.choose(path, domain) + + +def _walk_group( + node: DesignSpace, + path: str, + scope: Scope, + ctx: _Context, + prescribed: Any, + publish: Callable[[Any], None] | None, +) -> tuple[dict, dict]: + """ + Decides the children of a design space in order, then checks its + constraints (see `_walk`). + """ + values: dict = {} + if publish is not None: + publish(values) + inner = scope.push(values) + decisions = {} + for name, child in node.children.items(): + value, decision = _walk( + child, + _join(path, name), + inner, + ctx, + _ABSENT if prescribed is _ABSENT else prescribed.get(name, _ABSENT), + partial(values.__setitem__, name), + ) + values[name] = value + if decision is not _ABSENT: + decisions[name] = decision + if ctx.check: + for i, constraint in enumerate(node.constraints): + violation = _get_violation(constraint(inner)) + if violation > 0: + label = getattr(constraint, "__name__", "") + raise Infeasible( + f"constraint {i} ({label}) of {path or 'the design space'} " + + "is not satisfied", + violation, + ) + return values, decisions + + +def _get_violation(result: Any) -> float: + """ + Gets the violation of a constraint from its result: a boolean (`True` if + satisfied, a violation of 1 otherwise) or a number (satisfied if it is + not positive, its value is the violation otherwise). + """ + if isinstance(result, (bool, np.bool_)): + return 0.0 if result else 1.0 + return float(result) + + +def _walk_choice( + node: Choice, + path: str, + scope: Scope, + ctx: _Context, + prescribed: Any, + publish: Callable[[Any], None] | None, +) -> tuple[_ChoiceValue, list]: + """ + Decides the branch of a choice, then the branch (see `_walk`). + """ + choice = _ABSENT if prescribed is _ABSENT else prescribed[0] + name = ctx.decide(path, _Domain(levels=list(node.branches)), choice) + sub = None if prescribed is _ABSENT else prescribed[1] + result = _ChoiceValue(name) + if publish is not None: + publish(result) + result.value, decision = _walk( + node.branches[name], + _join(path, name), + scope, + ctx, + _ABSENT if sub is None else sub, + partial(setattr, result, "value"), + ) + return result, [name, None if decision is _ABSENT else decision] + + +def _walk_items( + node: Repeat, + path: str, + scope: Scope, + ctx: _Context, + count: int, + prescribed: Any, + publish: Callable[[Any], None] | None, +) -> tuple[_RepeatValue, list]: + """ + Decides the items of a repetition (see `_walk_repeat`). + """ + result = _RepeatValue(count) + if publish is not None: + publish(result) + decisions = [] + for k in range(count): + sub = _ABSENT if prescribed is _ABSENT else prescribed[k] + value, decision = _walk( + node.item, + f"{path}[{k}]", + scope.push({}, k), + ctx, + _ABSENT if sub is None else sub, + result.items.append, + ) + if len(result.items) == k: + # a value that is not a container is not published + result.items.append(value) + decisions.append(None if decision is _ABSENT else decision) + return result, decisions + + +def _walk_repeat( + node: Repeat, + path: str, + scope: Scope, + ctx: _Context, + prescribed: Any, + publish: Callable[[Any], None] | None, +) -> tuple[_RepeatValue, list]: + """ + Decides the count of a repetition, then its items, which are sorted by + their decisions and decided again in that order if they are unordered + (see `_walk`). + """ + if isinstance(node.count, Integer): + count = int( + ctx.decide( + _join(path, "count"), + node.count.domain(scope), + _ABSENT if prescribed is _ABSENT else len(prescribed), + ) + ) + else: + count = int(node.count) + result, decisions = _walk_items(node, path, scope, ctx, count, prescribed, publish) + if not node.ordered: + canonical = sorted(decisions, key=_decision_key) + if canonical != decisions: + result, decisions = _walk_items( + node, path, scope, ctx, count, canonical, publish + ) + return result, decisions + + +def _flatten(node: Node, value: Any, path: str, out: dict) -> None: + """ + Flattens the values of a node into `out`, by path: the chosen branch of + a choice at its path (and its values under the branch's name), the count + of a repetition at `.count` (and its items at `[k]`), and the + other values (except fixed values) at their paths. + """ + if isinstance(node, Fixed): + return + if isinstance(node, DesignSpace): + for name, child in node.children.items(): + _flatten(child, value[name], _join(path, name), out) + elif isinstance(node, Choice): + out[path] = value.choice + _flatten( + node.branches[value.choice], value.value, _join(path, value.choice), out + ) + elif isinstance(node, Repeat): + out[_join(path, "count")] = value.count + for k, item in enumerate(value.items): + _flatten(node.item, item, f"{path}[{k}]", out) + else: + out[path] = value + + +# --------------------------------------------------------------------------- +# designs and design spaces +# --------------------------------------------------------------------------- + + +class Design: + """ + A design: one decision of every active design variable of a design + space. Its values are given as attributes (or keys), as for the views of + the callables of the design space, and are those of a replicate (with + drawn uncertain parameters) if the design is realized (see `realize`). + """ + + def __init__( + self, + space: DesignSpace, + decisions: dict, + values: dict, + replicate: int | None = None, + ): + self.space, self.decisions, self.replicate = space, decisions, replicate + self._values = values + self.key = hashlib.sha1(_decision_key(decisions).encode()).hexdigest()[:12] + """str: An identifier of the design, from its decisions only (not + from its derived values or uncertain parameters).""" + + @property + def values(self) -> Values: + """Values: the values of the design.""" + return Values(self._values) + + def __getattr__(self, name: str) -> Any: + if name.startswith("_"): + raise AttributeError(name) + return getattr(self.values, name) + + def __getitem__(self, name: str) -> Any: + return self.values[name] + + def __eq__(self, other: object) -> bool: + return ( + isinstance(other, Design) + and self.key == other.key + and self.replicate == other.replicate + ) + + def __hash__(self) -> int: + return hash((self.key, self.replicate)) + + def flat(self) -> dict[str, Any]: + """ + Gets the values of the design by path, as for the columns of a + table: `a.b` for the value `b` of group `a`, `c` for the chosen + branch of choice `c` (and `c..d` for its values), `e.count` + for the count of repetition `e` (and `e[k].f` for the values of its + items). Fixed values are omitted. + + Returns: + dict: the values by path + """ + out: dict = {} + _flatten(self.space, self._values, "", out) + return out + + def realize(self, replicate: int, seed: int = 0, common: bool = True) -> Design: + """ + Realizes a replicate of the design: draws its uncertain parameters + (and computes the values derived from them). + + Each uncertain parameter is drawn from a random number generator + seeded by `seed`, `replicate`, and its path, so that with `common` + random numbers, a parameter at the same path (such as the phase of + the first orbit plane) takes the same value in the same replicate + of every design. Comparisons between designs then measure the + differences between the designs rather than between their draws, + which needs fewer replicates to rank them. Otherwise, the generator + is also seeded by the design's key, so that draws are independent + between designs. + + Args: + replicate (int): The replicate. + seed (int): The seed of the trade study. + common (bool): `True` to use common random numbers between + designs. + + Returns: + Design: the realized design + """ + stream = [seed, replicate] + ([] if common else [int(self.key, 16)]) + + def draw(path: str, node: Uncertain) -> Any: + rng = np.random.default_rng(stream + [zlib.crc32(path.encode())]) + return node.sampler(rng) + + values, _ = _walk( + self.space, "", Scope(), _Context(draw=draw, check=False), self.decisions + ) + return Design(self.space, self.decisions, values, replicate) + + def __repr__(self) -> str: + replicate = "" if self.replicate is None else f", replicate={self.replicate}" + return f"Design({self.key}{replicate}: {self.flat()})" + + +class _Odometer: + """ + Chooses the levels of the variables of successive walks in the order of + an odometer whose digits are the decisions of a walk, so that walks + enumerate every combination of levels, including those of variables + whose existence or domain depends on earlier decisions. + """ + + def __init__(self): + self.indices: list[int] = [] + self.sizes: list[int] = [] + self.position = 0 + + def choose(self, path: str, domain: _Domain) -> Any: + """ + Chooses the level of the current digit of the odometer (adding a + digit, at the first level, if the walk is longer than before). + """ + if domain.levels is None: + raise ValueError( + f"{path} is continuous: give it a step to enumerate the design space" + ) + if len(domain.levels) == 0: + raise Infeasible(f"{path} has no levels") + if self.position == len(self.indices): + self.indices.append(0) + self.sizes.append(len(domain.levels)) + level = domain.levels[self.indices[self.position]] + self.position += 1 + return level + + def advance(self) -> bool: + """ + Advances to the next combination after a walk, returning `False` + after the last. + """ + del self.indices[self.position :], self.sizes[self.position :] + self.position = 0 + while self.indices: + if self.indices[-1] + 1 < self.sizes[-1]: + self.indices[-1] += 1 + return True + self.indices.pop() + self.sizes.pop() + return False + + +def _lhs_column(n: int, rng: np.random.Generator) -> np.ndarray: + """ + Gets `n` values in [0, 1) stratified in `n` equal intervals in random + order (a column of a Latin hypercube sample). + """ + return (rng.permutation(n) + rng.random(n)) / n + + +class DesignSpace(Node): + """ + A group of nodes: the root of a design space, or a group within it (such + as the design of each orbit plane). Children are given by name, in the + order they are decided; plain values are fixed values. + + Constraints are callables of the group's values (and those of enclosing + groups), checked once the group's values are decided, that return + whether a design satisfies them (`True` or `False`) or by how much it + violates them: a number that is not positive if it satisfies them, and + otherwise the amount of violation (for example, `lambda d: d.satellites - + 12` for at most 12 satellites), which guides constraint-aware optimizers + toward feasible designs (see `optimize_optuna` and `make_pymoo_problem`). + They must not depend on uncertain parameters. + + Args: + constraints (Sequence[Callable]): The constraints. + **children (Any): The nodes, by name. + """ + + def __init__( + self, constraints: Sequence[Callable[[Scope], bool]] = (), **children: Any + ): + reserved = _RESERVED_NAMES.intersection(children) + if reserved: + raise ValueError(f"reserved names: {sorted(reserved)}") + self.children = {name: _as_node(node) for name, node in children.items()} + self.constraints = list(constraints) + + def __repr__(self) -> str: + return f"DesignSpace({', '.join(self.children)})" + + def _design(self, ctx: _Context) -> Design: + """ + Decides a design (with nominal uncertain parameters). + """ + values, decisions = _walk(self, "", Scope(), ctx) + return Design(self, decisions, values) + + def design(self, decisions: dict) -> Design: + """ + Gets the design of given decisions (see `Design.decisions`), checking + its constraints. + + Args: + decisions (dict): The decisions. + + Returns: + Design: the design + + Raises: + Infeasible: if the design violates a constraint. + """ + values, decisions = _walk(self, "", Scope(), _Context(), decisions) + return Design(self, decisions, values) + + def enumerate(self) -> list[Design]: + """ + Enumerates every feasible design (a full factorial design over the + levels of the design variables, including those that exist only in + some designs), without duplicates. + + Returns: + list[Design]: the designs, in the order of their decisions + + Raises: + ValueError: if a design variable is continuous. + """ + odometer = _Odometer() + ctx = _Context(choose=odometer.choose) + designs: dict[str, Design] = {} + while True: + try: + design = self._design(ctx) + designs.setdefault(design.key, design) + except Infeasible: + pass + if not odometer.advance(): + return list(designs.values()) + + def size(self) -> int: + """ + Counts the feasible designs (see `enumerate`). + + Returns: + int: the number of designs + """ + return len(self.enumerate()) + + def sample( + self, + n: int, + method: str = "lhs", + seed: int = 0, + max_tries: int = 1000, + ) -> list[Design]: + """ + Samples feasible designs, which may repeat. + + With `method="lhs"`, each design variable (identified by its path, + including those that exist only in some designs) is sampled in a + Latin hypercube: its range is divided into `n` equal parts and each + design samples a different part. A design that is infeasible is + drawn again at random, which disturbs the stratification. With + `method="random"`, every variable is sampled independently. + + Args: + n (int): The number of designs. + method (str): `"lhs"` (Latin hypercube) or `"random"`. + seed (int): The seed of the random number generator. + max_tries (int): The number of draws of a design before giving up. + + Returns: + list[Design]: the designs + + Raises: + Infeasible: if no feasible design is drawn in `max_tries`. + """ + if method not in ("lhs", "random"): + raise ValueError(f"method must be 'lhs' or 'random', not {method!r}") + rng = np.random.default_rng(seed) + columns: dict[str, np.ndarray] = {} + designs = [] + for i in range(n): + for attempt in range(max_tries): + stratified = method == "lhs" and attempt == 0 + + def unit(path: str, i: int = i, stratified: bool = stratified) -> float: + if not stratified: + return float(rng.random()) + if path not in columns: + columns[path] = _lhs_column(n, rng) + return float(columns[path][i]) + + ctx = _Context( + choose=lambda path, domain, unit=unit: domain.from_unit(unit(path)) + ) + try: + designs.append(self._design(ctx)) + break + except Infeasible: + continue + else: + raise Infeasible(f"no feasible design in {max_tries} draws") + return designs + + def unit_paths(self) -> list[str]: + """ + Gets the paths of every decision of the design space, in the order + they are decided: its design variables, its choices, and the counts + of its repetitions, with the items of each repetition up to its + largest count. These are the dimensions of the unit hypercube that + encodes its designs (see `encode` and `decode`). + + Returns: + list[str]: the paths + + Raises: + ValueError: if the count of a repetition has an upper bound that + is not fixed. + """ + return _unit_paths(self, "") + + def decode(self, unit: Sequence[float]) -> Design: + """ + Decodes a design from a point of the unit hypercube (a value in + [0, 1] for each of `unit_paths`): each decision maps the value of its + path to a level (each level spans an equal part of [0, 1]) or to a + point of its interval. Values of the paths of inactive nodes (such as + the branches not chosen) are ignored. This encodes the design space + for optimizers of fixed numbers of continuous variables, such as + pymoo's. + + Args: + unit (Sequence[float]): The values, in the order of `unit_paths`. + + Returns: + Design: the design + + Raises: + Infeasible: if the design violates a constraint. + """ + index = {path: i for i, path in enumerate(self.unit_paths())} + if len(unit) != len(index): + raise ValueError(f"expected {len(index)} values, not {len(unit)}") + return self._design( + _Context(choose=lambda path, domain: domain.from_unit(unit[index[path]])) + ) + + def encode(self, design: Design) -> np.ndarray: + """ + Encodes a design as a point of the unit hypercube (see `decode`): the + center of the part of [0, 1] of each decided level, and 0.5 for the + paths of inactive nodes. + + Args: + design (Design): The design. + + Returns: + numpy.ndarray: the values, in the order of `unit_paths` + """ + index = {path: i for i, path in enumerate(self.unit_paths())} + unit = np.full(len(index), 0.5) + + def record(path: str, domain: _Domain, value: Any) -> None: + unit[index[path]] = domain.to_unit(value) + + _walk(self, "", Scope(), _Context(record=record), design.decisions) + return unit + + def suggest(self, trial: Any) -> Design: + """ + Decides a design with an Optuna trial (define-by-run): each decision + is suggested by the trial, named by its path, with the kind of its + variable (`suggest_float`, with the step of a discrete `Real`; + `suggest_int`; or `suggest_categorical`, also for choices), so that + Optuna's samplers search the hierarchical design space directly. + + Args: + trial (optuna.trial.Trial): The trial. + + Returns: + Design: the design + + Raises: + Infeasible: if the design violates a constraint. + """ + return self._design( + _Context(choose=lambda path, domain: domain.suggest(trial, path)) + ) + + +def _unit_paths(node: Node, path: str) -> list[str]: + """ + Gets the paths of the decisions of a node (see `DesignSpace.unit_paths`). + """ + if isinstance(node, Variable): + return [path] + if isinstance(node, DesignSpace): + return [ + p + for name, child in node.children.items() + for p in _unit_paths(child, _join(path, name)) + ] + if isinstance(node, Choice): + return [path] + [ + p + for name, branch in node.branches.items() + for p in _unit_paths(branch, _join(path, name)) + ] + if isinstance(node, Repeat): + if isinstance(node.count, Integer): + if callable(node.count.high): + raise ValueError( + f"the count of {path} needs a fixed upper bound to be encoded" + ) + paths, largest = [_join(path, "count")], int(node.count.high) + else: + paths, largest = [], int(node.count) + return paths + [ + p for k in range(largest) for p in _unit_paths(node.item, f"{path}[{k}]") + ] + return [] diff --git a/src/tatc/tradespace/study.py b/src/tatc/tradespace/study.py new file mode 100644 index 00000000..a6dba880 --- /dev/null +++ b/src/tatc/tradespace/study.py @@ -0,0 +1,277 @@ +""" +Trade studies: the evaluation of designs from a design space, with +replicates that draw their uncertain parameters, in sequence or in parallel. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +import math +import os +import time +from collections.abc import Callable, Iterable, Sequence +from concurrent.futures import Executor, as_completed +from typing import Any + +import numpy as np +import pandas as pd + +from .space import Design, DesignSpace + +_STATUS_COLUMNS = ["design", "replicate", "feasible", "error", "seconds"] +"""Columns of the results of a study that are neither design values nor metrics.""" + + +def _get_executor(n_jobs: int) -> Executor: + """ + Gets a reusable executor of `n_jobs` worker processes (from joblib's + loky, which serializes functions defined in notebooks and lambdas). + """ + try: + # pylint: disable=import-outside-toplevel + from joblib.externals.loky import get_reusable_executor + except ImportError as error: + raise ImportError( + "parallel trade studies require joblib (pip install joblib), " + + "or pass an executor" + ) from error + # one thread per worker for the numerical libraries, whose thread pools + # (one thread per processor in each worker) otherwise exhaust memory + threads = { + name: "1" + for name in ( + "OMP_NUM_THREADS", + "OPENBLAS_NUM_THREADS", + "MKL_NUM_THREADS", + "NUMEXPR_NUM_THREADS", + "NUMBA_NUM_THREADS", + ) + } + return get_reusable_executor(max_workers=n_jobs, env=threads) + + +class Study: + """ + A trade study: designs from a design space, each built into an + architecture (or any object to evaluate) and evaluated in replicates. + + Each replicate realizes a design (see `Design.realize`), builds it with + `build`, and evaluates the result with `evaluate`, which returns its + outcomes: a mapping (or `pandas.Series`) of metrics, or a + `pandas.DataFrame` of several records of metrics (such as one per + sensor), whose named index is kept as columns. + + A design that `build` rejects with a `ValueError` (which includes the + validation errors of TAT-C's schemas) is recorded as infeasible, with + the error, rather than raised. + + Evaluations run in parallel with `n_jobs` worker processes (or an + `executor` with the interface of `concurrent.futures.Executor`). They are + sent to the workers in chunks of consecutive evaluations of the same + replicates, so that a cache of each worker (see `SatelliteCache`) is + shared by the designs of a replicate, which share their uncertain + parameters (with common random numbers). The functions, and the objects + they refer to, are copied to each worker for each chunk, so keep large + inputs out of them (for example, load them from files in the workers) if + copying them takes long. + + Args: + space (DesignSpace): The design space. + build (Callable): A function of a realized design that builds the + object to evaluate (for example, a list of satellites). + evaluate (Callable): A function of a built object that evaluates it. + replicates (int): The number of replicates of each design. + seed (int): The seed of the uncertain parameters. + common_random_numbers (bool): `True` to draw the same uncertain + parameters in the same replicate of every design (see + `Design.realize`). + n_jobs (int): The number of worker processes (1 to evaluate in this + process, -1 for one per processor), each limited to one thread of + the numerical libraries (OpenMP, OpenBLAS, MKL, and numba). + executor (concurrent.futures.Executor | None): An executor to use + instead of worker processes. + chunks_per_job (int): The number of chunks of evaluations per worker. + """ + + def __init__( + self, + space: DesignSpace, + build: Callable[[Design], Any], + evaluate: Callable[[Any], Any], + replicates: int = 1, + seed: int = 0, + common_random_numbers: bool = True, + n_jobs: int = 1, + executor: Executor | None = None, + chunks_per_job: int = 2, + ): + if replicates < 1: + raise ValueError("replicates must be at least 1") + if n_jobs == 0 or n_jobs < -1: + raise ValueError("n_jobs must be positive or -1") + if chunks_per_job < 1: + raise ValueError("chunks_per_job must be at least 1") + self.space, self.build, self.evaluate = space, build, evaluate + self.replicates, self.seed = replicates, seed + self.common_random_numbers = common_random_numbers + self.n_jobs, self.executor = n_jobs, executor + self.chunks_per_job = chunks_per_job + + def __getstate__(self) -> dict: + # an executor is not sent to workers + state = self.__dict__.copy() + state["executor"] = None + return state + + def _evaluate(self, design: Design, replicate: int) -> list[dict]: + """ + Evaluates a replicate of a design, returning its records. + """ + realized = design.realize(replicate, self.seed, self.common_random_numbers) + base = {"design": design.key, "replicate": replicate, **realized.flat()} + began = time.perf_counter() + try: + built = self.build(realized) + except ValueError as error: + return [{**base, "feasible": False, "error": str(error)}] + outcome = self.evaluate(built) + base.update(feasible=True, seconds=time.perf_counter() - began) + if isinstance(outcome, pd.DataFrame): + named = any(name is not None for name in outcome.index.names) + frame = outcome.reset_index() if named else outcome + return [{**base, **record} for record in frame.to_dict("records")] + return [{**base, **dict(outcome)}] + + def _run_chunk(self, tasks: list[tuple[int, Design, int]]) -> list[list[dict]]: + """ + Evaluates a chunk of tasks (index, design, replicate) in turn. + """ + return [self._evaluate(design, replicate) for _, design, replicate in tasks] + + @property + def workers(self) -> int: + """int: The number of workers that evaluate designs (1 in this process).""" + if self.executor is not None: + return max(getattr(self.executor, "_max_workers", 1) or 1, 1) + if self.n_jobs == -1: + return os.cpu_count() or 1 + return self.n_jobs + + def run( + self, + designs: Iterable[Design] | None = None, + progress: Callable[[int, int], None] | None = None, + ) -> pd.DataFrame: + """ + Evaluates designs in every replicate. Repeated designs (with the same + key) are evaluated once. + + Args: + designs (Iterable[Design] | None): The designs, or `None` for + every design of the design space (see + `DesignSpace.enumerate`). + progress (Callable | None): A function called as evaluations + complete with the number completed and the number of + evaluations. + + Returns: + pandas.DataFrame: The outcomes, a record per evaluation (or per + record of an evaluation), in the order of the designs and + replicates, with the design's key (`design`), the + `replicate`, the values of the design by path (see + `Design.flat`), whether it is `feasible` (and the `error` if + not), the time to build and evaluate it (`seconds`), and the + metrics. + """ + designs = self.space.enumerate() if designs is None else designs + unique = list({design.key: design for design in designs}.values()) + # tasks in the order of replicates, whose designs share uncertain values + tasks = [ + (i, design, replicate) + for replicate in range(self.replicates) + for i, design in enumerate(unique) + ] + total = len(tasks) + results: list[tuple[int, int, list[dict]]] = [] + if self.executor is None and self.n_jobs == 1: + for done, (i, design, replicate) in enumerate(tasks, 1): + results.append((i, replicate, self._evaluate(design, replicate))) + if progress is not None: + progress(done, total) + else: + executor = self.executor or _get_executor(self.workers) + n_chunks = min(total, self.workers * self.chunks_per_job) + size = math.ceil(total / max(n_chunks, 1)) + chunks = [tasks[k : k + size] for k in range(0, total, size)] + futures = { + executor.submit(self._run_chunk, chunk): chunk for chunk in chunks + } + done = 0 + for future in as_completed(futures): + chunk = futures[future] + for (i, _, replicate), records in zip(chunk, future.result()): + results.append((i, replicate, records)) + done += len(chunk) + if progress is not None: + progress(done, total) + results.sort(key=lambda result: (result[0], result[1])) + return pd.DataFrame.from_records( + [record for _, _, records in results for record in records] + ) + + +def summarize( + results: pd.DataFrame, + metrics: Sequence[str], + by: Sequence[str] = (), + design_columns: Sequence[str] | None = None, +) -> pd.DataFrame: + """ + Summarizes the metrics of the feasible results of a study over their + replicates: for each design (and each group of the columns `by`, such as + a sensor), the mean of each metric, its standard deviation (` + std`) and standard error (` sem`) between replicates, and the + number of replicates (`replicates`), with the values of the design. + + Args: + results (pandas.DataFrame): The results (see `Study.run`). + metrics (Sequence[str]): The columns of the metrics. + by (Sequence[str]): Other columns that group records of an + evaluation. + design_columns (Sequence[str] | None): The columns of the values of + designs, or `None` for those that are the same in every + replicate of a design (except the metrics). + + Returns: + pandas.DataFrame: the summary, a row per design (and group) + """ + feasible = results[results["feasible"]] if "feasible" in results else results + keys = ["design", *by] + if design_columns is None: + excluded = set(_STATUS_COLUMNS) | set(metrics) | set(by) + candidates = [column for column in feasible.columns if column not in excluded] + constant = feasible.groupby("design")[candidates].nunique(dropna=False) + design_columns = [ + column for column in candidates if (constant[column] <= 1).all() + ] + # metrics (such as a number of satellites) may also be values of designs + design_columns = [ + column + for column in design_columns + if column not in metrics and column not in by + ] + grouped = feasible.groupby(keys, sort=False) + summary = grouped[list(design_columns)].first() if design_columns else None + statistics = grouped[list(metrics)].agg(["mean", "std", "count"]) + columns = {} + for metric in metrics: + count = statistics[(metric, "count")] + columns[metric] = statistics[(metric, "mean")] + columns[f"{metric} std"] = statistics[(metric, "std")] + columns[f"{metric} sem"] = statistics[(metric, "std")] / np.sqrt(count) + columns["replicates"] = grouped["replicate"].nunique() + frame = pd.DataFrame(columns) + if summary is not None: + frame = summary.join(frame) + return frame.reset_index() diff --git a/src/tatc/tradespace/values.py b/src/tatc/tradespace/values.py new file mode 100644 index 00000000..0aaa2679 --- /dev/null +++ b/src/tatc/tradespace/values.py @@ -0,0 +1,165 @@ +""" +Views of the values of designs, and the scopes given to the callables of +design spaces. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +from collections.abc import Iterator, Mapping +from typing import Any + + +class _ChoiceValue: + """The value of a choice: the chosen branch and its value.""" + + __slots__ = ("choice", "value") + + def __init__(self, choice: str, value: Any = None): + self.choice, self.value = choice, value + + +class _RepeatValue: + """The value of a repetition: its count and its items.""" + + __slots__ = ("count", "items") + + def __init__(self, count: int): + self.count, self.items = count, [] + + +def _view(value: Any) -> Any: + """ + Wraps a decided value for attribute access. + """ + if isinstance(value, dict): + return Values(value) + if isinstance(value, _ChoiceValue): + return ChoiceValues(value) + if isinstance(value, _RepeatValue): + return RepeatValues(value) + return value + + +class Values(Mapping): + """ + A read-only view of the values of a design space (a group of nodes), by + attribute or by key. + """ + + def __init__(self, values: dict, index: int | None = None): + self._values, self._index = values, index + + def __getitem__(self, name: str) -> Any: + return _view(self._values[name]) + + def __getattr__(self, name: str) -> Any: + if name.startswith("_"): + raise AttributeError(name) + if name == "index" and self._index is not None: + return self._index + try: + return self[name] + except KeyError: + raise AttributeError(name) from None + + def __iter__(self) -> Iterator[str]: + return iter(self._values) + + def __len__(self) -> int: + return len(self._values) + + def __repr__(self) -> str: + return f"Values({ {k: _view(v) for k, v in self._values.items()} })" + + +class ChoiceValues: + """ + A read-only view of the value of a choice: the name of the chosen branch + (`choice`) and, as attributes, the values of the branch. + """ + + def __init__(self, value: _ChoiceValue): + self._value = value + + @property + def choice(self) -> str: + """The name of the chosen branch.""" + return self._value.choice + + @property + def value(self) -> Any: + """The value of the chosen branch.""" + return _view(self._value.value) + + def __getattr__(self, name: str) -> Any: + if name.startswith("_"): + raise AttributeError(name) + return getattr(self.value, name) + + def __getitem__(self, name: str) -> Any: + return self.value[name] + + def __repr__(self) -> str: + return f"ChoiceValues({self.choice!r}, {self.value!r})" + + +class RepeatValues: + """ + A read-only view of the value of a repetition: a sequence of the values + of its items, whose length is also given as `count`. + """ + + def __init__(self, value: _RepeatValue): + self._value = value + + @property + def count(self) -> int: + """The number of items.""" + return self._value.count + + def __getitem__(self, index: int) -> Any: + item = self._value.items[index] + return Values(item, index) if isinstance(item, dict) else _view(item) + + def __len__(self) -> int: + return len(self._value.items) + + def __iter__(self) -> Iterator[Any]: + return (self[k] for k in range(len(self))) + + def __repr__(self) -> str: + return f"RepeatValues({list(self)!r})" + + +class Scope: + """ + The values decided so far, as given to the callables of a design space. + A name resolves to the innermost enclosing group that declares it (and + has decided it), and `index` to the position of the innermost enclosing + repeated item. + """ + + def __init__(self, frames: tuple = ()): + self._frames = frames + + def push(self, values: dict, index: int | None = None) -> Scope: + """ + Gets the scope of a group within this scope (or of a repeated item, + at `index`). + """ + return Scope(self._frames + ((values, index),)) + + def __getattr__(self, name: str) -> Any: + if name.startswith("_"): + raise AttributeError(name) + for values, index in reversed(self._frames): + if name in values: + return _view(values[name]) + if name == "index" and index is not None: + return index + raise AttributeError(f"{name!r} is not decided before it is used") + + def __getitem__(self, name: str) -> Any: + return getattr(self, name) diff --git a/tests/tradespace/__init__.py b/tests/tradespace/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/tradespace/test_cache.py b/tests/tradespace/test_cache.py new file mode 100644 index 00000000..9b270c17 --- /dev/null +++ b/tests/tradespace/test_cache.py @@ -0,0 +1,171 @@ +""" +Unit tests for caches of analyses by satellite. + +@author Paul T. Grogan +""" + +import pickle +import tempfile +import unittest +from datetime import datetime, timedelta, timezone +from pathlib import Path + +import pandas as pd + +from tatc.analysis import collect_observations +from tatc.schemas import Instrument, Point, Satellite, SunSynchronousOrbit +from tatc.tradespace import ( + DesignSpace, + Integer, + SatelliteCache, + Study, + get_satellite_key, +) + +EPOCH = datetime(2026, 1, 1, tzinfo=timezone.utc) + + +def _satellite(name: str, anomaly: float = 0, altitude: float = 700e3) -> Satellite: + return Satellite( + name=name, + orbit=SunSynchronousOrbit( + altitude=altitude, + equator_crossing_time="13:30", + epoch=EPOCH, + true_anomaly=anomaly, + ), + instruments=[Instrument(name="imager", field_of_regard=100)], + ) + + +def _name(satellite: Satellite) -> str: + return satellite.name + + +def _frame(satellite: Satellite) -> pd.DataFrame: + return pd.DataFrame({"satellite": [satellite.name] * 2}) + + +class TestSatelliteKey(unittest.TestCase): + """ + Unit tests for satellite keys. + """ + + def test_name_is_ignored(self): + """Satellites that differ only in name share a key.""" + self.assertEqual( + get_satellite_key(_satellite("a")), get_satellite_key(_satellite("b")) + ) + + def test_content_is_keyed(self): + """Satellites with other orbits or instruments have other keys.""" + base = _satellite("a") + self.assertNotEqual( + get_satellite_key(base), get_satellite_key(_satellite("a", anomaly=90)) + ) + other = base.model_copy( + update={"instruments": [Instrument(name="imager", field_of_regard=90)]} + ) + self.assertNotEqual(get_satellite_key(base), get_satellite_key(other)) + + +class TestSatelliteCache(unittest.TestCase): + """ + Unit tests for caches of analyses by satellite. + """ + + def setUp(self): + self.calls = [] + + def analysis(satellite): + self.calls.append(satellite.name) + return pd.DataFrame( + {"satellite": [satellite.name] * 2, "value": [1.0, 2.0]} + ) + + self.analysis = analysis + + def test_hits_and_relabeling(self): + """Results are computed once per content and relabeled with the name.""" + cache = SatelliteCache(self.analysis) + first = cache([_satellite("a"), _satellite("b", anomaly=90)]) + second = cache([_satellite("c"), _satellite("d", anomaly=90)]) + self.assertEqual(self.calls, ["a", "b"]) + self.assertEqual((cache.hits, cache.misses), (2, 2)) + self.assertEqual(list(first.satellite), ["a", "a", "b", "b"]) + self.assertEqual(list(second.satellite), ["c", "c", "d", "d"]) + # the cached result is not changed by relabeling + self.assertEqual(list(cache([_satellite("a")]).satellite), ["a", "a"]) + + def test_disk_cache(self): + """Results on disk are shared by caches of the same namespace.""" + with tempfile.TemporaryDirectory() as directory: + with self.assertRaises(ValueError): + SatelliteCache(self.analysis, directory=directory) + SatelliteCache(self.analysis, directory, namespace="x")(_satellite("a")) + again = SatelliteCache(self.analysis, directory, namespace="x") + self.assertEqual(list(again(_satellite("b")).satellite), ["b", "b"]) + self.assertEqual((again.hits, again.misses), (1, 0)) + other = SatelliteCache(self.analysis, directory, namespace="y") + other(_satellite("c")) + self.assertEqual(other.misses, 1) + self.assertEqual(self.calls, ["a", "c"]) + + def test_unreadable_file(self): + """A result that cannot be read from disk is computed again.""" + with tempfile.TemporaryDirectory() as directory: + cache = SatelliteCache(self.analysis, directory, namespace="x") + cache(_satellite("a")) + for path in Path(directory).iterdir(): + path.write_bytes(b"not a pickle") + again = SatelliteCache(self.analysis, directory, namespace="x") + self.assertEqual(list(again(_satellite("b")).satellite), ["b", "b"]) + self.assertEqual(again.misses, 1) + + def test_disk_cache_in_parallel(self): + """Workers of a study share a cache on disk, storing each result once.""" + satellites = [_satellite(f"s{i}", anomaly=30 * (i % 4)) for i in range(40)] + with tempfile.TemporaryDirectory() as directory: + cache = SatelliteCache(_frame, directory, namespace="parallel") + study = Study( + DesignSpace(i=Integer(0, 39)), + lambda d: satellites[d.i], + lambda satellite: {"rows": len(cache(satellite))}, + n_jobs=4, + chunks_per_job=5, + ) + results = study.run() + self.assertTrue((results.rows == 2).all()) + files = sorted(p.suffix for p in Path(directory).iterdir()) + self.assertEqual(files, [".pkl"] * 4) + + def test_pickled_cache_is_empty(self): + """Copies of a cache (as sent to workers) start without results.""" + cache = SatelliteCache(_name) + cache.get(_satellite("a")) + copy = pickle.loads(pickle.dumps(cache)) + self.assertEqual(copy._memory, {}) # pylint: disable=protected-access + cache.clear() + self.assertEqual((cache.hits, cache.misses), (0, 0)) + + def test_non_frame_results(self): + """Results that are not data frames are listed.""" + cache = SatelliteCache(lambda satellite: satellite.name) + self.assertEqual(cache([_satellite("a"), _satellite("b")]), ["a", "a"]) + + def test_matches_analysis(self): + """Cached observations of satellites match those of the constellation.""" + points = [Point(id=i, latitude=10 * i, longitude=0) for i in range(5)] + end = EPOCH + timedelta(days=1) + satellites = [_satellite(f"s{i}", anomaly=120 * i) for i in range(3)] + cache = SatelliteCache( + lambda satellite: collect_observations(points, satellite, EPOCH, end) + ) + cached = cache(satellites).sort_values(["target_hash", "epoch"]) + direct = collect_observations(points, satellites, EPOCH, end).sort_values( + ["target_hash", "epoch"] + ) + pd.testing.assert_frame_equal( + cached.reset_index(drop=True)[direct.columns], + direct.reset_index(drop=True), + ) diff --git a/tests/tradespace/test_optimization.py b/tests/tradespace/test_optimization.py new file mode 100644 index 00000000..1064517d --- /dev/null +++ b/tests/tradespace/test_optimization.py @@ -0,0 +1,307 @@ +""" +Unit tests for searches of design spaces with optimizers. + +@author Paul T. Grogan +""" + +import importlib.util +import unittest + +import numpy as np +import pandas as pd + +from tatc.tradespace import ( + Categorical, + Choice, + DesignSpace, + Evaluations, + Infeasible, + Integer, + Real, + Repeat, + Study, + Uncertain, + hypervolume, + make_pymoo_problem, + optimize_optuna, + optimize_pymoo, + pareto_front, + summarize, +) + +HAS_OPTUNA = importlib.util.find_spec("optuna") is not None +HAS_PYMOO = importlib.util.find_spec("pymoo") is not None + +OBJECTIVES = {"cost": "min", "value": "max"} +REFERENCE = {"cost": 30, "value": 0} + + +def _space(): + """Constellations of planes, or a single satellite of a quality.""" + return DesignSpace( + layout=Choice( + planes=DesignSpace( + planes=Repeat( + DesignSpace(satellites=Integer(1, 4), size=Real(0.5, 2, step=0.5)), + count=Integer(1, 3), + ordered=False, + ) + ), + single=DesignSpace(quality=Categorical([1, 2, 3])), + ), + noise=Uncertain.uniform(-0.01, 0.01), + # at most 8 satellites, violated by the satellites in excess + constraints=[ + lambda d: ( + sum(p.satellites for p in d.layout.planes) - 8 + if d.layout.choice == "planes" + else True + ) + ], + ) + + +def _build(design): + if design.layout.choice == "single": + return {"cost": 2.0 * design.layout.quality, "value": design.layout.quality} + if any(p.size == 2 and p.satellites == 4 for p in design.layout.planes): + raise ValueError("too heavy") + cost = sum(p.satellites * p.size + 1 for p in design.layout.planes) + value = sum(np.sqrt(p.satellites) * p.size for p in design.layout.planes) + return {"cost": cost, "value": value + design.noise} + + +def _study(**kwargs): + return Study(_space(), _build, lambda metrics: metrics, replicates=2, **kwargs) + + +class TestEncoding(unittest.TestCase): + """ + Unit tests for encoding designs in the unit hypercube. + """ + + def test_unit_paths(self): + """Paths cover every decision, with repeated items up to the largest count.""" + paths = _space().unit_paths() + self.assertEqual( + paths[:3], + [ + "layout", + "layout.planes.planes.count", + "layout.planes.planes[0].satellites", + ], + ) + self.assertEqual(len(paths), 1 + 1 + 3 * 2 + 1) + self.assertEqual(paths[-1], "layout.single.quality") + + def test_round_trip(self): + """Every design decodes from its encoding.""" + space = _space() + for design in space.enumerate(): + self.assertEqual(space.decode(space.encode(design)).key, design.key) + + def test_decode_random(self): + """Random points decode to designs of the space (or infeasible ones).""" + space = _space() + keys = {design.key for design in space.enumerate()} + rng = np.random.default_rng(0) + decoded = 0 + for _ in range(200): + try: + design = space.decode(rng.random(len(space.unit_paths()))) + except Infeasible: + continue + decoded += 1 + self.assertIn(design.key, keys) + self.assertGreater(decoded, 100) + + def test_dynamic_count_bound(self): + """Counts need fixed upper bounds to be encoded.""" + space = DesignSpace( + n=Integer(1, 3), + items=Repeat(Integer(0, 1), count=Integer(1, lambda d: d.n)), + ) + with self.assertRaises(ValueError): + space.unit_paths() + + +class TestEvaluations(unittest.TestCase): + """ + Unit tests for evaluations of searches. + """ + + def test_memo(self): + """Designs are evaluated once, and infeasible designs have no objectives.""" + evaluations = Evaluations(_study(), OBJECTIVES) + designs = _space().enumerate()[:5] + first = evaluations.evaluate(designs + designs) + self.assertEqual(first[:5], first[5:]) + evaluations.evaluate(designs) + self.assertEqual(len(evaluations.results), 5 * 2) + + def test_one_record_per_evaluation(self): + """Objectives need one record per evaluation.""" + study = Study( + _space(), + lambda d: None, + lambda built: pd.DataFrame({"cost": [1, 2], "value": [1, 2]}), + ) + with self.assertRaises(ValueError): + Evaluations(study, OBJECTIVES).evaluate(_space().enumerate()[:1]) + + +def _exact_hypervolume(): + summary = summarize(_study().run(), list(OBJECTIVES)) + return summary, hypervolume(summary, OBJECTIVES, REFERENCE) + + +@unittest.skipUnless(HAS_OPTUNA, "requires optuna") +class TestOptuna(unittest.TestCase): + """ + Unit tests for searches with Optuna. + """ + + def test_suggest(self): + """Suggestions follow the kinds of the variables.""" + import optuna # pylint: disable=import-outside-toplevel + + trial = optuna.trial.FixedTrial( + { + "layout": "planes", + "layout.planes.planes.count": 2, + "layout.planes.planes[0].satellites": 3, + "layout.planes.planes[0].size": 1.5, + "layout.planes.planes[1].satellites": 1, + "layout.planes.planes[1].size": 0.5, + } + ) + design = _space().suggest(trial) + self.assertEqual( + [(p.satellites, p.size) for p in design.layout.planes], [(1, 0.5), (3, 1.5)] + ) + + def test_optimize(self): + """A search finds most of the hypervolume of the true front.""" + import optuna # pylint: disable=import-outside-toplevel + + from tatc.tradespace import ( + optimize_optuna, + ) # pylint: disable=import-outside-toplevel + + optuna.logging.set_verbosity(optuna.logging.WARNING) + summary, exact = _exact_hypervolume() + optuna_study, results = optimize_optuna( + _study(), + OBJECTIVES, + n_trials=150, + sampler=optuna.samplers.NSGAIISampler(seed=1, population_size=20), + ) + self.assertEqual(len(optuna_study.trials), 150) + found = summarize(results, list(OBJECTIVES)) + self.assertLessEqual(found.design.nunique(), 150) + self.assertGreater(hypervolume(found, OBJECTIVES, REFERENCE), 0.9 * exact) + self.assertTrue(pareto_front(summary, OBJECTIVES).any()) + + +@unittest.skipUnless(HAS_PYMOO, "requires pymoo") +class TestPymoo(unittest.TestCase): + """ + Unit tests for searches with pymoo. + """ + + def test_optimize(self): + """NSGA-II on the encoded space finds most of the hypervolume of the true front.""" + from tatc.tradespace import ( + optimize_pymoo, + ) # pylint: disable=import-outside-toplevel + + _, exact = _exact_hypervolume() + result, results = optimize_pymoo( + _study(), OBJECTIVES, termination=("n_gen", 15), seed=1 + ) + self.assertEqual(result.F.shape[1], 2) + found = summarize(results, list(OBJECTIVES)) + self.assertGreater(hypervolume(found, OBJECTIVES, REFERENCE), 0.9 * exact) + self.assertFalse(results.feasible.all()) # some designs were too heavy + + +@unittest.skipUnless(HAS_OPTUNA, "requires optuna") +class TestOptunaConstraints(unittest.TestCase): + """ + Unit tests for constraints in searches with Optuna. + """ + + def setUp(self): + import optuna # pylint: disable=import-outside-toplevel + + optuna.logging.set_verbosity(optuna.logging.WARNING) + self.optuna = optuna + + def test_violations(self): + """Trials record the violations of their designs' constraints.""" + optuna_study, _ = optimize_optuna( + _study(), + OBJECTIVES, + n_trials=80, + sampler=self.optuna.samplers.RandomSampler(seed=3), + ) + states = {trial.state for trial in optuna_study.trials} + self.assertEqual(states, {self.optuna.trial.TrialState.COMPLETE}) + violations = [trial.constraints["feasibility"] for trial in optuna_study.trials] + self.assertTrue(any(v == 0 for v in violations)) + excess = [v for v in violations if v > 0] + self.assertTrue(excess) + # violations of the space count satellites in excess; the study's are 1 + for trial in optuna_study.trials: + if "error" in trial.user_attrs: + planes = [ + trial.params[f"layout.planes.planes[{k}].satellites"] + for k in range(trial.params["layout.planes.planes.count"]) + ] + self.assertEqual(trial.constraints["feasibility"], sum(planes) - 8) + + def test_pruning(self): + """Without constraints, infeasible trials are pruned.""" + optuna_study, _ = optimize_optuna( + _study(), + OBJECTIVES, + n_trials=60, + sampler=self.optuna.samplers.RandomSampler(seed=3), + constraints=False, + ) + states = {trial.state for trial in optuna_study.trials} + self.assertIn(self.optuna.trial.TrialState.PRUNED, states) + self.assertTrue(all(not trial.constraints for trial in optuna_study.trials)) + + +@unittest.skipUnless(HAS_PYMOO, "requires pymoo") +class TestPymooConstraints(unittest.TestCase): + """ + Unit tests for constraints of pymoo problems. + """ + + def test_violations(self): + """Violations of the space are the constraint values of the problem.""" + from pymoo.core.evaluator import ( + Evaluator, + ) # pylint: disable=import-outside-toplevel + from pymoo.core.population import ( + Population, + ) # pylint: disable=import-outside-toplevel + + space = _space() + problem = make_pymoo_problem(_study(), OBJECTIVES) + light = space.design({"layout": ["single", {"quality": 2}]}) + # three planes of four satellites: the first branch, the largest count + # and number of satellites (the last of their levels) + paths = space.unit_paths() + heavy = np.full(len(paths), 0.1) + for i, path in enumerate(paths): + if path.endswith("count") or path.endswith("satellites"): + heavy[i] = 0.99 + with self.assertRaises(Infeasible) as context: + space.decode(heavy) + self.assertEqual(context.exception.violation, 4) + x = np.array([space.encode(light), heavy]) + population = Evaluator().eval(problem, Population.new(X=x)) + self.assertEqual(list(population.get("G")[:, 0]), [0, 4]) diff --git a/tests/tradespace/test_pareto.py b/tests/tradespace/test_pareto.py new file mode 100644 index 00000000..9b381ac8 --- /dev/null +++ b/tests/tradespace/test_pareto.py @@ -0,0 +1,169 @@ +""" +Unit tests for Pareto efficiency. + +@author Paul T. Grogan +""" + +import itertools +import unittest + +import numpy as np +import pandas as pd + +from tatc.tradespace import ( + hypervolume, + pareto_front, + pareto_probability, + pareto_ranks, +) + + +def _brute_hypervolume(costs: np.ndarray, reference: np.ndarray) -> float: + """Hypervolume (to minimize) by inclusion-exclusion over subsets.""" + total = 0.0 + for size in range(1, len(costs) + 1): + for subset in itertools.combinations(range(len(costs)), size): + corner = costs[list(subset)].max(axis=0) + total += (-1) ** (size + 1) * np.prod(np.clip(reference - corner, 0, None)) + return total + + +class TestPareto(unittest.TestCase): + """ + Unit tests for Pareto efficiency. + """ + + def setUp(self): + self.frame = pd.DataFrame( + { + "cost": [1, 2, 3, 2, 4, 1], + "value": [1, 3, 4, 2, 4, 1], + }, + index=list("abcdef"), + ) + self.objectives = {"cost": "min", "value": "max"} + + def test_front(self): + """The front is the non-dominated rows, including ties.""" + front = pareto_front(self.frame, self.objectives) + self.assertEqual(list(front[front].index), ["a", "b", "c", "f"]) + flipped = pareto_front(self.frame, {"cost": "max", "value": "max"}) + self.assertEqual(list(flipped[flipped].index), ["e"]) + + def test_ranks(self): + """Ranks peel successive fronts.""" + ranks = pareto_ranks(self.frame, self.objectives) + self.assertEqual(list(ranks), [0, 0, 0, 1, 1, 0]) + + def test_hypervolume_2d(self): + """The two-dimensional hypervolume is the area of the dominated staircase.""" + # costs (cost, -value) to (5, 0): a (1,-1), b (2,-3), c (3,-4) + area = hypervolume(self.frame, self.objectives, {"cost": 5, "value": 0}) + self.assertAlmostEqual(area, 4 * 1 + 3 * 2 + 2 * 1) + self.assertEqual(hypervolume(self.frame, self.objectives, [0, 10]), 0.0) + self.assertEqual(hypervolume(self.frame.iloc[:0], self.objectives, [5, 0]), 0) + + def test_hypervolume_matches_brute_force(self): + """Hypervolumes in three and four dimensions match inclusion-exclusion.""" + rng = np.random.default_rng(4) + for dimensions in (3, 4): + costs = rng.random((9, dimensions)) + frame = pd.DataFrame(costs, columns=[f"f{i}" for i in range(dimensions)]) + objectives = {column: "min" for column in frame.columns} + reference = np.full(dimensions, 1.1) + self.assertAlmostEqual( + hypervolume(frame, objectives, reference), + _brute_hypervolume(costs, reference), + ) + + def test_invalid(self): + """Directions and references are checked.""" + with self.assertRaises(ValueError): + pareto_front(self.frame, {"cost": "lowest"}) + with self.assertRaises(ValueError): + hypervolume(self.frame, self.objectives, [1]) + + def test_tolerance(self): + """Rows within the tolerances of the front are efficient.""" + frame = pd.DataFrame( + {"cost": [1.0, 1.05, 1.5, 2.0], "value": [1.0, 1.02, 0.99, 0.5]} + ) + objectives = {"cost": "min", "value": "max"} + self.assertEqual( + list(pareto_front(frame, objectives)), [True, True, False, False] + ) + # c is worse than a and b by 0.01 and 0.03 in value, within the + # tolerance; d is not + loose = pareto_front(frame, objectives, tolerance={"value": 0.05}) + self.assertEqual(list(loose), [True, True, True, False]) + ranks = pareto_ranks(frame, objectives, tolerance={"value": 0.05}) + self.assertEqual(list(ranks), [0, 0, 0, 1]) + # a larger tolerance keeps d (worse than a by 0.5 in value) + self.assertTrue(pareto_front(frame, objectives, tolerance={"value": 0.6}).all()) + with self.assertRaises(ValueError): + pareto_front(frame, objectives, tolerance={"other": 1}) + + +class TestParetoProbability(unittest.TestCase): + """ + Unit tests for the probability of Pareto efficiency. + """ + + @staticmethod + def _results(values): + """Results of designs (rows) in replicates (columns), with a cost of 1.""" + return pd.DataFrame( + [ + { + "design": f"d{i}", + "replicate": r, + "cost": 1.0, + "value": v, + "feasible": True, + } + for i, row in enumerate(values) + for r, v in enumerate(row) + ] + ) + + def test_settled(self): + """Designs separated in every replicate are efficient or not for sure.""" + results = self._results([[1, 2, 3], [5, 6, 7]]) + probability = pareto_probability(results, {"cost": "min", "value": "max"}) + self.assertEqual(list(probability.pareto_probability), [0, 1]) + self.assertEqual(list(probability.pareto), [False, True]) + self.assertEqual(list(probability.value), [2, 6]) + + def test_common_random_numbers(self): + """Designs that differ by a constant in every replicate are settled.""" + rng = np.random.default_rng(0) + common = rng.normal(0, 5, 8) + results = self._results([common, common + 0.1]) + probability = pareto_probability(results, {"cost": "min", "value": "max"}) + self.assertEqual(list(probability.pareto_probability), [0, 1]) + + def test_unsettled(self): + """Designs whose order changes between replicates are uncertain.""" + # equal means: d0 varies between replicates, d1 does not + results = self._results([[0, 2] * 4, [1] * 8]) + probability = pareto_probability( + results, {"cost": "min", "value": "max"}, n_resamples=300 + ) + p = probability.pareto_probability + self.assertTrue(((p > 0.05) & (p < 0.95)).all()) + + def test_groups(self): + """Fronts of groups are found separately.""" + results = pd.concat( + [ + self._results([[1, 2], [3, 4]]).assign(sensor="a"), + self._results([[3, 4], [1, 2]]).assign(sensor="b"), + ] + ) + probability = pareto_probability( + results, {"cost": "min", "value": "max"}, by=["sensor"] + ) + winners = probability[probability.pareto_probability == 1] + self.assertEqual( + sorted(zip(winners.sensor, winners.design)), [("a", "d1"), ("b", "d0")] + ) diff --git a/tests/tradespace/test_screening.py b/tests/tradespace/test_screening.py new file mode 100644 index 00000000..19015871 --- /dev/null +++ b/tests/tradespace/test_screening.py @@ -0,0 +1,105 @@ +""" +Unit tests for screening with analyses of increasing fidelity. + +@author Paul T. Grogan +""" + +import unittest + +import numpy as np + +from tatc.tradespace import ( + DesignSpace, + Integer, + Study, + Uncertain, + pareto_front, + screen, + summarize, +) + +OBJECTIVES = {"cost": "min", "value": "max"} + + +def _space(): + return DesignSpace( + a=Integer(1, 10), + b=Integer(1, 10), + noise=Uncertain.normal(0, 1), + constraints=[lambda d: d.a + d.b <= 16], + ) + + +def _metrics(design, noise_scale): + cost = design.a + design.b + value = np.sqrt(design.a) * np.log1p(design.b) + noise_scale * design.noise + return {"cost": cost, "value": value} + + +def _study(noise_scale, replicates): + # independent noise of each design, as of a cheap analysis + return Study( + _space(), + lambda d: _metrics(d, noise_scale), + lambda metrics: metrics, + replicates=replicates, + common_random_numbers=False, + ) + + +class TestScreen(unittest.TestCase): + """ + Unit tests for screening. + """ + + def setUp(self): + self.designs = _space().enumerate() + exact = summarize(_study(0, 1).run(self.designs), list(OBJECTIVES)) + self.front = set(exact.design[pareto_front(exact, OBJECTIVES)]) + + def test_keeps_whole_fronts(self): + """Each stage keeps whole fronts until it keeps enough designs.""" + screening = screen( + self.designs, [_study(0.3, 1), _study(0, 1)], OBJECTIVES, keep=20 + ) + first = screening.summaries[0] + self.assertGreaterEqual(first.kept.sum(), 20) + last_rank = first[first.kept].pareto_rank.max() + self.assertTrue((first[first.pareto_rank <= last_rank].kept).all()) + self.assertFalse((first[first.pareto_rank > last_rank].kept).any()) + self.assertEqual(len(screening.designs), first.kept.sum()) + self.assertEqual(set(screening.results.stage), {0, 1}) + self.assertEqual(len(screening.final), len(screening.designs)) + + def test_finds_front(self): + """A tolerance of the noise of the first stage keeps the efficient designs.""" + stages = [_study(0.3, 1), _study(0, 1)] + # about two standard deviations of the noise of the first stage + screening = screen( + self.designs, stages, OBJECTIVES, keep=0.1, tolerance={"value": 0.6} + ) + final = screening.final + found = set(final.design[pareto_front(final, OBJECTIVES)]) + self.assertEqual(found, self.front) + self.assertLess(len(screening.designs), 0.6 * len(self.designs)) + # without a tolerance, the noise loses efficient designs + screening = screen(self.designs, stages, OBJECTIVES, keep=0.1) + final = screening.final + found = set(final.design[pareto_front(final, OBJECTIVES)]) + self.assertLess(len(found & self.front), len(self.front)) + + def test_three_stages(self): + """Values of keep and tolerance can be given for each transition.""" + screening = screen( + self.designs, + [_study(0.5, 1), _study(0.1, 2), _study(0, 1)], + OBJECTIVES, + keep=[0.5, 10], + tolerance=[{"value": 1.0}, None], + ) + counts = [len(summary) for summary in screening.summaries] + self.assertEqual(counts[0], len(self.designs)) + self.assertGreaterEqual(counts[1], 0.5 * counts[0]) + self.assertGreaterEqual(counts[2], 10) + with self.assertRaises(ValueError): + screen(self.designs, [_study(0, 1)] * 3, OBJECTIVES, keep=[0.5]) diff --git a/tests/tradespace/test_space.py b/tests/tradespace/test_space.py new file mode 100644 index 00000000..7bbffd1a --- /dev/null +++ b/tests/tradespace/test_space.py @@ -0,0 +1,233 @@ +""" +Unit tests for design spaces. + +@author Paul T. Grogan +""" + +import math +import unittest + +from tatc.tradespace import ( + Categorical, + Choice, + Derived, + DesignSpace, + Infeasible, + Integer, + Real, + Repeat, + Uncertain, +) + + +def _planes_space(): + """Planes spread over 12 hours with a random phase, for at most 6 satellites.""" + return DesignSpace( + per_plane=Integer(1, 6), + planes=Repeat( + DesignSpace( + crossing=Derived(lambda d: (13.5 + 12 * d.index / d.planes.count) % 24), + phase=Uncertain.uniform(0, 360), + ), + count=Integer(1, 6), + ), + constraints=[lambda d: d.planes.count * d.per_plane <= 6], + ) + + +def _hierarchical_space(): + """A choice between Walker constellations and unordered sun-synchronous planes.""" + plane = DesignSpace( + crossing=Real(0, 18, step=6), + satellites=Integer(1, 2), + payload=Categorical(["atms", "cris"]), + phase=Uncertain.uniform(0, 360), + ) + return DesignSpace( + altitude=Real(700e3, 850e3, step=75e3), + layout=Choice( + walker=DesignSpace( + inclination=Real(40, 70, step=15), + planes=Integer(1, 3), + per_plane=Integer(1, 2), + relative_spacing=Integer(0, lambda d: d.planes - 1), + ), + sso=DesignSpace(planes=Repeat(plane, count=Integer(1, 2), ordered=False)), + ), + ) + + +class TestVariables(unittest.TestCase): + """ + Unit tests for design variables. + """ + + def test_levels(self): + """Discrete variables enumerate their levels, inclusive of the upper bound.""" + space = DesignSpace( + a=Real(0, 1, step=0.1), b=Integer(2, 10, step=4), c=Categorical("xyz") + ) + designs = space.enumerate() + self.assertEqual(len(designs), 11 * 3 * 3) + self.assertEqual(sorted({d.a for d in designs})[-1], 1.0) + self.assertEqual(sorted({d.b for d in designs}), [2, 6, 10]) + self.assertIsInstance(designs[0].b, int) + + def test_continuous_cannot_enumerate(self): + """A continuous variable can be sampled but not enumerated.""" + space = DesignSpace(a=Real(1, 100, log=True)) + with self.assertRaises(ValueError): + space.enumerate() + values = [d.a for d in space.sample(50, seed=0)] + self.assertTrue(all(1 <= v <= 100 for v in values)) + self.assertEqual(len(set(values)), 50) + + def test_dependent_bounds(self): + """Bounds may depend on earlier values.""" + space = DesignSpace( + planes=Integer(1, 4), spacing=Integer(0, lambda d: d.planes - 1) + ) + self.assertEqual(space.size(), 1 + 2 + 3 + 4) + + def test_empty_domain_is_infeasible(self): + """A variable without levels makes a design infeasible.""" + space = DesignSpace(a=Integer(0, 2), b=Integer(1, lambda d: d.a)) + self.assertEqual( + {(d.a, d.b) for d in space.enumerate()}, {(1, 1), (2, 1), (2, 2)} + ) + + def test_reserved_names(self): + """Names used by views cannot be children.""" + with self.assertRaises(ValueError): + DesignSpace(index=Integer(0, 1)) + + +class TestDesignSpace(unittest.TestCase): + """ + Unit tests for design spaces. + """ + + def test_constraints(self): + """Constraints remove designs.""" + designs = _planes_space().enumerate() + self.assertEqual(len(designs), 14) + pairs = {(d.planes.count, d.per_plane) for d in designs} + self.assertIn((2, 3), pairs) + self.assertNotIn((2, 4), pairs) + + def test_derived_and_scope(self): + """Derived values resolve names in enclosing groups and the item index.""" + design = [d for d in _planes_space().enumerate() if d.planes.count == 4][0] + self.assertEqual([p.crossing for p in design.planes], [13.5, 16.5, 19.5, 22.5]) + self.assertEqual(design.planes[2].index, 2) + self.assertEqual(len(design.planes), 4) + + def test_hierarchical_enumeration(self): + """Choices and repetitions enumerate the designs of each branch.""" + designs = _hierarchical_space().enumerate() + walker = [d for d in designs if d.layout.choice == "walker"] + sso = [d for d in designs if d.layout.choice == "sso"] + # 3 altitudes x 3 inclinations x (1 x 2 + 2 x 2 + 3 x 2) (planes x spacing x per plane) + self.assertEqual(len(walker), 3 * 3 * 12) + # 16 plane designs (4 x 2 x 2): one plane, or two unordered planes (16 x 17 / 2) + self.assertEqual(len(sso), 3 * (16 + 136)) + self.assertEqual(len({d.key for d in designs}), len(designs)) + + def test_unordered_items_are_canonical(self): + """Designs that differ only in the order of unordered items are one design.""" + space = _hierarchical_space() + first = {"crossing": 0.0, "satellites": 1, "payload": "atms"} + second = {"crossing": 6.0, "satellites": 2, "payload": "cris"} + a = space.design( + {"altitude": 700e3, "layout": ["sso", {"planes": [first, second]}]} + ) + b = space.design( + {"altitude": 700e3, "layout": ["sso", {"planes": [second, first]}]} + ) + self.assertEqual(a.key, b.key) + self.assertEqual( + [p.payload for p in a.layout.planes], [p.payload for p in b.layout.planes] + ) + self.assertEqual(a.decisions, b.decisions) + + def test_flat(self): + """Flat values are keyed by path, without fixed values.""" + space = DesignSpace(fixed=3, layout=Choice(a=DesignSpace(x=Integer(1, 1)))) + self.assertEqual(space.enumerate()[0].flat(), {"layout": "a", "layout.a.x": 1}) + flat = _planes_space().enumerate()[1].flat() + self.assertEqual(flat["planes.count"], 2) + self.assertEqual(flat["planes[1].crossing"], 19.5) + self.assertTrue(math.isnan(flat["planes[1].phase"])) + + def test_design_from_decisions(self): + """A design is rebuilt from its decisions, and its constraints are checked.""" + space = _planes_space() + for design in space.enumerate(): + self.assertEqual(space.design(design.decisions).key, design.key) + with self.assertRaises(Infeasible): + space.design({"per_plane": 4, "planes": [{}, {}]}) + + def test_sample(self): + """Sampled designs are feasible, and Latin hypercube samples are stratified.""" + space = _planes_space() + keys = {d.key for d in space.enumerate()} + for method in ("lhs", "random"): + designs = space.sample(30, method=method, seed=3) + self.assertEqual(len(designs), 30) + self.assertTrue({d.key for d in designs} <= keys) + stratified = DesignSpace(a=Real(0, 1)).sample(10, seed=0) + self.assertEqual(sorted(int(d.a * 10) for d in stratified), list(range(10))) + + def test_constraint_violation(self): + """Constraints may give the amount of their violation.""" + space = DesignSpace( + a=Integer(0, 5), constraints=[lambda d: d.a - 3, lambda d: d.a != 1] + ) + self.assertEqual([d.a for d in space.enumerate()], [0, 2, 3]) + with self.assertRaises(Infeasible) as context: + space.design({"a": 5}) + self.assertEqual(context.exception.violation, 2) + with self.assertRaises(Infeasible) as context: + space.design({"a": 1}) + self.assertEqual(context.exception.violation, 1) + + def test_infeasible_sample(self): + """Sampling gives up on a space without feasible designs.""" + space = DesignSpace(a=Integer(0, 1), constraints=[lambda d: False]) + with self.assertRaises(Infeasible): + space.sample(1, max_tries=5) + self.assertEqual(space.enumerate(), []) + + +class TestRealize(unittest.TestCase): + """ + Unit tests for realizing designs. + """ + + def test_common_random_numbers(self): + """Uncertain parameters at the same path are common to every design.""" + designs = _planes_space().enumerate() + phases = {d.realize(2, seed=7).planes[0].phase for d in designs} + self.assertEqual(len(phases), 1) + other = designs[0].realize(3, seed=7).planes[0].phase + self.assertNotIn(other, phases) + independent = { + d.realize(2, seed=7, common=False).planes[0].phase for d in designs + } + self.assertEqual(len(independent), len(designs)) + + def test_realize_is_reproducible(self): + """Realizing a design again gives the same values, and keeps its key.""" + design = _planes_space().enumerate()[5] + a, b = design.realize(1), design.realize(1) + self.assertEqual(a.flat(), b.flat()) + self.assertEqual(a.key, design.key) + self.assertEqual(a.replicate, 1) + self.assertTrue(all(0 <= p.phase < 360 for p in a.planes)) + + def test_uncertain_choice(self): + """Uncertain choices are drawn from their options.""" + space = DesignSpace(epoch=Uncertain.choice(["jan", "jul"])) + design = space.enumerate()[0] + self.assertIsNone(design.epoch) + self.assertEqual({design.realize(r).epoch for r in range(20)}, {"jan", "jul"}) diff --git a/tests/tradespace/test_study.py b/tests/tradespace/test_study.py new file mode 100644 index 00000000..3d68cce3 --- /dev/null +++ b/tests/tradespace/test_study.py @@ -0,0 +1,170 @@ +""" +Unit tests for trade studies. + +@author Paul T. Grogan +""" + +import unittest +from concurrent.futures import ThreadPoolExecutor +from datetime import datetime, timezone + +import numpy as np +import pandas as pd + +from tatc.schemas import CircularOrbit, Satellite, WalkerConstellation +from tatc.tradespace import DesignSpace, Integer, Real, Study, Uncertain, summarize + + +class TestStudy(unittest.TestCase): + """ + Unit tests for trade studies. + """ + + def setUp(self): + self.space = DesignSpace( + planes=Integer(1, 3), + per_plane=Integer(1, 3), + noise=Uncertain.uniform(0, 1), + ) + + def test_run_records(self): + """Every design is evaluated in every replicate, with its values and metrics.""" + study = Study( + self.space, + build=lambda d: (d.planes, d.per_plane, d.noise), + evaluate=lambda built: { + "satellites": built[0] * built[1], + "score": built[0] + built[2], + }, + replicates=4, + ) + results = study.run() + self.assertEqual(len(results), 9 * 4) + self.assertTrue(results.feasible.all()) + self.assertTrue( + (results.satellites == results.planes * results.per_plane).all() + ) + # common random numbers: the same noise in the same replicate of every design + self.assertEqual(results.groupby("replicate").noise.nunique().max(), 1) + self.assertEqual(results.groupby("design").noise.nunique().min(), 4) + + def test_independent_draws(self): + """Without common random numbers, designs draw independently.""" + study = Study( + self.space, + build=lambda d: d.noise, + evaluate=lambda noise: {"noise_out": noise}, + replicates=2, + common_random_numbers=False, + ) + results = study.run() + self.assertEqual(results.groupby("replicate").noise.nunique().min(), 9) + + def test_frame_outcomes_and_duplicates(self): + """Data frame outcomes give a record per row, and repeated designs run once.""" + designs = self.space.enumerate()[:2] * 3 + study = Study( + self.space, + build=lambda d: d.planes, + evaluate=lambda planes: pd.DataFrame( + {"sensor": ["a", "b"], "value": [planes, 2 * planes]} + ).set_index("sensor"), + ) + results = study.run(designs) + self.assertEqual(len(results), 2 * 2) + self.assertEqual(list(results.sensor), ["a", "b", "a", "b"]) + + def test_infeasible_designs(self): + """Designs rejected by validation are recorded as infeasible.""" + epoch = datetime(2026, 1, 1, tzinfo=timezone.utc) + space = DesignSpace( + altitude=Real(500e3, 600e3, step=100e3), + planes=Integer(1, 3), + satellites=Integer(1, 2), + ) + + def build(d): + return WalkerConstellation( + name="walker", + orbit=CircularOrbit(altitude=d.altitude, inclination=60, epoch=epoch), + number_planes=d.planes, + number_satellites=d.satellites, + ).generate_members() + + study = Study(space, build, lambda members: {"members": len(members)}) + results = study.run() + self.assertEqual(len(results), 12) + infeasible = results[~results.feasible] + # more planes than satellites + self.assertEqual(len(infeasible), 2 * 3) + self.assertTrue(infeasible.error.str.contains("number planes").all()) + feasible = results[results.feasible] + self.assertTrue((feasible.members == feasible.satellites).all()) + self.assertIsInstance(build(space.enumerate()[0])[0], Satellite) + + def test_progress(self): + """Progress is reported as evaluations complete.""" + calls = [] + Study( + self.space, + build=lambda d: None, + evaluate=lambda built: {}, + replicates=2, + ).run(progress=lambda done, total: calls.append((done, total))) + self.assertEqual(calls[0], (1, 18)) + self.assertEqual(calls[-1], (18, 18)) + + def _noise_study(self, **kwargs): + return Study( + self.space, + build=lambda d: (d.planes, d.per_plane, d.noise), + evaluate=lambda built: {"score": built[0] * built[1] + built[2]}, + replicates=3, + **kwargs, + ) + + def test_parallel_matches_sequential(self): + """Evaluations in worker processes give the results of a sequential run.""" + sequential = self._noise_study().run() + parallel = self._noise_study(n_jobs=2).run() + columns = [c for c in sequential.columns if c != "seconds"] + pd.testing.assert_frame_equal(sequential[columns], parallel[columns]) + + def test_executor(self): + """Evaluations run on a given executor, in the order of the designs.""" + with ThreadPoolExecutor(max_workers=3) as executor: + threaded = self._noise_study(executor=executor).run() + sequential = self._noise_study().run() + pd.testing.assert_series_equal(threaded.score, sequential.score) + self.assertEqual(self._noise_study(executor=executor).workers, 3) + + def test_summarize(self): + """Summaries give the mean and spread of metrics over replicates.""" + results = self._noise_study().run() + summary = summarize(results, ["score"]) + self.assertEqual(len(summary), 9) + self.assertIn("planes", summary.columns) + self.assertNotIn("noise", summary.columns) + self.assertTrue((summary.replicates == 3).all()) + first = results[results.design == summary.design[0]] + self.assertAlmostEqual(summary["score"][0], first.score.mean()) + self.assertAlmostEqual(summary["score std"][0], first.score.std()) + self.assertAlmostEqual(summary["score sem"][0], first.score.std() / np.sqrt(3)) + # a metric may also be a value of the design + overlap = summarize(results, ["score", "planes"], design_columns=["planes"]) + self.assertEqual(list(overlap.columns).count("planes"), 1) + + def test_summarize_by(self): + """Summaries group the records of an evaluation.""" + study = Study( + self.space, + build=lambda d: d.planes, + evaluate=lambda planes: pd.DataFrame( + {"sensor": ["a", "b"], "value": [planes, 2 * planes]} + ).set_index("sensor"), + replicates=2, + ) + summary = summarize(study.run(), ["value"], by=["sensor"]) + self.assertEqual(len(summary), 18) + b = summary[(summary.sensor == "b") & (summary.planes == 3)] + self.assertTrue((b.value == 6).all()) From 739646996ce628d7c5e7b07a825824a6e1c6d439 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Tue, 10 Nov 2026 06:58:01 -0700 Subject: [PATCH 02/52] add replicate statistics, requirements, adaptive replication, and constellation building blocks Add statistics of metrics over replicates (Mean, Quantile, Minimum, Maximum, StandardDeviation, Probability) and requirements on them as output constraints, with aggregate, and use them in pareto_probability, screen, and the Optuna and pymoo searches. Add refine, which adds replicates only to designs whose Pareto efficiency is uncertain, with tolerances of differences that do not matter, and evaluate given replicates with Study.run. Add building blocks of constellations: walker_space and sso_planes_space fragments, build_constellation with instruments or instrument catalog entries, and count_satellites and count_planes. Use them in the SearchTradeSpace example, with sections on refinement and reliable sampling. --- CHANGELOG.md | 3 + docs/api_reference/tradespace.rst | 52 + docs/examples/SearchTradeSpace.ipynb | 1550 ++++++++++++++++++----- src/tatc/tradespace/__init__.py | 47 +- src/tatc/tradespace/constellations.py | 347 +++++ src/tatc/tradespace/criteria.py | 363 ++++++ src/tatc/tradespace/optimization.py | 174 ++- src/tatc/tradespace/pareto.py | 147 ++- src/tatc/tradespace/refinement.py | 180 +++ src/tatc/tradespace/screening.py | 56 +- src/tatc/tradespace/study.py | 15 +- tests/tradespace/test_constellations.py | 195 +++ tests/tradespace/test_criteria.py | 208 +++ tests/tradespace/test_optimization.py | 67 + tests/tradespace/test_refinement.py | 143 +++ 15 files changed, 3117 insertions(+), 430 deletions(-) create mode 100644 src/tatc/tradespace/constellations.py create mode 100644 src/tatc/tradespace/criteria.py create mode 100644 src/tatc/tradespace/refinement.py create mode 100644 tests/tradespace/test_constellations.py create mode 100644 tests/tradespace/test_criteria.py create mode 100644 tests/tradespace/test_refinement.py diff --git a/CHANGELOG.md b/CHANGELOG.md index fb03871a..f1978010 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,6 +13,9 @@ Added: - Module `tradespace` (prototype) for trade studies. A `DesignSpace` declares design variables (`Real`, `Integer`, `Categorical`), fixed and `Derived` values, and `Uncertain` parameters (drawn per replicate, not searched), grouped hierarchically with `Choice` (one of several branches) and `Repeat` (a variable number of items, such as orbit planes, optionally unordered). Bounds, derived values, and constraints are callables of the values decided before them. `DesignSpace.enumerate` gives every feasible design (a full factorial design, including variables that exist only in some designs), and `sample` a Latin hypercube or random sample. A `Design` has a `key` from its decisions and `flat` values by path, and `realize` draws a replicate's uncertain parameters, with common random numbers between designs by default. `Study` builds and evaluates designs in replicates into a data frame, recording designs that fail validation as infeasible, in worker processes with `n_jobs` (or on an `executor`); `summarize` gives the mean, standard deviation, and standard error of metrics over replicates. - Class `tradespace.SatelliteCache`, which caches an analysis of single satellites by their content (orbit, instruments, and attitude, not their name, see `get_satellite_key`), in memory or on disk, so that designs that share satellites compute their results once. - Functions `tradespace.pareto_front`, `pareto_ranks` (both with optional tolerances of objectives, within which designs near the front are efficient), and `hypervolume` (exact) of designs with several objectives to minimize or maximize, and `pareto_probability`, the probability that each design is efficient given the uncertainty of its replicates (a bootstrap that resamples the same replicates for every design). + - Statistics of metrics over replicates (`tradespace.Mean`, `StandardDeviation`, `Minimum`, `Maximum`, `Quantile`, and `Probability`, the share of replicates that meet a threshold) and requirements on them (`Requirement`, output constraints that designs meet or violate by an amount once evaluated). `aggregate` gives the statistics and violations of each design; objectives and requirements of `pareto_probability` (which also gives the probability of meeting the requirements), `screen` (which ranks designs that miss requirements after those that meet them), `optimize_optuna` (a constraint of each trial for each requirement), and `optimize_pymoo` (a constraint for each requirement) name statistics, or metrics whose means they are. + - Function `tradespace.refine` (and class `Refinement`), which adds replicates only to the designs whose Pareto efficiency is uncertain, until it is settled, optionally with a tolerance of differences that do not matter (also of `pareto_probability`); `Study.run` evaluates given replicates (`replicates`). + - Building blocks of constellations: fragments of design spaces of Walker constellations (`tradespace.walker_space`) and planes of sun-synchronous orbits (`sso_planes_space`, whose planes have different crossing times), `build_constellation`, which builds the satellites of either with instruments or entries of the instrument catalog (with their validated attitudes, and several entries on one satellite), and `count_satellites` and `count_planes`. - Function `tradespace.screen` (and class `Screening`), which screens designs with studies of increasing fidelity, keeping whole fronts of the best designs of each stage for the next. - Searches of design spaces with optional optimizers: `tradespace.optimize_optuna` suggests designs with Optuna trials (`DesignSpace.suggest`, define-by-run over the hierarchical space), and `optimize_pymoo` and `make_pymoo_problem` search the unit hypercube that encodes a design space (`DesignSpace.unit_paths`, `encode`, and `decode`) with pymoo. Each design is evaluated once, and the designs proposed together are evaluated together, in parallel if the study is. Constraints of a design space may return the amount of their violation (`Infeasible.violation`), which Optuna's trials record (`set_constraint`) for its constraint-aware samplers, and which is the constraint value of pymoo problems. Optional dependencies `tradespace` (joblib, Optuna, and pymoo). - Example `SearchTradeSpace`, which searches a hierarchical trade space of constellations for the designs that sample points sufficiently: by evaluating every design, ranking them with the uncertainty of their replicates, screening, and searching with Optuna and pymoo. diff --git a/docs/api_reference/tradespace.rst b/docs/api_reference/tradespace.rst index 018b7252..7e4bd69c 100644 --- a/docs/api_reference/tradespace.rst +++ b/docs/api_reference/tradespace.rst @@ -44,6 +44,24 @@ Designs .. autoclass:: tatc.tradespace.Scope +Constellations +-------------- + +.. automodule:: tatc.tradespace.constellations + :no-members: + +.. autofunction:: tatc.tradespace.walker_space + +.. autofunction:: tatc.tradespace.sso_planes_space + +.. autofunction:: tatc.tradespace.build_constellation + +.. autofunction:: tatc.tradespace.count_satellites + +.. autofunction:: tatc.tradespace.count_planes + +.. autofunction:: tatc.tradespace.hours_to_time + Trade Studies ------------- @@ -52,6 +70,32 @@ Trade Studies .. autofunction:: tatc.tradespace.summarize +Statistics and Requirements +--------------------------- + +.. automodule:: tatc.tradespace.criteria + :no-members: + +.. autofunction:: tatc.tradespace.aggregate + +.. autoclass:: tatc.tradespace.Statistic + :members: reduce + +.. autoclass:: tatc.tradespace.Mean + +.. autoclass:: tatc.tradespace.StandardDeviation + +.. autoclass:: tatc.tradespace.Minimum + +.. autoclass:: tatc.tradespace.Maximum + +.. autoclass:: tatc.tradespace.Quantile + +.. autoclass:: tatc.tradespace.Probability + +.. autoclass:: tatc.tradespace.Requirement + :members: violation + Caches ------ @@ -74,6 +118,14 @@ Pareto Efficiency .. autofunction:: tatc.tradespace.pareto_probability +Adaptive Replication +-------------------- + +.. autofunction:: tatc.tradespace.refine + +.. autoclass:: tatc.tradespace.Refinement + :members: uncertain + Screening --------- diff --git a/docs/examples/SearchTradeSpace.ipynb b/docs/examples/SearchTradeSpace.ipynb index 848abd8b..c9bd8b10 100644 --- a/docs/examples/SearchTradeSpace.ipynb +++ b/docs/examples/SearchTradeSpace.ipynb @@ -28,10 +28,10 @@ "id": "c3d2e5f4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T05:21:06.335298Z", - "iopub.status.busy": "2026-11-10T05:21:06.335020Z", - "iopub.status.idle": "2026-11-10T05:21:07.046709Z", - "shell.execute_reply": "2026-11-10T05:21:07.045904Z" + "iopub.execute_input": "2026-11-10T05:58:30.755554Z", + "iopub.status.busy": "2026-11-10T05:58:30.755260Z", + "iopub.status.idle": "2026-11-10T05:58:31.599300Z", + "shell.execute_reply": "2026-11-10T05:58:31.598339Z" } }, "outputs": [], @@ -61,10 +61,10 @@ "source": [ "## Define the Design Space\n", "\n", - "A `DesignSpace` declares the design variables, in the order they are decided. Every design has an altitude and an imager's field of regard, and a layout that is one of two alternatives (a `Choice`):\n", + "A `DesignSpace` declares the design variables, in the order they are decided. Every design has an altitude and an imager's field of regard, and a layout that is one of two alternatives (a `Choice`), each declared with a building block of the `tatc.tradespace` module:\n", "\n", - "* a **Walker delta** constellation, with an inclination, a number of planes, a number of satellites in each plane, and the relative spacing of the satellites between planes (whose upper bound depends on the number of planes), or\n", - "* one or two **sun-synchronous** planes (a `Repeat` of planes), each with its own equator crossing time and number of satellites. The planes are unordered: two planes in either order are the same design. A constraint of the group requires the planes to have different crossing times (otherwise, they would be the same plane).\n", + "* a **Walker delta** constellation (`walker_space`), with an inclination, a number of planes, a number of satellites in each plane, and the relative spacing of the satellites between planes (whose upper bound depends on the number of planes), or\n", + "* one or two **sun-synchronous** planes (`sso_planes_space`, a `Repeat` of planes), each with its own equator crossing time and number of satellites. The planes are unordered: two planes in either order are the same design. A constraint of the building block requires the planes to have different crossing times (otherwise, they would be the same plane).\n", "\n", "The points sampled in each replicate are an `Uncertain` parameter (the seed of a random sample), drawn for each replicate rather than designed. The replicates use common random numbers: every design samples the same points in the same replicate, so that differences between designs are not differences between their samples.\n", "\n", @@ -77,10 +77,10 @@ "id": "e5f4a7b6", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T05:21:07.048629Z", - "iopub.status.busy": "2026-11-10T05:21:07.048297Z", - "iopub.status.idle": "2026-11-10T05:21:08.187349Z", - "shell.execute_reply": "2026-11-10T05:21:08.186504Z" + "iopub.execute_input": "2026-11-10T05:58:31.603174Z", + "iopub.status.busy": "2026-11-10T05:58:31.602654Z", + "iopub.status.idle": "2026-11-10T05:58:32.968088Z", + "shell.execute_reply": "2026-11-10T05:58:32.966883Z" } }, "outputs": [ @@ -93,43 +93,27 @@ } ], "source": [ - "from tatc.tradespace import Categorical, Choice, DesignSpace, Integer, Real, Repeat, Uncertain\n", - "\n", - "\n", - "def count_satellites(d):\n", - " \"\"\"The number of satellites of a design (or of the values decided so far).\"\"\"\n", - " if d.layout.choice == \"walker\":\n", - " return d.layout.planes * d.layout.per_plane\n", - " return sum(plane.satellites for plane in d.layout.planes)\n", - "\n", - "\n", - "def count_planes(d):\n", - " \"\"\"The number of orbit planes of a design.\"\"\"\n", - " return d.layout.planes if d.layout.choice == \"walker\" else d.layout.planes.count\n", - "\n", + "from tatc.tradespace import (\n", + " Categorical,\n", + " Choice,\n", + " DesignSpace,\n", + " Integer,\n", + " Real,\n", + " Uncertain,\n", + " count_satellites,\n", + " sso_planes_space,\n", + " walker_space,\n", + ")\n", "\n", "space = DesignSpace(\n", " altitude=Real(500e3, 800e3, step=100e3),\n", " field_of_regard=Categorical([30, 60]),\n", " layout=Choice(\n", - " walker=DesignSpace(\n", - " inclination=Real(45, 75, step=15),\n", - " planes=Integer(1, 4),\n", - " per_plane=Integer(1, 4),\n", - " relative_spacing=Integer(0, lambda d: d.planes - 1),\n", - " ),\n", - " sso=DesignSpace(\n", - " planes=Repeat(\n", - " DesignSpace(crossing=Real(6, 18, step=3), satellites=Integer(1, 2)),\n", - " count=Integer(1, 2),\n", - " ordered=False,\n", - " ),\n", - " # planes with the same crossing time would be the same plane\n", - " constraints=[lambda d: len({plane.crossing for plane in d.planes}) == d.planes.count],\n", - " ),\n", + " walker=walker_space(inclination=Real(45, 75, step=15), planes=Integer(1, 4), per_plane=Integer(1, 4)),\n", + " sso=sso_planes_space(crossing=Real(6, 18, step=3), satellites=Integer(1, 2), count=Integer(1, 2)),\n", " ),\n", " points_seed=Uncertain(lambda rng: int(rng.integers(2**31)), nominal=None),\n", - " constraints=[lambda d: count_satellites(d) - MAX_SATELLITES],\n", + " constraints=[lambda d: count_satellites(d.layout) - MAX_SATELLITES],\n", ")\n", "designs = space.enumerate()\n", "print(f\"{len(designs)} feasible designs of {len(space.unit_paths())} decisions\")" @@ -142,7 +126,7 @@ "source": [ "## Define the Study\n", "\n", - "A `Study` builds each design into its satellites (`build`) and evaluates them (`evaluate`) in each replicate. The evaluation collects the observations of the replicate's points by each satellite, from a `SatelliteCache`: designs share many satellites (the same orbit and imager, if not the same name), whose observations are computed once. The cache is kept on disk, where the parallel worker processes of the study (`n_jobs=-1`, one per processor) share it, and where it persists between sessions. Its namespace identifies the analysis: the points, the start, and the duration.\n", + "A `Study` builds each design into its satellites (`build`, with `build_constellation`, which builds the satellites of either layout with a payload: here, an imager, but also entries of the instrument catalog) and evaluates them (`evaluate`) in each replicate. The evaluation collects the observations of the replicate's points by each satellite, from a `SatelliteCache`: designs share many satellites (the same orbit and imager, if not the same name), whose observations are computed once. The cache is kept on disk, where the parallel worker processes of the study (`n_jobs=-1`, one per processor) share it, and where it persists between sessions. Its namespace identifies the analysis: the points, the start, and the duration.\n", "\n", "`make_study` makes studies of other durations and numbers of replicates, as for screening (below). Each evaluation also reports its cost (`satellite_days`, the satellites times the days analyzed), which measures the computation independently of the cache." ] @@ -153,18 +137,18 @@ "id": "a7b6c9d8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T05:21:08.189716Z", - "iopub.status.busy": "2026-11-10T05:21:08.189310Z", - "iopub.status.idle": "2026-11-10T05:21:08.196532Z", - "shell.execute_reply": "2026-11-10T05:21:08.195799Z" + "iopub.execute_input": "2026-11-10T05:58:32.971200Z", + "iopub.status.busy": "2026-11-10T05:58:32.970687Z", + "iopub.status.idle": "2026-11-10T05:58:32.979419Z", + "shell.execute_reply": "2026-11-10T05:58:32.978393Z" } }, "outputs": [], "source": [ "from tatc.analysis import collect_observations\n", "from tatc.generation import generate_points_random\n", - "from tatc.schemas import CircularOrbit, Instrument, Satellite, SunSynchronousOrbit, WalkerConstellation\n", - "from tatc.tradespace import SatelliteCache, Study\n", + "from tatc.schemas import Instrument\n", + "from tatc.tradespace import SatelliteCache, Study, build_constellation, count_planes\n", "\n", "CACHE_DIRECTORY = Path(tempfile.gettempdir()) / \"tatc-search-trade-space\"\n", "caches = {}\n", @@ -184,32 +168,8 @@ "\n", "def build(d):\n", " \"\"\"The design and its satellites.\"\"\"\n", - " instrument = Instrument(name=\"imager\", field_of_regard=d.field_of_regard)\n", - " if d.layout.choice == \"walker\":\n", - " members = WalkerConstellation(\n", - " name=\"walker\",\n", - " orbit=CircularOrbit(altitude=d.altitude, inclination=d.layout.inclination, epoch=START),\n", - " instruments=[instrument],\n", - " number_planes=d.layout.planes,\n", - " number_satellites=d.layout.planes * d.layout.per_plane,\n", - " relative_spacing=d.layout.relative_spacing,\n", - " ).generate_members()\n", - " else:\n", - " members = [\n", - " Satellite(\n", - " name=f\"plane {p + 1} satellite {s + 1}\",\n", - " orbit=SunSynchronousOrbit(\n", - " altitude=d.altitude,\n", - " equator_crossing_time=time_of_day(int(plane.crossing)),\n", - " epoch=START,\n", - " true_anomaly=360 * s / plane.satellites,\n", - " ),\n", - " instruments=[instrument],\n", - " )\n", - " for p, plane in enumerate(d.layout.planes)\n", - " for s in range(plane.satellites)\n", - " ]\n", - " return d, members\n", + " imager = Instrument(name=\"imager\", field_of_regard=d.field_of_regard)\n", + " return d, build_constellation(d.layout, imager, epoch=START, altitude=d.altitude)\n", "\n", "\n", "def make_study(duration=DURATION, replicates=N_REPLICATES):\n", @@ -221,7 +181,7 @@ " samples = get_cache(d.points_seed, duration)(members).groupby(\"target_hash\").size()\n", " return {\n", " \"satellites\": len(members),\n", - " \"planes\": count_planes(d),\n", + " \"planes\": count_planes(d.layout),\n", " \"sufficient\": 100 * (samples >= threshold).sum() / N_POINTS,\n", " \"satellite_days\": len(members) * duration / timedelta(days=1),\n", " }\n", @@ -249,10 +209,10 @@ "id": "c9d8e1f0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T05:21:08.198273Z", - "iopub.status.busy": "2026-11-10T05:21:08.198033Z", - "iopub.status.idle": "2026-11-10T05:21:15.174003Z", - "shell.execute_reply": "2026-11-10T05:21:15.173012Z" + "iopub.execute_input": "2026-11-10T05:58:32.981888Z", + "iopub.status.busy": "2026-11-10T05:58:32.981565Z", + "iopub.status.idle": "2026-11-10T05:58:41.434069Z", + "shell.execute_reply": "2026-11-10T05:58:41.433345Z" } }, "outputs": [ @@ -407,10 +367,10 @@ "id": "d0e9f2a1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T05:21:15.176165Z", - "iopub.status.busy": "2026-11-10T05:21:15.175970Z", - "iopub.status.idle": "2026-11-10T05:21:15.393143Z", - "shell.execute_reply": "2026-11-10T05:21:15.392292Z" + "iopub.execute_input": "2026-11-10T05:58:41.436010Z", + "iopub.status.busy": "2026-11-10T05:58:41.435817Z", + "iopub.status.idle": "2026-11-10T05:58:41.740991Z", + "shell.execute_reply": "2026-11-10T05:58:41.739810Z" } }, "outputs": [ @@ -491,10 +451,10 @@ "id": "a3b2c5d4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T05:21:15.395014Z", - "iopub.status.busy": "2026-11-10T05:21:15.394834Z", - "iopub.status.idle": "2026-11-10T05:22:06.536751Z", - "shell.execute_reply": "2026-11-10T05:22:06.535728Z" + "iopub.execute_input": "2026-11-10T05:58:41.743054Z", + "iopub.status.busy": "2026-11-10T05:58:41.742813Z", + "iopub.status.idle": "2026-11-10T05:59:32.360501Z", + "shell.execute_reply": "2026-11-10T05:59:32.359564Z" } }, "outputs": [ @@ -529,7 +489,7 @@ " \n", " \n", " \n", - " 91\n", + " 1052\n", " 800 km, 60 deg FOR, SSO: 1 at 15:00\n", " 1.0\n", " 1.0\n", @@ -538,7 +498,7 @@ " 0.25\n", " \n", " \n", - " 107\n", + " 1054\n", " 800 km, 60 deg FOR, SSO: 1 at 18:00\n", " 1.0\n", " 1.0\n", @@ -547,7 +507,7 @@ " 0.42\n", " \n", " \n", - " 827\n", + " 1048\n", " 800 km, 60 deg FOR, SSO: 1 at 09:00\n", " 1.0\n", " 1.0\n", @@ -556,7 +516,7 @@ " 0.74\n", " \n", " \n", - " 162\n", + " 1051\n", " 800 km, 60 deg FOR, SSO: 2 at 12:00\n", " 2.0\n", " 1.0\n", @@ -565,7 +525,7 @@ " 0.22\n", " \n", " \n", - " 1057\n", + " 960\n", " 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...\n", " 2.0\n", " 1.0\n", @@ -574,7 +534,7 @@ " 0.78\n", " \n", " \n", - " 235\n", + " 963\n", " 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...\n", " 2.0\n", " 2.0\n", @@ -583,7 +543,7 @@ " 1.00\n", " \n", " \n", - " 919\n", + " 961\n", " 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...\n", " 3.0\n", " 1.0\n", @@ -592,7 +552,7 @@ " 1.00\n", " \n", " \n", - " 1038\n", + " 1001\n", " 800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac...\n", " 3.0\n", " 3.0\n", @@ -601,7 +561,7 @@ " 0.29\n", " \n", " \n", - " 747\n", + " 698\n", " 700 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...\n", " 3.0\n", " 3.0\n", @@ -610,7 +570,7 @@ " 0.28\n", " \n", " \n", - " 125\n", + " 962\n", " 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...\n", " 4.0\n", " 1.0\n", @@ -619,7 +579,7 @@ " 1.00\n", " \n", " \n", - " 498\n", + " 965\n", " 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...\n", " 4.0\n", " 2.0\n", @@ -628,7 +588,7 @@ " 0.15\n", " \n", " \n", - " 599\n", + " 966\n", " 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...\n", " 4.0\n", " 2.0\n", @@ -637,7 +597,7 @@ " 0.32\n", " \n", " \n", - " 568\n", + " 980\n", " 800 km, 60 deg FOR, Walker 45 deg: 4 x 1 (spac...\n", " 4.0\n", " 4.0\n", @@ -646,7 +606,7 @@ " 0.40\n", " \n", " \n", - " 499\n", + " 1025\n", " 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...\n", " 6.0\n", " 2.0\n", @@ -655,7 +615,7 @@ " 0.32\n", " \n", " \n", - " 290\n", + " 1026\n", " 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...\n", " 6.0\n", " 2.0\n", @@ -669,38 +629,38 @@ ], "text/plain": [ " description satellites planes \\\n", - "91 800 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", - "107 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", - "827 800 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", - "162 800 km, 60 deg FOR, SSO: 2 at 12:00 2.0 1.0 \n", - "1057 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 1.0 \n", - "235 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", - "919 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 1.0 \n", - "1038 800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac... 3.0 3.0 \n", - "747 700 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", - "125 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", - "498 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", - "599 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", - "568 800 km, 60 deg FOR, Walker 45 deg: 4 x 1 (spac... 4.0 4.0 \n", - "499 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", - "290 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "1052 800 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", + "1054 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", + "1048 800 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", + "1051 800 km, 60 deg FOR, SSO: 2 at 12:00 2.0 1.0 \n", + "960 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 1.0 \n", + "963 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", + "961 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 1.0 \n", + "1001 800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac... 3.0 3.0 \n", + "698 700 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", + "962 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", + "965 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", + "966 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", + "980 800 km, 60 deg FOR, Walker 45 deg: 4 x 1 (spac... 4.0 4.0 \n", + "1025 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "1026 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", "\n", " sufficient pareto pareto_probability \n", - "91 4.0 False 0.25 \n", - "107 4.0 False 0.42 \n", - "827 4.2 True 0.74 \n", - "162 12.2 False 0.22 \n", - "1057 13.8 True 0.78 \n", - "235 28.6 True 1.00 \n", - "919 37.0 True 1.00 \n", - "1038 35.4 False 0.29 \n", - "747 35.8 False 0.28 \n", - "125 66.4 True 1.00 \n", - "498 66.2 False 0.15 \n", - "599 66.4 False 0.32 \n", - "568 66.4 False 0.40 \n", - "499 97.8 False 0.32 \n", - "290 98.0 True 1.00 " + "1052 4.0 False 0.25 \n", + "1054 4.0 False 0.42 \n", + "1048 4.2 True 0.74 \n", + "1051 12.2 False 0.22 \n", + "960 13.8 True 0.78 \n", + "963 28.6 True 1.00 \n", + "961 37.0 True 1.00 \n", + "1001 35.4 False 0.29 \n", + "698 35.8 False 0.28 \n", + "962 66.4 True 1.00 \n", + "965 66.2 False 0.15 \n", + "966 66.4 False 0.32 \n", + "980 66.4 False 0.40 \n", + "1025 97.8 False 0.32 \n", + "1026 98.0 True 1.00 " ] }, "execution_count": 6, @@ -727,29 +687,36 @@ }, { "cell_type": "markdown", - "id": "c5d4e7f6", + "id": "a4c2e6f8", "metadata": {}, "source": [ - "## Screen Designs with a Cheaper Analysis\n", + "## Refine Uncertain Designs\n", "\n", - "Evaluating every design is affordable here, but not for larger spaces or longer analyses. `screen` evaluates every design with a cheap study, keeps the best (whole fronts, until it keeps at least `keep` of them), and evaluates only those with the full study. A cheap study ranks designs less exactly, so a `tolerance` of an objective keeps designs that are within it of the front of the cheap study.\n", + "Five replicates settle the efficiency of most designs, but not of all. More replicates of every design would settle them, at the cost of evaluating every design again for each. `refine` instead adds replicates only to the designs whose efficiency is uncertain (efficient in more than 5% and fewer than 95% of the resamples), five at a time, and estimates their probabilities again, until none is uncertain (or a design has 40 replicates). The added replicates are the next ones after each design's own, which keeps common random numbers between the designs refined together.\n", "\n", - "The cheap study must rank designs as the full study would. Here, the screening study analyzes one replicate, rather than five, over a shorter period, with the threshold of sufficient sampling scaled to the period: 12 hours with two observations, or 6 hours with one. The table compares each screening's front with the true front (how many of its efficient designs it keeps, and its hypervolume), and its cost with that of evaluating every design." + "Some designs differ by less than any number of replicates could separate, such as those that sample nearly every point: a difference of a tenth of a percentage point does not matter to the trade. A tolerance of 1 percentage point of the share treats designs within it of the front as efficient (see `pareto_front`), so that refinement does not spend replicates on differences that do not matter." ] }, { "cell_type": "code", "execution_count": 7, - "id": "d6e5f8a7", + "id": "b5d3f7a9", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T05:22:06.538911Z", - "iopub.status.busy": "2026-11-10T05:22:06.538543Z", - "iopub.status.idle": "2026-11-10T05:22:16.593345Z", - "shell.execute_reply": "2026-11-10T05:22:16.592274Z" + "iopub.execute_input": "2026-11-10T05:59:32.362498Z", + "iopub.status.busy": "2026-11-10T05:59:32.362302Z", + "iopub.status.idle": "2026-11-10T06:09:18.478688Z", + "shell.execute_reply": "2026-11-10T06:09:18.477678Z" } }, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "655 evaluations added, 1.7% of those of 40 replicates of every design\n" + ] + }, { "data": { "text/html": [ @@ -771,78 +738,99 @@ " \n", " \n", " \n", - " screening study\n", - " keep (%)\n", - " tolerance (%)\n", - " designs kept\n", - " efficient designs kept\n", - " hypervolume (% of true front)\n", - " cost (% of every design)\n", + " round\n", + " uncertain\n", + " refined\n", + " evaluations\n", " \n", " \n", " \n", " \n", " 0\n", - " 12 h, 1 replicate\n", - " 5.0\n", - " NaN\n", - " 68\n", - " 5 of 6\n", - " 100.0\n", - " 16.0\n", + " 0\n", + " 20\n", + " 20\n", + " 100\n", " \n", " \n", " 1\n", - " 12 h, 1 replicate\n", - " 10.0\n", - " 5.0\n", - " 212\n", - " 6 of 6\n", - " 100.0\n", - " 23.7\n", + " 1\n", + " 21\n", + " 21\n", + " 105\n", " \n", " \n", " 2\n", - " 6 h, 1 replicate\n", - " 5.0\n", - " NaN\n", - " 55\n", - " 1 of 6\n", - " 79.0\n", - " 10.2\n", + " 2\n", + " 18\n", + " 18\n", + " 90\n", " \n", " \n", " 3\n", - " 6 h, 1 replicate\n", - " 20.0\n", - " NaN\n", - " 241\n", - " 6 of 6\n", - " 100.0\n", - " 24.8\n", + " 3\n", + " 17\n", + " 17\n", + " 85\n", + " \n", + " \n", + " 4\n", + " 4\n", + " 15\n", + " 15\n", + " 75\n", + " \n", + " \n", + " 5\n", + " 5\n", + " 14\n", + " 14\n", + " 70\n", + " \n", + " \n", + " 6\n", + " 6\n", + " 15\n", + " 15\n", + " 75\n", + " \n", + " \n", + " 7\n", + " 7\n", + " 13\n", + " 6\n", + " 30\n", + " \n", + " \n", + " 8\n", + " 8\n", + " 12\n", + " 3\n", + " 15\n", + " \n", + " \n", + " 9\n", + " 9\n", + " 12\n", + " 2\n", + " 10\n", " \n", " \n", "\n", "" ], "text/plain": [ - " screening study keep (%) tolerance (%) designs kept \\\n", - "0 12 h, 1 replicate 5.0 NaN 68 \n", - "1 12 h, 1 replicate 10.0 5.0 212 \n", - "2 6 h, 1 replicate 5.0 NaN 55 \n", - "3 6 h, 1 replicate 20.0 NaN 241 \n", - "\n", - " efficient designs kept hypervolume (% of true front) \\\n", - "0 5 of 6 100.0 \n", - "1 6 of 6 100.0 \n", - "2 1 of 6 79.0 \n", - "3 6 of 6 100.0 \n", - "\n", - " cost (% of every design) \n", - "0 16.0 \n", - "1 23.7 \n", - "2 10.2 \n", - "3 24.8 " + " round uncertain refined evaluations\n", + "0 0 20 20 100\n", + "1 1 21 21 105\n", + "2 2 18 18 90\n", + "3 3 17 17 85\n", + "4 4 15 15 75\n", + "5 5 14 14 70\n", + "6 6 15 15 75\n", + "7 7 13 6 30\n", + "8 8 12 3 15\n", + "9 9 12 2 10" ] }, "execution_count": 7, @@ -851,65 +839,27 @@ } ], "source": [ - "from tatc.tradespace import screen\n", - "\n", - "full_cost = results.satellite_days.sum()\n", - "true_front = set(summary.design[summary.pareto])\n", - "screenings = []\n", - "for hours, keep, tolerance in [(12, 0.05, None), (12, 0.1, 5.0), (6, 0.05, None), (6, 0.2, None)]:\n", - " screening = screen(\n", - " designs,\n", - " [make_study(timedelta(hours=hours), replicates=1), make_study()],\n", - " OBJECTIVES,\n", - " keep=keep,\n", - " tolerance=None if tolerance is None else {\"sufficient\": tolerance},\n", - " )\n", - " screenings.append(\n", - " {\n", - " \"screening study\": f\"{hours} h, 1 replicate\",\n", - " \"keep (%)\": 100 * keep,\n", - " \"tolerance (%)\": tolerance,\n", - " \"designs kept\": len(screening.designs),\n", - " \"efficient designs kept\": f\"{len(true_front & {d.key for d in screening.designs})} of {len(true_front)}\",\n", - " \"hypervolume (% of true front)\": 100 * hypervolume(screening.final, OBJECTIVES, REFERENCE) / exact_hypervolume,\n", - " \"cost (% of every design)\": 100 * screening.results.satellite_days.sum() / full_cost,\n", - " }\n", - " )\n", - "pd.DataFrame(screenings).round(1)" - ] - }, - { - "cell_type": "markdown", - "id": "e7f6a9b8", - "metadata": {}, - "source": [ - "The 12-hour screening study ranks designs nearly as the full study does. Keeping the best 5% of the designs finds a front with the hypervolume of the true front at 16% of the cost of evaluating every design, although it misses one efficient design, whose place a design with nearly the same objectives takes. Keeping 10%, with a tolerance of 5 percentage points, keeps every efficient design at 24% of the cost.\n", - "\n", - "The 6-hour screening study is cheaper, but ranks designs differently: one observation of a point in 6 hours separates designs less than four observations in a day do. Keeping 5% of the designs keeps only one of the six efficient ones (79% of the hypervolume), and it must keep 20% to keep them all, which costs as much as the 12-hour study. How many designs to keep depends on how well the cheap study ranks designs, which is worth checking on a sample of designs evaluated with both studies before screening a larger space." - ] - }, - { - "cell_type": "markdown", - "id": "f8a7b0c9", - "metadata": {}, - "source": [ - "## Search with Optimizers\n", - "\n", - "Larger design spaces cannot be enumerated or even screened, and an optimizer searches them for efficient designs instead. `optimize_optuna` suggests designs with Optuna's trials, which search the hierarchical design space directly (`DesignSpace.suggest`), and records the violation of the constraint of each infeasible design, which Optuna's samplers use to prefer feasible designs. `optimize_pymoo` searches the unit hypercube that encodes the design space (`DesignSpace.decode`) with a pymoo algorithm. Both evaluate each design once, however often it is proposed, and evaluate the designs proposed together in parallel.\n", + "from tatc.tradespace import refine\n", "\n", - "Each search below is given a budget of about 200 proposals, and is compared with a Latin hypercube sample of 200 designs (`DesignSpace.sample`). The designs evaluated (and the analyses of their satellites) are those of the evaluation of every design above, so they are retrieved from the cache." + "TOLERANCE = {\"sufficient\": 1.0} # percentage points of the share that do not matter\n", + "refinement = refine(\n", + " make_study(), designs, results, OBJECTIVES, step=5, max_replicates=40, n_resamples=1000, tolerance=TOLERANCE\n", + ")\n", + "added = len(refinement.results) - len(results)\n", + "print(f\"{added} evaluations added, {added / (len(designs) * 35):.1%} of those of 40 replicates of every design\")\n", + "refinement.history" ] }, { "cell_type": "code", "execution_count": 8, - "id": "a9b8c1d0", + "id": "c6e4a8b0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T05:22:16.596081Z", - "iopub.status.busy": "2026-11-10T05:22:16.595673Z", - "iopub.status.idle": "2026-11-10T05:22:18.360695Z", - "shell.execute_reply": "2026-11-10T05:22:18.359673Z" + "iopub.execute_input": "2026-11-10T06:09:18.480419Z", + "iopub.status.busy": "2026-11-10T06:09:18.480172Z", + "iopub.status.idle": "2026-11-10T06:09:18.538463Z", + "shell.execute_reply": "2026-11-10T06:09:18.537695Z" } }, "outputs": [ @@ -934,96 +884,1047 @@ " \n", " \n", " \n", - " designs evaluated\n", - " hypervolume (% of true front)\n", + " description\n", + " satellites\n", + " planes\n", + " sufficient\n", + " replicates\n", + " pareto\n", + " pareto_probability\n", " \n", " \n", " \n", " \n", - " Optuna (NSGA-II)\n", - " 140.0\n", - " 95.3\n", + " 772\n", + " 700 km, 60 deg FOR, SSO: 1 at 06:00\n", + " 1.0\n", + " 1.0\n", + " 2.68\n", + " 40\n", + " False\n", + " 0.16\n", " \n", " \n", - " pymoo (NSGA-II)\n", - " 87.0\n", - " 89.6\n", + " 774\n", + " 700 km, 60 deg FOR, SSO: 1 at 09:00\n", + " 1.0\n", + " 1.0\n", + " 2.70\n", + " 40\n", + " False\n", + " 0.19\n", " \n", " \n", - " Latin hypercube sample\n", - " 176.0\n", - " 80.3\n", + " 778\n", + " 700 km, 60 deg FOR, SSO: 1 at 15:00\n", + " 1.0\n", + " 1.0\n", + " 2.70\n", + " 40\n", + " False\n", + " 0.18\n", " \n", - " \n", - "\n", - "" - ], - "text/plain": [ - " designs evaluated hypervolume (% of true front)\n", - "Optuna (NSGA-II) 140.0 95.3\n", - "pymoo (NSGA-II) 87.0 89.6\n", - "Latin hypercube sample 176.0 80.3" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import optuna\n", - "from pymoo.algorithms.moo.nsga2 import NSGA2\n", - "\n", - "from tatc.tradespace import optimize_optuna, optimize_pymoo\n", - "\n", - "optuna.logging.set_verbosity(optuna.logging.WARNING)\n", - "BUDGET = 200\n", - "study = make_study()\n", - "searches = {}\n", - "_, searches[\"Optuna (NSGA-II)\"] = optimize_optuna(\n", - " study,\n", - " OBJECTIVES,\n", - " n_trials=BUDGET,\n", - " sampler=optuna.samplers.NSGAIISampler(population_size=20, seed=1),\n", - " batch_size=20,\n", - ")\n", - "_, searches[\"pymoo (NSGA-II)\"] = optimize_pymoo(study, OBJECTIVES, NSGA2(pop_size=20), (\"n_gen\", BUDGET // 20), seed=1)\n", - "searches[\"Latin hypercube sample\"] = study.run(space.sample(BUDGET, method=\"lhs\", seed=1))\n", - "\n", - "\n", - "def get_progress(search_results):\n", - " \"\"\"The hypervolume (% of the true front's) of the designs evaluated, as designs are evaluated.\"\"\"\n", - " means = summarize(search_results, list(OBJECTIVES), design_columns=[]).set_index(\"design\")\n", - " order = search_results.design.drop_duplicates()\n", - " counts = np.arange(10, len(order) + 1, 10)\n", - " return pd.Series(\n", - " [100 * hypervolume(means.reindex(order[:n]).dropna(), OBJECTIVES, REFERENCE) / exact_hypervolume for n in counts],\n", - " index=counts,\n", - " )\n", - "\n", - "\n", - "progress = {name: get_progress(search_results) for name, search_results in searches.items()}\n", - "pd.DataFrame(\n", - " {\n", - " name: {\n", - " \"designs evaluated\": search_results.design.nunique(),\n", - " \"hypervolume (% of true front)\": progress[name].iloc[-1],\n", - " }\n", - " for name, search_results in searches.items()\n", - " }\n", - ").T.round(1)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, + " \n", + " 780\n", + " 700 km, 60 deg FOR, SSO: 1 at 18:00\n", + " 1.0\n", + " 1.0\n", + " 2.72\n", + " 40\n", + " False\n", + " 0.19\n", + " \n", + " \n", + " 1017\n", + " 800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac...\n", + " 1.0\n", + " 1.0\n", + " 3.12\n", + " 40\n", + " False\n", + " 0.45\n", + " \n", + " \n", + " 1046\n", + " 800 km, 60 deg FOR, SSO: 1 at 06:00\n", + " 1.0\n", + " 1.0\n", + " 3.40\n", + " 40\n", + " True\n", + " 0.63\n", + " \n", + " \n", + " 1050\n", + " 800 km, 60 deg FOR, SSO: 1 at 12:00\n", + " 1.0\n", + " 1.0\n", + " 3.40\n", + " 40\n", + " True\n", + " 0.64\n", + " \n", + " \n", + " 1054\n", + " 800 km, 60 deg FOR, SSO: 1 at 18:00\n", + " 1.0\n", + " 1.0\n", + " 3.42\n", + " 40\n", + " True\n", + " 0.65\n", + " \n", + " \n", + " 1052\n", + " 800 km, 60 deg FOR, SSO: 1 at 15:00\n", + " 1.0\n", + " 1.0\n", + " 4.00\n", + " 5\n", + " True\n", + " 0.99\n", + " \n", + " \n", + " 1048\n", + " 800 km, 60 deg FOR, SSO: 1 at 09:00\n", + " 1.0\n", + " 1.0\n", + " 4.20\n", + " 5\n", + " True\n", + " 0.99\n", + " \n", + " \n", + " 960\n", + " 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...\n", + " 2.0\n", + " 1.0\n", + " 14.13\n", + " 15\n", + " True\n", + " 0.99\n", + " \n", + " \n", + " 963\n", + " 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...\n", + " 2.0\n", + " 2.0\n", + " 28.60\n", + " 5\n", + " True\n", + " 1.00\n", + " \n", + " \n", + " 961\n", + " 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...\n", + " 3.0\n", + " 1.0\n", + " 37.00\n", + " 5\n", + " True\n", + " 1.00\n", + " \n", + " \n", + " 973\n", + " 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...\n", + " 3.0\n", + " 3.0\n", + " 37.40\n", + " 40\n", + " True\n", + " 0.81\n", + " \n", + " \n", + " 962\n", + " 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...\n", + " 4.0\n", + " 1.0\n", + " 66.40\n", + " 5\n", + " True\n", + " 1.00\n", + " \n", + " \n", + " 965\n", + " 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...\n", + " 4.0\n", + " 2.0\n", + " 66.20\n", + " 5\n", + " True\n", + " 0.97\n", + " \n", + " \n", + " 966\n", + " 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...\n", + " 4.0\n", + " 2.0\n", + " 66.40\n", + " 5\n", + " True\n", + " 0.99\n", + " \n", + " \n", + " 980\n", + " 800 km, 60 deg FOR, Walker 45 deg: 4 x 1 (spac...\n", + " 4.0\n", + " 4.0\n", + " 66.70\n", + " 40\n", + " True\n", + " 0.74\n", + " \n", + " \n", + " 1025\n", + " 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...\n", + " 6.0\n", + " 2.0\n", + " 97.80\n", + " 5\n", + " True\n", + " 1.00\n", + " \n", + " \n", + " 1026\n", + " 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...\n", + " 6.0\n", + " 2.0\n", + " 98.00\n", + " 5\n", + " True\n", + " 1.00\n", + " \n", + " \n", + " 479\n", + " 600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...\n", + " 8.0\n", + " 2.0\n", + " 97.80\n", + " 5\n", + " True\n", + " 0.99\n", + " \n", + " \n", + " 480\n", + " 600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...\n", + " 8.0\n", + " 2.0\n", + " 97.80\n", + " 5\n", + " True\n", + " 0.99\n", + " \n", + " \n", + " 753\n", + " 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...\n", + " 8.0\n", + " 2.0\n", + " 97.80\n", + " 5\n", + " True\n", + " 0.99\n", + " \n", + " \n", + " 754\n", + " 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...\n", + " 8.0\n", + " 2.0\n", + " 97.80\n", + " 5\n", + " True\n", + " 0.99\n", + " \n", + " \n", + " 1027\n", + " 800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...\n", + " 8.0\n", + " 2.0\n", + " 98.00\n", + " 5\n", + " True\n", + " 1.00\n", + " \n", + " \n", + " 1028\n", + " 800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...\n", + " 8.0\n", + " 2.0\n", + " 98.00\n", + " 5\n", + " True\n", + " 1.00\n", + " \n", + " \n", + " 768\n", + " 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...\n", + " 8.0\n", + " 4.0\n", + " 97.80\n", + " 5\n", + " True\n", + " 0.99\n", + " \n", + " \n", + " 769\n", + " 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...\n", + " 8.0\n", + " 4.0\n", + " 97.80\n", + " 5\n", + " True\n", + " 0.99\n", + " \n", + " \n", + " 770\n", + " 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...\n", + " 8.0\n", + " 4.0\n", + " 97.80\n", + " 5\n", + " True\n", + " 0.99\n", + " \n", + " \n", + " 1043\n", + " 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...\n", + " 8.0\n", + " 4.0\n", + " 98.00\n", + " 5\n", + " True\n", + " 1.00\n", + " \n", + " \n", + " 1044\n", + " 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...\n", + " 8.0\n", + " 4.0\n", + " 98.00\n", + " 5\n", + " True\n", + " 1.00\n", + " \n", + " \n", + " 1045\n", + " 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...\n", + " 8.0\n", + " 4.0\n", + " 98.00\n", + " 5\n", + " True\n", + " 1.00\n", + " \n", + " \n", + " 761\n", + " 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", + " 9.0\n", + " 3.0\n", + " 97.69\n", + " 35\n", + " True\n", + " 0.92\n", + " \n", + " \n", + " 487\n", + " 600 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", + " 9.0\n", + " 3.0\n", + " 97.77\n", + " 35\n", + " True\n", + " 0.94\n", + " \n", + " \n", + " 763\n", + " 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", + " 9.0\n", + " 3.0\n", + " 97.96\n", + " 25\n", + " True\n", + " 0.97\n", + " \n", + " \n", + " 762\n", + " 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", + " 9.0\n", + " 3.0\n", + " 98.00\n", + " 25\n", + " True\n", + " 0.97\n", + " \n", + " \n", + " 1035\n", + " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", + " 9.0\n", + " 3.0\n", + " 98.00\n", + " 5\n", + " True\n", + " 0.96\n", + " \n", + " \n", + " 1036\n", + " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", + " 9.0\n", + " 3.0\n", + " 98.00\n", + " 5\n", + " True\n", + " 0.96\n", + " \n", + " \n", + " 1037\n", + " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", + " 9.0\n", + " 3.0\n", + " 98.00\n", + " 5\n", + " True\n", + " 0.96\n", + " \n", + " \n", + "\n", + "" + ], + "text/plain": [ + " description satellites planes \\\n", + "772 700 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", + "774 700 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", + "778 700 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", + "780 700 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", + "1017 800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac... 1.0 1.0 \n", + "1046 800 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", + "1050 800 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", + "1054 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", + "1052 800 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", + "1048 800 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", + "960 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 1.0 \n", + "963 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", + "961 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 1.0 \n", + "973 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", + "962 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", + "965 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", + "966 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", + "980 800 km, 60 deg FOR, Walker 45 deg: 4 x 1 (spac... 4.0 4.0 \n", + "1025 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "1026 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "479 600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", + "480 600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", + "753 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", + "754 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", + "1027 800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", + "1028 800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", + "768 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "769 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "770 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "1043 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "1044 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "1045 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "761 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "487 600 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "763 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "762 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "1035 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "1036 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "1037 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "\n", + " sufficient replicates pareto pareto_probability \n", + "772 2.68 40 False 0.16 \n", + "774 2.70 40 False 0.19 \n", + "778 2.70 40 False 0.18 \n", + "780 2.72 40 False 0.19 \n", + "1017 3.12 40 False 0.45 \n", + "1046 3.40 40 True 0.63 \n", + "1050 3.40 40 True 0.64 \n", + "1054 3.42 40 True 0.65 \n", + "1052 4.00 5 True 0.99 \n", + "1048 4.20 5 True 0.99 \n", + "960 14.13 15 True 0.99 \n", + "963 28.60 5 True 1.00 \n", + "961 37.00 5 True 1.00 \n", + "973 37.40 40 True 0.81 \n", + "962 66.40 5 True 1.00 \n", + "965 66.20 5 True 0.97 \n", + "966 66.40 5 True 0.99 \n", + "980 66.70 40 True 0.74 \n", + "1025 97.80 5 True 1.00 \n", + "1026 98.00 5 True 1.00 \n", + "479 97.80 5 True 0.99 \n", + "480 97.80 5 True 0.99 \n", + "753 97.80 5 True 0.99 \n", + "754 97.80 5 True 0.99 \n", + "1027 98.00 5 True 1.00 \n", + "1028 98.00 5 True 1.00 \n", + "768 97.80 5 True 0.99 \n", + "769 97.80 5 True 0.99 \n", + "770 97.80 5 True 0.99 \n", + "1043 98.00 5 True 1.00 \n", + "1044 98.00 5 True 1.00 \n", + "1045 98.00 5 True 1.00 \n", + "761 97.69 35 True 0.92 \n", + "487 97.77 35 True 0.94 \n", + "763 97.96 25 True 0.97 \n", + "762 98.00 25 True 0.97 \n", + "1035 98.00 5 True 0.96 \n", + "1036 98.00 5 True 0.96 \n", + "1037 98.00 5 True 0.96 " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "refined = refinement.probability\n", + "refined[\"description\"] = [describe(values.loc[key]) for key in refined.design]\n", + "refined[refined.pareto_probability >= 0.1].sort_values([\"satellites\", \"planes\", \"sufficient\"])[\n", + " [\"description\", \"satellites\", \"planes\", \"sufficient\", \"replicates\", \"pareto\", \"pareto_probability\"]\n", + "].round(2)" + ] + }, + { + "cell_type": "markdown", + "id": "d7f5b9c1", + "metadata": {}, + "source": [ + "Refinement adds 655 evaluations, 1.7% of those that 40 replicates of every design would take, to the few designs whose efficiency is uncertain. With the tolerance, the designs that sample nearly every point (six to nine satellites, about 98%) are all efficient candidates, with probabilities of 0.92 or more, rather than uncertain: they differ by less than matters. The designs that stay uncertain after ten rounds lie about one tolerance below the front, such as single satellites that sample about 3.4% of the points against the best single satellite's 4.2%: whether they are within the tolerance of the front is a question that more replicates settle only slowly, and one that does not change the trade. An absolute tolerance suits a share near saturation better than one near zero; a tolerance proportional to the objective would treat both alike." + ] + }, + { + "cell_type": "markdown", + "id": "e8a6c0d2", + "metadata": {}, + "source": [ + "## Require Reliable Sampling\n", + "\n", + "A mean share of points sufficiently sampled does not say how reliably a design achieves it: the share differs between samples of points. Statistics over the replicates other than the mean state how a design is judged, and requirements on them are output constraints. Here, the objective is the share that a design exceeds in 80% of the samples (its 0.2 quantile, `Quantile`), and a design is required to sample at least half of the points sufficiently in at least 80% of the samples (the probability of meeting a threshold, `Probability`, with a `Requirement`). `aggregate` gives the statistics and the violations of the requirements, and `pareto_probability` the probability that each design is efficient among those that meet them." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "f9b7d1e3", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-10T06:09:18.540370Z", + "iopub.status.busy": "2026-11-10T06:09:18.540117Z", + "iopub.status.idle": "2026-11-10T06:10:04.806057Z", + "shell.execute_reply": "2026-11-10T06:10:04.805052Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "194 of 1096 designs meet the requirement\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanessufficient p20reliabilityreplicatespareto_probabilityrequirements_probability
962800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.061.81.051.001.0
965800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.061.81.050.241.0
966800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.062.41.050.381.0
980800 km, 60 deg FOR, Walker 45 deg: 4 x 1 (spac...4.04.063.81.0400.451.0
1025800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.41.050.471.0
1026800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.61.051.001.0
487600 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.096.81.0350.121.0
762700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.096.81.0250.121.0
763700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.096.81.0250.111.0
\n", + "
" + ], + "text/plain": [ + " description satellites planes \\\n", + "962 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", + "965 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", + "966 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", + "980 800 km, 60 deg FOR, Walker 45 deg: 4 x 1 (spac... 4.0 4.0 \n", + "1025 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "1026 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "487 600 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "762 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "763 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "\n", + " sufficient p20 reliability replicates pareto_probability \\\n", + "962 61.8 1.0 5 1.00 \n", + "965 61.8 1.0 5 0.24 \n", + "966 62.4 1.0 5 0.38 \n", + "980 63.8 1.0 40 0.45 \n", + "1025 97.4 1.0 5 0.47 \n", + "1026 97.6 1.0 5 1.00 \n", + "487 96.8 1.0 35 0.12 \n", + "762 96.8 1.0 25 0.12 \n", + "763 96.8 1.0 25 0.11 \n", + "\n", + " requirements_probability \n", + "962 1.0 \n", + "965 1.0 \n", + "966 1.0 \n", + "980 1.0 \n", + "1025 1.0 \n", + "1026 1.0 \n", + "487 1.0 \n", + "762 1.0 \n", + "763 1.0 " + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import Probability, Quantile, Requirement, aggregate\n", + "\n", + "STATISTICS = {\n", + " \"sufficient p20\": Quantile(\"sufficient\", 0.2),\n", + " \"reliability\": Probability(\"sufficient\", \">=\", 50),\n", + "}\n", + "RELIABLE_OBJECTIVES = {\"satellites\": \"min\", \"planes\": \"min\", \"sufficient p20\": \"max\"}\n", + "REQUIREMENTS = [Requirement(\"reliability\", \">=\", 0.8)]\n", + "\n", + "reliable = pareto_probability(\n", + " refinement.results, RELIABLE_OBJECTIVES, n_resamples=1000, statistics=STATISTICS, requirements=REQUIREMENTS\n", + ")\n", + "reliable[\"description\"] = [describe(values.loc[key]) for key in reliable.design]\n", + "print(f\"{reliable.meets_requirements.sum()} of {len(reliable)} designs meet the requirement\")\n", + "reliable[reliable.pareto_probability >= 0.1].sort_values([\"satellites\", \"planes\"])[\n", + " [\"description\", \"satellites\", \"planes\", \"sufficient p20\", \"reliability\", \"replicates\", \"pareto_probability\", \"requirements_probability\"]\n", + "].round(2)" + ] + }, + { + "cell_type": "markdown", + "id": "a0c8e2f4", + "metadata": {}, + "source": [ + "194 of the 1,096 designs meet the requirement of sampling half of the points sufficiently in at least 80% of the samples, and none of them has fewer than four satellites: the best three satellites sample 37% of the points on average. Among those that meet it, four satellites in one plane (inclined 45 degrees) are efficient for sure, sampling at least 62% of the points in 80% of the samples, and so are six satellites in two planes inclined 75 degrees (at least 97%). Four satellites in two or four planes are nearly as good, with probabilities of 0.24 to 0.45, which are the alternatives to weigh with other criteria, such as the cost of launching more planes." + ] + }, + { + "cell_type": "markdown", + "id": "c5d4e7f6", + "metadata": {}, + "source": [ + "## Screen Designs with a Cheaper Analysis\n", + "\n", + "Evaluating every design is affordable here, but not for larger spaces or longer analyses. `screen` evaluates every design with a cheap study, keeps the best (whole fronts, until it keeps at least `keep` of them), and evaluates only those with the full study. A cheap study ranks designs less exactly, so a `tolerance` of an objective keeps designs that are within it of the front of the cheap study.\n", + "\n", + "The cheap study must rank designs as the full study would. Here, the screening study analyzes one replicate, rather than five, over a shorter period, with the threshold of sufficient sampling scaled to the period: 12 hours with two observations, or 6 hours with one. The table compares each screening's front with the true front (how many of its efficient designs it keeps, and its hypervolume), and its cost with that of evaluating every design." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "d6e5f8a7", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-10T06:10:04.807818Z", + "iopub.status.busy": "2026-11-10T06:10:04.807567Z", + "iopub.status.idle": "2026-11-10T06:10:18.896857Z", + "shell.execute_reply": "2026-11-10T06:10:18.895863Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
screening studykeep (%)tolerance (%)designs keptefficient designs kepthypervolume (% of true front)cost (% of every design)
012 h, 1 replicate5.0NaN685 of 6100.016.0
112 h, 1 replicate10.05.02126 of 6100.023.7
26 h, 1 replicate5.0NaN551 of 679.010.2
36 h, 1 replicate20.0NaN2416 of 6100.024.8
\n", + "
" + ], + "text/plain": [ + " screening study keep (%) tolerance (%) designs kept \\\n", + "0 12 h, 1 replicate 5.0 NaN 68 \n", + "1 12 h, 1 replicate 10.0 5.0 212 \n", + "2 6 h, 1 replicate 5.0 NaN 55 \n", + "3 6 h, 1 replicate 20.0 NaN 241 \n", + "\n", + " efficient designs kept hypervolume (% of true front) \\\n", + "0 5 of 6 100.0 \n", + "1 6 of 6 100.0 \n", + "2 1 of 6 79.0 \n", + "3 6 of 6 100.0 \n", + "\n", + " cost (% of every design) \n", + "0 16.0 \n", + "1 23.7 \n", + "2 10.2 \n", + "3 24.8 " + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import screen\n", + "\n", + "full_cost = results.satellite_days.sum()\n", + "true_front = set(summary.design[summary.pareto])\n", + "screenings = []\n", + "for hours, keep, tolerance in [(12, 0.05, None), (12, 0.1, 5.0), (6, 0.05, None), (6, 0.2, None)]:\n", + " screening = screen(\n", + " designs,\n", + " [make_study(timedelta(hours=hours), replicates=1), make_study()],\n", + " OBJECTIVES,\n", + " keep=keep,\n", + " tolerance=None if tolerance is None else {\"sufficient\": tolerance},\n", + " )\n", + " screenings.append(\n", + " {\n", + " \"screening study\": f\"{hours} h, 1 replicate\",\n", + " \"keep (%)\": 100 * keep,\n", + " \"tolerance (%)\": tolerance,\n", + " \"designs kept\": len(screening.designs),\n", + " \"efficient designs kept\": f\"{len(true_front & {d.key for d in screening.designs})} of {len(true_front)}\",\n", + " \"hypervolume (% of true front)\": 100 * hypervolume(screening.final, OBJECTIVES, REFERENCE) / exact_hypervolume,\n", + " \"cost (% of every design)\": 100 * screening.results.satellite_days.sum() / full_cost,\n", + " }\n", + " )\n", + "pd.DataFrame(screenings).round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "e7f6a9b8", + "metadata": {}, + "source": [ + "The 12-hour screening study ranks designs nearly as the full study does. Keeping the best 5% of the designs finds a front with the hypervolume of the true front at 16% of the cost of evaluating every design, although it misses one efficient design, whose place a design with nearly the same objectives takes. Keeping 10%, with a tolerance of 5 percentage points, keeps every efficient design at 24% of the cost.\n", + "\n", + "The 6-hour screening study is cheaper, but ranks designs differently: one observation of a point in 6 hours separates designs less than four observations in a day do. Keeping 5% of the designs keeps only one of the six efficient ones (79% of the hypervolume), and it must keep 20% to keep them all, which costs as much as the 12-hour study. How many designs to keep depends on how well the cheap study ranks designs, which is worth checking on a sample of designs evaluated with both studies before screening a larger space." + ] + }, + { + "cell_type": "markdown", + "id": "f8a7b0c9", + "metadata": {}, + "source": [ + "## Search with Optimizers\n", + "\n", + "Larger design spaces cannot be enumerated or even screened, and an optimizer searches them for efficient designs instead. `optimize_optuna` suggests designs with Optuna's trials, which search the hierarchical design space directly (`DesignSpace.suggest`), and records the violation of the constraint of each infeasible design, which Optuna's samplers use to prefer feasible designs. `optimize_pymoo` searches the unit hypercube that encodes the design space (`DesignSpace.decode`) with a pymoo algorithm. Both evaluate each design once, however often it is proposed, and evaluate the designs proposed together in parallel.\n", + "\n", + "Each search below is given a budget of about 200 proposals, and is compared with a Latin hypercube sample of 200 designs (`DesignSpace.sample`). The designs evaluated (and the analyses of their satellites) are those of the evaluation of every design above, so they are retrieved from the cache." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "a9b8c1d0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-10T06:10:18.898579Z", + "iopub.status.busy": "2026-11-10T06:10:18.898397Z", + "iopub.status.idle": "2026-11-10T06:10:23.607284Z", + "shell.execute_reply": "2026-11-10T06:10:23.606387Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
designs evaluatedhypervolume (% of true front)
Optuna (NSGA-II)140.095.3
pymoo (NSGA-II)87.089.6
Latin hypercube sample176.080.3
\n", + "
" + ], + "text/plain": [ + " designs evaluated hypervolume (% of true front)\n", + "Optuna (NSGA-II) 140.0 95.3\n", + "pymoo (NSGA-II) 87.0 89.6\n", + "Latin hypercube sample 176.0 80.3" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import optuna\n", + "from pymoo.algorithms.moo.nsga2 import NSGA2\n", + "\n", + "from tatc.tradespace import optimize_optuna, optimize_pymoo\n", + "\n", + "optuna.logging.set_verbosity(optuna.logging.WARNING)\n", + "BUDGET = 200\n", + "study = make_study()\n", + "searches = {}\n", + "_, searches[\"Optuna (NSGA-II)\"] = optimize_optuna(\n", + " study,\n", + " OBJECTIVES,\n", + " n_trials=BUDGET,\n", + " sampler=optuna.samplers.NSGAIISampler(population_size=20, seed=1),\n", + " batch_size=20,\n", + ")\n", + "_, searches[\"pymoo (NSGA-II)\"] = optimize_pymoo(study, OBJECTIVES, NSGA2(pop_size=20), (\"n_gen\", BUDGET // 20), seed=1)\n", + "searches[\"Latin hypercube sample\"] = study.run(space.sample(BUDGET, method=\"lhs\", seed=1))\n", + "\n", + "\n", + "def get_progress(search_results):\n", + " \"\"\"The hypervolume (% of the true front's) of the designs evaluated, as designs are evaluated.\"\"\"\n", + " means = summarize(search_results, list(OBJECTIVES), design_columns=[]).set_index(\"design\")\n", + " order = search_results.design.drop_duplicates()\n", + " counts = np.arange(10, len(order) + 1, 10)\n", + " return pd.Series(\n", + " [100 * hypervolume(means.reindex(order[:n]).dropna(), OBJECTIVES, REFERENCE) / exact_hypervolume for n in counts],\n", + " index=counts,\n", + " )\n", + "\n", + "\n", + "progress = {name: get_progress(search_results) for name, search_results in searches.items()}\n", + "pd.DataFrame(\n", + " {\n", + " name: {\n", + " \"designs evaluated\": search_results.design.nunique(),\n", + " \"hypervolume (% of true front)\": progress[name].iloc[-1],\n", + " }\n", + " for name, search_results in searches.items()\n", + " }\n", + ").T.round(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, "id": "b0c9d2e1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T05:22:18.362508Z", - "iopub.status.busy": "2026-11-10T05:22:18.362234Z", - "iopub.status.idle": "2026-11-10T05:22:18.507452Z", - "shell.execute_reply": "2026-11-10T05:22:18.506612Z" + "iopub.execute_input": "2026-11-10T06:10:23.609165Z", + "iopub.status.busy": "2026-11-10T06:10:23.608983Z", + "iopub.status.idle": "2026-11-10T06:10:23.736655Z", + "shell.execute_reply": "2026-11-10T06:10:23.735823Z" } }, "outputs": [ @@ -1071,9 +1972,10 @@ "source": [ "## Summary\n", "\n", - "* A `DesignSpace` declares a hierarchical trade space, with choices between alternatives (`Choice`), repeated elements such as orbit planes (`Repeat`), bounds that depend on other variables, constraints that measure their violation, and uncertain parameters (`Uncertain`) drawn for each replicate.\n", + "* A `DesignSpace` declares a hierarchical trade space, with choices between alternatives (`Choice`), repeated elements such as orbit planes (`Repeat`), bounds that depend on other variables, constraints that measure their violation, and uncertain parameters (`Uncertain`) drawn for each replicate. Building blocks declare common constellation layouts (`walker_space` and `sso_planes_space`) and build their satellites with instruments or entries of the instrument catalog (`build_constellation`).\n", "* A `Study` evaluates designs in replicates, in parallel, with a `SatelliteCache` that analyzes each distinct satellite once. Every design of a space of about a thousand designs can be evaluated in minutes.\n", - "* The front of the means of the replicates is uncertain: `pareto_probability` finds the designs whose efficiency the replicates settle, and those that are equally good candidates.\n", + "* The front of the means of the replicates is uncertain: `pareto_probability` finds the designs whose efficiency the replicates settle, and those that are equally good candidates, and `refine` adds replicates only to the latter, with a tolerance of differences that do not matter.\n", + "* Statistics other than means (such as a `Quantile` or the `Probability` of meeting a threshold) state how reliably a design performs, and `Requirement`s on them are output constraints.\n", "* `screen` evaluates every design with a cheap study and the best with the full one, which finds the front at a fraction of the cost if the cheap study ranks designs as the full one does.\n", "* `optimize_optuna` and `optimize_pymoo` search spaces too large to enumerate, and find most of the front with a fraction of the designs.\n", "\n", diff --git a/src/tatc/tradespace/__init__.py b/src/tatc/tradespace/__init__.py index 80c5c6ed..221c14a5 100644 --- a/src/tatc/tradespace/__init__.py +++ b/src/tatc/tradespace/__init__.py @@ -1,14 +1,35 @@ """ Trade space analysis: design spaces of (hierarchical) design variables and -uncertain parameters, trade studies that evaluate their designs (with caches -of analyses by satellite, in parallel), Pareto efficiency (with the -uncertainty of replicates), screening with analyses of increasing fidelity, +uncertain parameters, building blocks of constellations, +trade studies that evaluate their designs (with caches +of analyses by satellite, in parallel), statistics of replicates and +requirements on them, Pareto efficiency (with the uncertainty of replicates), +adaptive replication, screening with analyses of increasing fidelity, and searches with optimizers (Optuna and pymoo, optional dependencies). @author: Paul T. Grogan """ from .cache import SatelliteCache, get_satellite_key +from .constellations import ( + build_constellation, + count_planes, + count_satellites, + hours_to_time, + sso_planes_space, + walker_space, +) +from .criteria import ( + Maximum, + Mean, + Minimum, + Probability, + Quantile, + Requirement, + StandardDeviation, + Statistic, + aggregate, +) from .optimization import ( Evaluations, make_pymoo_problem, @@ -16,6 +37,7 @@ optimize_pymoo, ) from .pareto import hypervolume, pareto_front, pareto_probability, pareto_ranks +from .refinement import Refinement, refine from .screening import Screening, screen from .nodes import ( Categorical, @@ -44,17 +66,31 @@ "Fixed", "Infeasible", "Integer", + "Maximum", + "Mean", + "Minimum", + "Probability", + "Quantile", "Real", + "Refinement", "Repeat", "RepeatValues", + "Requirement", "SatelliteCache", - "Screening", "Scope", + "Screening", + "StandardDeviation", + "Statistic", "Study", "Uncertain", "Values", "Variable", + "aggregate", + "build_constellation", + "count_planes", + "count_satellites", "get_satellite_key", + "hours_to_time", "hypervolume", "make_pymoo_problem", "optimize_optuna", @@ -62,6 +98,9 @@ "pareto_front", "pareto_probability", "pareto_ranks", + "refine", "screen", + "sso_planes_space", "summarize", + "walker_space", ] diff --git a/src/tatc/tradespace/constellations.py b/src/tatc/tradespace/constellations.py new file mode 100644 index 00000000..00c93747 --- /dev/null +++ b/src/tatc/tradespace/constellations.py @@ -0,0 +1,347 @@ +""" +Building blocks of trade studies of constellations: fragments of design +spaces for common constellation layouts (Walker constellations and planes of +sun-synchronous orbits), a builder of the satellites of a layout with a +payload (instruments, or entries of the instrument catalog), and counts of +satellites and planes for objectives and constraints. + +A fragment is a `DesignSpace` to place in a larger design space, for example +as a branch of a `Choice` between layouts:: + + space = DesignSpace( + altitude=Real(500e3, 800e3, step=100e3), + sounder=Categorical(["atms", "cris"]), + layout=Choice( + walker=walker_space(inclination=Real(45, 75, step=15)), + sso=sso_planes_space(), + ), + ) + + def build(d): + return build_constellation( + d.layout, d.sounder, epoch=START, altitude=d.altitude + ) + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +from collections.abc import Callable, Sequence +from datetime import datetime, time +from typing import Any + +from ..schemas import ( + CircularOrbit, + Instrument, + Satellite, + SunSynchronousOrbit, + WalkerConstellation, +) +from .nodes import Fixed, Integer, Real, Repeat +from .space import DesignSpace +from .values import ChoiceValues, Scope, Values + +WALKER = "walker" +"""The kind of the layouts of `walker_space`.""" +SSO_PLANES = "sso planes" +"""The kind of the layouts of `sso_planes_space`.""" + + +def _node(value: Any, default: Any) -> Any: + return default if value is None else value + + +def walker_space( + *, + inclination: Any = None, + planes: Any = None, + per_plane: Any = None, + relative_spacing: Any = None, + altitude: Any = None, + configuration: Any = "delta", + constraints: Sequence[Callable[[Scope], Any]] = (), +) -> DesignSpace: + """ + Gets a fragment of a design space of Walker constellations (see + `tatc.schemas.WalkerConstellation`): their inclination (degrees), number + of planes, number of satellites in each plane, relative spacing of + satellites between planes, and (optionally, if not given to + `build_constellation`) altitude (meters). Each is a node of a design + space (such as a design variable) or a value. + + Args: + inclination (Any): The inclination, by default a variable from 30 to + 90 degrees in steps of 15. + planes (Any): The number of planes, by default a variable from 1 to 6. + per_plane (Any): The number of satellites in each plane, by default a + variable from 1 to 6. + relative_spacing (Any): The relative spacing, by default a variable + from 0 to the number of planes less 1. + altitude (Any): The altitude, if part of the layout. + configuration (Any): The configuration (`"delta"` or `"star"`). + constraints (Sequence[Callable]): Constraints of the fragment. + + Returns: + DesignSpace: the fragment + """ + children = { + "kind": Fixed(WALKER), + "configuration": configuration, + "inclination": _node(inclination, Real(30, 90, step=15)), + "planes": _node(planes, Integer(1, 6)), + "per_plane": _node(per_plane, Integer(1, 6)), + "relative_spacing": _node(relative_spacing, Integer(0, lambda d: d.planes - 1)), + } + if altitude is not None: + children["altitude"] = altitude + return DesignSpace(constraints=constraints, **children) + + +def _distinct_crossings(d: Scope) -> bool: + """Whether the planes of a layout have different crossing times.""" + crossings = [round(plane.crossing, 6) for plane in d.planes] + return len(set(crossings)) == len(crossings) + + +def sso_planes_space( + *, + crossing: Any = None, + satellites: Any = None, + count: Any = None, + phase: Any = 0.0, + altitude: Any = None, + ascending: Any = True, + ordered: bool = False, + distinct: bool = True, + constraints: Sequence[Callable[[Scope], Any]] = (), +) -> DesignSpace: + """ + Gets a fragment of a design space of planes of sun-synchronous orbits + (see `tatc.schemas.SunSynchronousOrbit`), each with its own equator + crossing time (local solar time, in hours), number of satellites (evenly + spaced in the plane), and phase (the true anomaly of its first satellite, + degrees), and (optionally, if not given to `build_constellation`) their + altitude (meters). Each is a node of a design space (such as a design + variable, a value derived from the index of the plane, or an uncertain + parameter) or a value. + + The planes are unordered by default: designs whose planes differ only in + their order are the same design (which requires that their values do + not depend on their index). Planes with the same crossing time would be + the same plane, so a constraint requires different crossing times + (unless `distinct` is `False`). + + Args: + crossing (Any): The crossing time of each plane, by default a variable + from 6 to 18 hours in steps of 1.5. + satellites (Any): The number of satellites of each plane, by default a + variable from 1 to 4. + count (Any): The number of planes, by default a variable from 1 to 3. + phase (Any): The phase of each plane (an uncertain parameter, such as + `Uncertain.uniform(0, 360)`, if it is not designed). + altitude (Any): The altitude, if part of the layout. + ascending (Any): Whether the crossing times are of ascending nodes. + ordered (bool): `True` if the planes are ordered (for example, if + their values depend on their index). + distinct (bool): `True` to require different crossing times. + constraints (Sequence[Callable]): Other constraints of the fragment. + + Returns: + DesignSpace: the fragment + """ + plane = DesignSpace( + crossing=_node(crossing, Real(6, 18, step=1.5)), + satellites=_node(satellites, Integer(1, 4)), + phase=phase, + ) + children = { + "kind": Fixed(SSO_PLANES), + "ascending": ascending, + "planes": Repeat(plane, count=_node(count, Integer(1, 3)), ordered=ordered), + } + if altitude is not None: + children["altitude"] = altitude + constraints = ([_distinct_crossings] if distinct else []) + list(constraints) + return DesignSpace(constraints=constraints, **children) + + +def _layout(layout: Any) -> Any: + """Gets the values of a layout (the chosen branch of a choice).""" + return layout.value if isinstance(layout, ChoiceValues) else layout + + +def _kind(layout: Any) -> str: + try: + return layout.kind + except AttributeError: + raise ValueError( + "a layout must be the values of walker_space or sso_planes_space" + ) from None + + +def count_satellites(layout: Any) -> int: + """ + Counts the satellites of a layout (the values of `walker_space` or + `sso_planes_space`, or of a choice of them), for objectives and + constraints. + + Args: + layout (Any): The values of the layout. + + Returns: + int: the number of satellites + """ + layout = _layout(layout) + if _kind(layout) == WALKER: + return int(layout.planes * layout.per_plane) + return int(sum(plane.satellites for plane in layout.planes)) + + +def count_planes(layout: Any) -> int: + """ + Counts the orbit planes of a layout (the values of `walker_space` or + `sso_planes_space`, or of a choice of them), each of which needs its own + launch. + + Args: + layout (Any): The values of the layout. + + Returns: + int: the number of planes + """ + layout = _layout(layout) + if _kind(layout) == WALKER: + return int(layout.planes) + return len(layout.planes) + + +def hours_to_time(hours: float) -> time: + """ + Converts a local time in hours (such as 13.5) to a time of day (13:30), + to the nearest second. + + Args: + hours (float): The time (hours, wrapped to [0, 24)). + + Returns: + datetime.time: the time of day + """ + seconds = round(hours * 3600) % 86400 + return time(seconds // 3600, seconds // 60 % 60, seconds % 60) + + +Payload = ( + Instrument + | Sequence[Instrument] + | str + | Sequence[str] + | Callable[[str, Any], Satellite] +) +"""A payload: instruments, catalog entries, or a function of a name and an +orbit that builds a satellite.""" + + +def _make_satellite( + payload: Any, name: str, orbit: Any, time_step: float | None +) -> Satellite: + """ + Makes a satellite with a payload in an orbit (see `build_constellation`). + """ + if callable(payload) and not isinstance(payload, Instrument): + return payload(name, orbit) + payloads = [payload] if isinstance(payload, (str, Instrument)) else list(payload) + if all(isinstance(item, Instrument) for item in payloads): + return Satellite(name=name, orbit=orbit, instruments=payloads) + if not all(isinstance(item, str) for item in payloads): + raise ValueError("a payload mixes instruments and catalog entries") + # pylint: disable=import-outside-toplevel + from ..catalog import get_entry + + instruments, attitude = [], None + for item in payloads: + entry_id, _, configuration = item.partition(":") + built = get_entry(entry_id).build( + configuration or None, orbit=orbit, time_step=time_step + ) + instruments.extend(built.instruments) + if attitude is None: + attitude = built.attitude + return Satellite(name=name, orbit=orbit, instruments=instruments, attitude=attitude) + + +def build_constellation( + layout: Values | ChoiceValues, + payload: Payload, + *, + epoch: datetime, + altitude: float | None = None, + name: str = "satellite", + time_step: float | None = None, +) -> list[Satellite]: + """ + Builds the satellites of a layout: the values of `walker_space` or + `sso_planes_space` in a design (or of a choice of them), at the + layout's altitude (or the given one), each with a payload: + + * an `Instrument` (or a list of instruments); + * the identifier of an entry of the instrument catalog (see + `tatc.catalog.get_entry`), optionally with a configuration after a + colon (such as `"atms:swath"`), whose instruments are built for the + orbit with the attitude they were validated with (and, if the + configuration tailors a field of view, the analysis `time_step`), or + a list of identifiers, whose instruments the satellite carries + together (with the attitude of the first); + * a function of a name and an orbit that builds a satellite. + + Satellites of Walker constellations are named `" "`, and + those of sun-synchronous planes `"

-"` (plane `p`, + satellite `s`). + + Args: + layout (Values | ChoiceValues): The values of the layout. + payload (Payload): The payload of each satellite. + epoch (datetime.datetime): The epoch of the orbits. + altitude (float | None): The altitude (meters), if the layout does + not give it. + name (str): The prefix of the names of the satellites. + time_step (float | None): The analysis time step (seconds), for + catalog configurations that tailor a field of view to it. + + Returns: + list[Satellite]: the satellites + """ + layout = _layout(layout) + kind = _kind(layout) + altitude = getattr(layout, "altitude", None) if altitude is None else altitude + if altitude is None: + raise ValueError("the layout has no altitude: give one") + if kind == WALKER: + members = WalkerConstellation( + name=name, + configuration=layout.configuration, + orbit=CircularOrbit( + altitude=altitude, inclination=layout.inclination, epoch=epoch + ), + number_planes=layout.planes, + number_satellites=layout.planes * layout.per_plane, + relative_spacing=layout.relative_spacing, + ).generate_members() + return [ + _make_satellite(payload, f"{name} {k + 1}", member.orbit, time_step) + for k, member in enumerate(members) + ] + satellites = [] + for p, plane in enumerate(layout.planes): + for s in range(plane.satellites): + orbit = SunSynchronousOrbit( + altitude=altitude, + equator_crossing_time=hours_to_time(plane.crossing), + equator_crossing_ascending=layout.ascending, + epoch=epoch, + true_anomaly=(plane.phase + 360 * s / plane.satellites) % 360, + ) + satellites.append( + _make_satellite(payload, f"{name} {p + 1}-{s + 1}", orbit, time_step) + ) + return satellites diff --git a/src/tatc/tradespace/criteria.py b/src/tatc/tradespace/criteria.py new file mode 100644 index 00000000..50643edc --- /dev/null +++ b/src/tatc/tradespace/criteria.py @@ -0,0 +1,363 @@ +""" +Criteria of designs over their replicates: statistics of the metrics of +their evaluations (such as a mean, a quantile, or the probability of meeting +a threshold), and requirements on these statistics. + +The outcomes of a design are uncertain if its replicates differ (see +`Uncertain`), and a statistic over the replicates states how a design is +judged: by its mean, by a pessimistic quantile, or by how reliably it meets +a threshold. A requirement on a statistic is an output constraint, which a +design meets or violates (by an amount) once it is evaluated, as opposed to +the constraints of a design space, which are known before. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +import operator as op +from collections.abc import Mapping, Sequence +from dataclasses import dataclass + +import numpy as np +import pandas as pd + +_OPERATORS = {">=": op.ge, ">": op.gt, "<=": op.le, "<": op.lt} + + +class Statistic: + """ + Base class of statistics of a metric (a column of the results of a study) + over the replicates of each design. + + Args: + column (str): The metric. + """ + + def __init__(self, column: str): + self.column = column + + def reduce(self, values: np.ndarray) -> np.ndarray: + """ + Computes the statistic of each design (row) from its values in its + replicates (columns), ignoring missing values (`NaN`). + + Args: + values (numpy.ndarray): The values (shape (designs, replicates)). + + Returns: + numpy.ndarray: the statistic of each design (`NaN` without values) + """ + raise NotImplementedError + + def __repr__(self) -> str: + return f"{type(self).__name__}({self.column!r})" + + +def _all_nan(values: np.ndarray) -> np.ndarray: + return np.all(np.isnan(values), axis=1) + + +def _nan_reduce(function, values: np.ndarray) -> np.ndarray: + """ + Applies a nan-aware reduction along replicates, giving `NaN` (without a + warning) for designs without values. + """ + result = np.full(values.shape[0], np.nan) + valid = ~_all_nan(values) + if np.any(valid): + result[valid] = function(values[valid], axis=1) + return result + + +class Mean(Statistic): + """ + The mean of a metric over the replicates. + """ + + def reduce(self, values: np.ndarray) -> np.ndarray: + return _nan_reduce(np.nanmean, values) + + +class StandardDeviation(Statistic): + """ + The (sample) standard deviation of a metric over the replicates, a + measure of how much a design's outcome depends on its uncertain + parameters (`NaN` with fewer than two replicates). + """ + + def reduce(self, values: np.ndarray) -> np.ndarray: + counts = np.sum(~np.isnan(values), axis=1) + result = np.full(values.shape[0], np.nan) + valid = counts > 1 + if np.any(valid): + result[valid] = np.nanstd(values[valid], axis=1, ddof=1) + return result + + +class Minimum(Statistic): + """ + The least value of a metric over the replicates (the worst case of a + metric to maximize). + """ + + def reduce(self, values: np.ndarray) -> np.ndarray: + return _nan_reduce(np.nanmin, values) + + +class Maximum(Statistic): + """ + The greatest value of a metric over the replicates (the worst case of a + metric to minimize). + """ + + def reduce(self, values: np.ndarray) -> np.ndarray: + return _nan_reduce(np.nanmax, values) + + +class Quantile(Statistic): + """ + A quantile of a metric over the replicates: for example, the 0.1 + quantile of a metric to maximize is a value that the design exceeds in + 90% of the replicates (by linear interpolation between them). + + Args: + column (str): The metric. + q (float): The quantile, between 0 and 1. + """ + + def __init__(self, column: str, q: float): + super().__init__(column) + if not 0 <= q <= 1: + raise ValueError("q must be between 0 and 1") + self.q = q + + def reduce(self, values: np.ndarray) -> np.ndarray: + return _nan_reduce(lambda v, axis: np.nanquantile(v, self.q, axis=axis), values) + + def __repr__(self) -> str: + return f"Quantile({self.column!r}, {self.q!r})" + + +class Probability(Statistic): + """ + The probability that a metric meets a threshold: the share (0 to 1) of + the replicates in which it does, such as the reliability of a design. + + Args: + column (str): The metric. + operator (str): The comparison: `">="`, `">"`, `"<="`, or `"<"`. + threshold (float): The threshold. + """ + + def __init__(self, column: str, operator: str, threshold: float): + super().__init__(column) + if operator not in _OPERATORS: + raise ValueError(f"operator must be one of {list(_OPERATORS)}") + self.operator, self.threshold = operator, threshold + + def reduce(self, values: np.ndarray) -> np.ndarray: + valid = ~np.isnan(values) + with np.errstate(invalid="ignore"): + met = _OPERATORS[self.operator](values, self.threshold) & valid + counts = valid.sum(axis=1) + result = np.full(values.shape[0], np.nan) + result[counts > 0] = met.sum(axis=1)[counts > 0] / counts[counts > 0] + return result + + def __repr__(self) -> str: + return f"Probability({self.column!r}, {self.operator!r}, {self.threshold!r})" + + +@dataclass(frozen=True) +class Requirement: + """ + A requirement on a statistic of a design (by its name in the statistics, + see `aggregate`, or a metric, whose mean it then is): for example, + `Requirement("sufficient p10", ">=", 80)`. A design that does not meet + it violates it by the difference between the statistic and the value. + + Args: + name (str): The statistic (or metric). + operator (str): The comparison: `">="`, `">"`, `"<="`, or `"<"`. + value (float): The required value. + """ + + name: str + operator: str + value: float + + def __post_init__(self): + if self.operator not in _OPERATORS: + raise ValueError(f"operator must be one of {list(_OPERATORS)}") + + def violation(self, statistic: np.ndarray) -> np.ndarray: + """ + Computes the violations of the requirement: 0 where the statistic + meets it, and otherwise how far it misses the value (`NaN` where the + statistic is). A strict comparison that the statistic misses by + equality is violated by a small amount. + + Args: + statistic (numpy.ndarray): The statistic of each design. + + Returns: + numpy.ndarray: the violations + """ + statistic = np.asarray(statistic, dtype=float) + if self.operator in (">=", ">"): + gap = self.value - statistic + else: + gap = statistic - self.value + with np.errstate(invalid="ignore"): + met = _OPERATORS[self.operator](statistic, self.value) + violation = np.where(met, 0.0, np.maximum(gap, 1e-9)) + return np.where(np.isnan(statistic), np.nan, violation) + + +def _get_statistics( + names: Sequence[str], + statistics: Mapping[str, Statistic | str] | None, +) -> dict[str, Statistic]: + """ + Gets the statistics of names: those given (a metric given as a string is + its mean), and the means of the metrics of names not given. + """ + statistics = dict(statistics or {}) + resolved = { + name: Mean(value) if isinstance(value, str) else value + for name, value in statistics.items() + } + for name in names: + if name not in resolved: + resolved[name] = Mean(name) + return resolved + + +def _get_matrices( + group: pd.DataFrame, columns: Sequence[str] +) -> tuple[pd.Index, pd.Index, dict[str, np.ndarray]]: + """ + Gets the values of metrics of each design (rows) in each replicate + (columns) of the results of a group. + """ + missing = [column for column in columns if column not in group.columns] + if missing: + raise ValueError(f"metrics that are not in the results: {missing}") + designs = pd.Index(group["design"].drop_duplicates()) + replicates = pd.Index(sorted(group["replicate"].unique())) + matrices = {} + for column in columns: + table = group.pivot_table( + index="design", columns="replicate", values=column, dropna=False + ) + matrices[column] = table.reindex(index=designs, columns=replicates).to_numpy( + dtype=float + ) + return designs, replicates, matrices + + +def _evaluate( + statistics: Mapping[str, Statistic], + requirements: Sequence[Requirement], + matrices: Mapping[str, np.ndarray], + columns: np.ndarray | None = None, +) -> tuple[dict[str, np.ndarray], np.ndarray]: + """ + Computes statistics (of the replicates `columns` of the matrices, or all) + and the total violation of the requirements of each design. + """ + values = {} + for name, statistic in statistics.items(): + matrix = matrices[statistic.column] + values[name] = statistic.reduce( + matrix if columns is None else matrix[:, columns] + ) + n = len(next(iter(matrices.values()))) if matrices else 0 + violation = np.zeros(n) + for requirement in requirements: + violation = violation + requirement.violation(values[requirement.name]) + return values, violation + + +def _check_names( + statistics: Mapping[str, Statistic], requirements: Sequence[Requirement] +) -> None: + for requirement in requirements: + if requirement.name not in statistics: + raise ValueError(f"no statistic named {requirement.name!r}") + + +def aggregate( + results: pd.DataFrame, + statistics: Mapping[str, Statistic | str] | Sequence[str], + requirements: Sequence[Requirement] = (), + by: Sequence[str] = (), + design_columns: Sequence[str] | None = None, +) -> pd.DataFrame: + """ + Aggregates the feasible results of a study (see `Study.run`) over the + replicates of each design (and each group of the columns `by`, such as a + sensor): the statistics, by name (a metric given as a string, or in a + list of names, is its mean), the number of `replicates`, the `violation` + of the requirements (their sum, 0 if the design meets them all), and + whether the design meets them (`meets_requirements`), with the values of the + design. + + Args: + results (pandas.DataFrame): The results. + statistics (Mapping[str, Statistic | str] | Sequence[str]): The + statistics, by name, or the metrics whose means to compute. + requirements (Sequence[Requirement]): Requirements on the statistics + (or on the means of metrics, which are added to the statistics). + by (Sequence[str]): Other columns that group records of an + evaluation. + design_columns (Sequence[str] | None): The columns of the values of + designs, or `None` for those that are the same in every + replicate of a design (except the metrics). + + Returns: + pandas.DataFrame: a row per design (and group) + """ + if not isinstance(statistics, Mapping): + statistics = {name: Mean(name) for name in statistics} + resolved = _get_statistics([r.name for r in requirements], statistics) + _check_names(resolved, requirements) + feasible = results[results["feasible"]] if "feasible" in results else results + metrics = sorted({statistic.column for statistic in resolved.values()}) + if design_columns is None: + excluded = { + "design", + "replicate", + "feasible", + "error", + "seconds", + *metrics, + *by, + } + candidates = [c for c in feasible.columns if c not in excluded] + constant = feasible.groupby("design")[candidates].nunique(dropna=False) + design_columns = [c for c in candidates if (constant[c] <= 1).all()] + design_columns = [c for c in design_columns if c not in resolved and c not in by] + frames = [] + groups = feasible.groupby(list(by), sort=False) if by else [((), feasible)] + for key, group in groups: + designs, _, matrices = _get_matrices(group, metrics) + values, violation = _evaluate(resolved, requirements, matrices) + frame = pd.DataFrame({"design": designs}) + for name, value in zip(by, key if isinstance(key, tuple) else (key,)): + frame[name] = value + first = group.drop_duplicates("design").set_index("design") + for column in design_columns: + frame[column] = first.loc[designs, column].to_numpy() + for name, value in values.items(): + frame[name] = value + frame["replicates"] = ( + group.groupby("design")["replicate"].nunique().reindex(designs).to_numpy() + ) + frame["violation"] = violation + frame["meets_requirements"] = violation == 0 + frames.append(frame) + if not frames: + return pd.DataFrame(columns=["design", *by, *resolved, "replicates"]) + return pd.concat(frames, ignore_index=True) diff --git a/src/tatc/tradespace/optimization.py b/src/tatc/tradespace/optimization.py index cc98971d..f76ead7d 100644 --- a/src/tatc/tradespace/optimization.py +++ b/src/tatc/tradespace/optimization.py @@ -4,23 +4,36 @@ `DesignSpace.suggest`) and pymoo (which searches the unit hypercube that encodes it, see `DesignSpace.decode`). Both are optional dependencies. -The objectives of a design are the means over its replicates of columns of -the results of its evaluations (see `Study.run`), which must have one record -per evaluation. Each design is evaluated once, however often an optimizer -proposes it, and designs proposed together are evaluated together, in -parallel if the study is (see `Study`). +The objectives of a design are statistics over its replicates of the +metrics of its evaluations (see `Study.run`, which must give one record per +evaluation): their means, or other statistics (see `aggregate`), such as a +quantile or the probability of meeting a threshold. Requirements on +statistics (see `Requirement`) are output constraints, whose violations the +optimizers minimize along with those of the constraints of the design space. +Each design is evaluated once, however often an optimizer proposes it, and +designs proposed together are evaluated together, in parallel if the study +is (see `Study`). @author: Paul T. Grogan """ from __future__ import annotations -from collections.abc import Mapping +from collections.abc import Mapping, Sequence from typing import Any import numpy as np import pandas as pd +from .criteria import ( + Requirement, + Statistic, + _check_names, + _evaluate, + _get_matrices, + _get_statistics, +) +from .pareto import _check_directions from .space import Design, Infeasible from .study import Study @@ -28,27 +41,38 @@ class Evaluations: """ The evaluations of designs for a search: the objectives of each design - (by its key), and the records of the study's evaluations. + (by its key), the violations of its requirements, and the records of the + study's evaluations. Args: study (Study): The study that evaluates designs. - objectives (Mapping[str, str]): The objectives: columns of the - results and their directions (`"min"` or `"max"`). + objectives (Mapping[str, str]): The objectives: statistics (or + metrics, whose means they are) and their directions (`"min"` or + `"max"`). + statistics (Mapping[str, Statistic | str] | None): Statistics, by + name, of objectives and requirements that are not means. + requirements (Sequence[Requirement]): Requirements on statistics. """ - def __init__(self, study: Study, objectives: Mapping[str, str]): - if len(objectives) == 0: - raise ValueError("at least one objective is required") - for column, direction in objectives.items(): - if direction not in ("min", "max"): - raise ValueError( - f"direction of {column!r} must be 'min' or 'max', " - + f"not {direction!r}" - ) + def __init__( + self, + study: Study, + objectives: Mapping[str, str], + statistics: Mapping[str, Statistic | str] | None = None, + requirements: Sequence[Requirement] = (), + ): + _check_directions(objectives) self.study, self.objectives = study, dict(objectives) + self.requirements = list(requirements) + names = list(objectives) + [r.name for r in self.requirements] + self.statistics = _get_statistics(names, statistics) + _check_names(self.statistics, self.requirements) self.values: dict[str, tuple[float, ...] | None] = {} """dict: The objectives of each evaluated design (by key), or `None` if it is infeasible.""" + self.violations: dict[str, tuple[float, ...] | None] = {} + """dict: The violation of each requirement by each evaluated design + (by key), or `None` if it is infeasible.""" self._records: list[pd.DataFrame] = [] @property @@ -62,7 +86,7 @@ def results(self) -> pd.DataFrame: def evaluate(self, designs: list[Design]) -> list[tuple[float, ...] | None]: """ Gets the objectives of designs, evaluating those not yet evaluated - together. + together (see also `violations`). Args: designs (list[Design]): The designs. @@ -75,18 +99,27 @@ def evaluate(self, designs: list[Design]) -> list[tuple[float, ...] | None]: if new: records = self.study.run(new) self._records.append(records) - for key, group in records.groupby("design", sort=False): - if not group["feasible"].all(): - self.values[key] = None - continue - if group["replicate"].duplicated().any(): - raise ValueError( - "objectives need one record per evaluation: make the " - + "study's evaluate function return a mapping of metrics" - ) - self.values[key] = tuple( - float(group[column].mean()) for column in self.objectives + if records.groupby(["design", "replicate"]).size().max() > 1: + raise ValueError( + "objectives need one record per evaluation: make the " + + "study's evaluate function return a mapping of metrics" ) + infeasible = set(records.loc[~records["feasible"], "design"]) + for key in infeasible: + self.values[key] = self.violations[key] = None + feasible = records[~records["design"].isin(infeasible)] + if len(feasible) > 0: + metrics = sorted({s.column for s in self.statistics.values()}) + keys, _, matrices = _get_matrices(feasible, metrics) + values, _ = _evaluate(self.statistics, [], matrices) + for i, key in enumerate(keys): + self.values[key] = tuple( + float(values[name][i]) for name in self.objectives + ) + self.violations[key] = tuple( + float(requirement.violation(values[requirement.name][i])) + for requirement in self.requirements + ) return [self.values[d.key] for d in designs] def worst(self) -> list[float]: @@ -97,7 +130,11 @@ def worst(self) -> list[float]: Returns: list[float]: the worst values, in the order of the objectives """ - feasible = [values for values in self.values.values() if values is not None] + feasible = [ + values + for values in self.values.values() + if values is not None and not np.isnan(values).any() + ] if not feasible: return [0.0] * len(self.objectives) table = np.array(feasible) @@ -115,11 +152,13 @@ def optimize_optuna( optuna_study: Any = None, batch_size: int | None = None, constraints: bool = True, + statistics: Mapping[str, Statistic | str] | None = None, + requirements: Sequence[Requirement] = (), ) -> tuple[Any, pd.DataFrame]: """ Searches a study's design space with Optuna: each trial suggests a design (see `DesignSpace.suggest`) and is told the means of its objectives over - its replicates. + its replicates (or other statistics, see `statistics`). With `constraints`, each trial records the violation of the constraints of its design (`trial.set_constraint`, under the name `"feasibility"`): @@ -132,6 +171,10 @@ def optimize_optuna( rank it. Without `constraints` (or with a version of Optuna before 5, which lacks `set_constraint`), an infeasible design prunes its trial. + Each requirement is a constraint of the trials (named by its statement, + such as `"sufficient p10 >= 80"`), whose value is its violation (see + `Requirement.violation`), and which requires `constraints`. + Trials are asked in batches, whose designs are evaluated together (in parallel, if the study is) before they are told. A batch defaults to one trial per worker of the study. @@ -149,6 +192,9 @@ def optimize_optuna( batch_size (int | None): The number of trials evaluated together. constraints (bool): `True` to record the violations of constraints, `False` to prune infeasible trials. + statistics (Mapping[str, Statistic | str] | None): Statistics, by + name, of objectives and requirements that are not means. + requirements (Sequence[Requirement]): Requirements on statistics. Returns: tuple[optuna.Study, pandas.DataFrame]: the Optuna study, and the @@ -161,7 +207,7 @@ def optimize_optuna( raise ImportError( "optimize_optuna requires optuna (pip install optuna)" ) from error - evaluations = Evaluations(study, objectives) + evaluations = Evaluations(study, objectives, statistics, requirements) directions = [ "minimize" if direction == "min" else "maximize" for direction in evaluations.objectives.values() @@ -170,10 +216,18 @@ def optimize_optuna( optuna_study = optuna.create_study(directions=directions, sampler=sampler) batch_size = batch_size or study.workers constrained = constraints and hasattr(optuna.trial.Trial, "set_constraint") + if requirements and not constrained: + raise ValueError("requirements need constraints (and Optuna 5 or later)") + names = [f"{r.name} {r.operator} {r.value}" for r in evaluations.requirements] + + def set_constraints(trial: Any, feasibility: float, violations) -> None: + trial.set_constraint("feasibility", feasibility) + for name, violation in zip(names, violations): + trial.set_constraint(name, violation) def infeasible(trial: Any, violation: float) -> None: if constrained: - trial.set_constraint("feasibility", max(violation, 1e-9)) + set_constraints(trial, max(violation, 1e-9), [0.0] * len(names)) optuna_study.tell(trial, evaluations.worst()) else: optuna_study.tell(trial, state=optuna.trial.TrialState.PRUNED) @@ -193,17 +247,27 @@ def infeasible(trial: Any, violation: float) -> None: trials.append(trial) designs.append(design) remaining -= min(batch_size, remaining) - for trial, values in zip(trials, evaluations.evaluate(designs)): + for trial, design, values in zip( + trials, designs, evaluations.evaluate(designs) + ): if values is None: infeasible(trial, 1.0) else: if constrained: - trial.set_constraint("feasibility", 0.0) - optuna_study.tell(trial, list(values)) + violations = evaluations.violations[design.key] + set_constraints(trial, 0.0, np.nan_to_num(violations, nan=1.0)) + optuna_study.tell( + trial, list(np.where(np.isnan(values), evaluations.worst(), values)) + ) return optuna_study, evaluations.results -def make_pymoo_problem(study: Study, objectives: Mapping[str, str]) -> Any: +def make_pymoo_problem( + study: Study, + objectives: Mapping[str, str], + statistics: Mapping[str, Statistic | str] | None = None, + requirements: Sequence[Requirement] = (), +) -> Any: """ Makes a pymoo problem of a study's design space: its variables are the unit hypercube that encodes the design space (see `DesignSpace.decode` @@ -211,15 +275,20 @@ def make_pymoo_problem(study: Study, objectives: Mapping[str, str]) -> Any: objectives are negated), and its constraint (`G <= 0`) is violated by designs that violate a constraint of the design space (by the amount of the violation, see `DesignSpace`) or that the study finds infeasible (by - 1). The designs of a population are evaluated together. + 1). Each requirement is a further constraint, whose value is its + violation (see `Requirement.violation`). The designs of a population are + evaluated together. The problem keeps its evaluations (`evaluations`, see `Evaluations`), whose `results` are those of every evaluation (see `Study.run`). Args: study (Study): The study that evaluates designs. - objectives (Mapping[str, str]): The objectives: columns of the - results and their directions (`"min"` or `"max"`). + objectives (Mapping[str, str]): The objectives: statistics (or + metrics) and their directions (`"min"` or `"max"`). + statistics (Mapping[str, Statistic | str] | None): Statistics, by + name, of objectives and requirements that are not means. + requirements (Sequence[Requirement]): Requirements on statistics. Returns: pymoo.core.problem.Problem: the problem @@ -232,7 +301,8 @@ def make_pymoo_problem(study: Study, objectives: Mapping[str, str]) -> Any: "make_pymoo_problem requires pymoo (pip install pymoo)" ) from error - evaluations = Evaluations(study, objectives) + evaluations = Evaluations(study, objectives, statistics, requirements) + n_requirements = len(evaluations.requirements) signs = np.array( [1.0 if direction == "min" else -1.0 for direction in objectives.values()] ) @@ -245,7 +315,11 @@ class DesignSpaceProblem(Problem): def __init__(self): super().__init__( - n_var=n_var, n_obj=len(signs), n_ieq_constr=1, xl=0.0, xu=1.0 + n_var=n_var, + n_obj=len(signs), + n_ieq_constr=1 + n_requirements, + xl=0.0, + xu=1.0, ) self.evaluations = evaluations @@ -261,13 +335,18 @@ def _evaluate(self, x, out, *args, **kwargs): feasible = [design for design in designs if design is not None] values = iter(evaluations.evaluate(feasible)) costs = np.zeros((len(designs), len(signs))) + unmet = np.zeros((len(designs), n_requirements)) for i, design in enumerate(designs): value = None if design is None else next(values) if value is not None: + value = np.where(np.isnan(value), evaluations.worst(), value) costs[i] = signs * np.asarray(value) violation[i] = 0.0 + unmet[i] = np.nan_to_num( + evaluations.violations[design.key], nan=1.0 + ) out["F"] = costs - out["G"] = violation[:, None] + out["G"] = np.column_stack([violation, unmet]) return DesignSpaceProblem() @@ -278,6 +357,8 @@ def optimize_pymoo( algorithm: Any = None, termination: Any = ("n_gen", 10), seed: int | None = None, + statistics: Mapping[str, Statistic | str] | None = None, + requirements: Sequence[Requirement] = (), **kwargs: Any, ) -> tuple[Any, pd.DataFrame]: """ @@ -292,6 +373,9 @@ def optimize_pymoo( `None` for NSGA-II with populations of 20. termination (Any): The termination criterion of `pymoo.optimize.minimize`. seed (int | None): The seed of the algorithm. + statistics (Mapping[str, Statistic | str] | None): Statistics, by + name, of objectives and requirements that are not means. + requirements (Sequence[Requirement]): Requirements on statistics. **kwargs (Any): Other arguments of `pymoo.optimize.minimize`. Returns: @@ -305,6 +389,6 @@ def optimize_pymoo( from pymoo.algorithms.moo.nsga2 import NSGA2 algorithm = NSGA2(pop_size=20) - problem = make_pymoo_problem(study, objectives) + problem = make_pymoo_problem(study, objectives, statistics, requirements) result = minimize(problem, algorithm, termination, seed=seed, **kwargs) return result, problem.evaluations.results diff --git a/src/tatc/tradespace/pareto.py b/src/tatc/tradespace/pareto.py index cd203e3c..5feb746b 100644 --- a/src/tatc/tradespace/pareto.py +++ b/src/tatc/tradespace/pareto.py @@ -16,10 +16,33 @@ import numpy as np import pandas as pd +from .criteria import ( + Requirement, + Statistic, + _check_names, + _evaluate, + _get_matrices, + _get_statistics, +) + Objectives = Mapping[str, str] """Objectives: columns and their directions (`"min"` or `"max"`).""" +def _check_directions(objectives: Objectives) -> list[str]: + """ + Checks the directions of objectives, returning them. + """ + if len(objectives) == 0: + raise ValueError("at least one objective is required") + for column, direction in objectives.items(): + if direction not in ("min", "max"): + raise ValueError( + f"direction of {column!r} must be 'min' or 'max', not {direction!r}" + ) + return list(objectives.values()) + + def _get_costs(frame: pd.DataFrame, objectives: Objectives) -> np.ndarray: """ Gets the objectives of a data frame as costs (to minimize): maximized @@ -221,76 +244,114 @@ def pareto_probability( by: Sequence[str] = (), n_resamples: int = 500, seed: int = 0, + statistics: Mapping[str, Statistic | str] | None = None, + requirements: Sequence[Requirement] = (), + tolerance: Mapping[str, float] | None = None, ) -> pd.DataFrame: """ - Estimates the probability that each design is Pareto-efficient, given the - uncertainty of the means of its objectives over replicates, by a - bootstrap: each resample draws replicates with replacement, the same - replicates for every design (which keeps the correlation between designs - of common random numbers, see `Design.realize`), and finds the front of - the means of the objectives over the drawn replicates. The probability - is the share of resamples in which a design is efficient. + Estimates the probability that each design is Pareto-efficient (and + meets the requirements, if any), given the uncertainty of its replicates, + by a bootstrap: each resample draws replicates with replacement, the + same replicates for every design (which keeps the correlation between + designs of common random numbers, see `Design.realize`), computes the + statistics of each design over the drawn replicates, and finds the front + of the designs that meet the requirements. The probability is the share + of resamples in which a design is on that front. + + Objectives and requirements name statistics (see `aggregate`): the + means of metrics, unless `statistics` define them otherwise (such as a + quantile or the probability of meeting a threshold). Designs that are efficient with a probability between 0 and 1 are those - whose efficiency the replicates do not settle: more replicates (or a - tolerance, see `pareto_front`) would settle it. With few replicates, - the bootstrap has few distinct resamples and understates the - uncertainty. + whose efficiency the replicates do not settle: more replicates (see + `refine`) would settle it, unless designs differ by less than matters (as + near saturation), which a `tolerance` of the objectives settles: designs + within the tolerances of the front are efficient (see `pareto_front`). With + few replicates, the bootstrap has few distinct resamples and understates + the uncertainty. Designs may have different replicates (as after + `refine`): replicates are drawn from all of them, and each design's + statistics are those of its drawn replicates (or of all of its + replicates, if none is drawn). Args: results (pandas.DataFrame): The results of a study (see `Study.run`), with a record per replicate of each design (and group of `by`). Infeasible results are ignored. - objectives (Mapping[str, str]): The objectives: columns and their - directions (`"min"` or `"max"`). + objectives (Mapping[str, str]): The objectives: statistics (or + metrics) and their directions (`"min"` or `"max"`). by (Sequence[str]): Columns that group records of an evaluation (such as a sensor), whose fronts are found separately. n_resamples (int): The number of resamples. seed (int): The seed of the resamples. + statistics (Mapping[str, Statistic | str] | None): Statistics, by + name, of objectives and requirements that are not means. + requirements (Sequence[Requirement]): Requirements on statistics. + tolerance (Mapping[str, float] | None): The tolerances of objectives + (by name, zero if not given). Returns: - pandas.DataFrame: a row per design (and group): the means of the - objectives over every replicate, whether the design is efficient - by these means (`pareto`), and the probability that it is - (`pareto_probability`) + pandas.DataFrame: a row per design (and group): the statistics of + the objectives (and requirements) over every replicate, the + number of `replicates`, whether the design meets the + requirements (`meets_requirements`) and is efficient among those + that do (`pareto`) by these statistics, the probability that it + is efficient (`pareto_probability`), and the probability that it + meets the requirements (`requirements_probability`) """ + names = list(objectives) + [requirement.name for requirement in requirements] + resolved = _get_statistics(names, statistics) + resolved = {name: resolved[name] for name in dict.fromkeys(names)} + _check_names(resolved, requirements) + signs = np.array( + [1.0 if d == "min" else -1.0 for d in _check_directions(objectives)] + ) + tolerances = _get_tolerances(objectives, tolerance) feasible = results[results["feasible"]] if "feasible" in results else results - columns = list(objectives) - signs = _get_costs(pd.DataFrame({column: [1.0] for column in columns}), objectives)[ - 0 - ] + metrics = sorted({statistic.column for statistic in resolved.values()}) rng = np.random.default_rng(seed) frames = [] groups = feasible.groupby(list(by), sort=False) if by else [((), feasible)] for key, group in groups: - # the costs of each objective, design (rows), and replicate (columns) - tables = [ - group.pivot_table(index="design", columns="replicate", values=column) - for column in columns - ] - designs, replicates = tables[0].index, tables[0].columns - costs = np.stack( - [ - sign * table.loc[designs, replicates].to_numpy(dtype=float) - for sign, table in zip(signs, tables) - ] - ) - means = np.nanmean(costs, axis=2).T + designs, replicates, matrices = _get_matrices(group, metrics) + values, violation = _evaluate(resolved, requirements, matrices) + + def front(values, violation): + costs = np.column_stack( + [s * values[name] for s, name in zip(signs, objectives)] + ) + ok = (violation == 0) & ~np.isnan(costs).any(axis=1) + efficient = np.zeros(len(costs), dtype=bool) + efficient[ok] = ~_dominated(costs[ok], tolerances) + return efficient, ok + + efficient, meets = front(values, violation) counts = np.zeros(len(designs)) + met = np.zeros(len(designs)) for _ in range(n_resamples): drawn = rng.integers(0, len(replicates), len(replicates)) - sample = np.nanmean(costs[:, :, drawn], axis=2).T - # a design without a value in any drawn replicate is not ranked - valid = ~np.isnan(sample).any(axis=1) - front = np.zeros(len(designs), dtype=bool) - front[valid] = ~_dominated(sample[valid]) - counts += front + sample, sample_violation = _evaluate( + resolved, requirements, matrices, drawn + ) + # designs without a drawn replicate keep the statistics of all of theirs + for name in sample: + missing = np.isnan(sample[name]) & ~np.isnan(values[name]) + sample[name][missing] = values[name][missing] + missing = np.isnan(sample_violation) + sample_violation[missing] = violation[missing] + sample_front, sample_meets = front(sample, sample_violation) + counts += sample_front + met += sample_meets frame = pd.DataFrame({"design": designs}) for name, value in zip(by, key if isinstance(key, tuple) else (key,)): frame[name] = value - for i, column in enumerate(columns): - frame[column] = signs[i] * means[:, i] - frame["pareto"] = ~_dominated(means) + for name, value in values.items(): + frame[name] = value + frame["replicates"] = ( + group.groupby("design")["replicate"].nunique().reindex(designs).to_numpy() + ) + frame["meets_requirements"] = meets + frame["pareto"] = efficient frame["pareto_probability"] = counts / n_resamples + frame["requirements_probability"] = met / n_resamples frames.append(frame) return pd.concat(frames, ignore_index=True) diff --git a/src/tatc/tradespace/refinement.py b/src/tatc/tradespace/refinement.py new file mode 100644 index 00000000..d3e26a9e --- /dev/null +++ b/src/tatc/tradespace/refinement.py @@ -0,0 +1,180 @@ +""" +Adaptive replication: replicates added only to the designs whose Pareto +efficiency their replicates do not settle. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +from collections.abc import Mapping, Sequence +from dataclasses import dataclass, field + +import pandas as pd + +from .criteria import Requirement, Statistic +from .pareto import pareto_probability +from .space import Design +from .study import Study + + +@dataclass +class Refinement: + """ + The outcome of an adaptive replication (see `refine`). + """ + + results: pd.DataFrame + """pandas.DataFrame: The results of every evaluation, those given and + those added (see `Study.run`).""" + probability: pd.DataFrame + """pandas.DataFrame: The probability that each design is efficient after + the last round (see `pareto_probability`).""" + history: pd.DataFrame = field(default_factory=pd.DataFrame) + """pandas.DataFrame: For each round, the number of designs whose + efficiency is uncertain (`uncertain`), the number to which replicates + were added (`refined`), and the evaluations added (`evaluations`).""" + + @property + def uncertain(self) -> pd.DataFrame: + """pandas.DataFrame: The rows of `probability` whose efficiency is + still uncertain (as of the bounds of `refine`).""" + return self.probability[self.probability["uncertain"]] + + +def refine( + study: Study, + designs: Sequence[Design], + results: pd.DataFrame, + objectives: Mapping[str, str], + statistics: Mapping[str, Statistic | str] | None = None, + requirements: Sequence[Requirement] = (), + by: Sequence[str] = (), + bounds: tuple[float, float] = (0.05, 0.95), + step: int | None = None, + max_replicates: int | None = None, + max_rounds: int = 10, + n_resamples: int = 500, + seed: int = 0, + tolerance: Mapping[str, float] | None = None, +) -> Refinement: + """ + Adds replicates to the designs whose Pareto efficiency is uncertain, + until it is settled: in each round, the probability that each design is + efficient (and meets the requirements) is estimated by a bootstrap (see + `pareto_probability`), and each design whose probability is strictly + between the `bounds` gets `step` more replicates, up to + `max_replicates`. Rounds end when no design is uncertain (or can be + refined), or after `max_rounds`. + + Replicates are added in order (the next indices after a design's + replicates), so that designs refined together share their uncertain + parameters (with common random numbers, see `Design.realize`). Designs + that are surely efficient or surely not keep their replicates, which + saves the evaluations that uniform replication would spend on them. + + Designs that differ by less than any number of replicates could + separate (such as designs near saturation) stay uncertain: give a + `tolerance` of the objectives within which differences do not matter, + so that such designs are all efficient (see `pareto_probability`). + + Args: + study (Study): The study that evaluates designs. + designs (Sequence[Design]): The designs (those of the results). + results (pandas.DataFrame): The results of the designs (see + `Study.run`). + objectives (Mapping[str, str]): The objectives: statistics (or + metrics) and their directions (`"min"` or `"max"`). + statistics (Mapping[str, Statistic | str] | None): Statistics, by + name, of objectives and requirements that are not means. + requirements (Sequence[Requirement]): Requirements on statistics. + by (Sequence[str]): Columns that group records of an evaluation (such + as a sensor); a design is uncertain if it is in any group. + bounds (tuple[float, float]): The probabilities between which a + design is uncertain. + step (int | None): The replicates added to an uncertain design in a + round, or `None` for the study's number of replicates. + max_replicates (int | None): The most replicates of a design, if + limited. + max_rounds (int): The most rounds. + n_resamples (int): The number of resamples of each bootstrap. + seed (int): The seed of the bootstraps. + tolerance (Mapping[str, float] | None): The tolerances of objectives + (by name, zero if not given, see `pareto_front`). + + Returns: + Refinement: the results, the final probabilities, and the history + """ + low, high = bounds + if not 0 <= low < high <= 1: + raise ValueError("bounds must satisfy 0 <= low < high <= 1") + step = study.replicates if step is None else step + if step < 1: + raise ValueError("step must be at least 1") + by_key = {design.key: design for design in designs} + frames = [results] + history = [] + + def estimate(round_: int) -> pd.DataFrame: + probability = pareto_probability( + pd.concat(frames, ignore_index=True), + objectives, + by=by, + n_resamples=n_resamples, + seed=seed + round_, + statistics=statistics, + requirements=requirements, + tolerance=tolerance, + ) + probability["uncertain"] = (probability["pareto_probability"] > low) & ( + probability["pareto_probability"] < high + ) + return probability + + for round_ in range(max_rounds): + probability = estimate(round_) + uncertain = probability.groupby("design")["uncertain"].any() + uncertain = list(uncertain[uncertain].index) + combined = pd.concat(frames, ignore_index=True) + # the next replicate of each uncertain design + following = combined.groupby("design")["replicate"].max() + 1 + refined = [ + key + for key in uncertain + if key in by_key + and (max_replicates is None or following[key] + step <= max_replicates) + ] + if not refined: + history.append( + { + "round": round_, + "uncertain": len(uncertain), + "refined": 0, + "evaluations": 0, + } + ) + break + added = 0 + # designs with the same next replicate are evaluated together + for start, keys in pd.Series(following[refined]).groupby(following[refined]): + new = study.run( + [by_key[key] for key in keys.index], + replicates=range(int(start), int(start) + step), + ) + frames.append(new) + added += new.groupby(["design", "replicate"]).ngroups + history.append( + { + "round": round_, + "uncertain": len(uncertain), + "refined": len(refined), + "evaluations": added, + } + ) + else: + probability = estimate(max_rounds) + return Refinement( + results=pd.concat(frames, ignore_index=True), + probability=probability, + history=pd.DataFrame(history), + ) diff --git a/src/tatc/tradespace/screening.py b/src/tatc/tradespace/screening.py index e9a7d65e..54d078c9 100644 --- a/src/tatc/tradespace/screening.py +++ b/src/tatc/tradespace/screening.py @@ -12,11 +12,33 @@ from collections.abc import Mapping, Sequence from dataclasses import dataclass, field +import numpy as np import pandas as pd +from .criteria import Requirement, Statistic, _get_statistics, aggregate from .pareto import pareto_ranks from .space import Design -from .study import Study, summarize +from .study import Study + + +def _rank( + summary: pd.DataFrame, + objectives: Mapping[str, str], + tolerance: Mapping[str, float] | None, +) -> pd.Series: + """ + Ranks designs: those that meet the requirements by non-dominated sorting + of their objectives, then the others by their violations. + """ + ranks = pd.Series(-1, index=summary.index, name="pareto_rank") + meets = summary["meets_requirements"] + if meets.any(): + ranks[meets] = pareto_ranks(summary[meets], objectives, tolerance) + if (~meets).any(): + start = int(ranks[meets].max()) + 1 if meets.any() else 0 + violation = summary.loc[~meets, "violation"].fillna(np.inf) + ranks[~meets] = start + violation.rank(method="dense").astype(int) - 1 + return ranks @dataclass @@ -58,13 +80,22 @@ def screen( objectives: Mapping[str, str], keep: float | int | Sequence[float | int] = 0.25, tolerance: Mapping[str, float] | Sequence[Mapping[str, float] | None] | None = None, + statistics: Mapping[str, Statistic | str] | None = None, + requirements: Sequence[Requirement] = (), ) -> Screening: """ Screens designs with studies of increasing fidelity (and cost): each study (stage) evaluates the designs kept by the one before, ranks them by - non-dominated sorting of the means of their objectives (see - `pareto_ranks`), and keeps whole fronts, best first, until it keeps at - least `keep` designs (a number, or a share of the feasible designs). + non-dominated sorting of their objectives (see `pareto_ranks`): the means + of metrics, or other statistics over their replicates (see `aggregate`), + and keeps whole fronts, best first, until it keeps at least `keep` + designs (a number, or a share of the feasible designs). + + Designs that miss a requirement are ranked after those that meet them + all, in order of their violation (see `aggregate`), rather than dropped: + a cheap analysis may miss a requirement that the full analysis meets, so + designs that nearly meet the requirements are kept if `keep` reaches + them. A cheap analysis ranks designs less exactly than an expensive one, so a design it ranks just behind another may be better: keep enough designs, @@ -78,14 +109,17 @@ def screen( designs (Sequence[Design]): The designs to screen. studies (Sequence[Study]): The studies of each stage, in order of increasing fidelity. - objectives (Mapping[str, str]): The objectives: columns of the - results and their directions (`"min"` or `"max"`). + objectives (Mapping[str, str]): The objectives: statistics (or + metrics) and their directions (`"min"` or `"max"`). keep (float | int | Sequence): The designs kept by each stage but the last: a number (int), or a share of its feasible designs (float), or a value for each stage. tolerance (Mapping | Sequence | None): The tolerances of objectives in each stage but the last (see `pareto_front`), or the same for each stage. + statistics (Mapping[str, Statistic | str] | None): Statistics, by + name, of objectives and requirements that are not means. + requirements (Sequence[Requirement]): Requirements on statistics. Returns: Screening: the results and summaries of each stage @@ -98,18 +132,18 @@ def screen( tolerances = [tolerance] * transitions else: tolerances = _per_stage(tolerance, transitions, "tolerance") + names = list(objectives) + [requirement.name for requirement in requirements] + resolved = _get_statistics(names, statistics) current = list({design.key: design for design in designs}.values()) screening = Screening(results=pd.DataFrame()) frames = [] for stage, study in enumerate(studies): results = study.run(current).assign(stage=stage) frames.append(results) - summary = summarize(results, list(objectives), design_columns=[]) + summary = aggregate(results, resolved, requirements, design_columns=[]) summary = summary.dropna(subset=list(objectives)).reset_index(drop=True) - summary["pareto_rank"] = pareto_ranks( - summary, - objectives, - tolerances[stage] if stage < transitions else None, + summary["pareto_rank"] = _rank( + summary, objectives, tolerances[stage] if stage < transitions else None ) if stage < transitions: amount = keeps[stage] diff --git a/src/tatc/tradespace/study.py b/src/tatc/tradespace/study.py index a6dba880..01048b05 100644 --- a/src/tatc/tradespace/study.py +++ b/src/tatc/tradespace/study.py @@ -162,10 +162,12 @@ def run( self, designs: Iterable[Design] | None = None, progress: Callable[[int, int], None] | None = None, + replicates: Iterable[int] | None = None, ) -> pd.DataFrame: """ - Evaluates designs in every replicate. Repeated designs (with the same - key) are evaluated once. + Evaluates designs in every replicate (or in given replicates, such as + additional ones, see `refine`). Repeated designs (with the same key) + are evaluated once. Args: designs (Iterable[Design] | None): The designs, or `None` for @@ -174,6 +176,9 @@ def run( progress (Callable | None): A function called as evaluations complete with the number completed and the number of evaluations. + replicates (Iterable[int] | None): The replicates (their + indices, which seed their uncertain parameters), or `None` for + the study's (`range(replicates)`). Returns: pandas.DataFrame: The outcomes, a record per evaluation (or per @@ -189,7 +194,11 @@ def run( # tasks in the order of replicates, whose designs share uncertain values tasks = [ (i, design, replicate) - for replicate in range(self.replicates) + for replicate in ( + range(self.replicates) + if replicates is None + else sorted(set(replicates)) + ) for i, design in enumerate(unique) ] total = len(tasks) diff --git a/tests/tradespace/test_constellations.py b/tests/tradespace/test_constellations.py new file mode 100644 index 00000000..3c69e20a --- /dev/null +++ b/tests/tradespace/test_constellations.py @@ -0,0 +1,195 @@ +""" +Unit tests for building blocks of constellations. + +@author Paul T. Grogan +""" + +import unittest +from datetime import datetime, time, timezone + +import numpy as np + +from tatc.schemas import Instrument, Satellite +from tatc.tradespace import ( + Categorical, + Choice, + Derived, + DesignSpace, + Integer, + Real, + Uncertain, + build_constellation, + count_planes, + count_satellites, + hours_to_time, + sso_planes_space, + walker_space, +) + +EPOCH = datetime(2026, 1, 1, tzinfo=timezone.utc) +IMAGER = Instrument(name="imager", field_of_regard=60) + + +def _space(): + return DesignSpace( + altitude=Real(600e3, 700e3, step=100e3), + layout=Choice( + walker=walker_space( + inclination=Real(45, 60, step=15), + planes=Integer(1, 3), + per_plane=Integer(1, 2), + ), + sso=sso_planes_space( + crossing=Real(9, 15, step=3), + satellites=Integer(1, 2), + count=Integer(1, 2), + ), + ), + constraints=[lambda d: count_satellites(d.layout) - 4], + ) + + +class TestFragments(unittest.TestCase): + """ + Unit tests for fragments of design spaces. + """ + + def test_enumeration(self): + """Fragments enumerate their layouts, with constraints.""" + designs = _space().enumerate() + walker = [d for d in designs if d.layout.choice == "walker"] + sso = [d for d in designs if d.layout.choice == "sso"] + # 2 altitudes x 2 inclinations x (planes, per plane, spacing) with at most + # 4 satellites: 1x1, 1x2 (1 each), 2x1, 2x2 (2 each), 3x1 (3) + self.assertEqual(len(walker), 2 * 2 * (1 + 1 + 2 + 2 + 3)) + # 6 plane designs: one plane (6), or two with different crossings + # (6 x 6 - same-crossing pairs) / 2 unordered = 12 + self.assertEqual(len(sso), 2 * (6 + 12)) + for design in sso: + crossings = [plane.crossing for plane in design.layout.planes] + self.assertEqual(len(set(crossings)), len(crossings)) + self.assertTrue(all(count_satellites(d.layout) <= 4 for d in designs)) + + def test_counts(self): + """Satellites and planes are counted for each kind of layout.""" + designs = _space().enumerate() + walker = [d for d in designs if d.layout.choice == "walker"][-1] + self.assertEqual(count_planes(walker.layout), walker.layout.planes) + self.assertEqual( + count_satellites(walker.layout), + walker.layout.planes * walker.layout.per_plane, + ) + sso = [d for d in designs if d.layout.choice == "sso"][-1] + self.assertEqual(count_planes(sso.layout), sso.layout.planes.count) + with self.assertRaises(ValueError): + count_planes(sso) + + def test_defaults(self): + """Fragments have default variables.""" + self.assertGreater(DesignSpace(layout=walker_space(altitude=500e3)).size(), 100) + self.assertGreater( + DesignSpace(layout=sso_planes_space(altitude=500e3)).size(), 100 + ) + + +class TestBuild(unittest.TestCase): + """ + Unit tests for building constellations. + """ + + def test_walker(self): + """Walker layouts build the members of a Walker constellation.""" + space = DesignSpace( + altitude=650e3, + layout=walker_space( + inclination=55, planes=3, per_plane=2, relative_spacing=1 + ), + ) + design = space.enumerate()[0] + satellites = build_constellation( + design.layout, IMAGER, epoch=EPOCH, altitude=design.altitude, name="w" + ) + self.assertEqual(len(satellites), 6) + self.assertEqual(satellites[0].name, "w 1") + self.assertEqual(satellites[0].instruments, [IMAGER]) + raans = {round(s.orbit.right_ascension_ascending_node, 6) for s in satellites} + self.assertEqual(len(raans), 3) + self.assertTrue(all(s.orbit.inclination == 55 for s in satellites)) + + def test_sso(self): + """Sun-synchronous layouts build evenly spaced satellites in their planes.""" + space = DesignSpace( + layout=sso_planes_space( + crossing=13.5, + satellites=4, + count=1, + phase=Uncertain.uniform(0, 360), + altitude=700e3, + ), + ) + design = space.enumerate()[0].realize(0) + satellites = build_constellation(design.layout, [IMAGER], epoch=EPOCH) + self.assertEqual( + [s.name for s in satellites][:2], ["satellite 1-1", "satellite 1-2"] + ) + anomalies = [s.orbit.true_anomaly for s in satellites] + gaps = np.diff(np.unwrap(np.radians(anomalies))) + np.testing.assert_allclose(np.degrees(gaps) % 360, 90) + self.assertEqual(satellites[0].orbit.equator_crossing_time, time(13, 30)) + self.assertAlmostEqual(anomalies[0], design.layout.planes[0].phase) + + def test_derived_planes(self): + """Plane values may be derived from their index and enclosing values.""" + space = DesignSpace( + per_plane=Integer(1, 2), + layout=sso_planes_space( + crossing=Derived(lambda d: (13.5 + 12 * d.index / d.planes.count) % 24), + satellites=Derived(lambda d: d.per_plane), + count=Integer(1, 3), + ordered=True, + ), + ) + design = [d for d in space.enumerate() if len(d.layout.planes) == 3][-1] + satellites = build_constellation( + design.layout, IMAGER, epoch=EPOCH, altitude=830e3 + ) + self.assertEqual(len(satellites), 3 * design.per_plane) + times = sorted({s.orbit.equator_crossing_time for s in satellites}) + self.assertEqual(times, [time(13, 30), time(17, 30), time(21, 30)]) + + def test_catalog_payloads(self): + """Catalog entries are built with their validated attitude.""" + space = DesignSpace( + sounder=Categorical(["atms", "cris"]), + layout=sso_planes_space(crossing=13.5, satellites=1, count=1), + ) + design = space.enumerate()[0] + satellite = build_constellation( + design.layout, design.sounder, epoch=EPOCH, altitude=830e3, time_step=30 + )[0] + self.assertIsInstance(satellite, Satellite) + self.assertIsNotNone(satellite.attitude) + both = build_constellation( + design.layout, + ["atms:swath", "cris:swath"], + epoch=EPOCH, + altitude=830e3, + time_step=30, + )[0] + self.assertEqual(len(both.instruments), 2) + custom = build_constellation( + design.layout, + lambda name, orbit: Satellite(name=name, orbit=orbit, instruments=[IMAGER]), + epoch=EPOCH, + altitude=830e3, + )[0] + self.assertEqual(custom.instruments, [IMAGER]) + with self.assertRaises(ValueError): + build_constellation(design.layout, IMAGER, epoch=EPOCH) + + def test_hours_to_time(self): + """Hours convert to times of day, wrapping and rounding to seconds.""" + self.assertEqual(hours_to_time(13.5), time(13, 30)) + self.assertEqual(hours_to_time(15.9), time(15, 54)) + self.assertEqual(hours_to_time(24.25), time(0, 15)) + self.assertEqual(hours_to_time(10.9999999), time(11, 0)) diff --git a/tests/tradespace/test_criteria.py b/tests/tradespace/test_criteria.py new file mode 100644 index 00000000..970c803b --- /dev/null +++ b/tests/tradespace/test_criteria.py @@ -0,0 +1,208 @@ +""" +Unit tests for statistics over replicates and requirements on them. + +@author Paul T. Grogan +""" + +import unittest + +import numpy as np +import pandas as pd + +from tatc.tradespace import ( + DesignSpace, + Integer, + Maximum, + Mean, + Minimum, + Probability, + Quantile, + Requirement, + StandardDeviation, + Study, + Uncertain, + aggregate, + pareto_probability, + screen, +) + +VALUES = np.array( + [[1.0, 2.0, 3.0, np.nan], [4.0, np.nan, np.nan, np.nan], [np.nan] * 4] +) + + +class TestStatistics(unittest.TestCase): + """ + Unit tests for statistics. + """ + + def test_reductions(self): + """Statistics ignore missing replicates.""" + np.testing.assert_allclose(Mean("x").reduce(VALUES), [2, 4, np.nan]) + np.testing.assert_allclose(Minimum("x").reduce(VALUES), [1, 4, np.nan]) + np.testing.assert_allclose(Maximum("x").reduce(VALUES), [3, 4, np.nan]) + np.testing.assert_allclose(Quantile("x", 0.25).reduce(VALUES), [1.5, 4, np.nan]) + np.testing.assert_allclose( + StandardDeviation("x").reduce(VALUES), [1, np.nan, np.nan] + ) + np.testing.assert_allclose( + Probability("x", ">=", 2).reduce(VALUES), [2 / 3, 1, np.nan] + ) + np.testing.assert_allclose( + Probability("x", "<", 2).reduce(VALUES), [1 / 3, 0, np.nan] + ) + + def test_invalid(self): + """Quantiles and operators are checked.""" + with self.assertRaises(ValueError): + Quantile("x", 1.5) + with self.assertRaises(ValueError): + Probability("x", "==", 1) + with self.assertRaises(ValueError): + Requirement("x", "!=", 1) + + +class TestRequirement(unittest.TestCase): + """ + Unit tests for requirements. + """ + + def test_violation(self): + """Violations are the gaps to the required values.""" + statistic = np.array([5.0, 10.0, 12.0, np.nan]) + np.testing.assert_allclose( + Requirement("x", ">=", 10).violation(statistic), [5, 0, 0, np.nan] + ) + np.testing.assert_allclose( + Requirement("x", "<=", 10).violation(statistic), [0, 0, 2, np.nan] + ) + strict = Requirement("x", ">", 10).violation(statistic) + self.assertGreater(strict[1], 0) + self.assertEqual(strict[2], 0) + + +def _results(): + """Results of three designs in four replicates.""" + values = {"a": [10, 12, 14, 16], "b": [5, 30, 5, 30], "c": [1, 1, 1, 1]} + return pd.DataFrame( + [ + { + "design": key, + "replicate": r, + "feasible": True, + "cost": {"a": 2, "b": 2, "c": 1}[key], + "value": v, + "size": {"a": "small", "b": "small", "c": "large"}[key], + } + for key, row in values.items() + for r, v in enumerate(row) + ] + ) + + +class TestAggregate(unittest.TestCase): + """ + Unit tests for aggregating results. + """ + + def test_statistics_and_requirements(self): + """Statistics, violations, and design values are aggregated.""" + frame = aggregate( + _results(), + {"value": "value", "value p25": Quantile("value", 0.25), "cost": "cost"}, + [Requirement("value p25", ">=", 5), Requirement("cost", "<=", 1.5)], + ).set_index("design") + self.assertEqual(frame.loc["a", "value"], 13) + self.assertAlmostEqual(frame.loc["b", "value p25"], 5) + self.assertEqual(frame.loc["a", "violation"], 0.5) + self.assertEqual(frame.loc["c", "violation"], 4) + self.assertEqual(list(frame.meets_requirements), [False, False, False]) + self.assertEqual(frame.loc["c", "size"], "large") + self.assertTrue((frame.replicates == 4).all()) + + def test_metric_names(self): + """Metrics given as names are their means, and requirements add theirs.""" + frame = aggregate(_results(), ["value"], [Requirement("cost", "<=", 1)]) + self.assertIn("cost", frame.columns) + self.assertEqual(list(frame.meets_requirements), [False, False, True]) + # a requirement on a metric that the results do not have + with self.assertRaises(ValueError): + aggregate(_results(), {"v": Mean("value")}, [Requirement("w", ">=", 1)]) + + +class TestParetoProbabilityRequirements(unittest.TestCase): + """ + Unit tests for the probability of efficiency with statistics and requirements. + """ + + def test_quantile_objective(self): + """A pessimistic objective prefers the design with less spread.""" + objectives = {"cost": "min", "value": "max"} + by_mean = pareto_probability(_results(), objectives).set_index("design") + self.assertTrue(by_mean.loc["b", "pareto"]) # b has the larger mean + pessimistic = pareto_probability( + _results(), + {"cost": "min", "value q": "max"}, + statistics={"value q": Quantile("value", 0.25)}, + ).set_index("design") + self.assertTrue(pessimistic.loc["a", "pareto"]) + self.assertFalse(pessimistic.loc["b", "pareto"]) + + def test_requirements(self): + """Designs that miss a requirement are not efficient.""" + probability = pareto_probability( + _results(), + {"cost": "min", "value": "max"}, + requirements=[Requirement("reliable", ">=", 0.75)], + statistics={"reliable": Probability("value", ">=", 10)}, + ).set_index("design") + self.assertEqual(list(probability.meets_requirements), [True, False, False]) + # a is efficient unless b meets the requirement (and dominates it) + self.assertEqual(probability.loc["a", "requirements_probability"], 1) + self.assertGreater(probability.loc["a", "pareto_probability"], 0.5) + self.assertLess(probability.loc["a", "pareto_probability"], 1) + self.assertEqual(probability.loc["c", "pareto_probability"], 0) + # b meets the threshold in half of its replicates: it meets the + # requirement in some resamples, and is then efficient + self.assertGreater(probability.loc["b", "requirements_probability"], 0.1) + self.assertLess(probability.loc["b", "requirements_probability"], 0.9) + self.assertEqual(probability.loc["c", "requirements_probability"], 0) + + def test_unequal_replicates(self): + """Designs may have different replicates.""" + results = _results() + results = results[~((results.design == "c") & (results.replicate > 0))] + probability = pareto_probability(results, {"cost": "min", "value": "max"}) + self.assertEqual(list(probability.replicates), [4, 4, 1]) + self.assertEqual( + probability.set_index("design").loc["c", "pareto_probability"], 1 + ) + + +class TestScreenRequirements(unittest.TestCase): + """ + Unit tests for screening with requirements. + """ + + def test_misses_ranked_last(self): + """Designs that miss requirements are ranked after those that meet them.""" + space = DesignSpace(a=Integer(1, 6), noise=Uncertain.uniform(0, 1)) + study = Study( + space, + lambda d: d, + lambda d: {"cost": d.a, "value": d.a**0.5 + d.noise}, + replicates=2, + ) + screening = screen( + space.enumerate(), + [study, study], + {"cost": "min", "value": "max"}, + keep=4, + requirements=[Requirement("cost", "<=", 3)], + ) + first = screening.summaries[0].set_index("design") + meets = first[first.meets_requirements] + misses = first[~first.meets_requirements] + self.assertGreater(misses.pareto_rank.min(), meets.pareto_rank.max()) + # the nearest miss (cost 4) is kept to fill four designs + self.assertEqual(sorted(first[first.kept].cost), [1, 2, 3, 4]) diff --git a/tests/tradespace/test_optimization.py b/tests/tradespace/test_optimization.py index 1064517d..85d26b09 100644 --- a/tests/tradespace/test_optimization.py +++ b/tests/tradespace/test_optimization.py @@ -17,8 +17,10 @@ Evaluations, Infeasible, Integer, + Minimum, Real, Repeat, + Requirement, Study, Uncertain, hypervolume, @@ -305,3 +307,68 @@ def test_violations(self): x = np.array([space.encode(light), heavy]) population = Evaluator().eval(problem, Population.new(X=x)) self.assertEqual(list(population.get("G")[:, 0]), [0, 4]) + + +@unittest.skipUnless(HAS_OPTUNA and HAS_PYMOO, "requires optuna and pymoo") +class TestRequirements(unittest.TestCase): + """ + Unit tests for requirements in searches. + """ + + REQUIREMENTS = [Requirement("value p0", ">=", 2)] + STATISTICS = {"value p0": Minimum("value")} + + def test_evaluations(self): + """Evaluations give the violations of requirements on statistics.""" + evaluations = Evaluations( + _study(), OBJECTIVES, self.STATISTICS, self.REQUIREMENTS + ) + designs = [d for d in _space().enumerate() if d.layout.choice == "single"] + values = evaluations.evaluate(designs) + for design, value in zip(designs, values): + violation = evaluations.violations[design.key][0] + # the least value over replicates is the quality less the noise + self.assertAlmostEqual(violation, max(2 - value[1], 0), delta=0.02) + + def test_optuna(self): + """Trials record the violation of each requirement.""" + import optuna # pylint: disable=import-outside-toplevel + + optuna.logging.set_verbosity(optuna.logging.WARNING) + optuna_study, _ = optimize_optuna( + _study(), + OBJECTIVES, + n_trials=40, + sampler=optuna.samplers.RandomSampler(seed=1), + statistics=self.STATISTICS, + requirements=self.REQUIREMENTS, + ) + keys = {tuple(sorted(trial.constraints)) for trial in optuna_study.trials} + self.assertEqual(keys, {("feasibility", "value p0 >= 2")}) + violations = [t.constraints["value p0 >= 2"] for t in optuna_study.trials] + self.assertTrue(any(v > 0 for v in violations)) + with self.assertRaises(ValueError): + optimize_optuna( + _study(), + OBJECTIVES, + n_trials=1, + constraints=False, + requirements=self.REQUIREMENTS, + statistics=self.STATISTICS, + ) + + def test_pymoo(self): + """Problems have a constraint for each requirement.""" + problem = make_pymoo_problem( + _study(), OBJECTIVES, self.STATISTICS, self.REQUIREMENTS + ) + self.assertEqual(problem.n_ieq_constr, 2) + result, _ = optimize_pymoo( + _study(), + OBJECTIVES, + termination=("n_gen", 3), + seed=1, + statistics=self.STATISTICS, + requirements=self.REQUIREMENTS, + ) + self.assertEqual(result.pop.get("G").shape[1], 2) diff --git a/tests/tradespace/test_refinement.py b/tests/tradespace/test_refinement.py new file mode 100644 index 00000000..5af910d6 --- /dev/null +++ b/tests/tradespace/test_refinement.py @@ -0,0 +1,143 @@ +""" +Unit tests for adaptive replication. + +@author Paul T. Grogan +""" + +import unittest + +import numpy as np + +from tatc.tradespace import ( + DesignSpace, + Integer, + Quantile, + Study, + Uncertain, + pareto_probability, + refine, +) + +OBJECTIVES = {"cost": "min", "value": "max"} + + +def _study(replicates=5): + """Designs whose values are close to others' within noise for some costs.""" + space = DesignSpace( + cost=Integer(1, 8), + variant=Integer(0, 2), + noise=Uncertain.normal(0, 1), + ) + + def evaluate(d): + # variants 0 and 1 differ by a unit of noise; variant 2 is clearly worse + value = np.sqrt(d.cost) * 3 + {0: 0.0, 1: 1.0, 2: -3.0}[d.variant] + return {"cost": d.cost, "value": value + d.noise} + + # independent noise between designs, so that close designs are uncertain + return Study( + space, lambda d: d, evaluate, replicates=replicates, common_random_numbers=False + ) + + +class TestRefine(unittest.TestCase): + """ + Unit tests for adaptive replication. + """ + + def setUp(self): + self.study = _study() + self.designs = self.study.space.enumerate() + self.results = self.study.run(self.designs) + + def test_refines_uncertain_designs(self): + """Replicates are added only to uncertain designs, which become fewer.""" + refinement = refine( + self.study, + self.designs, + self.results, + OBJECTIVES, + step=5, + max_rounds=6, + n_resamples=200, + ) + history = refinement.history + self.assertGreater(history.refined.iloc[0], 0) + replicates = refinement.results.groupby("design").replicate.nunique() + # the clearly worse variant is never refined + worse = [d.key for d in self.designs if d.variant == 2] + self.assertTrue((replicates[worse] == 5).all()) + self.assertGreater(replicates.max(), 5) + before = pareto_probability(self.results, OBJECTIVES, n_resamples=200) + uncertain_before = ( + (before.pareto_probability > 0.05) & (before.pareto_probability < 0.95) + ).sum() + self.assertLess(len(refinement.uncertain), uncertain_before) + # far fewer evaluations than uniform replication to the same depth + uniform = replicates.max() * len(self.designs) + self.assertLess(len(refinement.results), 0.6 * uniform) + + def test_replicates_continue(self): + """Added replicates follow each design's own.""" + refinement = refine( + self.study, self.designs, self.results, OBJECTIVES, step=2, max_rounds=1 + ) + added = refinement.results.iloc[len(self.results) :] + self.assertTrue(set(added.replicate) <= {5, 6}) + self.assertFalse(refinement.results.duplicated(["design", "replicate"]).any()) + + def test_limits(self): + """Refinement stops at the most replicates of a design.""" + refinement = refine( + self.study, + self.designs, + self.results, + OBJECTIVES, + step=3, + max_replicates=8, + max_rounds=5, + ) + self.assertLessEqual( + refinement.results.groupby("design").replicate.nunique().max(), 8 + ) + self.assertEqual(refinement.history.refined.iloc[-1], 0) + with self.assertRaises(ValueError): + refine( + self.study, self.designs, self.results, OBJECTIVES, bounds=(0.9, 0.1) + ) + + def test_statistics(self): + """Refinement uses the statistics of the objectives.""" + refinement = refine( + self.study, + self.designs, + self.results, + {"cost": "min", "value p25": "max"}, + statistics={"value p25": Quantile("value", 0.25)}, + max_rounds=1, + ) + self.assertIn("value p25", refinement.probability.columns) + + def test_tolerance(self): + """A tolerance settles designs that are within it of the front.""" + strict = pareto_probability(self.results, OBJECTIVES, n_resamples=300) + tolerant = pareto_probability( + self.results, OBJECTIVES, n_resamples=300, tolerance={"value": 2.0} + ) + # designs efficient for sure, of the better variant (within 2 of each other) + self.assertGreater( + (tolerant.pareto_probability >= 0.95).sum(), + (strict.pareto_probability >= 0.95).sum(), + ) + refinement = refine( + self.study, + self.designs, + self.results, + OBJECTIVES, + max_rounds=1, + tolerance={"value": 2.0}, + ) + settled = refinement.probability.pareto_probability >= 0.95 + self.assertGreaterEqual( + settled.sum(), (tolerant.pareto_probability >= 0.95).sum() + ) From a9979f24d996070daa807ce6c4e16b2a9674fcc3 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Tue, 10 Nov 2026 08:23:55 -0700 Subject: [PATCH 03/52] add sampling sufficiency analysis, result stores, failures, and sensitivity Add tatc.analysis.sufficiency: estimate_sampling_error (exact error of the mean of a field with an exponential correlation in time, with effective samples), sample_field and compare_sampled_means (sampling errors against a nature run), compute_revisit_statistics (revisit quantiles and longest gaps), and compute_local_time_coverage. Add to tatc.tradespace: ResultStore, a persistent SQLite store of the evaluations of a study, so that interrupted or extended studies evaluate only what is new; Uncertain.seed and remove_failures for failures of satellites; tolerances as percentages; and sensitivity and main_effects. Return an empty frame from a SatelliteCache without satellites, and skip the executor when every evaluation is stored. Extend the SearchTradeSpace example with the share of points accurately sampled, sensitivity, and robustness to failures. --- CHANGELOG.md | 2 + docs/api_reference/analysis/index.rst | 1 + docs/api_reference/analysis/sufficiency.rst | 23 + docs/api_reference/tradespace.rst | 17 +- docs/examples/SearchTradeSpace.ipynb | 959 ++++++++++++++++++-- src/tatc/analysis/__init__.py | 16 +- src/tatc/analysis/sufficiency.py | 497 ++++++++++ src/tatc/tradespace/__init__.py | 10 +- src/tatc/tradespace/cache.py | 6 +- src/tatc/tradespace/constellations.py | 34 + src/tatc/tradespace/nodes.py | 11 + src/tatc/tradespace/pareto.py | 57 +- src/tatc/tradespace/refinement.py | 7 +- src/tatc/tradespace/sensitivity.py | 107 +++ src/tatc/tradespace/store.py | 117 +++ src/tatc/tradespace/study.py | 39 +- tests/analysis/test_sufficiency.py | 225 +++++ tests/tradespace/test_cache.py | 6 + tests/tradespace/test_constellations.py | 41 + tests/tradespace/test_pareto.py | 20 + tests/tradespace/test_sensitivity.py | 57 ++ tests/tradespace/test_store.py | 97 ++ 22 files changed, 2234 insertions(+), 115 deletions(-) create mode 100644 docs/api_reference/analysis/sufficiency.rst create mode 100644 src/tatc/analysis/sufficiency.py create mode 100644 src/tatc/tradespace/sensitivity.py create mode 100644 src/tatc/tradespace/store.py create mode 100644 tests/analysis/test_sufficiency.py create mode 100644 tests/tradespace/test_sensitivity.py create mode 100644 tests/tradespace/test_store.py diff --git a/CHANGELOG.md b/CHANGELOG.md index f1978010..e5c60118 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,11 +10,13 @@ Added: - Field `type` of a catalog configuration's `attitude` (`attitude`, `glint`, or `target`), which builds an `Attitude`, `GlintAttitude`, or `TargetAttitude`, as for OCO-2's glint mode. - Field `blind_intervals` of `Attitude`: intervals of argument of latitude in which a space system's instruments do not observe, for example while the body or a mechanism moves. Observations in them are not valid, so point observations, ground tracks (`valid_obs`, and the swaths of `compute_ground_track`), orbit tracks, and ground pixels omit them, and the periods and swaths of region observations end at them. Method `is_observing` of attitudes, schedules, and instruments. - Field `type` (`instrument`, `pointed`, or `conical`) of `Instrument`, `PointedInstrument`, and `ConicalInstrument`, which identifies the instrument class in serialized data. Data without a `type` loads as the class its fields imply. + - Analysis methods of the statistical sufficiency of observations (module `analysis.sufficiency`): `estimate_sampling_error`, the error of estimating the mean of a field over a period from each target's samples, for a field with a standard deviation and an exponential correlation in time (exact, see `sampling_error_variance`), with the effective number of independent samples; `sample_field`, which samples a field (an xarray `DataArray`, such as a nature run) at the time and place of each observation, and `compare_sampled_means`, which measures the sampling error against it; `compute_revisit_statistics`, the quantiles of revisits and the longest gap of each target (including the edges of the period); and `compute_local_time_coverage`, the distribution of samples in local time of day. - Module `tradespace` (prototype) for trade studies. A `DesignSpace` declares design variables (`Real`, `Integer`, `Categorical`), fixed and `Derived` values, and `Uncertain` parameters (drawn per replicate, not searched), grouped hierarchically with `Choice` (one of several branches) and `Repeat` (a variable number of items, such as orbit planes, optionally unordered). Bounds, derived values, and constraints are callables of the values decided before them. `DesignSpace.enumerate` gives every feasible design (a full factorial design, including variables that exist only in some designs), and `sample` a Latin hypercube or random sample. A `Design` has a `key` from its decisions and `flat` values by path, and `realize` draws a replicate's uncertain parameters, with common random numbers between designs by default. `Study` builds and evaluates designs in replicates into a data frame, recording designs that fail validation as infeasible, in worker processes with `n_jobs` (or on an `executor`); `summarize` gives the mean, standard deviation, and standard error of metrics over replicates. - Class `tradespace.SatelliteCache`, which caches an analysis of single satellites by their content (orbit, instruments, and attitude, not their name, see `get_satellite_key`), in memory or on disk, so that designs that share satellites compute their results once. - Functions `tradespace.pareto_front`, `pareto_ranks` (both with optional tolerances of objectives, within which designs near the front are efficient), and `hypervolume` (exact) of designs with several objectives to minimize or maximize, and `pareto_probability`, the probability that each design is efficient given the uncertainty of its replicates (a bootstrap that resamples the same replicates for every design). - Statistics of metrics over replicates (`tradespace.Mean`, `StandardDeviation`, `Minimum`, `Maximum`, `Quantile`, and `Probability`, the share of replicates that meet a threshold) and requirements on them (`Requirement`, output constraints that designs meet or violate by an amount once evaluated). `aggregate` gives the statistics and violations of each design; objectives and requirements of `pareto_probability` (which also gives the probability of meeting the requirements), `screen` (which ranks designs that miss requirements after those that meet them), `optimize_optuna` (a constraint of each trial for each requirement), and `optimize_pymoo` (a constraint for each requirement) name statistics, or metrics whose means they are. - Function `tradespace.refine` (and class `Refinement`), which adds replicates only to the designs whose Pareto efficiency is uncertain, until it is settled, optionally with a tolerance of differences that do not matter (also of `pareto_probability`); `Study.run` evaluates given replicates (`replicates`). + - Class `tradespace.ResultStore`, a persistent store (SQLite) of the evaluations of a study (argument `store` of `Study`), from which a study that is interrupted or extended takes the evaluations stored before. Function `tradespace.sensitivity` (and `main_effects`), the share of the variance of metrics explained by each design variable where it is active. Tolerances of objectives may be percentages of their values (such as `"5%"`). `Uncertain.seed` draws a seed of random numbers for each replicate, and `remove_failures` removes the satellites that fail, the same in every design. - Building blocks of constellations: fragments of design spaces of Walker constellations (`tradespace.walker_space`) and planes of sun-synchronous orbits (`sso_planes_space`, whose planes have different crossing times), `build_constellation`, which builds the satellites of either with instruments or entries of the instrument catalog (with their validated attitudes, and several entries on one satellite), and `count_satellites` and `count_planes`. - Function `tradespace.screen` (and class `Screening`), which screens designs with studies of increasing fidelity, keeping whole fronts of the best designs of each stage for the next. - Searches of design spaces with optional optimizers: `tradespace.optimize_optuna` suggests designs with Optuna trials (`DesignSpace.suggest`, define-by-run over the hierarchical space), and `optimize_pymoo` and `make_pymoo_problem` search the unit hypercube that encodes a design space (`DesignSpace.unit_paths`, `encode`, and `decode`) with pymoo. Each design is evaluated once, and the designs proposed together are evaluated together, in parallel if the study is. Constraints of a design space may return the amount of their violation (`Infeasible.violation`), which Optuna's trials record (`set_constraint`) for its constraint-aware samplers, and which is the constraint value of pymoo problems. Optional dependencies `tradespace` (joblib, Optuna, and pymoo). diff --git a/docs/api_reference/analysis/index.rst b/docs/api_reference/analysis/index.rst index 83bc1532..7bc24188 100644 --- a/docs/api_reference/analysis/index.rst +++ b/docs/api_reference/analysis/index.rst @@ -8,6 +8,7 @@ Analysis functions simulate mission operation to compute key performance metrics :maxdepth: 1 coverage + sufficiency track coincidence feature_coverage diff --git a/docs/api_reference/analysis/sufficiency.rst b/docs/api_reference/analysis/sufficiency.rst new file mode 100644 index 00000000..477ef6a2 --- /dev/null +++ b/docs/api_reference/analysis/sufficiency.rst @@ -0,0 +1,23 @@ +Statistical Sufficiency +======================= + +.. automodule:: tatc.analysis.sufficiency + :no-members: + +Estimate Sampling Errors +------------------------ +.. autofunction:: tatc.analysis.estimate_sampling_error + +.. autofunction:: tatc.analysis.sampling_error_variance + +Sample Fields +------------- +.. autofunction:: tatc.analysis.sample_field + +.. autofunction:: tatc.analysis.compare_sampled_means + +Revisits and Local Times +------------------------ +.. autofunction:: tatc.analysis.compute_revisit_statistics + +.. autofunction:: tatc.analysis.compute_local_time_coverage diff --git a/docs/api_reference/tradespace.rst b/docs/api_reference/tradespace.rst index 7e4bd69c..bba2c8b2 100644 --- a/docs/api_reference/tradespace.rst +++ b/docs/api_reference/tradespace.rst @@ -20,7 +20,7 @@ Design Spaces .. autoclass:: tatc.tradespace.Derived .. autoclass:: tatc.tradespace.Uncertain - :members: uniform, normal, choice + :members: uniform, normal, choice, seed .. autoclass:: tatc.tradespace.Choice @@ -62,6 +62,8 @@ Constellations .. autofunction:: tatc.tradespace.hours_to_time +.. autofunction:: tatc.tradespace.remove_failures + Trade Studies ------------- @@ -96,6 +98,12 @@ Statistics and Requirements .. autoclass:: tatc.tradespace.Requirement :members: violation +Stores of Results +----------------- + +.. autoclass:: tatc.tradespace.ResultStore + :members: get, put, clear + Caches ------ @@ -126,6 +134,13 @@ Adaptive Replication .. autoclass:: tatc.tradespace.Refinement :members: uncertain +Sensitivity +----------- + +.. autofunction:: tatc.tradespace.sensitivity + +.. autofunction:: tatc.tradespace.main_effects + Screening --------- diff --git a/docs/examples/SearchTradeSpace.ipynb b/docs/examples/SearchTradeSpace.ipynb index c9bd8b10..2a9e59b3 100644 --- a/docs/examples/SearchTradeSpace.ipynb +++ b/docs/examples/SearchTradeSpace.ipynb @@ -9,7 +9,7 @@ "\n", "This example demonstrates how to search a trade space of constellation designs for Pareto-efficient designs with the `tatc.tradespace` module: declaring a hierarchical design space, evaluating designs in replicates (in parallel, with a cache of the analysis of each satellite), ranking them with the uncertainty of their replicates, screening them with a cheaper analysis, and searching the space with optimizers (Optuna and pymoo, installed with `pip install tatc[tradespace]`).\n", "\n", - "The trade is a sampling problem of a pre-Phase A study: how many satellites, in how many orbit planes (each of which needs its own launch), sample the Earth sufficiently often? A point is **sufficiently sampled** if an imager observes it at least four times in a day, and the objective is the share of points that are. The points are a random sample of the Earth, so the share is a statistical estimate: each replicate of a design draws a different sample of points, which is the uncertainty of the estimate." + "The trade is a sampling problem of a pre-Phase A study: how many satellites, in how many orbit planes (each of which needs its own launch), sample the Earth sufficiently often? A point is **sufficiently sampled** if an imager observes it at least four times in a day, and the objective is the share of points that are. A second objective measures sufficiency by its purpose: a point is **accurately sampled** if the mean of its samples estimates the daily mean of a field that varies within hours (such as convective precipitation) with an error of at most half the field's standard deviation. The points are a random sample of the Earth, so the share is a statistical estimate: each replicate of a design draws a different sample of points, which is the uncertainty of the estimate." ] }, { @@ -28,10 +28,10 @@ "id": "c3d2e5f4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T05:58:30.755554Z", - "iopub.status.busy": "2026-11-10T05:58:30.755260Z", - "iopub.status.idle": "2026-11-10T05:58:31.599300Z", - "shell.execute_reply": "2026-11-10T05:58:31.598339Z" + "iopub.execute_input": "2026-11-10T14:23:18.993844Z", + "iopub.status.busy": "2026-11-10T14:23:18.993609Z", + "iopub.status.idle": "2026-11-10T14:23:19.706382Z", + "shell.execute_reply": "2026-11-10T14:23:19.705579Z" } }, "outputs": [], @@ -50,6 +50,8 @@ "N_REPLICATES = 5 # replicates (samples of points) of each design\n", "SAMPLES_PER_DAY = 4 # a point is sufficiently sampled if it is observed at least this often\n", "MAX_SATELLITES = 10\n", + "DECORRELATION_TIME = timedelta(hours=3) # of the field whose daily mean is estimated\n", + "MAX_RELATIVE_ERROR = 0.5 # a point is accurately sampled within this share of the field's standard deviation\n", "\n", "BLUE, ORANGE, AQUA, YELLOW, GRAY, INK = \"#2a78d6\", \"#eb6834\", \"#1baf7a\", \"#eda100\", \"#8a8a86\", \"#2b2b29\"" ] @@ -66,7 +68,7 @@ "* a **Walker delta** constellation (`walker_space`), with an inclination, a number of planes, a number of satellites in each plane, and the relative spacing of the satellites between planes (whose upper bound depends on the number of planes), or\n", "* one or two **sun-synchronous** planes (`sso_planes_space`, a `Repeat` of planes), each with its own equator crossing time and number of satellites. The planes are unordered: two planes in either order are the same design. A constraint of the building block requires the planes to have different crossing times (otherwise, they would be the same plane).\n", "\n", - "The points sampled in each replicate are an `Uncertain` parameter (the seed of a random sample), drawn for each replicate rather than designed. The replicates use common random numbers: every design samples the same points in the same replicate, so that differences between designs are not differences between their samples.\n", + "The points sampled in each replicate are an `Uncertain` parameter (the seed of a random sample, `Uncertain.seed`), drawn for each replicate rather than designed, as are the failures of satellites (used below). The replicates use common random numbers: every design samples the same points in the same replicate, so that differences between designs are not differences between their samples.\n", "\n", "The constraint on the number of satellites returns the number in excess of the limit (a number that is not positive if the design satisfies it), rather than `True` or `False`, so that optimizers can tell how far an infeasible design is from a feasible one." ] @@ -77,10 +79,10 @@ "id": "e5f4a7b6", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T05:58:31.603174Z", - "iopub.status.busy": "2026-11-10T05:58:31.602654Z", - "iopub.status.idle": "2026-11-10T05:58:32.968088Z", - "shell.execute_reply": "2026-11-10T05:58:32.966883Z" + "iopub.execute_input": "2026-11-10T14:23:19.708265Z", + "iopub.status.busy": "2026-11-10T14:23:19.707962Z", + "iopub.status.idle": "2026-11-10T14:23:20.832042Z", + "shell.execute_reply": "2026-11-10T14:23:20.831242Z" } }, "outputs": [ @@ -112,7 +114,8 @@ " walker=walker_space(inclination=Real(45, 75, step=15), planes=Integer(1, 4), per_plane=Integer(1, 4)),\n", " sso=sso_planes_space(crossing=Real(6, 18, step=3), satellites=Integer(1, 2), count=Integer(1, 2)),\n", " ),\n", - " points_seed=Uncertain(lambda rng: int(rng.integers(2**31)), nominal=None),\n", + " points_seed=Uncertain.seed(),\n", + " failure_seed=Uncertain.seed(),\n", " constraints=[lambda d: count_satellites(d.layout) - MAX_SATELLITES],\n", ")\n", "designs = space.enumerate()\n", @@ -128,7 +131,9 @@ "\n", "A `Study` builds each design into its satellites (`build`, with `build_constellation`, which builds the satellites of either layout with a payload: here, an imager, but also entries of the instrument catalog) and evaluates them (`evaluate`) in each replicate. The evaluation collects the observations of the replicate's points by each satellite, from a `SatelliteCache`: designs share many satellites (the same orbit and imager, if not the same name), whose observations are computed once. The cache is kept on disk, where the parallel worker processes of the study (`n_jobs=-1`, one per processor) share it, and where it persists between sessions. Its namespace identifies the analysis: the points, the start, and the duration.\n", "\n", - "`make_study` makes studies of other durations and numbers of replicates, as for screening (below). Each evaluation also reports its cost (`satellite_days`, the satellites times the days analyzed), which measures the computation independently of the cache." + "The evaluation computes both objectives: the share of points with at least four samples, and the share whose sampling error (`tatc.analysis.estimate_sampling_error`, for an exponential correlation in time with a decorrelation time of 3 hours) is at most half the field's standard deviation. A `ResultStore` keeps the records of the evaluations in a file, so that running the notebook again (or resuming it after an interruption) takes them from the file rather than evaluating them again.\n", + "\n", + "`make_study` makes studies of other durations, numbers of replicates, and probabilities that satellites fail, as for screening and robustness (below). Each evaluation also reports its cost (`satellite_days`, the satellites times the days analyzed), which measures the computation independently of the cache." ] }, { @@ -137,18 +142,18 @@ "id": "a7b6c9d8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T05:58:32.971200Z", - "iopub.status.busy": "2026-11-10T05:58:32.970687Z", - "iopub.status.idle": "2026-11-10T05:58:32.979419Z", - "shell.execute_reply": "2026-11-10T05:58:32.978393Z" + "iopub.execute_input": "2026-11-10T14:23:20.834188Z", + "iopub.status.busy": "2026-11-10T14:23:20.833776Z", + "iopub.status.idle": "2026-11-10T14:23:20.840749Z", + "shell.execute_reply": "2026-11-10T14:23:20.839985Z" } }, "outputs": [], "source": [ - "from tatc.analysis import collect_observations\n", + "from tatc.analysis import collect_observations, estimate_sampling_error\n", "from tatc.generation import generate_points_random\n", "from tatc.schemas import Instrument\n", - "from tatc.tradespace import SatelliteCache, Study, build_constellation, count_planes\n", + "from tatc.tradespace import ResultStore, SatelliteCache, Study, build_constellation, count_planes, remove_failures\n", "\n", "CACHE_DIRECTORY = Path(tempfile.gettempdir()) / \"tatc-search-trade-space\"\n", "caches = {}\n", @@ -166,27 +171,37 @@ " return caches[seed, duration]\n", "\n", "\n", - "def build(d):\n", - " \"\"\"The design and its satellites.\"\"\"\n", - " imager = Instrument(name=\"imager\", field_of_regard=d.field_of_regard)\n", - " return d, build_constellation(d.layout, imager, epoch=START, altitude=d.altitude)\n", - "\n", - "\n", - "def make_study(duration=DURATION, replicates=N_REPLICATES):\n", - " \"\"\"A study of the share (%) of points sampled sufficiently over a duration.\"\"\"\n", + "def make_study(duration=DURATION, replicates=N_REPLICATES, failure_probability=0.0):\n", + " \"\"\"A study of the shares (%) of points sampled sufficiently and accurately over a duration, by the satellites\n", + " of each design that do not fail.\"\"\"\n", " threshold = SAMPLES_PER_DAY * duration / timedelta(days=1)\n", "\n", + " def build(d):\n", + " imager = Instrument(name=\"imager\", field_of_regard=d.field_of_regard)\n", + " members = build_constellation(d.layout, imager, epoch=START, altitude=d.altitude)\n", + " return d, members, remove_failures(members, failure_probability, d.failure_seed)\n", + "\n", " def evaluate(built):\n", - " d, members = built\n", - " samples = get_cache(d.points_seed, duration)(members).groupby(\"target_hash\").size()\n", + " d, members, working = built\n", + " counts = {\"satellites\": len(members), \"planes\": count_planes(d.layout)}\n", + " if not working: # every satellite failed\n", + " return {**counts, \"sufficient\": 0.0, \"accurate\": 0.0, \"satellite_days\": 0.0}\n", + " observations = get_cache(d.points_seed, duration)(working)\n", + " samples = observations.groupby(\"target_hash\").size()\n", + " error = estimate_sampling_error(observations, START, START + duration, DECORRELATION_TIME)\n", " return {\n", - " \"satellites\": len(members),\n", - " \"planes\": count_planes(d.layout),\n", + " **counts,\n", " \"sufficient\": 100 * (samples >= threshold).sum() / N_POINTS,\n", - " \"satellite_days\": len(members) * duration / timedelta(days=1),\n", + " \"accurate\": 100 * (error.relative_error <= MAX_RELATIVE_ERROR).sum() / N_POINTS,\n", + " \"satellite_days\": len(working) * duration / timedelta(days=1),\n", " }\n", "\n", - " return Study(space, build, evaluate, replicates=replicates, n_jobs=-1)\n", + " store = ResultStore(\n", + " CACHE_DIRECTORY / \"results.sqlite\",\n", + " namespace=f\"{N_POINTS} points, start {START.isoformat()}, duration {duration}, failures \"\n", + " + f\"{failure_probability}, accuracy {MAX_RELATIVE_ERROR} at {DECORRELATION_TIME}\",\n", + " )\n", + " return Study(space, build, evaluate, replicates=replicates, n_jobs=-1, store=store)\n", "\n", "\n", "OBJECTIVES = {\"satellites\": \"min\", \"planes\": \"min\", \"sufficient\": \"max\"}\n", @@ -209,10 +224,10 @@ "id": "c9d8e1f0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T05:58:32.981888Z", - "iopub.status.busy": "2026-11-10T05:58:32.981565Z", - "iopub.status.idle": "2026-11-10T05:58:41.434069Z", - "shell.execute_reply": "2026-11-10T05:58:41.433345Z" + "iopub.execute_input": "2026-11-10T14:23:20.842351Z", + "iopub.status.busy": "2026-11-10T14:23:20.842125Z", + "iopub.status.idle": "2026-11-10T14:23:21.183348Z", + "shell.execute_reply": "2026-11-10T14:23:21.182423Z" } }, "outputs": [ @@ -334,7 +349,9 @@ "print(f\"{len(results)} evaluations: {len(designs)} designs x {N_REPLICATES} replicates\")\n", "\n", "# the values of each design, and the means of its objectives over the replicates\n", - "values = results.drop_duplicates(\"design\").set_index(\"design\").drop(columns=[\"replicate\", \"points_seed\", \"seconds\", \"sufficient\", \"feasible\"])\n", + "values = results.drop_duplicates(\"design\").set_index(\"design\").drop(\n", + " columns=[\"replicate\", \"points_seed\", \"failure_seed\", \"seconds\", \"sufficient\", \"accurate\", \"feasible\"]\n", + ")\n", "summary = summarize(results, list(OBJECTIVES), design_columns=[])\n", "summary[\"pareto\"] = pareto_front(summary, OBJECTIVES)\n", "exact_hypervolume = hypervolume(summary, OBJECTIVES, REFERENCE)\n", @@ -367,10 +384,10 @@ "id": "d0e9f2a1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T05:58:41.436010Z", - "iopub.status.busy": "2026-11-10T05:58:41.435817Z", - "iopub.status.idle": "2026-11-10T05:58:41.740991Z", - "shell.execute_reply": "2026-11-10T05:58:41.739810Z" + "iopub.execute_input": "2026-11-10T14:23:21.185331Z", + "iopub.status.busy": "2026-11-10T14:23:21.185054Z", + "iopub.status.idle": "2026-11-10T14:23:21.446495Z", + "shell.execute_reply": "2026-11-10T14:23:21.445410Z" } }, "outputs": [ @@ -435,6 +452,560 @@ "Of the 1,096 feasible designs, six are Pareto-efficient (ringed in the figure). All of them fly at the highest altitude (800 km) with the wider field of regard (60 degrees), which observe the most points per satellite, so the trade is in the number of satellites and planes. One satellite samples only 4% of the points sufficiently (at least four times a day), and the share rises steeply with the number of satellites: two satellites in two planes (29%) sample twice as many points as two in one plane (14%), and six satellites in two inclined planes sample 98%. No design with more than six satellites is efficient, because six already sample nearly every point. Designs with the same number of satellites differ widely: their layout (inclination, planes, and phasing) matters as much as their number." ] }, + { + "cell_type": "markdown", + "id": "f1a2b3c4", + "metadata": {}, + "source": [ + "## Measure the Sampling Error\n", + "\n", + "Four samples a day count the same whether they come hours apart or minutes apart, but they do not estimate a daily mean equally well: samples closer together than the field's decorrelation time repeat each other. The share of points accurately sampled measures what the samples are for. The table gives the efficient designs by this objective (with the numbers of satellites and planes, as before), and the figure compares the two objectives for every design." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a2b3c4d5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-10T14:23:21.448598Z", + "iopub.status.busy": "2026-11-10T14:23:21.448243Z", + "iopub.status.idle": "2026-11-10T14:23:21.601390Z", + "shell.execute_reply": "2026-11-10T14:23:21.600441Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "

\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanessufficientaccurateaccurate sem
1046800 km, 60 deg FOR, SSO: 1 at 06:001.01.03.44.81.0
1049800 km, 60 deg FOR, SSO: 2 at 09:002.01.011.611.40.9
963800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.028.633.81.7
1019800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...3.01.024.619.21.1
1088800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:003.02.026.458.01.5
972800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...3.03.036.058.61.3
1020800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac...4.01.047.227.21.2
1079800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:004.02.052.282.81.3
758700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...6.03.087.497.00.5
1035800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.098.098.00.5
1036800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.098.098.00.5
1037800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.098.098.00.5
\n", + "
" + ], + "text/plain": [ + " description satellites planes \\\n", + "1046 800 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", + "1049 800 km, 60 deg FOR, SSO: 2 at 09:00 2.0 1.0 \n", + "963 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", + "1019 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... 3.0 1.0 \n", + "1088 800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00 3.0 2.0 \n", + "972 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", + "1020 800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac... 4.0 1.0 \n", + "1079 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00 4.0 2.0 \n", + "758 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... 6.0 3.0 \n", + "1035 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "1036 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "1037 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "\n", + " sufficient accurate accurate sem \n", + "1046 3.4 4.8 1.0 \n", + "1049 11.6 11.4 0.9 \n", + "963 28.6 33.8 1.7 \n", + "1019 24.6 19.2 1.1 \n", + "1088 26.4 58.0 1.5 \n", + "972 36.0 58.6 1.3 \n", + "1020 47.2 27.2 1.2 \n", + "1079 52.2 82.8 1.3 \n", + "758 87.4 97.0 0.5 \n", + "1035 98.0 98.0 0.5 \n", + "1036 98.0 98.0 0.5 \n", + "1037 98.0 98.0 0.5 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ACCURACY = {\"satellites\": \"min\", \"planes\": \"min\", \"accurate\": \"max\"}\n", + "accuracy = summarize(results, [\"satellites\", \"planes\", \"sufficient\", \"accurate\"], design_columns=[])\n", + "accuracy[\"description\"] = [describe(values.loc[key]) for key in accuracy.design]\n", + "accuracy[\"pareto\"] = pareto_front(accuracy, ACCURACY)\n", + "accuracy[accuracy.pareto].sort_values([\"satellites\", \"planes\"])[\n", + " [\"description\", \"satellites\", \"planes\", \"sufficient\", \"accurate\", \"accurate sem\"]\n", + "].round(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b3c4d5e6", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-10T14:23:21.603175Z", + "iopub.status.busy": "2026-11-10T14:23:21.602982Z", + "iopub.status.idle": "2026-11-10T14:23:21.794247Z", + "shell.execute_reply": "2026-11-10T14:23:21.793338Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(6.5, 5))\n", + "for planes, color in PLANE_COLORS.items():\n", + " selected = accuracy.planes == planes\n", + " ax.scatter(\n", + " accuracy.sufficient[selected], accuracy.accurate[selected], s=14, color=color, alpha=0.6, lw=0,\n", + " label=f\"{planes} plane{'s' if planes > 1 else ''}\",\n", + " )\n", + "ax.plot([0, 100], [0, 100], color=GRAY, lw=1, ls=\"--\")\n", + "ax.annotate(\"equal shares\", (80, 80), xytext=(6, -10), textcoords=\"offset points\", fontsize=8, color=GRAY)\n", + "ax.set(xlabel=\"Points sufficiently sampled (%)\", ylabel=\"Points accurately sampled (%)\", xlim=(0, 102), ylim=(0, 102))\n", + "ax.grid(color=\"#e6e6e3\", lw=0.8)\n", + "ax.set_axisbelow(True)\n", + "for side in (\"top\", \"right\"):\n", + " ax.spines[side].set_visible(False)\n", + "ax.legend(loc=\"upper left\", fontsize=8, frameon=False, markerscale=1.6)\n", + "ax.set_title(\"Sampling counts and sampling errors of every design\", fontsize=10)\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c4d5e6f7", + "metadata": {}, + "source": [ + "The revisits of two designs of four satellites with similar shares of points sufficiently sampled show why they differ in accuracy: the times between their samples (`tatc.analysis.compute_revisit_statistics`), including the longest gap of the day, and the times of day they sample (`tatc.analysis.compute_local_time_coverage`, in eight 3-hour intervals of local time)." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d5e6f7a8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-10T14:23:21.796370Z", + "iopub.status.busy": "2026-11-10T14:23:21.795998Z", + "iopub.status.idle": "2026-11-10T14:23:21.925573Z", + "shell.execute_reply": "2026-11-10T14:23:21.924719Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sufficient (%)accurate (%)median revisit (h)median longest gap (h)median 3-h intervals sampled
design
800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spacing 0)66.425.00.414.52.0
800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:0052.282.85.610.43.0
\n", + "
" + ], + "text/plain": [ + " sufficient (%) \\\n", + "design \n", + "800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spaci... 66.4 \n", + "800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00 52.2 \n", + "\n", + " accurate (%) \\\n", + "design \n", + "800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spaci... 25.0 \n", + "800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00 82.8 \n", + "\n", + " median revisit (h) \\\n", + "design \n", + "800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spaci... 0.4 \n", + "800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00 5.6 \n", + "\n", + " median longest gap (h) \\\n", + "design \n", + "800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spaci... 14.5 \n", + "800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00 10.4 \n", + "\n", + " median 3-h intervals sampled \n", + "design \n", + "800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spaci... 2.0 \n", + "800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00 3.0 " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.analysis import compute_local_time_coverage, compute_revisit_statistics\n", + "\n", + "four = accuracy[(accuracy.satellites == 4)].sort_values(\"sufficient\", ascending=False)\n", + "# the most sufficiently sampling design of four satellites, and the most accurately sampling one of another layout\n", + "first = four.iloc[0]\n", + "second = four[four.design != first.design].sort_values(\"accurate\", ascending=False).iloc[0]\n", + "by_key = {d.key: d for d in designs}\n", + "rows = []\n", + "for row in (first, second):\n", + " d = by_key[row.design].realize(0)\n", + " _, members, _ = make_study().build(d)\n", + " observations = get_cache(d.points_seed, DURATION)(members)\n", + " points = generate_points_random(N_POINTS, seed=d.points_seed)\n", + " revisits = compute_revisit_statistics(observations, START, START + DURATION, targets=points)\n", + " local = compute_local_time_coverage(observations, targets=points)\n", + " observed = revisits[revisits.samples > 0]\n", + " rows.append(\n", + " {\n", + " \"design\": row.description,\n", + " \"sufficient (%)\": row.sufficient,\n", + " \"accurate (%)\": row.accurate,\n", + " \"median revisit (h)\": observed[\"revisit p50\"].dt.total_seconds().median() / 3600,\n", + " \"median longest gap (h)\": revisits.max_gap.dt.total_seconds().median() / 3600,\n", + " \"median 3-h intervals sampled\": local.local_bins_sampled.median(),\n", + " }\n", + " )\n", + "pd.DataFrame(rows).set_index(\"design\").round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "e6f7a8b9", + "metadata": {}, + "source": [ + "Counting samples and measuring their sampling error rank designs differently. Satellites in one plane (blue in the figure) sample many points four times a day, but in bursts: consecutive passes of satellites that follow each other in a plane, minutes apart, repeat each other for a field that decorrelates in hours. Four satellites in one Walker plane sample 66% of the points at least four times a day, but only 25% accurately: half of their revisits are 0.4 hours apart, and they leave a gap of 14.5 hours. Four satellites in two sun-synchronous planes sample fewer points four times (52%) but 83% accurately: their samples are 5.6 hours apart, in three of the eight 3-hour intervals of the day. Designs in a single plane remain efficient only as those that need the fewest launches, and sample at most 27% of the points accurately; six satellites in three planes sample 97% of the points accurately, as many as nine." + ] + }, + { + "cell_type": "markdown", + "id": "f7a8b9c0", + "metadata": {}, + "source": [ + "## Find What Drives the Objectives\n", + "\n", + "`sensitivity` gives the share of the variance of each objective (over the designs, by their means over the replicates) that each design variable explains, among the designs in which the variable is active: the variables of the Walker layout apply only to Walker designs, and those of the sun-synchronous layout only to theirs." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "a8b9c0d1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-10T14:23:21.927361Z", + "iopub.status.busy": "2026-11-10T14:23:21.927182Z", + "iopub.status.idle": "2026-11-10T14:23:21.951726Z", + "shell.execute_reply": "2026-11-10T14:23:21.950884Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sufficientaccurateactive
variable
field_of_regard0.250.251.00
layout.walker.per_plane0.220.180.64
layout0.180.121.00
layout.walker.planes0.120.290.64
layout.sso.planes.count0.110.190.36
altitude0.030.041.00
layout.walker.relative_spacing0.030.070.64
layout.walker.inclination0.000.000.64
\n", + "
" + ], + "text/plain": [ + " sufficient accurate active\n", + "variable \n", + "field_of_regard 0.25 0.25 1.00\n", + "layout.walker.per_plane 0.22 0.18 0.64\n", + "layout 0.18 0.12 1.00\n", + "layout.walker.planes 0.12 0.29 0.64\n", + "layout.sso.planes.count 0.11 0.19 0.36\n", + "altitude 0.03 0.04 1.00\n", + "layout.walker.relative_spacing 0.03 0.07 0.64\n", + "layout.walker.inclination 0.00 0.00 0.64" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import sensitivity\n", + "\n", + "frame = accuracy.join(values.drop(columns=[\"satellites\", \"planes\", \"satellite_days\"]), on=\"design\")\n", + "variables = [\n", + " \"altitude\",\n", + " \"field_of_regard\",\n", + " \"layout\",\n", + " \"layout.walker.inclination\",\n", + " \"layout.walker.planes\",\n", + " \"layout.walker.per_plane\",\n", + " \"layout.walker.relative_spacing\",\n", + " \"layout.sso.planes.count\",\n", + "]\n", + "sensitivity(frame, variables, [\"sufficient\", \"accurate\"]).round(2)" + ] + }, + { + "cell_type": "markdown", + "id": "b9c0d1e2", + "metadata": {}, + "source": [ + "The field of regard explains the most of both objectives (25% of their variance), as it sets the swath of every satellite. The layout matters next, but differently for the two objectives: the number of satellites in each Walker plane explains more of the share of points sufficiently sampled (22%) than of those accurately sampled (18%), and the number of Walker planes the reverse (12% and 29%), as more planes spread the samples in time. The altitude explains little of either objective (3 to 4%), although a higher orbit widens the swath: its effect is small next to those of the field of regard and the layout. The inclination explains nothing on average over the Walker designs." + ] + }, { "cell_type": "markdown", "id": "f2a1b4c3", @@ -447,14 +1018,14 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 10, "id": "a3b2c5d4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T05:58:41.743054Z", - "iopub.status.busy": "2026-11-10T05:58:41.742813Z", - "iopub.status.idle": "2026-11-10T05:59:32.360501Z", - "shell.execute_reply": "2026-11-10T05:59:32.359564Z" + "iopub.execute_input": "2026-11-10T14:23:21.953651Z", + "iopub.status.busy": "2026-11-10T14:23:21.953354Z", + "iopub.status.idle": "2026-11-10T14:24:13.516597Z", + "shell.execute_reply": "2026-11-10T14:24:13.515732Z" } }, "outputs": [ @@ -663,7 +1234,7 @@ "1026 98.0 True 1.00 " ] }, - "execution_count": 6, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -699,14 +1270,14 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 11, "id": "b5d3f7a9", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T05:59:32.362498Z", - "iopub.status.busy": "2026-11-10T05:59:32.362302Z", - "iopub.status.idle": "2026-11-10T06:09:18.478688Z", - "shell.execute_reply": "2026-11-10T06:09:18.477678Z" + "iopub.execute_input": "2026-11-10T14:24:13.518409Z", + "iopub.status.busy": "2026-11-10T14:24:13.518224Z", + "iopub.status.idle": "2026-11-10T14:33:23.433467Z", + "shell.execute_reply": "2026-11-10T14:33:23.432618Z" } }, "outputs": [ @@ -833,7 +1404,7 @@ "9 9 12 2 10" ] }, - "execution_count": 7, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -852,14 +1423,14 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 12, "id": "c6e4a8b0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T06:09:18.480419Z", - "iopub.status.busy": "2026-11-10T06:09:18.480172Z", - "iopub.status.idle": "2026-11-10T06:09:18.538463Z", - "shell.execute_reply": "2026-11-10T06:09:18.537695Z" + "iopub.execute_input": "2026-11-10T14:33:23.435219Z", + "iopub.status.busy": "2026-11-10T14:33:23.435026Z", + "iopub.status.idle": "2026-11-10T14:33:23.493558Z", + "shell.execute_reply": "2026-11-10T14:33:23.492795Z" } }, "outputs": [ @@ -1372,7 +1943,7 @@ "1037 98.00 5 True 0.96 " ] }, - "execution_count": 8, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -1405,14 +1976,14 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 13, "id": "f9b7d1e3", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T06:09:18.540370Z", - "iopub.status.busy": "2026-11-10T06:09:18.540117Z", - "iopub.status.idle": "2026-11-10T06:10:04.806057Z", - "shell.execute_reply": "2026-11-10T06:10:04.805052Z" + "iopub.execute_input": "2026-11-10T14:33:23.496058Z", + "iopub.status.busy": "2026-11-10T14:33:23.495814Z", + "iopub.status.idle": "2026-11-10T14:34:09.295054Z", + "shell.execute_reply": "2026-11-10T14:34:09.294169Z" } }, "outputs": [ @@ -1593,7 +2164,7 @@ "763 1.0 " ] }, - "execution_count": 9, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -1626,6 +2197,223 @@ "194 of the 1,096 designs meet the requirement of sampling half of the points sufficiently in at least 80% of the samples, and none of them has fewer than four satellites: the best three satellites sample 37% of the points on average. Among those that meet it, four satellites in one plane (inclined 45 degrees) are efficient for sure, sampling at least 62% of the points in 80% of the samples, and so are six satellites in two planes inclined 75 degrees (at least 97%). Four satellites in two or four planes are nearly as good, with probabilities of 0.24 to 0.45, which are the alternatives to weigh with other criteria, such as the cost of launching more planes." ] }, + { + "cell_type": "markdown", + "id": "c0d1e2f3", + "metadata": {}, + "source": [ + "## Assess Robustness to Failures\n", + "\n", + "A design that needs every satellite to work is fragile. A study in which each satellite fails with a probability of 10% (`remove_failures`, drawn in each replicate from an uncertain seed, so that the satellite at the same position fails in every design) evaluates the efficient designs (by the share of points accurately sampled) in 20 replicates. The table compares their shares with and without failures, on average and in the worst 10% of the replicates (`Quantile`)." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "d1e2f3a4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-10T14:34:09.296720Z", + "iopub.status.busy": "2026-11-10T14:34:09.296542Z", + "iopub.status.idle": "2026-11-10T14:34:15.497075Z", + "shell.execute_reply": "2026-11-10T14:34:15.496146Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionaccurateaccurate p10accurate with failuresaccurate p10 with failures
design
de5bf5d3c148800 km, 60 deg FOR, SSO: 1 at 06:003.91.03.60.9
7274d007018f800 km, 60 deg FOR, SSO: 2 at 09:009.65.98.63.8
b85daf65c3a4800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...16.711.014.35.9
104e33a3c842800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac...28.624.824.411.0
33b006848799800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...31.725.026.81.8
ceabaa8327b8800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:0054.849.048.028.2
92ff9cd17e00800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...57.852.652.631.9
25d7b27dab28800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:0082.277.773.050.8
716cb479efda700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...97.295.089.979.0
679ca275c8fc800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...98.096.097.796.0
5529c21520be800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...98.096.097.896.0
de505bc89299800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...98.096.097.495.9
\n", + "
" + ], + "text/plain": [ + " description accurate \\\n", + "design \n", + "de5bf5d3c148 800 km, 60 deg FOR, SSO: 1 at 06:00 3.9 \n", + "7274d007018f 800 km, 60 deg FOR, SSO: 2 at 09:00 9.6 \n", + "b85daf65c3a4 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... 16.7 \n", + "104e33a3c842 800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac... 28.6 \n", + "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 31.7 \n", + "ceabaa8327b8 800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00 54.8 \n", + "92ff9cd17e00 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 57.8 \n", + "25d7b27dab28 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00 82.2 \n", + "716cb479efda 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... 97.2 \n", + "679ca275c8fc 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 98.0 \n", + "5529c21520be 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 98.0 \n", + "de505bc89299 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 98.0 \n", + "\n", + " accurate p10 accurate with failures accurate p10 with failures \n", + "design \n", + "de5bf5d3c148 1.0 3.6 0.9 \n", + "7274d007018f 5.9 8.6 3.8 \n", + "b85daf65c3a4 11.0 14.3 5.9 \n", + "104e33a3c842 24.8 24.4 11.0 \n", + "33b006848799 25.0 26.8 1.8 \n", + "ceabaa8327b8 49.0 48.0 28.2 \n", + "92ff9cd17e00 52.6 52.6 31.9 \n", + "25d7b27dab28 77.7 73.0 50.8 \n", + "716cb479efda 95.0 89.9 79.0 \n", + "679ca275c8fc 96.0 97.7 96.0 \n", + "5529c21520be 96.0 97.8 96.0 \n", + "de505bc89299 96.0 97.4 95.9 " + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "robust_designs = [by_key[key] for key in accuracy.design[accuracy.pareto]]\n", + "failing = make_study(replicates=20, failure_probability=0.1).run(robust_designs)\n", + "nominal = make_study(replicates=20).run(robust_designs)\n", + "STATS = {\"accurate\": \"accurate\", \"accurate p10\": Quantile(\"accurate\", 0.1)}\n", + "robustness = aggregate(nominal, STATS).set_index(\"design\")[list(STATS)].join(\n", + " aggregate(failing, STATS).set_index(\"design\")[list(STATS)].add_suffix(\" with failures\")\n", + ")\n", + "robustness.insert(0, \"description\", [describe(values.loc[key]) for key in robustness.index])\n", + "robustness.sort_values(\"accurate\").round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "e2f3a4b5", + "metadata": {}, + "source": [ + "Designs that are equally accurate without failures differ with them. Nine satellites in three planes hardly change (98% accurate, and at least 96% in the worst 10% of the replicates), as the failure of a satellite leaves others in its plane. Six satellites in three planes lose 7 points on average, and four in two sun-synchronous planes 9 points, with as little as 51% in the worst 10% of the replicates. Two satellites in two planes lose 5 points on average, but nearly everything in the worst replicates, in which one of the two fails. The worst case, as a quantile over replicates with failures, is a criterion for the robustness of a design that its mean hides." + ] + }, { "cell_type": "markdown", "id": "c5d4e7f6", @@ -1640,14 +2428,14 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 15, "id": "d6e5f8a7", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T06:10:04.807818Z", - "iopub.status.busy": "2026-11-10T06:10:04.807567Z", - "iopub.status.idle": "2026-11-10T06:10:18.896857Z", - "shell.execute_reply": "2026-11-10T06:10:18.895863Z" + "iopub.execute_input": "2026-11-10T14:34:15.498765Z", + "iopub.status.busy": "2026-11-10T14:34:15.498582Z", + "iopub.status.idle": "2026-11-10T14:34:19.927627Z", + "shell.execute_reply": "2026-11-10T14:34:19.926602Z" } }, "outputs": [ @@ -1746,7 +2534,7 @@ "3 24.8 " ] }, - "execution_count": 10, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -1803,14 +2591,14 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 16, "id": "a9b8c1d0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T06:10:18.898579Z", - "iopub.status.busy": "2026-11-10T06:10:18.898397Z", - "iopub.status.idle": "2026-11-10T06:10:23.607284Z", - "shell.execute_reply": "2026-11-10T06:10:23.606387Z" + "iopub.execute_input": "2026-11-10T14:34:19.929324Z", + "iopub.status.busy": "2026-11-10T14:34:19.929141Z", + "iopub.status.idle": "2026-11-10T14:34:20.778477Z", + "shell.execute_reply": "2026-11-10T14:34:20.777554Z" } }, "outputs": [ @@ -1866,7 +2654,7 @@ "Latin hypercube sample 176.0 80.3" ] }, - "execution_count": 11, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -1917,14 +2705,14 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 17, "id": "b0c9d2e1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T06:10:23.609165Z", - "iopub.status.busy": "2026-11-10T06:10:23.608983Z", - "iopub.status.idle": "2026-11-10T06:10:23.736655Z", - "shell.execute_reply": "2026-11-10T06:10:23.735823Z" + "iopub.execute_input": "2026-11-10T14:34:20.780108Z", + "iopub.status.busy": "2026-11-10T14:34:20.779926Z", + "iopub.status.idle": "2026-11-10T14:34:20.903110Z", + "shell.execute_reply": "2026-11-10T14:34:20.902151Z" } }, "outputs": [ @@ -1973,13 +2761,14 @@ "## Summary\n", "\n", "* A `DesignSpace` declares a hierarchical trade space, with choices between alternatives (`Choice`), repeated elements such as orbit planes (`Repeat`), bounds that depend on other variables, constraints that measure their violation, and uncertain parameters (`Uncertain`) drawn for each replicate. Building blocks declare common constellation layouts (`walker_space` and `sso_planes_space`) and build their satellites with instruments or entries of the instrument catalog (`build_constellation`).\n", - "* A `Study` evaluates designs in replicates, in parallel, with a `SatelliteCache` that analyzes each distinct satellite once. Every design of a space of about a thousand designs can be evaluated in minutes.\n", + "* A `Study` evaluates designs in replicates, in parallel, with a `SatelliteCache` that analyzes each distinct satellite once and a `ResultStore` that keeps its evaluations. Every design of a space of about a thousand designs can be evaluated in minutes.\n", + "* Statistical sufficiency is measured by the sampling error of the statistic that observations estimate (`tatc.analysis.estimate_sampling_error`), which counts of samples overstate when samples cluster in time, as they do in a single plane; revisit statistics and local time coverage explain it.\n", "* The front of the means of the replicates is uncertain: `pareto_probability` finds the designs whose efficiency the replicates settle, and those that are equally good candidates, and `refine` adds replicates only to the latter, with a tolerance of differences that do not matter.\n", - "* Statistics other than means (such as a `Quantile` or the `Probability` of meeting a threshold) state how reliably a design performs, and `Requirement`s on them are output constraints.\n", + "* Statistics other than means (such as a `Quantile` or the `Probability` of meeting a threshold) state how reliably a design performs, including with failures of satellites (`remove_failures`), and `Requirement`s on them are output constraints. `sensitivity` finds the design variables that drive each objective.\n", "* `screen` evaluates every design with a cheap study and the best with the full one, which finds the front at a fraction of the cost if the cheap study ranks designs as the full one does.\n", "* `optimize_optuna` and `optimize_pymoo` search spaces too large to enumerate, and find most of the front with a fraction of the designs.\n", "\n", - "The objectives here are geometric: the share of points observed at least four times a day, and the numbers of satellites and planes as proxies of cost. The uncertainty is that of the sample of points; other uncertainties (such as the phase of the satellites or the period of the analysis) are further `Uncertain` parameters of the design space." + "The sampling error here is that of a model of the field (an exponential correlation in time with a decorrelation time of 3 hours); with a simulation of the field (a nature run), `tatc.analysis.sample_field` and `compare_sampled_means` measure it directly. The numbers of satellites and planes are proxies of cost. The uncertainties are those of the sample of points and the failures of satellites; others (such as the phase of the satellites or the period of the analysis) are further `Uncertain` parameters of the design space." ] } ], diff --git a/src/tatc/analysis/__init__.py b/src/tatc/analysis/__init__.py index e3dae03c..d254d61e 100644 --- a/src/tatc/analysis/__init__.py +++ b/src/tatc/analysis/__init__.py @@ -58,6 +58,14 @@ from .space_sampling import ( collect_space_observations, ) +from .sufficiency import ( + compare_sampled_means, + compute_local_time_coverage, + compute_revisit_statistics, + estimate_sampling_error, + sample_field, + sampling_error_variance, +) __all__ = [ "DopMethod", @@ -79,18 +87,24 @@ "collect_region_observations", "collect_ro_observations", "collect_space_observations", + "compare_sampled_means", "compute_access_periods", "compute_dop", "compute_ground_track", "compute_latencies", + "compute_local_time_coverage", "compute_platform_track", - "compute_sample_sizes", "compute_radar_track", "compute_region_access_periods", + "compute_revisit_statistics", + "compute_sample_sizes", + "estimate_sampling_error", "find_coincident_ground_track", "find_coincident_observations", "grid_latencies", "grid_observations", "reduce_latencies", "reduce_observations", + "sample_field", + "sampling_error_variance", ] diff --git a/src/tatc/analysis/sufficiency.py b/src/tatc/analysis/sufficiency.py new file mode 100644 index 00000000..b6bf5e36 --- /dev/null +++ b/src/tatc/analysis/sufficiency.py @@ -0,0 +1,497 @@ +""" +Methods to assess the statistical sufficiency of observations: how well the +samples of a target (such as a point) estimate a statistic of a varying +field, and how their times are distributed. + +Observations sample a field (such as precipitation or temperature) at +discrete times, from which a statistic (such as the mean over a month) is +estimated. Its error depends on how many samples there are, and on how they +are spread in time relative to how quickly the field decorrelates: samples +closer together than the decorrelation time repeat each other. The error +can be estimated for a model of the field (`estimate_sampling_error`) or +measured against a simulation of it (a nature run, see `sample_field` and +`compare_sampled_means`). The distribution of the samples in time +(`compute_revisit_statistics`) and in local time of day +(`compute_local_time_coverage`, for fields with daily cycles) explains it. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +from collections.abc import Mapping, Sequence +from datetime import datetime, timedelta +from typing import Any + +import geopandas as gpd +import numpy as np +import pandas as pd + +from ..utils.geometry import _hash_geometries + + +def _get_points(geometries: gpd.GeoSeries) -> tuple[np.ndarray, np.ndarray]: + """ + Gets the longitudes and latitudes (degrees) of geometries: points, or the + representative points of other geometries. + """ + points = geometries.representative_point() + return points.x.to_numpy(), points.y.to_numpy() + + +def _get_seconds(times: pd.Series | pd.Index, origin: datetime) -> np.ndarray: + """ + Gets times as seconds after an origin. + """ + times = pd.DatetimeIndex(pd.to_datetime(times, utc=True)) + return np.asarray((times - pd.Timestamp(origin)).total_seconds(), dtype=float) + + +def _get_targets( + observations: pd.DataFrame, targets: gpd.GeoDataFrame | gpd.GeoSeries | None +) -> gpd.GeoDataFrame: + """ + Gets the targets: those given (identified by the hash of their geometry), + or those observed. + """ + if targets is None: + first = observations.drop_duplicates("target_hash") + return gpd.GeoDataFrame( + {"target_hash": first["target_hash"].to_numpy()}, + geometry=first.geometry.to_numpy(), + crs="EPSG:4326", + ) + geometry = targets if isinstance(targets, gpd.GeoSeries) else targets.geometry + return gpd.GeoDataFrame( + {"target_hash": _hash_geometries(geometry)}, + geometry=geometry.to_numpy(), + crs="EPSG:4326", + ) + + +def _exponential_integral(t: np.ndarray, length: float, scale: float) -> np.ndarray: + """ + Integrates the exponential correlation exp(-|t - s| / scale) over s in + [0, length], for each time t. + """ + inside = (t >= 0) & (t <= length) + before = np.exp(-np.abs(t) / scale) - np.exp(-np.abs(length - t) / scale) + within = 2 - np.exp(-t / scale) - np.exp(-(length - t) / scale) + return scale * np.where(inside, within, np.abs(before)) + + +def sampling_error_variance( + times: Sequence[float] | np.ndarray, + length: float, + decorrelation_time: float, +) -> float: + """ + Computes the variance (as a share of the variance of the field) of the + error of estimating the mean of a field over a period from its samples + at given times: the mean of the samples, compared with the mean over the + period. The field is stationary, with an exponential correlation in time + (`exp(-|dt| / decorrelation_time)`, a first-order Markov process), for + which the variance is exact: + + var(e) / var(x) = (1/n^2) sum_ij r(t_i - t_j) + - (2/(n L)) sum_i integral_0^L r(t_i - s) ds + + (1/L^2) integral_0^L integral_0^L r(s - s') ds ds' + + Samples farther apart than the decorrelation time are nearly independent, + and the variance approaches 1/n; samples closer together repeat each + other, and the variance falls less. + + Args: + times (Sequence[float]): The times of the samples (seconds after the + start of the period). + length (float): The length of the period (seconds). + decorrelation_time (float): The decorrelation time (seconds). + + Returns: + float: the variance of the error, as a share of the field's variance + (`NaN` without samples) + """ + return _error_terms(times, length, decorrelation_time)[1] + + +def _error_terms( + times: Sequence[float] | np.ndarray, length: float, decorrelation_time: float +) -> tuple[float, float]: + """ + Computes the mean correlation between pairs of samples (the variance of + their mean, as a share of the field's) and the variance of the sampling + error (see `sampling_error_variance`). + """ + t = np.asarray(times, dtype=float) + if len(t) == 0: + return np.nan, np.nan + if length <= 0 or decorrelation_time <= 0: + raise ValueError("the length and decorrelation time must be positive") + scale = decorrelation_time + pairs = np.exp(-np.abs(t[:, None] - t[None, :]) / scale).mean() + cross = _exponential_integral(t, length, scale).sum() / (len(t) * length) + within = 2 * (scale * length - scale**2 * (1 - np.exp(-length / scale))) / length**2 + return float(pairs), float(max(pairs - 2 * cross + within, 0.0)) + + +def estimate_sampling_error( + observations: gpd.GeoDataFrame, + start: datetime, + end: datetime, + decorrelation_time: timedelta, + standard_deviation: float | Mapping[str, float] | pd.Series = 1.0, + targets: gpd.GeoDataFrame | gpd.GeoSeries | None = None, + time_column: str = "epoch", +) -> gpd.GeoDataFrame: + """ + Estimates the sampling error of each target: the error of estimating the + mean of a field over a period from the target's samples (observations) + for a model of the field, stationary with a standard deviation and an + exponential correlation in time with a decorrelation time (see + `sampling_error_variance`). The decorrelation time of a field is the time + over which its values become nearly independent: hours for convective + precipitation, days for synoptic temperature. + + Gives for each target the number of `samples`, the standard deviation of + the error (`sampling_error`, in the units of the field's standard + deviation), the error relative to the field's standard deviation + (`relative_error`), and the effective number of independent samples + (`effective_samples`): the number of independent samples whose mean + would vary as much as the mean of the samples (the inverse of the mean + correlation between pairs of samples), which equals the number of + samples if they are farther apart than the decorrelation time, and is + less if they repeat each other. Targets without samples have no error + estimate (`NaN`) and no effective samples. + + Args: + observations (geopandas.GeoDataFrame): The observations (see + `collect_observations`), with the `target_hash` and the time + (`time_column`) of each sample. + start (datetime.datetime): The start of the period. + end (datetime.datetime): The end of the period. + decorrelation_time (datetime.timedelta): The decorrelation time of the + field. + standard_deviation (float | Mapping | pandas.Series): The standard + deviation of the field, or of each target (by `target_hash`). + targets (geopandas.GeoDataFrame | geopandas.GeoSeries | None): The + targets, including those not observed, or `None` for those + observed. + time_column (str): The column of the times of the samples. + + Returns: + geopandas.GeoDataFrame: a row per target + """ + length = (end - start).total_seconds() + scale = decorrelation_time.total_seconds() + result = _get_targets(observations, targets) + seconds = pd.Series( + _get_seconds(observations[time_column], start), index=observations.index + ) + groups = seconds.groupby(observations["target_hash"].to_numpy()) + terms = { + key: _error_terms(group.to_numpy(), length, scale) for key, group in groups + } + variance = {key: value[1] for key, value in terms.items()} + correlation = {key: value[0] for key, value in terms.items()} + counts = groups.size() + result["samples"] = result["target_hash"].map(counts).fillna(0).astype(int) + relative_variance = result["target_hash"].map(variance).astype(float) + if isinstance(standard_deviation, (Mapping, pd.Series)): + sigma = result["target_hash"].map(standard_deviation).astype(float) + else: + sigma = float(standard_deviation) + result["relative_error"] = np.sqrt(relative_variance) + result["sampling_error"] = result["relative_error"] * sigma + result["effective_samples"] = ( + 1 / result["target_hash"].map(correlation).astype(float) + ).fillna(0.0) + return result + + +def compute_revisit_statistics( + observations: gpd.GeoDataFrame, + start: datetime, + end: datetime, + quantiles: Sequence[float] = (0.5, 0.9), + targets: gpd.GeoDataFrame | gpd.GeoSeries | None = None, + time_column: str = "epoch", +) -> gpd.GeoDataFrame: + """ + Computes statistics of the revisits of each target over a period: the + number of `samples`, the mean and quantiles of the times between + consecutive samples (`revisit`, and `revisit p50`, `revisit p90`, ...), + and the longest time without a sample (`max_gap`), including the times + from the start of the period to the first sample and from the last + sample to the end, which a mean revisit hides. Targets without samples + have a gap of the whole period. + + Args: + observations (geopandas.GeoDataFrame): The observations (see + `collect_observations`), with the `target_hash` and the time + (`time_column`) of each sample. + start (datetime.datetime): The start of the period. + end (datetime.datetime): The end of the period. + quantiles (Sequence[float]): The quantiles of the revisits. + targets (geopandas.GeoDataFrame | geopandas.GeoSeries | None): The + targets, including those not observed, or `None` for those + observed. + time_column (str): The column of the times of the samples. + + Returns: + geopandas.GeoDataFrame: a row per target + """ + length = (end - start).total_seconds() + result = _get_targets(observations, targets) + seconds = pd.Series( + _get_seconds(observations[time_column], start), index=observations.index + ) + rows = {} + for key, group in seconds.groupby(observations["target_hash"].to_numpy()): + t = np.sort(group.to_numpy()) + gaps = np.diff(t) + edges = np.diff(np.concatenate([[0.0], t, [length]])) + row = { + "samples": len(t), + "revisit": gaps.mean() if len(gaps) else np.nan, + "max_gap": edges.max(), + } + for q in quantiles: + row[f"revisit p{round(100 * q)}"] = ( + np.quantile(gaps, q) if len(gaps) else np.nan + ) + rows[key] = row + table = pd.DataFrame.from_dict(rows, orient="index") + columns = ["samples", "revisit"] + [f"revisit p{round(100 * q)}" for q in quantiles] + for column in columns + ["max_gap"]: + values = ( + result["target_hash"].map(table[column]) + if column in table + else pd.Series(np.nan, index=result.index) + ) + result[column] = values + result["samples"] = result["samples"].fillna(0).astype(int) + result["max_gap"] = result["max_gap"].fillna(length) + for column in columns[1:] + ["max_gap"]: + result[column] = pd.to_timedelta(result[column], unit="s") + return result + + +def compute_local_time_coverage( + observations: gpd.GeoDataFrame, + bins: int = 8, + targets: gpd.GeoDataFrame | gpd.GeoSeries | None = None, + time_column: str = "epoch", +) -> gpd.GeoDataFrame: + """ + Computes the distribution of the samples of each target in local (mean + solar) time of day, which a field with a daily cycle (such as convective + precipitation, or land surface temperature) needs to be sampled across: + the number of samples in each of `bins` equal intervals of the day (`local + 00:00`, ...), the number of intervals sampled (`local_bins_sampled`), and + their share (`local_time_coverage`). The local time of a sample is the + universal time plus the target's longitude (15 degrees per hour). + + Args: + observations (geopandas.GeoDataFrame): The observations (see + `collect_observations`), with the `target_hash` and the time + (`time_column`) of each sample. + bins (int): The number of intervals of the day. + targets (geopandas.GeoDataFrame | geopandas.GeoSeries | None): The + targets, including those not observed, or `None` for those + observed. + time_column (str): The column of the times of the samples. + + Returns: + geopandas.GeoDataFrame: a row per target + """ + if bins < 1: + raise ValueError("bins must be at least 1") + result = _get_targets(observations, targets) + longitude, _ = _get_points(observations.geometry) + times = pd.to_datetime(observations[time_column], utc=True) + hours = ( + times.dt.hour + times.dt.minute / 60 + times.dt.second / 3600 + ).to_numpy() + longitude / 15 + index = np.floor((hours % 24) / (24 / bins)).astype(int) % bins + counts = ( + pd.crosstab(observations["target_hash"].to_numpy(), index) + .reindex(columns=range(bins), fill_value=0) + .reindex(result["target_hash"], fill_value=0) + ) + width = 24 / bins + for k in range(bins): + hour = k * width + label = f"local {int(hour):02d}:{round(60 * (hour % 1)):02d}" + result[label] = counts[k].to_numpy() + sampled = (counts.to_numpy() > 0).sum(axis=1) + result["local_bins_sampled"] = sampled + result["local_time_coverage"] = sampled / bins + return result + + +def _get_dimension(field: Any, names: Sequence[str], given: str | None) -> str: + """Gets the name of a dimension of a field.""" + if given is not None: + return given + for name in names: + if name in field.dims: + return name + raise ValueError(f"the field has no dimension named any of {list(names)}") + + +def _field_times(field: Any, dimension: str, times: pd.Series) -> np.ndarray: + """ + Converts times to those of the time coordinate of a field: naive (UTC) if + the field's are. + """ + times = pd.to_datetime(times, utc=True) + if getattr(field[dimension].dtype, "tz", None) is None: + times = times.dt.tz_convert("UTC").dt.tz_localize(None) + return times.to_numpy() + + +def _field_longitudes(field: Any, dimension: str, longitude: np.ndarray) -> np.ndarray: + """ + Converts longitudes to the convention of a field: [0, 360) if its + longitudes exceed 180 degrees, else [-180, 180). + """ + if float(field[dimension].max()) > 180: + return np.mod(longitude, 360) + return (longitude + 180) % 360 - 180 + + +def sample_field( + observations: gpd.GeoDataFrame, + field: Any, + name: str | None = None, + method: str = "nearest", + time_column: str = "epoch", + dimensions: Mapping[str, str] | None = None, +) -> gpd.GeoDataFrame: + """ + Samples a field (such as a variable of a nature run) at the time and place + of each observation: at its point (or the representative point of its + region), by the nearest value or by linear interpolation in time and + space. Observations outside the period of the field have no value + (`NaN`). Requires xarray. + + Args: + observations (geopandas.GeoDataFrame): The observations, with the time + (`time_column`) of each sample. + field (xarray.DataArray): The field, with dimensions of time, + latitude, and longitude (by default named `time`, `lat` or + `latitude`, and `lon` or `longitude`), in degrees, with longitudes + in [-180, 180) or [0, 360). + name (str | None): The column of the sampled values, or `None` for the + field's name (or `"value"`). + method (str): `"nearest"` or `"linear"`. + time_column (str): The column of the times of the samples. + dimensions (Mapping[str, str] | None): The names of the field's + dimensions of `time`, `lat`, and `lon`, if not the defaults. + + Returns: + geopandas.GeoDataFrame: the observations, with the sampled values + """ + # pylint: disable=import-outside-toplevel + import xarray as xr + + if method not in ("nearest", "linear"): + raise ValueError(f"method must be 'nearest' or 'linear', not {method!r}") + dimensions = dict(dimensions or {}) + time_dim = _get_dimension(field, ["time"], dimensions.get("time")) + lat_dim = _get_dimension(field, ["lat", "latitude"], dimensions.get("lat")) + lon_dim = _get_dimension(field, ["lon", "longitude"], dimensions.get("lon")) + name = name or field.name or "value" + result = observations.copy() + if len(observations) == 0: + result[name] = pd.Series(dtype=float) + return result + longitude, latitude = _get_points(observations.geometry) + where = { + time_dim: xr.DataArray( + _field_times(field, time_dim, observations[time_column]), dims="sample" + ), + lat_dim: xr.DataArray(latitude, dims="sample"), + lon_dim: xr.DataArray( + _field_longitudes(field, lon_dim, longitude), dims="sample" + ), + } + if method == "nearest": + values = field.sel(where, method="nearest").to_numpy().astype(float) + times = where[time_dim].to_numpy() + coordinate = field[time_dim].to_numpy() + outside = (times < coordinate.min()) | (times > coordinate.max()) + values[outside] = np.nan + else: + values = field.interp(where).to_numpy().astype(float) + result[name] = values + return result + + +def compare_sampled_means( + sampled: gpd.GeoDataFrame, + field: Any, + start: datetime, + end: datetime, + name: str | None = None, + targets: gpd.GeoDataFrame | gpd.GeoSeries | None = None, + method: str = "nearest", + dimensions: Mapping[str, str] | None = None, +) -> gpd.GeoDataFrame: + """ + Compares the mean of each target's samples of a field (see + `sample_field`) with the true mean of the field at the target over a + period (the mean of its values at the target's place, nearest or + interpolated, at every time of the field in the period): the number of + `samples`, the `sampled_mean`, the `true_mean`, and the `error` (sampled + less true), which measures the sampling error against a simulation of + the field. Targets without samples have no sampled mean (`NaN`). Requires + xarray. + + Args: + sampled (geopandas.GeoDataFrame): The observations with sampled + values. + field (xarray.DataArray): The field (see `sample_field`). + start (datetime.datetime): The start of the period. + end (datetime.datetime): The end of the period. + name (str | None): The column of the sampled values, or `None` for the + field's name (or `"value"`). + targets (geopandas.GeoDataFrame | geopandas.GeoSeries | None): The + targets, including those not observed, or `None` for those + observed. + method (str): `"nearest"` or `"linear"`, for the field at the targets. + dimensions (Mapping[str, str] | None): The names of the field's + dimensions of `time`, `lat`, and `lon`, if not the defaults. + + Returns: + geopandas.GeoDataFrame: a row per target + """ + # pylint: disable=import-outside-toplevel + import xarray as xr + + name = name or field.name or "value" + dimensions = dict(dimensions or {}) + time_dim = _get_dimension(field, ["time"], dimensions.get("time")) + lat_dim = _get_dimension(field, ["lat", "latitude"], dimensions.get("lat")) + lon_dim = _get_dimension(field, ["lon", "longitude"], dimensions.get("lon")) + result = _get_targets(sampled, targets) + window = _field_times(field, time_dim, pd.Series([start, end])) + period = field.sel({time_dim: slice(window[0], window[1])}) + longitude, latitude = _get_points(result.geometry) + where = { + lat_dim: xr.DataArray(latitude, dims="target"), + lon_dim: xr.DataArray( + _field_longitudes(field, lon_dim, longitude), dims="target" + ), + } + at_targets = ( + period.sel(where, method="nearest") + if method == "nearest" + else period.interp(where) + ) + result["true_mean"] = at_targets.mean(dim=time_dim).to_numpy().astype(float) + groups = sampled.groupby("target_hash")[name] + result["samples"] = result["target_hash"].map(groups.count()).fillna(0).astype(int) + result["sampled_mean"] = result["target_hash"].map(groups.mean()).astype(float) + result["error"] = result["sampled_mean"] - result["true_mean"] + return result diff --git a/src/tatc/tradespace/__init__.py b/src/tatc/tradespace/__init__.py index 221c14a5..a62d38ef 100644 --- a/src/tatc/tradespace/__init__.py +++ b/src/tatc/tradespace/__init__.py @@ -4,7 +4,8 @@ trade studies that evaluate their designs (with caches of analyses by satellite, in parallel), statistics of replicates and requirements on them, Pareto efficiency (with the uncertainty of replicates), -adaptive replication, screening with analyses of increasing fidelity, +adaptive replication, persistent stores of results, sensitivity analysis, +screening with analyses of increasing fidelity, and searches with optimizers (Optuna and pymoo, optional dependencies). @author: Paul T. Grogan @@ -16,6 +17,7 @@ count_planes, count_satellites, hours_to_time, + remove_failures, sso_planes_space, walker_space, ) @@ -39,6 +41,7 @@ from .pareto import hypervolume, pareto_front, pareto_probability, pareto_ranks from .refinement import Refinement, refine from .screening import Screening, screen +from .sensitivity import main_effects, sensitivity from .nodes import ( Categorical, Choice, @@ -52,6 +55,7 @@ Variable, ) from .space import Design, DesignSpace +from .store import ResultStore from .study import Study, summarize from .values import ChoiceValues, RepeatValues, Scope, Values @@ -76,6 +80,7 @@ "Repeat", "RepeatValues", "Requirement", + "ResultStore", "SatelliteCache", "Scope", "Screening", @@ -92,6 +97,7 @@ "get_satellite_key", "hours_to_time", "hypervolume", + "main_effects", "make_pymoo_problem", "optimize_optuna", "optimize_pymoo", @@ -99,7 +105,9 @@ "pareto_probability", "pareto_ranks", "refine", + "remove_failures", "screen", + "sensitivity", "sso_planes_space", "summarize", "walker_space", diff --git a/src/tatc/tradespace/cache.py b/src/tatc/tradespace/cache.py index 9f330318..9f9062d0 100644 --- a/src/tatc/tradespace/cache.py +++ b/src/tatc/tradespace/cache.py @@ -171,7 +171,8 @@ def get(self, satellite: Satellite) -> Any: def __call__(self, satellites: Satellite | Iterable[Satellite]) -> Any: """ Gets the results of satellites, concatenated if they are data frames - (or the list of results otherwise). + (or the list of results otherwise), or an empty data frame if there are + no satellites. Args: satellites (Satellite | Iterable[Satellite]): The satellites. @@ -182,6 +183,9 @@ def __call__(self, satellites: Satellite | Iterable[Satellite]) -> Any: if isinstance(satellites, Satellite): satellites = [satellites] results = [self.get(satellite) for satellite in satellites] + if not results: + # no satellites (such as if all fail): an empty frame + return pd.DataFrame() if results and all(isinstance(result, pd.DataFrame) for result in results): non_empty = [result for result in results if len(result) > 0] if not non_empty: diff --git a/src/tatc/tradespace/constellations.py b/src/tatc/tradespace/constellations.py index 00c93747..1ff02300 100644 --- a/src/tatc/tradespace/constellations.py +++ b/src/tatc/tradespace/constellations.py @@ -31,6 +31,8 @@ def build(d): from datetime import datetime, time from typing import Any +import numpy as np + from ..schemas import ( CircularOrbit, Instrument, @@ -345,3 +347,35 @@ def build_constellation( _make_satellite(payload, f"{name} {p + 1}-{s + 1}", orbit, time_step) ) return satellites + + +def remove_failures( + satellites: Sequence[Satellite], probability: float, seed: int | None +) -> list[Satellite]: + """ + Removes the satellites that fail, each with a probability, for the + robustness of a design to failures: drawn for each replicate from an + uncertain seed (see `Uncertain.seed`). Whether a satellite fails depends + only on the seed and its position in the list, so that with common + random numbers, the satellite at the same position fails in the same + replicate of every design. + + Args: + satellites (Sequence[Satellite]): The satellites, in the order they + are built. + probability (float): The probability that a satellite fails. + seed (int | None): The seed of the replicate, or `None` (as before a + design is realized) for no failures. + + Returns: + list[Satellite]: the satellites that do not fail + """ + if not 0 <= probability <= 1: + raise ValueError("probability must be between 0 and 1") + if seed is None or probability == 0: + return list(satellites) + return [ + satellite + for k, satellite in enumerate(satellites) + if np.random.default_rng([seed, k]).random() >= probability + ] diff --git a/src/tatc/tradespace/nodes.py b/src/tatc/tradespace/nodes.py index f07902f1..387d6c13 100644 --- a/src/tatc/tradespace/nodes.py +++ b/src/tatc/tradespace/nodes.py @@ -319,6 +319,17 @@ def normal(cls, mean: float, std: float) -> Uncertain: """ return cls(lambda rng: float(rng.normal(mean, std))) + @classmethod + def seed(cls) -> Uncertain: + """ + An uncertain seed of random numbers (an integer), for randomness that + a build or evaluation function draws itself, such as a sample of + targets or the failures of satellites (see `remove_failures`). With + common random numbers, every design draws the same seed in the same + replicate. + """ + return cls(lambda rng: int(rng.integers(2**31)), None) + @classmethod def choice(cls, options: Sequence, p: Sequence[float] | None = None) -> Uncertain: """ diff --git a/src/tatc/tradespace/pareto.py b/src/tatc/tradespace/pareto.py index 5feb746b..77a659bc 100644 --- a/src/tatc/tradespace/pareto.py +++ b/src/tatc/tradespace/pareto.py @@ -64,17 +64,34 @@ def _get_costs(frame: pd.DataFrame, objectives: Objectives) -> np.ndarray: return costs +Tolerance = float | str +"""A tolerance of an objective: a value in its units, or a share of its value +(a string of a percentage, such as `"5%"`).""" + + def _get_tolerances( - objectives: Objectives, tolerance: Mapping[str, float] | None + objectives: Objectives, tolerance: Mapping[str, Tolerance] | None ) -> np.ndarray: """ - Gets the tolerances of the objectives (zero if not given). + Gets the tolerances of the objectives (zero if not given): their absolute + values (first row) and their shares of the values of the objectives + (second row). """ tolerance = tolerance or {} unknown = set(tolerance) - set(objectives) if unknown: raise ValueError(f"tolerances of columns that are not objectives: {unknown}") - values = np.array([float(tolerance.get(column, 0.0)) for column in objectives]) + values = np.zeros((2, len(objectives))) + for i, column in enumerate(objectives): + value = tolerance.get(column, 0.0) + if isinstance(value, str): + if not value.strip().endswith("%"): + raise ValueError( + f"a tolerance string must be a percentage, not {value!r}" + ) + values[1, i] = float(value.strip()[:-1]) / 100 + else: + values[0, i] = float(value) if np.any(values < 0): raise ValueError("tolerances must not be negative") return values @@ -86,15 +103,18 @@ def _dominated( """ Finds the points (rows of costs) dominated by another, even if the other is penalized by the tolerances: no worse in every cost, and better in at - least one, by at least its tolerance. + least one, by at least its tolerance (absolute, plus a share of the + magnitude of the cost of the point it would dominate, see + `_get_tolerances`). """ n = len(costs) - tolerances = np.zeros(costs.shape[1]) if tolerances is None else tolerances + tolerances = np.zeros((2, costs.shape[1])) if tolerances is None else tolerances + absolute, relative = tolerances dominated = np.zeros(n, dtype=bool) for start in range(0, n, block): part = costs[start : start + block] # [i, j]: point j dominates point i of the block - penalized = costs[None, :, :] + tolerances + penalized = costs[None, :, :] + absolute + relative * np.abs(part[:, None, :]) no_worse = np.all(penalized <= part[:, None, :], axis=2) better = np.any(penalized < part[:, None, :], axis=2) dominated[start : start + block] = np.any(no_worse & better, axis=1) @@ -104,7 +124,7 @@ def _dominated( def pareto_front( frame: pd.DataFrame, objectives: Objectives, - tolerance: Mapping[str, float] | None = None, + tolerance: Mapping[str, Tolerance] | None = None, ) -> pd.Series: """ Finds the Pareto-efficient (non-dominated) rows of a data frame: those @@ -114,7 +134,9 @@ def pareto_front( With a `tolerance` of an objective, a row dominates another only if it would still dominate it if it were worse by the tolerance in that - objective. Rows within the tolerances of the front (that no other row is + objective: a value in the objective's units, or a share of the other + row's value (a percentage, such as `"5%"`), which suits objectives that + range over orders of magnitude. Rows within the tolerances of the front (that no other row is clearly better than) are then efficient as well, which suits objectives estimated with an uncertainty (such as a few standard errors of their means, see `summarize`), or by a cheaper analysis (see `screen`). @@ -123,8 +145,9 @@ def pareto_front( frame (pandas.DataFrame): The rows (such as designs). objectives (Mapping[str, str]): The objectives: columns and their directions (`"min"` or `"max"`). - tolerance (Mapping[str, float] | None): The tolerances of objectives - (by column, zero if not given). + tolerance (Mapping[str, float | str] | None): The tolerances of + objectives (by column, zero if not given): values, or + percentages of values (such as `"5%"`). Returns: pandas.Series: whether each row is efficient (boolean, with the @@ -140,7 +163,7 @@ def pareto_front( def pareto_ranks( frame: pd.DataFrame, objectives: Objectives, - tolerance: Mapping[str, float] | None = None, + tolerance: Mapping[str, Tolerance] | None = None, ) -> pd.Series: """ Ranks the rows of a data frame by non-dominated sorting: rank 0 is the @@ -151,8 +174,9 @@ def pareto_ranks( frame (pandas.DataFrame): The rows (such as designs). objectives (Mapping[str, str]): The objectives: columns and their directions (`"min"` or `"max"`). - tolerance (Mapping[str, float] | None): The tolerances of objectives - (by column, zero if not given). + tolerance (Mapping[str, float | str] | None): The tolerances of + objectives (by column, zero if not given): values, or + percentages of values (such as `"5%"`). Returns: pandas.Series: the rank of each row (with the frame's index) @@ -246,7 +270,7 @@ def pareto_probability( seed: int = 0, statistics: Mapping[str, Statistic | str] | None = None, requirements: Sequence[Requirement] = (), - tolerance: Mapping[str, float] | None = None, + tolerance: Mapping[str, Tolerance] | None = None, ) -> pd.DataFrame: """ Estimates the probability that each design is Pareto-efficient (and @@ -286,8 +310,9 @@ def pareto_probability( statistics (Mapping[str, Statistic | str] | None): Statistics, by name, of objectives and requirements that are not means. requirements (Sequence[Requirement]): Requirements on statistics. - tolerance (Mapping[str, float] | None): The tolerances of objectives - (by name, zero if not given). + tolerance (Mapping[str, float | str] | None): The tolerances of + objectives (by name, zero if not given): values, or percentages of + values (such as `"5%"`). Returns: pandas.DataFrame: a row per design (and group): the statistics of diff --git a/src/tatc/tradespace/refinement.py b/src/tatc/tradespace/refinement.py index d3e26a9e..101f7247 100644 --- a/src/tatc/tradespace/refinement.py +++ b/src/tatc/tradespace/refinement.py @@ -56,7 +56,7 @@ def refine( max_rounds: int = 10, n_resamples: int = 500, seed: int = 0, - tolerance: Mapping[str, float] | None = None, + tolerance: Mapping[str, float | str] | None = None, ) -> Refinement: """ Adds replicates to the designs whose Pareto efficiency is uncertain, @@ -99,8 +99,9 @@ def refine( max_rounds (int): The most rounds. n_resamples (int): The number of resamples of each bootstrap. seed (int): The seed of the bootstraps. - tolerance (Mapping[str, float] | None): The tolerances of objectives - (by name, zero if not given, see `pareto_front`). + tolerance (Mapping[str, float | str] | None): The tolerances of + objectives (by name, zero if not given): values, or percentages of + values (such as `"5%"`, see `pareto_front`). Returns: Refinement: the results, the final probabilities, and the history diff --git a/src/tatc/tradespace/sensitivity.py b/src/tatc/tradespace/sensitivity.py new file mode 100644 index 00000000..8cd9fb83 --- /dev/null +++ b/src/tatc/tradespace/sensitivity.py @@ -0,0 +1,107 @@ +""" +Sensitivity of the metrics of designs to their design variables: which +decisions drive which outcomes, from the designs of a study (an enumeration, +or a sample such as a Latin hypercube). + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +from collections.abc import Sequence + +import numpy as np +import pandas as pd + + +def _levels(values: pd.Series, max_levels: int) -> pd.Series: + """ + Gets the levels of a variable: its values, or (for a numeric variable + with more than `max_levels` values) equal-count bins of them. + """ + if pd.api.types.is_numeric_dtype(values) and values.nunique() > max_levels: + return pd.qcut(values, max_levels, duplicates="drop").astype(str) + return values + + +def main_effects( + frame: pd.DataFrame, variable: str, metric: str, max_levels: int = 10 +) -> pd.DataFrame: + """ + Computes the main effects of a design variable on a metric: the mean (and + standard deviation and count) of the metric over the designs at each + level of the variable, among the designs in which the variable is active + (not `NaN`, as a variable of a branch not chosen is). + + Args: + frame (pandas.DataFrame): The designs, with their values (see + `Design.flat`) and metrics (such as a summary of a study, see + `summarize` or `aggregate`). + variable (str): The column of the variable. + metric (str): The column of the metric. + max_levels (int): The most levels of a numeric variable, beyond which + its values are grouped in bins of equal counts. + + Returns: + pandas.DataFrame: a row per level: the `mean`, `std`, and `count` of + the metric + """ + active = frame.dropna(subset=[variable, metric]) + levels = _levels(active[variable], max_levels) + return active.groupby(levels, sort=True)[metric].agg(["mean", "std", "count"]) + + +def sensitivity( + frame: pd.DataFrame, + variables: Sequence[str], + metrics: Sequence[str], + max_levels: int = 10, +) -> pd.DataFrame: + """ + Computes the sensitivity of metrics to design variables: for each + variable and metric, the share of the variance of the metric explained + by the levels of the variable (the correlation ratio, eta squared, of a + one-way analysis of variance), among the designs in which the variable is + active, and the share of the designs in which it is (`active`). + + A share near 1 means that the variable alone determines the metric; a + share near 0, that the metric hardly depends on it. The shares of a full + factorial enumeration are first-order effects (the shares of different + variables do not add to 1 if variables interact); those of a sample + estimate them. The shares of variables that are active in different + designs (such as those of different branches of a choice) are of + different designs, and compare how much each matters where it applies. + + Args: + frame (pandas.DataFrame): The designs, with their values (see + `Design.flat`) and metrics (such as a summary of a study, see + `summarize` or `aggregate`). + variables (Sequence[str]): The columns of the variables. + metrics (Sequence[str]): The columns of the metrics. + max_levels (int): The most levels of a numeric variable, beyond which + its values are grouped in bins of equal counts. + + Returns: + pandas.DataFrame: a row per variable: the share of each metric's + variance it explains, and the share of designs in which it is + `active`, sorted by the share of the first metric + """ + rows = [] + for variable in variables: + row: dict = {"variable": variable} + active = frame[variable].notna() + row["active"] = float(active.mean()) + for metric in metrics: + subset = frame[active & frame[metric].notna()] + values = subset[metric].astype(float) + total = float(((values - values.mean()) ** 2).sum()) + if len(subset) < 2 or total == 0: + row[metric] = np.nan + continue + levels = _levels(subset[variable], max_levels) + means = values.groupby(levels).transform("mean") + row[metric] = float(((means - values.mean()) ** 2).sum()) / total + rows.append(row) + result = pd.DataFrame(rows).set_index("variable") + result = result[[*metrics, "active"]] + return result.sort_values(metrics[0], ascending=False) if metrics else result diff --git a/src/tatc/tradespace/store.py b/src/tatc/tradespace/store.py new file mode 100644 index 00000000..61534b60 --- /dev/null +++ b/src/tatc/tradespace/store.py @@ -0,0 +1,117 @@ +""" +Persistent stores of the results of trade studies, so that a study that is +interrupted resumes where it stopped, and a study that is extended (with +more designs or replicates) evaluates only what is new. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +import os +import pickle +import sqlite3 +from collections.abc import Iterable +from contextlib import closing +from pathlib import Path + + +class ResultStore: + """ + A store of the records of the evaluations of a study (see `Study.run`), + by the key of each design and its replicate, in a SQLite database file. + + The `namespace` identifies the study: its design space's build and + evaluation functions and their fixed inputs (such as the targets and the + period of the analysis), as the records are only keyed by the namespace, + the design, and the replicate. Change it whenever the study changes. + Several studies may share a file, in their own namespaces. + + Args: + path (str | os.PathLike): The database file (created if needed). + namespace (str): An identifier of the study. + """ + + def __init__(self, path: str | os.PathLike, namespace: str): + if not namespace: + raise ValueError("a store requires a namespace") + self.path, self.namespace = Path(path), namespace + self.path.parent.mkdir(parents=True, exist_ok=True) + with closing(self._connect()) as connection: + with connection: + connection.execute( + "CREATE TABLE IF NOT EXISTS results (namespace TEXT, design TEXT, " + + "replicate INTEGER, records BLOB, " + + "PRIMARY KEY (namespace, design, replicate))" + ) + + def _connect(self) -> sqlite3.Connection: + return sqlite3.connect(self.path, timeout=60) + + def get(self, keys: Iterable[tuple[str, int]]) -> dict[tuple[str, int], list[dict]]: + """ + Gets the stored records of evaluations. + + Args: + keys (Iterable[tuple[str, int]]): The evaluations: the key of a + design and its replicate. + + Returns: + dict: the records of each stored evaluation (others are omitted) + """ + keys = list(keys) + found = {} + with closing(self._connect()) as connection: + for start in range(0, len(keys), 500): + part = keys[start : start + 500] + designs = sorted({design for design, _ in part}) + marks = ",".join("?" * len(designs)) + rows = connection.execute( + "SELECT design, replicate, records FROM results " + + f"WHERE namespace = ? AND design IN ({marks})", + [self.namespace, *designs], + ).fetchall() + wanted = set(part) + for design, replicate, blob in rows: + if (design, replicate) in wanted: + found[design, replicate] = pickle.loads(blob) + return found + + def put(self, items: Iterable[tuple[str, int, list[dict]]]) -> None: + """ + Stores the records of evaluations, replacing any stored before. + + Args: + items (Iterable[tuple[str, int, list[dict]]]): The evaluations: the + key of a design, its replicate, and its records. + """ + rows = [ + (self.namespace, design, int(replicate), pickle.dumps(records)) + for design, replicate, records in items + ] + if rows: + with closing(self._connect()) as connection: + with connection: + connection.executemany( + "INSERT OR REPLACE INTO results VALUES (?, ?, ?, ?)", rows + ) + + def __len__(self) -> int: + with closing(self._connect()) as connection: + (count,) = connection.execute( + "SELECT COUNT(*) FROM results WHERE namespace = ?", [self.namespace] + ).fetchone() + return count + + def clear(self) -> None: + """ + Removes the stored records of the namespace. + """ + with closing(self._connect()) as connection: + with connection: + connection.execute( + "DELETE FROM results WHERE namespace = ?", [self.namespace] + ) + + def __repr__(self) -> str: + return f"ResultStore({str(self.path)!r}, {self.namespace!r}: {len(self)} evaluations)" diff --git a/src/tatc/tradespace/study.py b/src/tatc/tradespace/study.py index 01048b05..e668e5ea 100644 --- a/src/tatc/tradespace/study.py +++ b/src/tatc/tradespace/study.py @@ -18,6 +18,7 @@ import pandas as pd from .space import Design, DesignSpace +from .store import ResultStore _STATUS_COLUMNS = ["design", "replicate", "feasible", "error", "seconds"] """Columns of the results of a study that are neither design values nor metrics.""" @@ -92,6 +93,10 @@ class Study: executor (concurrent.futures.Executor | None): An executor to use instead of worker processes. chunks_per_job (int): The number of chunks of evaluations per worker. + store (ResultStore | None): A store of the records of evaluations, from + which evaluations stored before are taken rather than evaluated + again, and to which new ones are added as they complete (see + `ResultStore`). """ def __init__( @@ -105,6 +110,7 @@ def __init__( n_jobs: int = 1, executor: Executor | None = None, chunks_per_job: int = 2, + store: ResultStore | None = None, ): if replicates < 1: raise ValueError("replicates must be at least 1") @@ -117,11 +123,12 @@ def __init__( self.common_random_numbers = common_random_numbers self.n_jobs, self.executor = n_jobs, executor self.chunks_per_job = chunks_per_job + self.store = store def __getstate__(self) -> dict: - # an executor is not sent to workers + # an executor and a store are not sent to workers state = self.__dict__.copy() - state["executor"] = None + state["executor"] = state["store"] = None return state def _evaluate(self, design: Design, replicate: int) -> list[dict]: @@ -175,7 +182,7 @@ def run( `DesignSpace.enumerate`). progress (Callable | None): A function called as evaluations complete with the number completed and the number of - evaluations. + evaluations (not counting those taken from the store). replicates (Iterable[int] | None): The replicates (their indices, which seed their uncertain parameters), or `None` for the study's (`range(replicates)`). @@ -201,14 +208,26 @@ def run( ) for i, design in enumerate(unique) ] - total = len(tasks) results: list[tuple[int, int, list[dict]]] = [] + if self.store is not None: + # evaluations stored before (by an interrupted or earlier run) + stored = self.store.get((d.key, replicate) for _, d, replicate in tasks) + results.extend( + (i, replicate, stored[design.key, replicate]) + for i, design, replicate in tasks + if (design.key, replicate) in stored + ) + tasks = [t for t in tasks if (t[1].key, t[2]) not in stored] + total = len(tasks) if self.executor is None and self.n_jobs == 1: for done, (i, design, replicate) in enumerate(tasks, 1): - results.append((i, replicate, self._evaluate(design, replicate))) + records = self._evaluate(design, replicate) + results.append((i, replicate, records)) + if self.store is not None: + self.store.put([(design.key, replicate, records)]) if progress is not None: progress(done, total) - else: + elif tasks: executor = self.executor or _get_executor(self.workers) n_chunks = min(total, self.workers * self.chunks_per_job) size = math.ceil(total / max(n_chunks, 1)) @@ -219,8 +238,14 @@ def run( done = 0 for future in as_completed(futures): chunk = futures[future] - for (i, _, replicate), records in zip(chunk, future.result()): + evaluated = future.result() + for (i, _, replicate), records in zip(chunk, evaluated): results.append((i, replicate, records)) + if self.store is not None: + self.store.put( + (design.key, replicate, records) + for (_, design, replicate), records in zip(chunk, evaluated) + ) done += len(chunk) if progress is not None: progress(done, total) diff --git a/tests/analysis/test_sufficiency.py b/tests/analysis/test_sufficiency.py new file mode 100644 index 00000000..ac2b3ed7 --- /dev/null +++ b/tests/analysis/test_sufficiency.py @@ -0,0 +1,225 @@ +""" +Unit tests for methods to assess the statistical sufficiency of observations. + +@author Paul T. Grogan +""" + +import importlib.util +import unittest +from datetime import datetime, timedelta, timezone + +import geopandas as gpd +import numpy as np +import pandas as pd +from shapely.geometry import Point + +from tatc.analysis import ( + compare_sampled_means, + compute_local_time_coverage, + compute_revisit_statistics, + estimate_sampling_error, + sample_field, + sampling_error_variance, +) +from tatc.utils import hash_geometry + +HAS_XARRAY = importlib.util.find_spec("xarray") is not None +START = datetime(2026, 1, 1, tzinfo=timezone.utc) +DAY = timedelta(days=1) + + +def _observations(samples): + """Observations of points (longitude, latitude) at hours after the start.""" + rows = [ + { + "geometry": Point(lon, lat), + "target_hash": hash_geometry(Point(lon, lat)), + "epoch": START + timedelta(hours=hour), + } + for (lon, lat), hours in samples.items() + for hour in hours + ] + return gpd.GeoDataFrame(rows, crs="EPSG:4326") + + +class TestSamplingErrorVariance(unittest.TestCase): + """ + Unit tests for the variance of sampling errors. + """ + + def test_limits(self): + """Independent samples give 1/n; dense samples give no error.""" + length = 1000.0 + # samples far apart relative to the decorrelation time + sparse = sampling_error_variance(np.linspace(50, 950, 10), length, 1.0) + self.assertAlmostEqual(sparse, 1 / 10, delta=0.01) + dense = sampling_error_variance(np.arange(0.5, 1000, 1.0), length, 10.0) + self.assertLess(dense, 0.001) + # a field that hardly varies over the period is estimated by one sample + self.assertLess(sampling_error_variance([500.0], length, 1e6), 0.01) + self.assertTrue(np.isnan(sampling_error_variance([], length, 1.0))) + # samples closer than the decorrelation time repeat each other + clustered = sampling_error_variance(np.linspace(0, 1, 10), length, 10.0) + self.assertGreater(clustered, 0.5) + with self.assertRaises(ValueError): + sampling_error_variance([1.0], 0, 1.0) + + def test_monte_carlo(self): + """The variance matches simulations of a first-order Markov process.""" + rng = np.random.default_rng(0) + dt, length, scale = 0.1, 48.0, 3.0 + steps = int(length / dt) + rho = np.exp(-dt / scale) + n = 4000 + x = np.empty((n, steps)) + x[:, 0] = rng.normal(size=n) + noise = rng.normal(size=(n, steps)) * np.sqrt(1 - rho**2) + for k in range(1, steps): + x[:, k] = rho * x[:, k - 1] + noise[:, k] + grid = (np.arange(steps) + 0.5) * dt + for times in ([10.0, 22.0, 34.0, 46.0], [12.0, 13.0, 14.0], [24.0]): + index = [int(t / dt) for t in times] + errors = x[:, index].mean(axis=1) - x.mean(axis=1) + expected = sampling_error_variance(grid[index], length, scale) + self.assertAlmostEqual(np.var(errors) / expected, 1, delta=0.08) + + +class TestEstimateSamplingError(unittest.TestCase): + """ + Unit tests for estimates of sampling errors. + """ + + def test_targets(self): + """Each target's error follows its samples, and unobserved targets have none.""" + observations = _observations( + {(0, 0): [2, 8, 14, 20], (10, 0): [2, 3], (20, 0): [12]} + ) + targets = gpd.GeoSeries([Point(0, 0), Point(10, 0), Point(20, 0), Point(30, 0)]) + error = estimate_sampling_error( + observations, + START, + START + DAY, + timedelta(hours=1), + standard_deviation=2.0, + targets=targets, + ) + self.assertEqual(list(error.samples), [4, 2, 1, 0]) + self.assertTrue( + error.relative_error[0] < error.relative_error[1] < error.relative_error[2] + ) + np.testing.assert_allclose( + error.sampling_error[:3], 2 * error.relative_error[:3] + ) + self.assertTrue(np.isnan(error.relative_error[3])) + self.assertEqual(error.effective_samples[3], 0) + # four samples six hours apart are nearly independent; two an hour apart are not + self.assertAlmostEqual(error.effective_samples[0], 4, delta=0.5) + self.assertLess(error.effective_samples[1], 2) + + def test_standard_deviation_by_target(self): + """The standard deviation may differ between targets.""" + observations = _observations({(0, 0): [6, 18], (10, 0): [6, 18]}) + sigma = {hash_geometry(Point(0, 0)): 1.0, hash_geometry(Point(10, 0)): 3.0} + error = estimate_sampling_error( + observations, START, START + DAY, timedelta(hours=2), sigma + ) + self.assertAlmostEqual(error.sampling_error[1], 3 * error.sampling_error[0]) + + +class TestRevisitStatistics(unittest.TestCase): + """ + Unit tests for revisit statistics. + """ + + def test_gaps(self): + """Revisits are between samples; gaps include the edges of the period.""" + observations = _observations({(0, 0): [1, 3, 11], (10, 0): [12]}) + targets = gpd.GeoSeries([Point(0, 0), Point(10, 0), Point(20, 0)]) + stats = compute_revisit_statistics( + observations, START, START + DAY, quantiles=(0.5,), targets=targets + ) + self.assertEqual(list(stats.samples), [3, 1, 0]) + self.assertEqual(stats.revisit[0], timedelta(hours=5)) + self.assertEqual(stats["revisit p50"][0], timedelta(hours=5)) + self.assertEqual(stats.max_gap[0], timedelta(hours=13)) + self.assertEqual(stats.max_gap[1], timedelta(hours=12)) + self.assertTrue(pd.isna(stats.revisit[1])) + self.assertEqual(stats.max_gap[2], DAY) + + +class TestLocalTimeCoverage(unittest.TestCase): + """ + Unit tests for local time coverage. + """ + + def test_bins(self): + """Samples are binned by local mean solar time.""" + # at 90 degrees east, local time is six hours after universal time + observations = _observations({(90, 0): [0, 1, 12], (-90, 0): [10, 22]}) + coverage = compute_local_time_coverage(observations, bins=4) + east = coverage.iloc[0] + self.assertEqual(east["local 06:00"], 2) + self.assertEqual(east["local 18:00"], 1) + self.assertEqual(east.local_bins_sampled, 2) + west = coverage.iloc[1] + # 04:00 and 16:00 local time + self.assertEqual((west["local 00:00"], west["local 12:00"]), (1, 1)) + self.assertEqual(west.local_time_coverage, 0.5) + with self.assertRaises(ValueError): + compute_local_time_coverage(observations, bins=0) + + +@unittest.skipUnless(HAS_XARRAY, "requires xarray") +class TestSampleField(unittest.TestCase): + """ + Unit tests for sampling fields. + """ + + def setUp(self): + import xarray as xr # pylint: disable=import-outside-toplevel + + times = pd.date_range("2026-01-01", periods=25, freq="h") + lat = np.arange(-10.0, 11.0, 1.0) + lon = np.arange(0.0, 360.0, 1.0) + hours = np.arange(25, dtype=float) + # a field linear in time, latitude, and longitude (0-360) + values = ( + hours[:, None, None] + 10 * lat[None, :, None] + 0.1 * lon[None, None, :] + ) + self.field = xr.DataArray( + values, + dims=("time", "lat", "lon"), + coords={"time": times, "lat": lat, "lon": lon}, + name="temperature", + ) + + def test_linear(self): + """Linear interpolation recovers a linear field, across longitude conventions.""" + observations = _observations({(10.5, 2.25): [3.5], (-20, -1): [6]}) + sampled = sample_field(observations, self.field, method="linear") + expected = [3.5 + 22.5 + 1.05, 6 - 10 + 0.1 * 340] + np.testing.assert_allclose(sampled.temperature, expected) + + def test_nearest_and_outside(self): + """Nearest values snap to the grid; times outside the field have no value.""" + observations = _observations({(10.4, 2.2): [3.4, 30]}) + sampled = sample_field(observations, self.field, name="t") + self.assertAlmostEqual(sampled.t[0], 3 + 20 + 1.0) + self.assertTrue(np.isnan(sampled.t[1])) + + def test_compare_means(self): + """Sampled means are compared with the means of the field over the period.""" + observations = _observations({(10, 2): [0, 24], (20, 0): [12]}) + sampled = sample_field(observations, self.field) + comparison = compare_sampled_means( + sampled, + self.field, + START, + START + DAY, + targets=gpd.GeoSeries([Point(10, 2), Point(20, 0), Point(30, 0)]), + ) + # the field's mean over hours 0 to 24 is its value at hour 12 + np.testing.assert_allclose(comparison.true_mean, [12 + 20 + 1, 12 + 2, 12 + 3]) + np.testing.assert_allclose(comparison.error[:2], [0, 0], atol=1e-9) + self.assertEqual(list(comparison.samples), [2, 1, 0]) + self.assertTrue(np.isnan(comparison.sampled_mean[2])) diff --git a/tests/tradespace/test_cache.py b/tests/tradespace/test_cache.py index 9b270c17..fd566545 100644 --- a/tests/tradespace/test_cache.py +++ b/tests/tradespace/test_cache.py @@ -148,6 +148,12 @@ def test_pickled_cache_is_empty(self): cache.clear() self.assertEqual((cache.hits, cache.misses), (0, 0)) + def test_no_satellites(self): + """No satellites give an empty frame.""" + result = SatelliteCache(self.analysis)([]) + self.assertIsInstance(result, pd.DataFrame) + self.assertEqual(len(result), 0) + def test_non_frame_results(self): """Results that are not data frames are listed.""" cache = SatelliteCache(lambda satellite: satellite.name) diff --git a/tests/tradespace/test_constellations.py b/tests/tradespace/test_constellations.py index 3c69e20a..394fdaaf 100644 --- a/tests/tradespace/test_constellations.py +++ b/tests/tradespace/test_constellations.py @@ -22,6 +22,7 @@ count_planes, count_satellites, hours_to_time, + remove_failures, sso_planes_space, walker_space, ) @@ -193,3 +194,43 @@ def test_hours_to_time(self): self.assertEqual(hours_to_time(15.9), time(15, 54)) self.assertEqual(hours_to_time(24.25), time(0, 15)) self.assertEqual(hours_to_time(10.9999999), time(11, 0)) + + +class TestFailures(unittest.TestCase): + """ + Unit tests for failures of satellites. + """ + + def test_remove_failures(self): + """Failures depend on the seed and position, common to every design.""" + satellites = [ + Satellite(name=f"s{k}", orbit=_orbit(), instruments=[IMAGER]) + for k in range(200) + ] + survivors = remove_failures(satellites, 0.25, seed=7) + self.assertAlmostEqual(len(survivors) / 200, 0.75, delta=0.08) + # the first 10 satellites fail alike in a design of 10 + first = {s.name for s in remove_failures(satellites[:10], 0.25, seed=7)} + self.assertEqual(first, {s.name for s in survivors if int(s.name[1:]) < 10}) + self.assertEqual(len(remove_failures(satellites, 0.25, seed=None)), 200) + self.assertEqual(remove_failures(satellites, 1.0, seed=3), []) + with self.assertRaises(ValueError): + remove_failures(satellites, 1.5, seed=3) + + def test_seed(self): + """Uncertain seeds are drawn for each replicate, common to designs.""" + space = DesignSpace(a=Integer(1, 2), seed=Uncertain.seed()) + a, b = space.enumerate() + self.assertIsNone(a.seed) + self.assertEqual(a.realize(3).seed, b.realize(3).seed) + self.assertNotEqual(a.realize(3).seed, a.realize(4).seed) + + +def _orbit(): + from tatc.schemas import ( + SunSynchronousOrbit, + ) # pylint: disable=import-outside-toplevel + + return SunSynchronousOrbit( + altitude=700e3, equator_crossing_time="10:30", epoch=EPOCH + ) diff --git a/tests/tradespace/test_pareto.py b/tests/tradespace/test_pareto.py index 9b381ac8..66d67080 100644 --- a/tests/tradespace/test_pareto.py +++ b/tests/tradespace/test_pareto.py @@ -104,6 +104,26 @@ def test_tolerance(self): pareto_front(frame, objectives, tolerance={"other": 1}) +class TestRelativeTolerance(unittest.TestCase): + """ + Unit tests for tolerances proportional to objectives. + """ + + def test_relative(self): + """A percentage tolerates differences in proportion to the values.""" + frame = pd.DataFrame({"cost": [1, 1, 2, 2], "value": [100.0, 96.0, 4.0, 3.0]}) + objectives = {"cost": "min", "value": "max"} + # 5% of 96 (4.8) tolerates 96 against 100; 5% of 3 (0.15) does not + # tolerate 3 against 4 + front = pareto_front(frame, objectives, tolerance={"value": "5%"}) + self.assertEqual(list(front), [True, True, False, False]) + # an absolute tolerance of 1 does not tolerate 96 against 100 + absolute = pareto_front(frame, objectives, tolerance={"value": 1.0}) + self.assertEqual(list(absolute), [True, False, False, False]) + with self.assertRaises(ValueError): + pareto_front(frame, objectives, tolerance={"value": "5"}) + + class TestParetoProbability(unittest.TestCase): """ Unit tests for the probability of Pareto efficiency. diff --git a/tests/tradespace/test_sensitivity.py b/tests/tradespace/test_sensitivity.py new file mode 100644 index 00000000..d2512726 --- /dev/null +++ b/tests/tradespace/test_sensitivity.py @@ -0,0 +1,57 @@ +""" +Unit tests for sensitivity analysis. + +@author Paul T. Grogan +""" + +import unittest + +import numpy as np +import pandas as pd + +from tatc.tradespace import main_effects, sensitivity + + +class TestSensitivity(unittest.TestCase): + """ + Unit tests for sensitivity analysis. + """ + + def setUp(self): + rng = np.random.default_rng(0) + a = np.repeat([1, 2, 3, 4], 50) + b = np.tile(["x", "y"], 100) + c = rng.uniform(0, 1, 200) + branch = np.where(np.arange(200) < 100, 1.0, np.nan) + self.frame = pd.DataFrame( + { + "a": a, + "b": b, + "c": c, + "branch": branch, + # a drives the metric, b a little, c not at all + "metric": 10 * a + + np.where(b == "x", 1.0, 0.0) + + rng.normal(0, 0.1, 200), + } + ) + + def test_shares(self): + """Variables that drive a metric explain most of its variance.""" + result = sensitivity(self.frame, ["a", "b", "c", "branch"], ["metric"]) + self.assertEqual(result.index[0], "a") + self.assertGreater(result.loc["a", "metric"], 0.95) + self.assertLess(result.loc["b", "metric"], 0.05) + self.assertLess(result.loc["c", "metric"], 0.1) + self.assertEqual(result.loc["branch", "active"], 0.5) + self.assertEqual(result.loc["a", "active"], 1.0) + # a variable with one level where active explains nothing within it + self.assertAlmostEqual(result.loc["branch", "metric"], 0) + + def test_main_effects(self): + """Main effects are the means of the metric at each level.""" + effects = main_effects(self.frame, "a", "metric") + np.testing.assert_allclose(effects["mean"], [10.5, 20.5, 30.5, 40.5], atol=0.1) + self.assertEqual(list(effects["count"]), [50] * 4) + binned = main_effects(self.frame, "c", "metric", max_levels=4) + self.assertEqual(len(binned), 4) diff --git a/tests/tradespace/test_store.py b/tests/tradespace/test_store.py new file mode 100644 index 00000000..4157881a --- /dev/null +++ b/tests/tradespace/test_store.py @@ -0,0 +1,97 @@ +""" +Unit tests for persistent stores of results. + +@author Paul T. Grogan +""" + +import tempfile +import unittest +from pathlib import Path + +import pandas as pd + +from tatc.tradespace import DesignSpace, Integer, ResultStore, Study, Uncertain + + +class _Interrupt(Exception): + """An interruption of a study.""" + + +class TestResultStore(unittest.TestCase): + """ + Unit tests for stores of results. + """ + + def setUp(self): + self.directory = tempfile.TemporaryDirectory() + self.path = Path(self.directory.name) / "results.sqlite" + self.space = DesignSpace(a=Integer(1, 4), noise=Uncertain.uniform(0, 1)) + self.calls = [] + + def tearDown(self): + self.directory.cleanup() + + def _study(self, store, fail_at=None, **kwargs): + def evaluate(d): + if fail_at is not None and len(self.calls) == fail_at: + raise _Interrupt() + self.calls.append((d.a, d.noise)) + return {"value": d.a + d.noise} + + return Study( + self.space, lambda d: d, evaluate, replicates=3, store=store, **kwargs + ) + + def test_store_and_get(self): + """Records are stored and retrieved by design and replicate.""" + store = ResultStore(self.path, "x") + store.put([("d1", 0, [{"value": 1}]), ("d1", 1, [{"value": 2}])]) + self.assertEqual(len(store), 2) + self.assertEqual(store.get([("d1", 1), ("d2", 0)]), {("d1", 1): [{"value": 2}]}) + other = ResultStore(self.path, "y") + self.assertEqual(len(other), 0) + store.clear() + self.assertEqual(len(store), 0) + with self.assertRaises(ValueError): + ResultStore(self.path, "") + + def test_resume(self): + """An interrupted study resumes, evaluating only what is not stored.""" + store = ResultStore(self.path, "study") + with self.assertRaises(_Interrupt): + self._study(store, fail_at=5).run() + self.assertEqual(len(store), 5) + resumed = self._study(store).run() + self.assertEqual(len(self.calls), 12) # 5 before, 7 after + complete = self._study(None).run() + columns = [c for c in complete.columns if c != "seconds"] + pd.testing.assert_frame_equal(resumed[columns], complete[columns]) + # a later run takes every evaluation from the store + self.calls.clear() + self._study(store).run() + self.assertEqual(self.calls, []) + + def test_more_replicates(self): + """Extending a study evaluates only the new replicates.""" + store = ResultStore(self.path, "study") + self._study(store).run() + self.calls.clear() + results = self._study(store).run(replicates=range(5)) + self.assertEqual(len(self.calls), 4 * 2) + self.assertEqual(len(results), 4 * 5) + + def test_parallel(self): + """Parallel studies store their evaluations as chunks complete.""" + store = ResultStore(self.path, "study") + study = Study( + self.space, + lambda d: d, + lambda d: {"value": d.a + d.noise}, + replicates=3, + store=store, + n_jobs=2, + ) + results = study.run() + self.assertEqual(len(store), 12) + again = study.run() + pd.testing.assert_frame_equal(results, again) From 8070e7336b49042074b7b4a5316859de2ae24796 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Tue, 10 Nov 2026 08:55:53 -0700 Subject: [PATCH 04/52] fix documentation build warnings Document the Variable base class of design spaces, render the sampling error formula as a literal block, add a blank line before the columns of compute_latencies, link the license and citation files by their GitHub URLs in the README, and refer to the Looking Up section of the CollectPlatformTrack example without an anchor that the documentation lacks. --- README.md | 6 +++--- docs/api_reference/tradespace.rst | 3 +++ docs/examples/CollectPlatformTrack.ipynb | 2 +- src/tatc/analysis/latency_sampling.py | 1 + src/tatc/analysis/sufficiency.py | 2 +- 5 files changed, 9 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index d1c58bf6..79e388a3 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,7 @@ [![Python Versions](https://img.shields.io/pypi/pyversions/tatc.svg)](https://pypi.org/project/tatc/) [![Unit Tests](https://github.com/code-lab-org/tatc/actions/workflows/unit-test.yml/badge.svg)](https://github.com/code-lab-org/tatc/actions/workflows/unit-test.yml) [![Documentation](https://readthedocs.org/projects/tatc/badge/?version=latest)](https://tatc.readthedocs.io) -[![License](https://img.shields.io/badge/license-BSD--3--Clause-blue.svg)](LICENSE) +[![License](https://img.shields.io/badge/license-BSD--3--Clause-blue.svg)](https://github.com/code-lab-org/tatc/blob/main/LICENSE) [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.17363628.svg)](https://doi.org/10.5281/zenodo.17363628) The Tradespace Analysis Toolkit for Constellations (TAT-C) provides low-level @@ -101,12 +101,12 @@ pylint --rcfile=.pylintrc src/tatc ## License This project is licensed under the BSD 3-Clause License — see -[LICENSE](LICENSE) for details. +[LICENSE](https://github.com/code-lab-org/tatc/blob/main/LICENSE) for details. ## Citation If you use TAT-C in your research, please cite it using the metadata in -[CITATION.cff](CITATION.cff), or the DOI badge above for the latest release. +[CITATION.cff](https://github.com/code-lab-org/tatc/blob/main/CITATION.cff), or the DOI badge above for the latest release. ## Contact diff --git a/docs/api_reference/tradespace.rst b/docs/api_reference/tradespace.rst index bba2c8b2..1612d71c 100644 --- a/docs/api_reference/tradespace.rst +++ b/docs/api_reference/tradespace.rst @@ -9,6 +9,9 @@ Design Spaces .. autoclass:: tatc.tradespace.DesignSpace :members: enumerate, size, sample, design, suggest, unit_paths, encode, decode +.. autoclass:: tatc.tradespace.Variable + :members: domain + .. autoclass:: tatc.tradespace.Real .. autoclass:: tatc.tradespace.Integer diff --git a/docs/examples/CollectPlatformTrack.ipynb b/docs/examples/CollectPlatformTrack.ipynb index 8c7e45a7..48e05a06 100644 --- a/docs/examples/CollectPlatformTrack.ipynb +++ b/docs/examples/CollectPlatformTrack.ipynb @@ -63,7 +63,7 @@ "id": "24c69568", "metadata": {}, "source": [ - "The `collect_platform_track` method computes each instrument's footprint. By default it projects onto the platform's ground elevation; pass `elevation` to use another target elevation, either below the instruments (looking down) or above them (looking up, see [Looking Up](#Looking-Up)). As in `collect_ground_track`, `instrument_index` selects one instrument of each platform (the first by default), or `None` selects all of them. Results are formatted as a flat GeoDataFrame, similar to a regular pandas DataFrame with a geospatial column labeled `geometry`. Other columns:\n", + "The `collect_platform_track` method computes each instrument's footprint. By default it projects onto the platform's ground elevation; pass `elevation` to use another target elevation, either below the instruments (looking down) or above them (looking up, see the section Looking Up below). As in `collect_ground_track`, `instrument_index` selects one instrument of each platform (the first by default), or `None` selects all of them. Results are formatted as a flat GeoDataFrame, similar to a regular pandas DataFrame with a geospatial column labeled `geometry`. Other columns:\n", " * `platform`: platform name\n", " * `instrument`: instrument name\n", " * `elevation`: target elevation (m) onto which the footprint is projected" diff --git a/src/tatc/analysis/latency_sampling.py b/src/tatc/analysis/latency_sampling.py index 56b52e85..19dfcbd9 100644 --- a/src/tatc/analysis/latency_sampling.py +++ b/src/tatc/analysis/latency_sampling.py @@ -150,6 +150,7 @@ def compute_latencies( Returns: geopandas.GeoDataFrame: The data frame of collected latency results, sorted by the 'observed' column in ascending order. It includes the following columns: + - 'target_hash' (str): Hash of the observation point (see `tatc.utils.geometry.hash_geometry`). - 'geometry' (geometry): Geometry representing the observation point. diff --git a/src/tatc/analysis/sufficiency.py b/src/tatc/analysis/sufficiency.py index b6bf5e36..37892972 100644 --- a/src/tatc/analysis/sufficiency.py +++ b/src/tatc/analysis/sufficiency.py @@ -91,7 +91,7 @@ def sampling_error_variance( at given times: the mean of the samples, compared with the mean over the period. The field is stationary, with an exponential correlation in time (`exp(-|dt| / decorrelation_time)`, a first-order Markov process), for - which the variance is exact: + which the variance is exact:: var(e) / var(x) = (1/n^2) sum_ij r(t_i - t_j) - (2/(n L)) sum_i integral_0^L r(t_i - s) ds From f574ef3eacb472701ab147425a1ca84f8b50e5df Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Tue, 10 Nov 2026 11:51:53 -0700 Subject: [PATCH 05/52] add IMERG validation of sampling error estimates and per-target decorrelation times --- CHANGELOG.md | 2 +- .../ValidateSamplingErrorIMERG.ipynb | 1031 +++++++++++++++++ docs/validation/index.rst | 3 +- docs/validation/summary.rst | 15 + src/tatc/analysis/sufficiency.py | 22 +- tests/analysis/test_sufficiency.py | 22 + 6 files changed, 1088 insertions(+), 7 deletions(-) create mode 100644 docs/validation/ValidateSamplingErrorIMERG.ipynb diff --git a/CHANGELOG.md b/CHANGELOG.md index e5c60118..bf09f7c2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,7 +10,7 @@ Added: - Field `type` of a catalog configuration's `attitude` (`attitude`, `glint`, or `target`), which builds an `Attitude`, `GlintAttitude`, or `TargetAttitude`, as for OCO-2's glint mode. - Field `blind_intervals` of `Attitude`: intervals of argument of latitude in which a space system's instruments do not observe, for example while the body or a mechanism moves. Observations in them are not valid, so point observations, ground tracks (`valid_obs`, and the swaths of `compute_ground_track`), orbit tracks, and ground pixels omit them, and the periods and swaths of region observations end at them. Method `is_observing` of attitudes, schedules, and instruments. - Field `type` (`instrument`, `pointed`, or `conical`) of `Instrument`, `PointedInstrument`, and `ConicalInstrument`, which identifies the instrument class in serialized data. Data without a `type` loads as the class its fields imply. - - Analysis methods of the statistical sufficiency of observations (module `analysis.sufficiency`): `estimate_sampling_error`, the error of estimating the mean of a field over a period from each target's samples, for a field with a standard deviation and an exponential correlation in time (exact, see `sampling_error_variance`), with the effective number of independent samples; `sample_field`, which samples a field (an xarray `DataArray`, such as a nature run) at the time and place of each observation, and `compare_sampled_means`, which measures the sampling error against it; `compute_revisit_statistics`, the quantiles of revisits and the longest gap of each target (including the edges of the period); and `compute_local_time_coverage`, the distribution of samples in local time of day. + - Analysis methods of the statistical sufficiency of observations (module `analysis.sufficiency`): `estimate_sampling_error`, the error of estimating the mean of a field over a period from each target's samples, for a field with a standard deviation and an exponential correlation in time (exact, see `sampling_error_variance`), with the effective number of independent samples; `sample_field`, which samples a field (an xarray `DataArray`, such as a nature run) at the time and place of each observation, and `compare_sampled_means`, which measures the sampling error against it; `compute_revisit_statistics`, the quantiles of revisits and the longest gap of each target (including the edges of the period); and `compute_local_time_coverage`, the distribution of samples in local time of day. The decorrelation time of `estimate_sampling_error` may differ between targets. The validation notebook `ValidateSamplingErrorIMERG` compares its predictions with the errors of monthly means of IMERG precipitation sampled by four constellation designs. - Module `tradespace` (prototype) for trade studies. A `DesignSpace` declares design variables (`Real`, `Integer`, `Categorical`), fixed and `Derived` values, and `Uncertain` parameters (drawn per replicate, not searched), grouped hierarchically with `Choice` (one of several branches) and `Repeat` (a variable number of items, such as orbit planes, optionally unordered). Bounds, derived values, and constraints are callables of the values decided before them. `DesignSpace.enumerate` gives every feasible design (a full factorial design, including variables that exist only in some designs), and `sample` a Latin hypercube or random sample. A `Design` has a `key` from its decisions and `flat` values by path, and `realize` draws a replicate's uncertain parameters, with common random numbers between designs by default. `Study` builds and evaluates designs in replicates into a data frame, recording designs that fail validation as infeasible, in worker processes with `n_jobs` (or on an `executor`); `summarize` gives the mean, standard deviation, and standard error of metrics over replicates. - Class `tradespace.SatelliteCache`, which caches an analysis of single satellites by their content (orbit, instruments, and attitude, not their name, see `get_satellite_key`), in memory or on disk, so that designs that share satellites compute their results once. - Functions `tradespace.pareto_front`, `pareto_ranks` (both with optional tolerances of objectives, within which designs near the front are efficient), and `hypervolume` (exact) of designs with several objectives to minimize or maximize, and `pareto_probability`, the probability that each design is efficient given the uncertainty of its replicates (a bootstrap that resamples the same replicates for every design). diff --git a/docs/validation/ValidateSamplingErrorIMERG.ipynb b/docs/validation/ValidateSamplingErrorIMERG.ipynb new file mode 100644 index 00000000..8bd4a2ef --- /dev/null +++ b/docs/validation/ValidateSamplingErrorIMERG.ipynb @@ -0,0 +1,1031 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c0a1b2c3", + "metadata": {}, + "source": [ + "# Sampling Error Validation: GPM IMERG\n", + "\n", + "This notebook validates TAT-C's estimate of the **sampling error** of observations (`tatc.analysis.estimate_sampling_error`): the error of estimating the mean of a varying field over a period, such as the monthly mean precipitation at a place, from the samples that a constellation observes. The estimate models the field as stationary, with a standard deviation and an exponential correlation in time (a decorrelation time), for which the variance of the error is exact. Whether real precipitation behaves enough like this model for its predictions to hold is what this notebook tests.\n", + "\n", + "The reference is the [Integrated Multi-satellitE Retrievals for GPM (IMERG)](https://gpm.nasa.gov/data/imerg) Final Run, which estimates precipitation every half-hour on a 0.1 deg grid by merging the observations of the GPM constellation. It serves as the true field: the mean of its half-hourly values over a month is the true monthly mean, and its values at the times that a constellation observes are the samples. The region is the Maritime Continent (10 deg S to 10 deg N, 95 to 115 deg E: Sumatra, Borneo, Java, and the seas between), whose land and ocean have some of the strongest daily cycles of precipitation on Earth, a hard case for a model without one.\n", + "\n", + "Four constellation designs sample the field over July 2025: the GPM Core Observatory's GMI (a precessing, 65 deg inclined orbit), one sun-synchronous ATMS-like sounder (13:30), three of them (13:30, 17:30, and 21:30), and all four together. The tests compare the predicted and actual errors of the monthly means at 1,600 points:\n", + "\n", + "* **Test 1: Field statistics.** The standard deviation and decorrelation time of the field, and how well one month predicts the next.\n", + "* **Test 2: Sampling errors.** The predicted and actual errors of each design, with the statistics of the field estimated from the previous month (June 2025), as a study would estimate them from climatology.\n", + "* **Test 3: Model inputs.** How the estimates of the statistics, and the correlation model, change the predictions.\n", + "* **Test 4: Daily cycle.** Whether the errors of sun-synchronous sampling, at fixed local times, exceed the predictions where the daily cycle is strong." + ] + }, + { + "cell_type": "markdown", + "id": "c1b2c3d4", + "metadata": {}, + "source": [ + "## Reference Data\n", + "\n", + "The IMERG Final Run half-hourly product ([`GPM_3IMERGHH`](https://disc.gsfc.nasa.gov/datasets/GPM_3IMERGHH_07/summary), version 07), distributed by the NASA Goddard Earth Sciences Data and Information Services Center (GES DISC), holds one file per half-hour with the precipitation rate (mm/h) of each 0.1 deg cell, averaged over the half-hour. Every fifth cell of the region in each direction (a 0.5 deg grid of 40 by 40 cells) is downloaded for every half-hour of June and July 2025 through the [OPeNDAP](https://opendap.earthdata.nasa.gov/) service, which subsets the files on the server (requiring a free [NASA Earthdata Login](https://urs.earthdata.nasa.gov/) account and the `earthaccess` package), and is cached in a local `data/imerg` directory (about 1 MB per month).\n", + "\n", + "The times of the half-hours are taken from the file names (the start of each half-hour), as the time variable of the subsets returned by the service repeats some values." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "c2c3d4e5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-10T16:28:05.733965Z", + "iopub.status.busy": "2026-11-10T16:28:05.733794Z", + "iopub.status.idle": "2026-11-10T16:28:08.374645Z", + "shell.execute_reply": "2026-11-10T16:28:08.373779Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "June: 1440 half-hours, mean 0.286 mm/h\n", + "July: 1488 half-hours, mean 0.200 mm/h\n" + ] + } + ], + "source": [ + "import re\n", + "from concurrent.futures import ThreadPoolExecutor\n", + "from datetime import datetime, timedelta, timezone\n", + "from pathlib import Path\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import requests\n", + "import xarray as xr\n", + "\n", + "DATA_DIR = Path(\"data\") / \"imerg\"\n", + "DATA_DIR.mkdir(parents=True, exist_ok=True)\n", + "COLLECTION = \"C2723754847-GES_DISC\" # GPM_3IMERGHH version 07\n", + "LON, LAT = \"2750:5:2949\", \"800:5:999\" # every fifth 0.1 deg cell of 95 to 115 E and 10 S to 10 N\n", + "MONTHS = {\"202506\": (\"2025-06-01\", \"2025-06-30\"), \"202507\": (\"2025-07-01\", \"2025-07-31\")}\n", + "\n", + "\n", + "def download_month(month, session):\n", + " \"\"\"Downloads the subsets of the half-hourly files of a month, with their times from the file names.\"\"\"\n", + " first, last = MONTHS[month]\n", + " names = [\n", + " item[\"umm\"][\"GranuleUR\"]\n", + " for item in requests.get(\n", + " \"https://cmr.earthdata.nasa.gov/search/granules.umm_json\",\n", + " params={\"collection_concept_id\": COLLECTION, \"temporal\": f\"{first}T00:00:00Z,{last}T23:59:59Z\", \"page_size\": 2000},\n", + " timeout=60,\n", + " ).json()[\"items\"]\n", + " ]\n", + " query = (\n", + " f\"dap4.ce=/Grid/precipitation%5B0%5D%5B{LON}%5D%5B{LAT}%5D;/Grid/lon%5B{LON}%5D;/Grid/lat%5B{LAT}%5D\"\n", + " )\n", + "\n", + " def fetch(name):\n", + " url = f\"https://opendap.earthdata.nasa.gov/collections/{COLLECTION}/granules/{name.replace(':', '%3A')}.dap.nc4?{query}\"\n", + " for attempt in range(6):\n", + " response = session.get(url, timeout=120)\n", + " if response.status_code == 200:\n", + " path = DATA_DIR / \"parts\" / f\"{name.split(':')[-1]}.nc4\"\n", + " path.parent.mkdir(exist_ok=True)\n", + " path.write_bytes(response.content)\n", + " return path\n", + " raise RuntimeError(f\"failed to download {name}\")\n", + "\n", + " with ThreadPoolExecutor(8) as pool:\n", + " paths = list(pool.map(fetch, sorted(names)))\n", + " times = [pd.Timestamp(\"T\".join(re.search(r\"\\.(\\d{8})-S(\\d{6})-E\", p.name).groups())) for p in paths]\n", + " frames = [xr.open_dataset(p, group=\"Grid\", decode_times=False).precipitation.isel(time=0).load() for p in paths]\n", + " grid = xr.concat(frames, dim=pd.Index(times, name=\"time\")).transpose(\"time\", \"lat\", \"lon\")\n", + " grid.rename(\"precipitation\").to_dataset().to_netcdf(DATA_DIR / f\"imerg_hh_{month}_maritime.nc\")\n", + "\n", + "\n", + "session = None\n", + "for month in MONTHS:\n", + " if not (DATA_DIR / f\"imerg_hh_{month}_maritime.nc\").exists():\n", + " if session is None:\n", + " import earthaccess\n", + "\n", + " earthaccess.login()\n", + " session = earthaccess.get_requests_https_session()\n", + " download_month(month, session)\n", + "\n", + "\n", + "def load_month(month):\n", + " \"\"\"The precipitation (mm/h) of a month, at the middle of each half-hour.\"\"\"\n", + " data = xr.open_dataset(DATA_DIR / f\"imerg_hh_{month}_maritime.nc\").precipitation.astype(float)\n", + " data = data.assign_coords(\n", + " time=data.time.values + np.timedelta64(15, \"m\"),\n", + " lat=data.lat.astype(float).round(2),\n", + " lon=data.lon.astype(float).round(2),\n", + " )\n", + " return data.transpose(\"time\", \"lat\", \"lon\")\n", + "\n", + "\n", + "june, july = load_month(\"202506\"), load_month(\"202507\")\n", + "START, END = datetime(2025, 7, 1, tzinfo=timezone.utc), datetime(2025, 8, 1, tzinfo=timezone.utc)\n", + "print(f\"June: {june.sizes['time']} half-hours, mean {float(june.mean()):.3f} mm/h\")\n", + "print(f\"July: {july.sizes['time']} half-hours, mean {float(july.mean()):.3f} mm/h\")" + ] + }, + { + "cell_type": "markdown", + "id": "c3d4e5f6", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "The points are the centers of the 1,600 cells, identified by the hash of their geometry, as are TAT-C's observations of them. The designs fly generated orbits (at the start of July 2025) with instruments whose fields of regard give the swaths of GMI (885 km at 407 km) and ATMS (2,600 km at 824 km). Every observation (an access period of a point) is one sample, at the middle of the access period, of the half-hour that contains it (`tatc.analysis.sample_field`)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c4e5f6a7", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-10T16:28:08.376625Z", + "iopub.status.busy": "2026-11-10T16:28:08.376213Z", + "iopub.status.idle": "2026-11-10T16:29:50.714084Z", + "shell.execute_reply": "2026-11-10T16:29:50.713349Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
satellitespoints observedmedian samplesRMS error of the monthly mean (mm/h)
GMI1.01600.022.00.219
one sun-synchronous1.01600.059.00.120
three sun-synchronous3.01600.0176.00.045
GMI + three sun-synchronous4.01600.0198.00.048
\n", + "
" + ], + "text/plain": [ + " satellites points observed median samples \\\n", + "GMI 1.0 1600.0 22.0 \n", + "one sun-synchronous 1.0 1600.0 59.0 \n", + "three sun-synchronous 3.0 1600.0 176.0 \n", + "GMI + three sun-synchronous 4.0 1600.0 198.0 \n", + "\n", + " RMS error of the monthly mean (mm/h) \n", + "GMI 0.219 \n", + "one sun-synchronous 0.120 \n", + "three sun-synchronous 0.045 \n", + "GMI + three sun-synchronous 0.048 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import geopandas as gpd\n", + "from shapely.geometry import Point\n", + "\n", + "from tatc.analysis import collect_observations, compare_sampled_means, estimate_sampling_error, sample_field\n", + "from tatc.schemas import CircularOrbit, Instrument, Satellite, SunSynchronousOrbit\n", + "from tatc.utils import hash_geometry, swath_width_to_field_of_regard\n", + "\n", + "lon, lat = np.meshgrid(july.lon.values, july.lat.values)\n", + "points = gpd.GeoDataFrame(geometry=[Point(x, y) for x, y in zip(lon.ravel(), lat.ravel())], crs=\"EPSG:4326\")\n", + "points[\"target_hash\"] = [hash_geometry(point) for point in points.geometry]\n", + "GMI = Instrument(name=\"gmi\", field_of_regard=swath_width_to_field_of_regard(407e3, 885e3))\n", + "ATMS = Instrument(name=\"atms\", field_of_regard=swath_width_to_field_of_regard(824e3, 2600e3))\n", + "\n", + "\n", + "def sounder(crossing):\n", + " \"\"\"An ATMS-like sounder in a sun-synchronous orbit with an ascending equator crossing time.\"\"\"\n", + " orbit = SunSynchronousOrbit(altitude=824e3, equator_crossing_time=crossing, epoch=START)\n", + " return Satellite(name=f\"sounder {crossing}\", orbit=orbit, instruments=[ATMS])\n", + "\n", + "\n", + "gpm = Satellite(name=\"gpm\", orbit=CircularOrbit(altitude=407e3, inclination=65, epoch=START), instruments=[GMI])\n", + "DESIGNS = {\n", + " \"GMI\": [gpm],\n", + " \"one sun-synchronous\": [sounder(\"13:30\")],\n", + " \"three sun-synchronous\": [sounder(\"13:30\"), sounder(\"17:30\"), sounder(\"21:30\")],\n", + " \"GMI + three sun-synchronous\": [gpm, sounder(\"13:30\"), sounder(\"17:30\"), sounder(\"21:30\")],\n", + "}\n", + "observations, actual = {}, {}\n", + "for name, satellites in DESIGNS.items():\n", + " observations[name] = collect_observations(points, satellites, START, END)\n", + " sampled = sample_field(observations[name], july, name=\"precipitation\")\n", + " actual[name] = compare_sampled_means(\n", + " sampled, july, START, END, name=\"precipitation\", targets=points\n", + " ).set_index(\"target_hash\")\n", + "pd.DataFrame(\n", + " {\n", + " name: {\n", + " \"satellites\": len(DESIGNS[name]),\n", + " \"points observed\": int((actual[name].samples > 0).sum()),\n", + " \"median samples\": actual[name].samples.median(),\n", + " \"RMS error of the monthly mean (mm/h)\": np.sqrt((actual[name].error ** 2).mean()),\n", + " }\n", + " for name in DESIGNS\n", + " }\n", + ").T.round(3)" + ] + }, + { + "cell_type": "markdown", + "id": "c5f6a7b8", + "metadata": {}, + "source": [ + "## Test 1: Field Statistics\n", + "\n", + "The model of the field needs its standard deviation and its decorrelation time at each point. Both are estimated from the half-hourly series of each point: the standard deviation directly, and the decorrelation time by fitting an exponential, `exp(-lag / T)`, to the autocorrelation of the anomalies (the values less the monthly mean) at lags of 0.5 to 12 hours, where the autocorrelation exceeds 0.05. The figure compares the median autocorrelation with the exponential of the median decorrelation time.\n", + "\n", + "A study estimates these statistics before the observations exist, from climatology or another period. Here, the statistics of June predict the errors of July, and the table compares the statistics of the two months: their medians, and the correlation between their values at the points. The standard deviation smoothed over neighboring points (a 2.5 deg box of 5 by 5 points) is a more robust estimate of a point's than its own month, as rain at a point in a month is dominated by a few storms." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c6a7b8c9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-10T16:29:50.716145Z", + "iopub.status.busy": "2026-11-10T16:29:50.715917Z", + "iopub.status.idle": "2026-11-10T16:29:51.012572Z", + "shell.execute_reply": "2026-11-10T16:29:51.011672Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
June (median)July (median)correlation of June and July at the points
mean0.2610.1750.245
sigma1.1160.8710.161
smoothed sigma1.2020.9220.214
decorrelation (h)2.7402.8500.265
\n", + "
" + ], + "text/plain": [ + " June (median) July (median) \\\n", + "mean 0.261 0.175 \n", + "sigma 1.116 0.871 \n", + "smoothed sigma 1.202 0.922 \n", + "decorrelation (h) 2.740 2.850 \n", + "\n", + " correlation of June and July at the points \n", + "mean 0.245 \n", + "sigma 0.161 \n", + "smoothed sigma 0.214 \n", + "decorrelation (h) 0.265 " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from scipy.ndimage import uniform_filter\n", + "\n", + "LAGS = np.arange(1, 25) # half-hours\n", + "\n", + "\n", + "def field_statistics(field):\n", + " \"\"\"The standard deviation, autocorrelation, and decorrelation time (h) of each point's half-hourly series.\"\"\"\n", + " series = field.values.reshape(field.sizes[\"time\"], -1).T # points (in the order of the points), times\n", + " anomaly = series - series.mean(axis=1, keepdims=True)\n", + " variance = anomaly.var(axis=1)\n", + " rho = np.array([(anomaly[:, :-k] * anomaly[:, k:]).mean(axis=1) / variance for k in LAGS]).T\n", + " scale = np.full(len(series), np.nan)\n", + " for i in range(len(series)):\n", + " fit = rho[i] > 0.05\n", + " x, y = LAGS[fit] * 0.5, np.log(rho[i][fit])\n", + " scale[i] = -(x @ x) / (x @ y) if fit.any() else np.nan\n", + " sigma = series.std(axis=1, ddof=1)\n", + " smooth = uniform_filter(sigma.reshape(field.sizes[\"lat\"], field.sizes[\"lon\"]), size=5, mode=\"nearest\").ravel()\n", + " stats = pd.DataFrame(\n", + " {\"mean\": series.mean(axis=1), \"sigma\": sigma, \"smoothed sigma\": smooth, \"decorrelation (h)\": scale},\n", + " index=points.target_hash,\n", + " )\n", + " return stats, rho\n", + "\n", + "\n", + "june_stats, june_rho = field_statistics(june)\n", + "july_stats, july_rho = field_statistics(july)\n", + "pd.DataFrame(\n", + " {\n", + " \"June (median)\": june_stats.median(),\n", + " \"July (median)\": july_stats.median(),\n", + " \"correlation of June and July at the points\": [\n", + " np.corrcoef(june_stats[c], july_stats[c if c != \"smoothed sigma\" else \"sigma\"])[0, 1]\n", + " if c != \"decorrelation (h)\"\n", + " else june_stats[c].corr(july_stats[c])\n", + " for c in june_stats.columns\n", + " ],\n", + " }\n", + ").round(3)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c7b8c9d0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-10T16:29:51.014228Z", + "iopub.status.busy": "2026-11-10T16:29:51.014049Z", + "iopub.status.idle": "2026-11-10T16:29:51.186838Z", + "shell.execute_reply": "2026-11-10T16:29:51.186073Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "BLUE, ORANGE, AQUA, YELLOW, GRAY, INK = \"#2a78d6\", \"#eb6834\", \"#1baf7a\", \"#eda100\", \"#8a8a86\", \"#2b2b29\"\n", + "fig, ax = plt.subplots(figsize=(8, 4))\n", + "hours = LAGS * 0.5\n", + "for rho, color, label in [(june_rho, GRAY, \"June\"), (july_rho, BLUE, \"July\")]:\n", + " ax.fill_between(hours, *np.percentile(rho, [25, 75], axis=0), color=color, alpha=0.15, lw=0)\n", + " ax.plot(hours, np.median(rho, axis=0), color=color, lw=2, label=f\"{label} (median and interquartile range)\")\n", + "scale = june_stats[\"decorrelation (h)\"].median()\n", + "ax.plot(hours, np.exp(-hours / scale), color=ORANGE, lw=2, ls=\"--\", label=f\"exponential, T = {scale:.1f} h (June)\")\n", + "ax.axhline(0, color=GRAY, lw=0.8)\n", + "ax.set(xlabel=\"Lag (hours)\", ylabel=\"Autocorrelation of anomalies\", xlim=(0, 12))\n", + "ax.grid(axis=\"y\", color=\"#e6e6e3\", lw=0.8)\n", + "for side in (\"top\", \"right\"):\n", + " ax.spines[side].set_visible(False)\n", + "ax.legend(fontsize=8, frameon=False)\n", + "ax.set_title(\"Autocorrelation of half-hourly precipitation at the 1,600 points\", fontsize=10)\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c8c9d0e1", + "metadata": {}, + "source": [ + "The decorrelation time is stable between months: 2.7 hours in June and 2.9 hours in July (medians over the points), and the exponential of June's decorrelation time follows the measured autocorrelation, though precipitation decorrelates somewhat faster (an autocorrelation of 0.42 at 2 hours in July, against 0.48 for the exponential). The standard deviation is not stable at a point: June was wetter than July (a median of 1.12 against 0.87 mm/h), and the standard deviations of the points in the two months are hardly correlated (0.16), as each month's rain at a point is dominated by a few storms. Smoothing over neighboring points raises the correlation only to 0.21, but averages out much of the noise of a single month." + ] + }, + { + "cell_type": "markdown", + "id": "c9d0e1f2", + "metadata": {}, + "source": [ + "## Test 2: Sampling Errors\n", + "\n", + "For each design, `estimate_sampling_error` predicts the error of each point's monthly mean from the times of its samples, with the statistics of June: the smoothed standard deviation of each point, and the median decorrelation time of the region. The predicted errors are standard deviations: if the model holds, the actual errors divided by the predicted ones (the standardized errors) have a root mean square of 1, and 95% of them are within 2. The table gives these, and the root mean square of the predicted and actual errors over the points. The figure compares them for groups of points with similar predicted errors (fifths of the points, by predicted error)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d0e1f2a3", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-10T16:29:51.188555Z", + "iopub.status.busy": "2026-11-10T16:29:51.188379Z", + "iopub.status.idle": "2026-11-10T16:29:52.173418Z", + "shell.execute_reply": "2026-11-10T16:29:52.172342Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
median samplesmedian effective samplespredicted RMS (mm/h)actual RMS (mm/h)RMS standardized errorwithin 2 predicted (%)
GMI22.021.7900.2510.2191.03095.250
one sun-synchronous59.057.5850.1300.1201.05294.375
three sun-synchronous176.0110.8400.0530.0451.01794.438
GMI + three sun-synchronous198.0109.0140.0550.0481.03593.875
\n", + "
" + ], + "text/plain": [ + " median samples median effective samples \\\n", + "GMI 22.0 21.790 \n", + "one sun-synchronous 59.0 57.585 \n", + "three sun-synchronous 176.0 110.840 \n", + "GMI + three sun-synchronous 198.0 109.014 \n", + "\n", + " predicted RMS (mm/h) actual RMS (mm/h) \\\n", + "GMI 0.251 0.219 \n", + "one sun-synchronous 0.130 0.120 \n", + "three sun-synchronous 0.053 0.045 \n", + "GMI + three sun-synchronous 0.055 0.048 \n", + "\n", + " RMS standardized error within 2 predicted (%) \n", + "GMI 1.030 95.250 \n", + "one sun-synchronous 1.052 94.375 \n", + "three sun-synchronous 1.017 94.438 \n", + "GMI + three sun-synchronous 1.035 93.875 " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "REGIONAL_DECORRELATION = timedelta(hours=float(june_stats[\"decorrelation (h)\"].median()))\n", + "\n", + "\n", + "def evaluate(name, decorrelation_time, standard_deviation):\n", + " \"\"\"The predicted and actual errors of the monthly means of the points observed by a design.\"\"\"\n", + " predicted = estimate_sampling_error(\n", + " observations[name], START, END, decorrelation_time, standard_deviation, targets=points\n", + " ).set_index(\"target_hash\")\n", + " merged = actual[name].join(predicted[[\"sampling_error\", \"effective_samples\"]])\n", + " merged = merged[merged.samples > 0]\n", + " merged[\"z\"] = merged.error / merged.sampling_error\n", + " return merged\n", + "\n", + "\n", + "def score(merged):\n", + " \"\"\"Summary statistics of predicted and actual errors.\"\"\"\n", + " return {\n", + " \"predicted RMS (mm/h)\": np.sqrt((merged.sampling_error**2).mean()),\n", + " \"actual RMS (mm/h)\": np.sqrt((merged.error**2).mean()),\n", + " \"RMS standardized error\": np.sqrt((merged.z**2).mean()),\n", + " \"within 2 predicted (%)\": 100 * (merged.z.abs() <= 2).mean(),\n", + " }\n", + "\n", + "\n", + "held_out = {name: evaluate(name, REGIONAL_DECORRELATION, june_stats[\"smoothed sigma\"]) for name in DESIGNS}\n", + "test2 = pd.DataFrame(\n", + " {\n", + " name: {\"median samples\": m.samples.median(), \"median effective samples\": m.effective_samples.median(), **score(m)}\n", + " for name, m in held_out.items()\n", + " }\n", + ").T\n", + "test2.round(3)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "d1f2a3b4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-10T16:29:52.175241Z", + "iopub.status.busy": "2026-11-10T16:29:52.174941Z", + "iopub.status.idle": "2026-11-10T16:29:52.473739Z", + "shell.execute_reply": "2026-11-10T16:29:52.472826Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(6, 5))\n", + "for (name, merged), color in zip(held_out.items(), (BLUE, ORANGE, AQUA, YELLOW)):\n", + " groups = merged.groupby(pd.qcut(merged.sampling_error, 5), observed=True)\n", + " predicted = groups.sampling_error.apply(lambda e: np.sqrt((e**2).mean()))\n", + " measured = groups.error.apply(lambda e: np.sqrt((e**2).mean()))\n", + " ax.plot(predicted, measured, marker=\"o\", ms=7, mec=\"white\", mew=1.2, color=color, lw=2, label=name)\n", + "limits = (0.008, 0.6)\n", + "ax.plot(limits, limits, color=GRAY, lw=1, ls=\"--\")\n", + "ax.annotate(\"predicted = actual\", (0.3, 0.3), xytext=(-20, 10), textcoords=\"offset points\", fontsize=8, color=GRAY, rotation=38)\n", + "ax.set(xscale=\"log\", yscale=\"log\", xlim=limits, ylim=limits, xlabel=\"Predicted RMS error (mm/h)\", ylabel=\"Actual RMS error (mm/h)\")\n", + "ax.grid(color=\"#e6e6e3\", lw=0.8, which=\"major\")\n", + "for side in (\"top\", \"right\"):\n", + " ax.spines[side].set_visible(False)\n", + "ax.legend(fontsize=8, frameon=False, loc=\"upper left\")\n", + "ax.set_title(\"Errors of monthly means, by fifths of predicted error\", fontsize=10)\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "d2a3b4c5", + "metadata": {}, + "source": [ + "With the statistics of June, the predicted errors of July's monthly means hold for every design: the root mean square of the standardized errors is 1.02 to 1.05, and 94 to 95% of the errors are within 2 predicted standard deviations (95% for a normal distribution). The predictions are 8 to 18% larger than the actual errors on average over the points, as June was wetter than July, which a study can only know from climatology.\n", + "\n", + "The figure shows that the predictions rank the designs correctly, by an order of magnitude from GMI alone (22 samples a month, an error of 0.22 mm/h) to three sun-synchronous satellites (176 samples, 0.045 mm/h), and capture a design's error to within its spread. Within a design, the predictions distinguish points less well: the actual errors of GMI's points hardly differ between the groups whose predicted errors differ by a factor of 2.5, as the differences between the standard deviations of the points in June do not persist in July. The model also predicts, and the samples confirm, that adding GMI to the three sun-synchronous satellites slightly increases the error of a simple mean of the samples (0.048 against 0.045 mm/h): GMI's samples add little independent information, and they weight the times of its passes more than a mean of the field does." + ] + }, + { + "cell_type": "markdown", + "id": "d3b4c5d6", + "metadata": {}, + "source": [ + "## Test 3: Model Inputs\n", + "\n", + "The predictions depend on the statistics of the field. The table gives the root mean square of the standardized errors of each design for other inputs: the statistics of each point in June (rather than smoothed or regional), one regional standard deviation, the statistics of July itself (which a study would not have), and samples taken as independent (a decorrelation time of a second, for which the error is the familiar `sigma / sqrt(n)`)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d4c5d6e7", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-10T16:29:52.475431Z", + "iopub.status.busy": "2026-11-10T16:29:52.475192Z", + "iopub.status.idle": "2026-11-10T16:29:58.713120Z", + "shell.execute_reply": "2026-11-10T16:29:58.712203Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
June, smoothed sigma (Test 2)June, each point's sigma and decorrelationJune, regional sigmaJuly, each point's sigma and decorrelationindependent samples (June, smoothed sigma)
GMI1.031.191.001.010.95
one sun-synchronous1.051.291.071.120.81
three sun-synchronous1.021.210.991.070.55
GMI + three sun-synchronous1.041.231.011.080.62
\n", + "
" + ], + "text/plain": [ + " June, smoothed sigma (Test 2) \\\n", + "GMI 1.03 \n", + "one sun-synchronous 1.05 \n", + "three sun-synchronous 1.02 \n", + "GMI + three sun-synchronous 1.04 \n", + "\n", + " June, each point's sigma and decorrelation \\\n", + "GMI 1.19 \n", + "one sun-synchronous 1.29 \n", + "three sun-synchronous 1.21 \n", + "GMI + three sun-synchronous 1.23 \n", + "\n", + " June, regional sigma \\\n", + "GMI 1.00 \n", + "one sun-synchronous 1.07 \n", + "three sun-synchronous 0.99 \n", + "GMI + three sun-synchronous 1.01 \n", + "\n", + " July, each point's sigma and decorrelation \\\n", + "GMI 1.01 \n", + "one sun-synchronous 1.12 \n", + "three sun-synchronous 1.07 \n", + "GMI + three sun-synchronous 1.08 \n", + "\n", + " independent samples (June, smoothed sigma) \n", + "GMI 0.95 \n", + "one sun-synchronous 0.81 \n", + "three sun-synchronous 0.55 \n", + "GMI + three sun-synchronous 0.62 " + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "variants = {\n", + " \"June, smoothed sigma (Test 2)\": (REGIONAL_DECORRELATION, june_stats[\"smoothed sigma\"]),\n", + " \"June, each point's sigma and decorrelation\": (\n", + " pd.to_timedelta(june_stats[\"decorrelation (h)\"].fillna(june_stats[\"decorrelation (h)\"].median()), unit=\"h\"),\n", + " june_stats.sigma,\n", + " ),\n", + " \"June, regional sigma\": (REGIONAL_DECORRELATION, float(june_stats.sigma.median())),\n", + " \"July, each point's sigma and decorrelation\": (\n", + " pd.to_timedelta(july_stats[\"decorrelation (h)\"].fillna(july_stats[\"decorrelation (h)\"].median()), unit=\"h\"),\n", + " july_stats.sigma,\n", + " ),\n", + " \"independent samples (June, smoothed sigma)\": (timedelta(seconds=1), june_stats[\"smoothed sigma\"]),\n", + "}\n", + "test3 = pd.DataFrame(\n", + " {\n", + " variant: {name: score(evaluate(name, scale, sigma))[\"RMS standardized error\"] for name in DESIGNS}\n", + " for variant, (scale, sigma) in variants.items()\n", + " }\n", + ")\n", + "test3.round(2)" + ] + }, + { + "cell_type": "markdown", + "id": "d5d6e7f8", + "metadata": {}, + "source": [ + "The inputs matter more than the details of the model. Each point's own standard deviation from June gives standardized errors of 1.19 to 1.29: the predictions are right on average but wrong at individual points, by the noise of a single month's statistics. One regional standard deviation, or the smoothed standard deviations of Test 2, give 0.99 to 1.07, as does each point's statistics from July itself (1.01 to 1.12), which a study would not have.\n", + "\n", + "Taking samples as independent (the error of a mean of `n` independent samples, `sigma / sqrt(n)`) is adequate for sparse sampling (0.95 for GMI's 22 samples a month) but overpredicts the errors of dense sampling by up to 1.8 times (0.55 for the three sun-synchronous satellites): samples within a few hours of each other repeat each other, but they also share their variations with the monthly mean that they estimate, which the exponential correlation model accounts for." + ] + }, + { + "cell_type": "markdown", + "id": "d6e7f8a9", + "metadata": {}, + "source": [ + "## Test 4: Daily Cycle\n", + "\n", + "The model's field is stationary: it has no daily cycle. Sun-synchronous satellites observe each point at nearly the same local times every day, so where precipitation has a strong daily cycle, their samples repeat the same phase of it, and the error of the mean has a systematic part (a bias) that the model does not predict. The daily cycle of each point is its mean precipitation in each 3-hour interval of local (mean solar) time in July, and its strength is the range of these means relative to the monthly mean. The table gives, for thirds of the points by the strength of their daily cycle, the root mean square of the standardized errors of each design (as in Test 2), and the mean error of the single sun-synchronous design relative to the mean precipitation." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d7f8a9b0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-10T16:29:58.714807Z", + "iopub.status.busy": "2026-11-10T16:29:58.714632Z", + "iopub.status.idle": "2026-11-10T16:29:58.907962Z", + "shell.execute_reply": "2026-11-10T16:29:58.907051Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
daily range / mean (median)GMIone sun-synchronousthree sun-synchronousGMI + three sun-synchronousone sun-synchronous: mean error (% of mean)
weak1.381.050.911.061.083.39
moderate2.020.850.960.930.911.80
strong2.921.161.251.051.112.99
\n", + "
" + ], + "text/plain": [ + " daily range / mean (median) GMI one sun-synchronous \\\n", + "weak 1.38 1.05 0.91 \n", + "moderate 2.02 0.85 0.96 \n", + "strong 2.92 1.16 1.25 \n", + "\n", + " three sun-synchronous GMI + three sun-synchronous \\\n", + "weak 1.06 1.08 \n", + "moderate 0.93 0.91 \n", + "strong 1.05 1.11 \n", + "\n", + " one sun-synchronous: mean error (% of mean) \n", + "weak 3.39 \n", + "moderate 1.80 \n", + "strong 2.99 " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "series = july.values.reshape(july.sizes[\"time\"], -1).T\n", + "utc_hours = july.time.dt.hour.values + july.time.dt.minute.values / 60\n", + "local_bin = (((utc_hours[None, :] + points.geometry.x.values[:, None] / 15) % 24) // 3).astype(int)\n", + "cycle = np.array([[series[i, local_bin[i] == b].mean() for b in range(8)] for i in range(len(points))])\n", + "strength = pd.Series((cycle.max(axis=1) - cycle.min(axis=1)) / series.mean(axis=1), index=points.target_hash)\n", + "band = pd.qcut(strength, 3, labels=[\"weak\", \"moderate\", \"strong\"])\n", + "test4 = pd.DataFrame(\n", + " {\n", + " name: merged.groupby(band.reindex(merged.index), observed=True).z.apply(lambda z: np.sqrt((z**2).mean()))\n", + " for name, merged in held_out.items()\n", + " }\n", + ")\n", + "single = held_out[\"one sun-synchronous\"]\n", + "test4[\"one sun-synchronous: mean error (% of mean)\"] = single.groupby(band.reindex(single.index), observed=True).apply(\n", + " lambda g: 100 * g.error.mean() / g.true_mean.mean()\n", + ")\n", + "test4.insert(0, \"daily range / mean (median)\", strength.groupby(band, observed=True).median())\n", + "test4.round(2)" + ] + }, + { + "cell_type": "markdown", + "id": "d8a9b0c1", + "metadata": {}, + "source": [ + "The daily cycle is the main limit of the model. At the third of the points with the strongest daily cycles (whose 3-hourly means range over about 3 times the monthly mean), the errors of the single sun-synchronous satellite are 25% larger than predicted (1.25), and those of GMI 16% larger, whereas they are within 15% of the predictions at the other points. The satellites that sample more local times are less affected (1.05 for three sun-synchronous satellites). The single sun-synchronous satellite also overestimates the monthly means by 2 to 3% (a bias at its local times of 13:30 and 01:30), small next to its random error here (60% of the mean). A study of a design that samples a strongly cycling field at few local times should expect errors somewhat larger than predicted." + ] + }, + { + "cell_type": "markdown", + "id": "d9b0c1d2", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "| Test | Metric | Result |\n", + "|---|---|---|\n", + "| Field statistics | Decorrelation time (median, June and July) | 2.7 and 2.9 h |\n", + "| | Correlation of standard deviations of June and July at the points (each point, smoothed) | 0.16, 0.21 |\n", + "| Sampling errors (June statistics) | RMS standardized error of July's monthly means | 1.02 to 1.05 (four designs) |\n", + "| | Errors within 2 predicted standard deviations | 94 to 95% |\n", + "| | Errors of designs (actual RMS) | 0.22 mm/h (GMI, 22 samples a month) to 0.045 mm/h (three sun-synchronous, 176 samples), ranked as predicted |\n", + "| Model inputs | RMS standardized error: each point's June statistics; regional; July's | 1.19 to 1.29; 0.99 to 1.07; 1.01 to 1.12 |\n", + "| | Independent samples (`sigma / sqrt(n)`) | 0.55 to 0.95 (overpredicts dense sampling by up to 1.8 times) |\n", + "| Daily cycle | RMS standardized error at the strongest third of daily cycles | 1.25 (one sun-synchronous), 1.16 (GMI), 1.05 (three) |\n", + "| | Bias of one sun-synchronous satellite | +2 to +3% of the mean |\n", + "\n", + "TAT-C's sampling error model predicts the errors of monthly mean precipitation from real constellations' samples, given a standard deviation from another month (smoothed over neighboring points or regional) and a regional decorrelation time. Use smoothed or climatological standard deviations rather than a single month's at each point, and expect errors up to 25% larger than predicted where the field's daily cycle is strong and the design samples few local times.\n", + "\n", + "Limitations:\n", + "\n", + "* **One region and month.** The Maritime Continent in July, with convective precipitation and strong daily cycles; other fields (such as temperature) and seasons have other statistics.\n", + "* **IMERG as the truth.** IMERG's half-hourly values merge the observations of the same kinds of satellites, interpolated between them by the motion of the precipitation, which may smooth its variations within hours and lengthen its decorrelation time.\n", + "* **Temporal sampling only.** Each sample is the value of a 0.1 deg cell in its half-hour: the footprints of the instruments, the times within the half-hour, and the errors of the retrievals are not modeled." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/validation/index.rst b/docs/validation/index.rst index b8f0a090..283f5aef 100644 --- a/docs/validation/index.rst +++ b/docs/validation/index.rst @@ -31,6 +31,7 @@ The following compare TAT-C analysis results with reference data from operationa ValidateConicalGMI.ipynb ValidateCoincidenceGMIAMSR2.ipynb ValidateGridSMAP.ipynb + ValidateSamplingErrorIMERG.ipynb ValidateOrbitGeneration.ipynb ValidateDopGNSS.ipynb ValidateLatencyNOAA20.ipynb @@ -48,7 +49,7 @@ The following compare TAT-C analysis results with reference data from operationa ValidateSampleSizes.ipynb ValidateFeaturesTCPRIMED.ipynb -These notebooks download reference data on first run, except ``ValidateSampleSizes``, which reuses the data of the imager and conical scanner notebooks, and ``ValidateSpaceCOSMIC2``, which reuses the data of ``ValidateROCOSMIC2``. ``ValidateSpaceSOCRATES`` includes a sample of a SOCRATES run (data from CelesTrak). The MLS, NISAR, AMSR2, GMI, SWOT, ICESat-2, ECOSTRESS, PACE, MODIS, OCO-2, GPM, GRACE-FO, and SMAP data require a free `NASA Earthdata Login `_ account, and the orbit histories of the Landsat 9, TC PRIMED, and GRACE-FO notebooks a free `Space-Track.org `_ account. The notebooks require additional dependencies, which can be installed via:: +These notebooks download reference data on first run, except ``ValidateSampleSizes``, which reuses the data of the imager and conical scanner notebooks, and ``ValidateSpaceCOSMIC2``, which reuses the data of ``ValidateROCOSMIC2``. ``ValidateSpaceSOCRATES`` includes a sample of a SOCRATES run (data from CelesTrak). The MLS, NISAR, AMSR2, GMI, SWOT, ICESat-2, ECOSTRESS, PACE, MODIS, OCO-2, GPM, GRACE-FO, SMAP, and IMERG data require a free `NASA Earthdata Login `_ account, and the orbit histories of the Landsat 9, TC PRIMED, and GRACE-FO notebooks a free `Space-Track.org `_ account. The notebooks require additional dependencies, which can be installed via:: pip install tatc[validation] diff --git a/docs/validation/summary.rst b/docs/validation/summary.rst index 53ce2072..6aec5fa2 100644 --- a/docs/validation/summary.rst +++ b/docs/validation/summary.rst @@ -197,6 +197,12 @@ Coverage Analyses - GMI and AMSR2 within 15 minutes - With `instantaneous=True`, 97.7% of true coincidences found and 99.9% of those found true, within 2.4 s (95th percentile); 98.2% of coincident points within coincident footprints (:doc:`ValidateCoincidenceGMIAMSR2`) + * - Sampling error (`estimate_sampling_error`) + - IMERG half-hourly precipitation, Maritime Continent, July 2025; four constellation designs + - With the statistics of June, errors of July's monthly means at 1,600 points as predicted (RMS standardized + errors 1.02 to 1.05; 94 to 95% within 2 predicted standard deviations); designs ranked by an order of magnitude, + as predicted; independent samples (`sigma / sqrt(n)`) overpredict dense sampling by up to 1.8 times + (:doc:`ValidateSamplingErrorIMERG`) Limb, Occultation, and Satellite-to-Satellite Analyses ====================================================== @@ -287,6 +293,11 @@ numerical error in TAT-C: 5 deg reproduces the acquisitions of sun-synchronous land imagers. * **Coincidences of samples.** Observation periods of scanning instruments last minutes; compare their epochs with `instantaneous=True`. +* **Statistics of sampled fields.** A single month's standard deviation of + precipitation at a point predicts the next month's poorly (a correlation of + 0.16); smoothed or regional standard deviations, from climatology or another + period, give calibrated sampling errors, and one regional decorrelation time + suffices. * **Navigation constellations.** Model the operational satellites (those with healthy broadcast ephemerides); public TLE groups include others, which make DOP 4 to 16% optimistic. @@ -302,6 +313,10 @@ Not Modeled * Pointing limits in `collect_space_observations`, such as an antenna's field of view, and slews between attitudes, which are instantaneous. * Acquisition plans, downlink processing time, and data gaps. +* Daily cycles of sampled fields: sampling errors model a stationary field, so + sun-synchronous sampling of a field with a strong daily cycle has errors up + to 25% larger than predicted, and a small bias (2 to 3% for IMERG + precipitation over the Maritime Continent). Changes to TAT-C from Validation ================================ diff --git a/src/tatc/analysis/sufficiency.py b/src/tatc/analysis/sufficiency.py index 37892972..6e489352 100644 --- a/src/tatc/analysis/sufficiency.py +++ b/src/tatc/analysis/sufficiency.py @@ -138,7 +138,7 @@ def estimate_sampling_error( observations: gpd.GeoDataFrame, start: datetime, end: datetime, - decorrelation_time: timedelta, + decorrelation_time: timedelta | Mapping[str, timedelta] | pd.Series, standard_deviation: float | Mapping[str, float] | pd.Series = 1.0, targets: gpd.GeoDataFrame | gpd.GeoSeries | None = None, time_column: str = "epoch", @@ -169,8 +169,10 @@ def estimate_sampling_error( (`time_column`) of each sample. start (datetime.datetime): The start of the period. end (datetime.datetime): The end of the period. - decorrelation_time (datetime.timedelta): The decorrelation time of the - field. + decorrelation_time (datetime.timedelta | Mapping | pandas.Series): The + decorrelation time of the field, or of each target (by + `target_hash`), as for a field that decorrelates faster in some + places (such as over land) than others. standard_deviation (float | Mapping | pandas.Series): The standard deviation of the field, or of each target (by `target_hash`). targets (geopandas.GeoDataFrame | geopandas.GeoSeries | None): The @@ -182,14 +184,24 @@ def estimate_sampling_error( geopandas.GeoDataFrame: a row per target """ length = (end - start).total_seconds() - scale = decorrelation_time.total_seconds() + if isinstance(decorrelation_time, (Mapping, pd.Series)): + scales = { + key: pd.Timedelta(value).total_seconds() + for key, value in dict(decorrelation_time).items() + } + else: + scales = None + scale = decorrelation_time.total_seconds() result = _get_targets(observations, targets) seconds = pd.Series( _get_seconds(observations[time_column], start), index=observations.index ) groups = seconds.groupby(observations["target_hash"].to_numpy()) terms = { - key: _error_terms(group.to_numpy(), length, scale) for key, group in groups + key: _error_terms( + group.to_numpy(), length, scale if scales is None else scales[key] + ) + for key, group in groups } variance = {key: value[1] for key, value in terms.items()} correlation = {key: value[0] for key, value in terms.items()} diff --git a/tests/analysis/test_sufficiency.py b/tests/analysis/test_sufficiency.py index ac2b3ed7..d7a3de93 100644 --- a/tests/analysis/test_sufficiency.py +++ b/tests/analysis/test_sufficiency.py @@ -126,6 +126,28 @@ def test_standard_deviation_by_target(self): self.assertAlmostEqual(error.sampling_error[1], 3 * error.sampling_error[0]) +class TestDecorrelationByTarget(unittest.TestCase): + """ + Unit tests for decorrelation times of each target. + """ + + def test_by_target(self): + """Each target may have its own decorrelation time.""" + observations = _observations({(0, 0): [6, 7], (10, 0): [6, 7]}) + scales = { + hash_geometry(Point(0, 0)): timedelta(minutes=10), + hash_geometry(Point(10, 0)): timedelta(hours=10), + } + error = estimate_sampling_error(observations, START, START + DAY, scales) + # samples an hour apart are independent for the shorter decorrelation time + self.assertAlmostEqual(error.effective_samples[0], 2, delta=0.01) + self.assertLess(error.effective_samples[1], 1.2) + single = estimate_sampling_error( + observations, START, START + DAY, timedelta(minutes=10) + ) + self.assertAlmostEqual(single.relative_error[0], error.relative_error[0]) + + class TestRevisitStatistics(unittest.TestCase): """ Unit tests for revisit statistics. From 86c376abc902ed0a71bf9ae41aca37862ff54638 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Tue, 10 Nov 2026 21:24:03 -0700 Subject: [PATCH 06/52] key stored results by study fingerprints, add confirmation with new replicates, minimum replicates of refinement, and adjusted sensitivity --- CHANGELOG.md | 1 + docs/api_reference/tradespace.rst | 14 +- docs/examples/SearchTradeSpace.ipynb | 675 ++++++++++++++++++++++---- src/tatc/tradespace/__init__.py | 8 +- src/tatc/tradespace/cache.py | 17 +- src/tatc/tradespace/confirmation.py | 153 ++++++ src/tatc/tradespace/fingerprint.py | 234 +++++++++ src/tatc/tradespace/refinement.py | 59 ++- src/tatc/tradespace/sensitivity.py | 30 +- src/tatc/tradespace/store.py | 69 ++- src/tatc/tradespace/study.py | 51 +- tests/tradespace/test_cache.py | 14 + tests/tradespace/test_confirmation.py | 102 ++++ tests/tradespace/test_fingerprint.py | 140 ++++++ tests/tradespace/test_refinement.py | 51 ++ tests/tradespace/test_sensitivity.py | 24 + tests/tradespace/test_store.py | 45 +- 17 files changed, 1548 insertions(+), 139 deletions(-) create mode 100644 src/tatc/tradespace/confirmation.py create mode 100644 src/tatc/tradespace/fingerprint.py create mode 100644 tests/tradespace/test_confirmation.py create mode 100644 tests/tradespace/test_fingerprint.py diff --git a/CHANGELOG.md b/CHANGELOG.md index e41d4557..5c695c6a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -20,6 +20,7 @@ Added: - Building blocks of constellations: fragments of design spaces of Walker constellations (`tradespace.walker_space`) and planes of sun-synchronous orbits (`sso_planes_space`, whose planes have different crossing times), `build_constellation`, which builds the satellites of either with instruments or entries of the instrument catalog (with their validated attitudes, and several entries on one satellite), and `count_satellites` and `count_planes`. - Function `tradespace.screen` (and class `Screening`), which screens designs with studies of increasing fidelity, keeping whole fronts of the best designs of each stage for the next. - Searches of design spaces with optional optimizers: `tradespace.optimize_optuna` suggests designs with Optuna trials (`DesignSpace.suggest`, define-by-run over the hierarchical space), and `optimize_pymoo` and `make_pymoo_problem` search the unit hypercube that encodes a design space (`DesignSpace.unit_paths`, `encode`, and `decode`) with pymoo. Each design is evaluated once, and the designs proposed together are evaluated together, in parallel if the study is. Constraints of a design space may return the amount of their violation (`Infeasible.violation`), which Optuna's trials record (`set_constraint`) for its constraint-aware samplers, and which is the constraint value of pymoo problems. Optional dependencies `tradespace` (joblib, Optuna, and pymoo). + - Function `tradespace.confirm` (and class `Confirmation`), which evaluates selected designs (such as a front) with new replicates that played no part in their selection, removing the optimism of the selection (the winner's curse, `Confirmation.optimism`). `ResultStore` keys evaluations by the fingerprint of a study (`Study.fingerprint`, see `get_fingerprint`: its seed, use of common random numbers, design space, and build and evaluation functions, and the version of TAT-C), warning if it holds evaluations of other definitions, which are not reused; `SatelliteCache` keys results on disk by the fingerprint of its function. `refine` treats designs with fewer than `min_replicates` (5) as uncertain whatever their probability, adds the replicates left to `max_replicates` in a last partial step, and warns if designs remain uncertain without a tolerance. `sensitivity` gives adjusted shares (epsilon squared) by default, without the share that the levels of a variable explain by chance (`adjusted=False` for correlation ratios). - Example `SearchTradeSpace`, which searches a hierarchical trade space of constellations for the designs that sample points sufficiently: by evaluating every design, ranking them with the uncertainty of their replicates, screening, and searching with Optuna and pymoo. - The `RunOSSEMonsoon` example declares its constellation trade as a design space, caches the looks of each satellite, evaluates its replicates in parallel, and finds its Pareto-efficient designs. diff --git a/docs/api_reference/tradespace.rst b/docs/api_reference/tradespace.rst index 1612d71c..1d28b133 100644 --- a/docs/api_reference/tradespace.rst +++ b/docs/api_reference/tradespace.rst @@ -71,7 +71,7 @@ Trade Studies ------------- .. autoclass:: tatc.tradespace.Study - :members: run, workers + :members: run, workers, fingerprint .. autofunction:: tatc.tradespace.summarize @@ -105,7 +105,9 @@ Stores of Results ----------------- .. autoclass:: tatc.tradespace.ResultStore - :members: get, put, clear + :members: get, put, contexts, clear + +.. autofunction:: tatc.tradespace.get_fingerprint Caches ------ @@ -137,6 +139,14 @@ Adaptive Replication .. autoclass:: tatc.tradespace.Refinement :members: uncertain +Confirmation +------------ + +.. autofunction:: tatc.tradespace.confirm + +.. autoclass:: tatc.tradespace.Confirmation + :members: optimism + Sensitivity ----------- diff --git a/docs/examples/SearchTradeSpace.ipynb b/docs/examples/SearchTradeSpace.ipynb index 2a9e59b3..62345cf9 100644 --- a/docs/examples/SearchTradeSpace.ipynb +++ b/docs/examples/SearchTradeSpace.ipynb @@ -28,10 +28,10 @@ "id": "c3d2e5f4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T14:23:18.993844Z", - "iopub.status.busy": "2026-11-10T14:23:18.993609Z", - "iopub.status.idle": "2026-11-10T14:23:19.706382Z", - "shell.execute_reply": "2026-11-10T14:23:19.705579Z" + "iopub.execute_input": "2026-11-11T03:30:47.336314Z", + "iopub.status.busy": "2026-11-11T03:30:47.336057Z", + "iopub.status.idle": "2026-11-11T03:30:48.389377Z", + "shell.execute_reply": "2026-11-11T03:30:48.388372Z" } }, "outputs": [], @@ -79,10 +79,10 @@ "id": "e5f4a7b6", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T14:23:19.708265Z", - "iopub.status.busy": "2026-11-10T14:23:19.707962Z", - "iopub.status.idle": "2026-11-10T14:23:20.832042Z", - "shell.execute_reply": "2026-11-10T14:23:20.831242Z" + "iopub.execute_input": "2026-11-11T03:30:48.391487Z", + "iopub.status.busy": "2026-11-11T03:30:48.391145Z", + "iopub.status.idle": "2026-11-11T03:30:49.633458Z", + "shell.execute_reply": "2026-11-11T03:30:49.632460Z" } }, "outputs": [ @@ -142,10 +142,10 @@ "id": "a7b6c9d8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T14:23:20.834188Z", - "iopub.status.busy": "2026-11-10T14:23:20.833776Z", - "iopub.status.idle": "2026-11-10T14:23:20.840749Z", - "shell.execute_reply": "2026-11-10T14:23:20.839985Z" + "iopub.execute_input": "2026-11-11T03:30:49.635457Z", + "iopub.status.busy": "2026-11-11T03:30:49.635158Z", + "iopub.status.idle": "2026-11-11T03:30:49.642567Z", + "shell.execute_reply": "2026-11-11T03:30:49.641760Z" } }, "outputs": [], @@ -224,10 +224,10 @@ "id": "c9d8e1f0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T14:23:20.842351Z", - "iopub.status.busy": "2026-11-10T14:23:20.842125Z", - "iopub.status.idle": "2026-11-10T14:23:21.183348Z", - "shell.execute_reply": "2026-11-10T14:23:21.182423Z" + "iopub.execute_input": "2026-11-11T03:30:49.644249Z", + "iopub.status.busy": "2026-11-11T03:30:49.644008Z", + "iopub.status.idle": "2026-11-11T03:31:34.138996Z", + "shell.execute_reply": "2026-11-11T03:31:34.138057Z" } }, "outputs": [ @@ -384,10 +384,10 @@ "id": "d0e9f2a1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T14:23:21.185331Z", - "iopub.status.busy": "2026-11-10T14:23:21.185054Z", - "iopub.status.idle": "2026-11-10T14:23:21.446495Z", - "shell.execute_reply": "2026-11-10T14:23:21.445410Z" + "iopub.execute_input": "2026-11-11T03:31:34.141405Z", + "iopub.status.busy": "2026-11-11T03:31:34.140980Z", + "iopub.status.idle": "2026-11-11T03:31:34.519059Z", + "shell.execute_reply": "2026-11-11T03:31:34.517870Z" } }, "outputs": [ @@ -468,10 +468,10 @@ "id": "a2b3c4d5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T14:23:21.448598Z", - "iopub.status.busy": "2026-11-10T14:23:21.448243Z", - "iopub.status.idle": "2026-11-10T14:23:21.601390Z", - "shell.execute_reply": "2026-11-10T14:23:21.600441Z" + "iopub.execute_input": "2026-11-11T03:31:34.521466Z", + "iopub.status.busy": "2026-11-11T03:31:34.521132Z", + "iopub.status.idle": "2026-11-11T03:31:34.729723Z", + "shell.execute_reply": "2026-11-11T03:31:34.728457Z" } }, "outputs": [ @@ -668,10 +668,10 @@ "id": "b3c4d5e6", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T14:23:21.603175Z", - "iopub.status.busy": "2026-11-10T14:23:21.602982Z", - "iopub.status.idle": "2026-11-10T14:23:21.794247Z", - "shell.execute_reply": "2026-11-10T14:23:21.793338Z" + "iopub.execute_input": "2026-11-11T03:31:34.732260Z", + "iopub.status.busy": "2026-11-11T03:31:34.731999Z", + "iopub.status.idle": "2026-11-11T03:31:34.943955Z", + "shell.execute_reply": "2026-11-11T03:31:34.943100Z" } }, "outputs": [ @@ -721,10 +721,10 @@ "id": "d5e6f7a8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T14:23:21.796370Z", - "iopub.status.busy": "2026-11-10T14:23:21.795998Z", - "iopub.status.idle": "2026-11-10T14:23:21.925573Z", - "shell.execute_reply": "2026-11-10T14:23:21.924719Z" + "iopub.execute_input": "2026-11-11T03:31:34.946427Z", + "iopub.status.busy": "2026-11-11T03:31:34.946141Z", + "iopub.status.idle": "2026-11-11T03:31:35.174596Z", + "shell.execute_reply": "2026-11-11T03:31:35.173717Z" } }, "outputs": [ @@ -862,7 +862,7 @@ "source": [ "## Find What Drives the Objectives\n", "\n", - "`sensitivity` gives the share of the variance of each objective (over the designs, by their means over the replicates) that each design variable explains, among the designs in which the variable is active: the variables of the Walker layout apply only to Walker designs, and those of the sun-synchronous layout only to theirs." + "`sensitivity` gives the share of the variance of each objective (over the designs, by their means over the replicates) that each design variable explains, among the designs in which the variable is active: the variables of the Walker layout apply only to Walker designs, and those of the sun-synchronous layout only to theirs. The shares are adjusted for the variance that the levels of a variable would explain by chance, which matters for samples of designs and for variables of many levels." ] }, { @@ -871,10 +871,10 @@ "id": "a8b9c0d1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T14:23:21.927361Z", - "iopub.status.busy": "2026-11-10T14:23:21.927182Z", - "iopub.status.idle": "2026-11-10T14:23:21.951726Z", - "shell.execute_reply": "2026-11-10T14:23:21.950884Z" + "iopub.execute_input": "2026-11-11T03:31:35.176631Z", + "iopub.status.busy": "2026-11-11T03:31:35.176436Z", + "iopub.status.idle": "2026-11-11T03:31:35.212416Z", + "shell.execute_reply": "2026-11-11T03:31:35.211420Z" } }, "outputs": [ @@ -944,13 +944,13 @@ " \n", " altitude\n", " 0.03\n", - " 0.04\n", + " 0.03\n", " 1.00\n", " \n", " \n", " layout.walker.relative_spacing\n", " 0.03\n", - " 0.07\n", + " 0.06\n", " 0.64\n", " \n", " \n", @@ -971,8 +971,8 @@ "layout 0.18 0.12 1.00\n", "layout.walker.planes 0.12 0.29 0.64\n", "layout.sso.planes.count 0.11 0.19 0.36\n", - "altitude 0.03 0.04 1.00\n", - "layout.walker.relative_spacing 0.03 0.07 0.64\n", + "altitude 0.03 0.03 1.00\n", + "layout.walker.relative_spacing 0.03 0.06 0.64\n", "layout.walker.inclination 0.00 0.00 0.64" ] }, @@ -1003,7 +1003,7 @@ "id": "b9c0d1e2", "metadata": {}, "source": [ - "The field of regard explains the most of both objectives (25% of their variance), as it sets the swath of every satellite. The layout matters next, but differently for the two objectives: the number of satellites in each Walker plane explains more of the share of points sufficiently sampled (22%) than of those accurately sampled (18%), and the number of Walker planes the reverse (12% and 29%), as more planes spread the samples in time. The altitude explains little of either objective (3 to 4%), although a higher orbit widens the swath: its effect is small next to those of the field of regard and the layout. The inclination explains nothing on average over the Walker designs." + "The field of regard explains the most of both objectives (25% of their variance), as it sets the swath of every satellite. The layout matters next, but differently for the two objectives: the number of satellites in each Walker plane explains more of the share of points sufficiently sampled (22%) than of those accurately sampled (18%), and the number of Walker planes the reverse (12% and 29%), as more planes spread the samples in time. The altitude explains little of either objective (3%), although a higher orbit widens the swath: its effect is small next to those of the field of regard and the layout. The inclination explains nothing on average over the Walker designs." ] }, { @@ -1022,10 +1022,10 @@ "id": "a3b2c5d4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T14:23:21.953651Z", - "iopub.status.busy": "2026-11-10T14:23:21.953354Z", - "iopub.status.idle": "2026-11-10T14:24:13.516597Z", - "shell.execute_reply": "2026-11-10T14:24:13.515732Z" + "iopub.execute_input": "2026-11-11T03:31:35.214523Z", + "iopub.status.busy": "2026-11-11T03:31:35.214231Z", + "iopub.status.idle": "2026-11-11T03:32:37.303506Z", + "shell.execute_reply": "2026-11-11T03:32:37.302802Z" } }, "outputs": [ @@ -1274,10 +1274,10 @@ "id": "b5d3f7a9", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T14:24:13.518409Z", - "iopub.status.busy": "2026-11-10T14:24:13.518224Z", - "iopub.status.idle": "2026-11-10T14:33:23.433467Z", - "shell.execute_reply": "2026-11-10T14:33:23.432618Z" + "iopub.execute_input": "2026-11-11T03:32:37.305165Z", + "iopub.status.busy": "2026-11-11T03:32:37.304909Z", + "iopub.status.idle": "2026-11-11T03:44:27.663743Z", + "shell.execute_reply": "2026-11-11T03:44:27.662985Z" } }, "outputs": [ @@ -1427,10 +1427,10 @@ "id": "c6e4a8b0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T14:33:23.435219Z", - "iopub.status.busy": "2026-11-10T14:33:23.435026Z", - "iopub.status.idle": "2026-11-10T14:33:23.493558Z", - "shell.execute_reply": "2026-11-10T14:33:23.492795Z" + "iopub.execute_input": "2026-11-11T03:44:27.665482Z", + "iopub.status.busy": "2026-11-11T03:44:27.665237Z", + "iopub.status.idle": "2026-11-11T03:44:27.722198Z", + "shell.execute_reply": "2026-11-11T03:44:27.721509Z" } }, "outputs": [ @@ -1964,6 +1964,511 @@ "Refinement adds 655 evaluations, 1.7% of those that 40 replicates of every design would take, to the few designs whose efficiency is uncertain. With the tolerance, the designs that sample nearly every point (six to nine satellites, about 98%) are all efficient candidates, with probabilities of 0.92 or more, rather than uncertain: they differ by less than matters. The designs that stay uncertain after ten rounds lie about one tolerance below the front, such as single satellites that sample about 3.4% of the points against the best single satellite's 4.2%: whether they are within the tolerance of the front is a question that more replicates settle only slowly, and one that does not change the trade. An absolute tolerance suits a share near saturation better than one near zero; a tolerance proportional to the objective would treat both alike." ] }, + { + "cell_type": "markdown", + "id": "e1f2a3b4", + "metadata": {}, + "source": [ + "## Confirm the Front\n", + "\n", + "The efficient designs were selected for their means over their replicates, so they are selected in part for the luck of those replicates: among a thousand designs, those that look best are likely to have drawn favorable samples of points (the winner's curse). `confirm` evaluates the selected designs with new replicates, which played no part in their selection (the same for every design, which keeps common random numbers), and finds the front among them by these replicates. The difference between the means of the replicates that selected the designs and those of the new ones measures the optimism of the selection." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "f2a3b4c5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-11T03:44:27.723683Z", + "iopub.status.busy": "2026-11-11T03:44:27.723445Z", + "iopub.status.idle": "2026-11-11T03:44:44.343617Z", + "shell.execute_reply": "2026-11-11T03:44:44.342858Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "optimism of the selection: -0.35 percentage points\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanessufficient selectedsufficientreplicatespareto
33800 km, 60 deg FOR, SSO: 1 at 18:001.01.03.422.6520True
29800 km, 60 deg FOR, SSO: 1 at 06:001.01.03.402.7520True
30800 km, 60 deg FOR, SSO: 1 at 09:001.01.04.202.8020True
31800 km, 60 deg FOR, SSO: 1 at 12:001.01.03.402.9020True
32800 km, 60 deg FOR, SSO: 1 at 15:001.01.04.002.9020True
11800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...2.01.014.1314.7020True
14800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.028.6027.5520True
12800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...3.01.037.0037.1520True
17800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...3.03.037.4037.4020True
13800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.066.4066.8520True
15800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.066.2066.8520True
16800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.066.4067.1520True
18800 km, 60 deg FOR, Walker 45 deg: 4 x 1 (spac...4.04.066.7066.9520True
20800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.098.0098.4520True
19800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.8098.5520True
0600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.8098.4520True
1600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.8098.5020True
3700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.8098.6520True
4700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.8098.6520True
21800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.098.0098.7020True
22800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.098.0098.7020True
8700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.8098.6520True
9700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.8098.6520True
10700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.8098.6520True
28800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.098.0098.6520True
26800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.098.0098.7020True
27800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.098.0098.7020True
5700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.6998.0520True
2600 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.7798.4520True
7700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.9698.6020True
6700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.098.0098.6520True
23800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.098.0098.7020True
24800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.098.0098.7020True
25800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.098.0098.7020True
\n", + "
" + ], + "text/plain": [ + " description satellites planes \\\n", + "33 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", + "29 800 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", + "30 800 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", + "31 800 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", + "32 800 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", + "11 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 1.0 \n", + "14 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", + "12 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 1.0 \n", + "17 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", + "13 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", + "15 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", + "16 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", + "18 800 km, 60 deg FOR, Walker 45 deg: 4 x 1 (spac... 4.0 4.0 \n", + "20 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "19 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "0 600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", + "1 600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", + "3 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", + "4 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", + "21 800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", + "22 800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", + "8 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "9 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "10 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "28 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "26 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "27 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "5 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "2 600 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "7 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "6 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "23 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "24 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "25 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "\n", + " sufficient selected sufficient replicates pareto \n", + "33 3.42 2.65 20 True \n", + "29 3.40 2.75 20 True \n", + "30 4.20 2.80 20 True \n", + "31 3.40 2.90 20 True \n", + "32 4.00 2.90 20 True \n", + "11 14.13 14.70 20 True \n", + "14 28.60 27.55 20 True \n", + "12 37.00 37.15 20 True \n", + "17 37.40 37.40 20 True \n", + "13 66.40 66.85 20 True \n", + "15 66.20 66.85 20 True \n", + "16 66.40 67.15 20 True \n", + "18 66.70 66.95 20 True \n", + "20 98.00 98.45 20 True \n", + "19 97.80 98.55 20 True \n", + "0 97.80 98.45 20 True \n", + "1 97.80 98.50 20 True \n", + "3 97.80 98.65 20 True \n", + "4 97.80 98.65 20 True \n", + "21 98.00 98.70 20 True \n", + "22 98.00 98.70 20 True \n", + "8 97.80 98.65 20 True \n", + "9 97.80 98.65 20 True \n", + "10 97.80 98.65 20 True \n", + "28 98.00 98.65 20 True \n", + "26 98.00 98.70 20 True \n", + "27 98.00 98.70 20 True \n", + "5 97.69 98.05 20 True \n", + "2 97.77 98.45 20 True \n", + "7 97.96 98.60 20 True \n", + "6 98.00 98.65 20 True \n", + "23 98.00 98.70 20 True \n", + "24 98.00 98.70 20 True \n", + "25 98.00 98.70 20 True " + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import confirm\n", + "\n", + "selected = [by_key[key] for key in refined.design[refined.pareto]]\n", + "confirmation = confirm(make_study(), selected, refinement.results, OBJECTIVES, replicates=20, tolerance=TOLERANCE)\n", + "confirmed = confirmation.summary\n", + "confirmed[\"description\"] = [describe(values.loc[key]) for key in confirmed.design]\n", + "print(f\"optimism of the selection: {confirmation.optimism(OBJECTIVES)['sufficient']:.2f} percentage points\")\n", + "confirmed.sort_values([\"satellites\", \"planes\", \"sufficient\"])[\n", + " [\"description\", \"satellites\", \"planes\", \"sufficient selected\", \"sufficient\", \"replicates\", \"pareto\"]\n", + "].round(2)" + ] + }, + { + "cell_type": "markdown", + "id": "a3b4c5d6", + "metadata": {}, + "source": [ + "The selection is optimistic where it chose among many nearly equal designs. The single satellites, the best of dozens of single-satellite designs that sample 3 to 4% of the points, sample 2.7 to 2.9% with the new replicates, 0.5 to 1.4 percentage points fewer, and the one that looked best (crossing the equator at 09:00, with 4.2%) is no better than the others. The designs of two to nine satellites confirm their shares within about a percentage point. Most sample slightly more points with the new replicates (by 0.2 to 0.9 points), as the new samples of points happen to be sampled more easily by every design: common random numbers share this difference between samples among the designs, and it is not an effect of the selection. The mean optimism over the designs (-0.35 points) mixes the two, so compare the designs one by one. Every confirmed design remains efficient within the tolerance: the shape of the front is confirmed, but its single-satellite end is less good than it looked." + ] + }, { "cell_type": "markdown", "id": "e8a6c0d2", @@ -1976,14 +2481,14 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "id": "f9b7d1e3", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T14:33:23.496058Z", - "iopub.status.busy": "2026-11-10T14:33:23.495814Z", - "iopub.status.idle": "2026-11-10T14:34:09.295054Z", - "shell.execute_reply": "2026-11-10T14:34:09.294169Z" + "iopub.execute_input": "2026-11-11T03:44:44.345307Z", + "iopub.status.busy": "2026-11-11T03:44:44.345039Z", + "iopub.status.idle": "2026-11-11T03:45:29.659955Z", + "shell.execute_reply": "2026-11-11T03:45:29.659266Z" } }, "outputs": [ @@ -2164,7 +2669,7 @@ "763 1.0 " ] }, - "execution_count": 13, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -2209,14 +2714,14 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "id": "d1e2f3a4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T14:34:09.296720Z", - "iopub.status.busy": "2026-11-10T14:34:09.296542Z", - "iopub.status.idle": "2026-11-10T14:34:15.497075Z", - "shell.execute_reply": "2026-11-10T14:34:15.496146Z" + "iopub.execute_input": "2026-11-11T03:45:29.661723Z", + "iopub.status.busy": "2026-11-11T03:45:29.661476Z", + "iopub.status.idle": "2026-11-11T03:45:38.414811Z", + "shell.execute_reply": "2026-11-11T03:45:38.414116Z" } }, "outputs": [ @@ -2389,7 +2894,7 @@ "de505bc89299 96.0 97.4 95.9 " ] }, - "execution_count": 14, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -2428,14 +2933,14 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "id": "d6e5f8a7", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T14:34:15.498765Z", - "iopub.status.busy": "2026-11-10T14:34:15.498582Z", - "iopub.status.idle": "2026-11-10T14:34:19.927627Z", - "shell.execute_reply": "2026-11-10T14:34:19.926602Z" + "iopub.execute_input": "2026-11-11T03:45:38.416476Z", + "iopub.status.busy": "2026-11-11T03:45:38.416250Z", + "iopub.status.idle": "2026-11-11T03:45:56.306968Z", + "shell.execute_reply": "2026-11-11T03:45:56.306286Z" } }, "outputs": [ @@ -2534,7 +3039,7 @@ "3 24.8 " ] }, - "execution_count": 15, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -2591,14 +3096,14 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "id": "a9b8c1d0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T14:34:19.929324Z", - "iopub.status.busy": "2026-11-10T14:34:19.929141Z", - "iopub.status.idle": "2026-11-10T14:34:20.778477Z", - "shell.execute_reply": "2026-11-10T14:34:20.777554Z" + "iopub.execute_input": "2026-11-11T03:45:56.308635Z", + "iopub.status.busy": "2026-11-11T03:45:56.308378Z", + "iopub.status.idle": "2026-11-11T03:46:01.482988Z", + "shell.execute_reply": "2026-11-11T03:46:01.482221Z" } }, "outputs": [ @@ -2654,7 +3159,7 @@ "Latin hypercube sample 176.0 80.3" ] }, - "execution_count": 16, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -2705,14 +3210,14 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "id": "b0c9d2e1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-10T14:34:20.780108Z", - "iopub.status.busy": "2026-11-10T14:34:20.779926Z", - "iopub.status.idle": "2026-11-10T14:34:20.903110Z", - "shell.execute_reply": "2026-11-10T14:34:20.902151Z" + "iopub.execute_input": "2026-11-11T03:46:01.484554Z", + "iopub.status.busy": "2026-11-11T03:46:01.484367Z", + "iopub.status.idle": "2026-11-11T03:46:01.616512Z", + "shell.execute_reply": "2026-11-11T03:46:01.615805Z" } }, "outputs": [ @@ -2761,9 +3266,9 @@ "## Summary\n", "\n", "* A `DesignSpace` declares a hierarchical trade space, with choices between alternatives (`Choice`), repeated elements such as orbit planes (`Repeat`), bounds that depend on other variables, constraints that measure their violation, and uncertain parameters (`Uncertain`) drawn for each replicate. Building blocks declare common constellation layouts (`walker_space` and `sso_planes_space`) and build their satellites with instruments or entries of the instrument catalog (`build_constellation`).\n", - "* A `Study` evaluates designs in replicates, in parallel, with a `SatelliteCache` that analyzes each distinct satellite once and a `ResultStore` that keeps its evaluations. Every design of a space of about a thousand designs can be evaluated in minutes.\n", + "* A `Study` evaluates designs in replicates, in parallel, with a `SatelliteCache` that analyzes each distinct satellite once and a `ResultStore` that keeps its evaluations (by the fingerprint of the study, so that a changed study evaluates its designs again). Every design of a space of about a thousand designs can be evaluated in minutes.\n", "* Statistical sufficiency is measured by the sampling error of the statistic that observations estimate (`tatc.analysis.estimate_sampling_error`), which counts of samples overstate when samples cluster in time, as they do in a single plane; revisit statistics and local time coverage explain it.\n", - "* The front of the means of the replicates is uncertain: `pareto_probability` finds the designs whose efficiency the replicates settle, and those that are equally good candidates, and `refine` adds replicates only to the latter, with a tolerance of differences that do not matter.\n", + "* The front of the means of the replicates is uncertain: `pareto_probability` finds the designs whose efficiency the replicates settle, and those that are equally good candidates, and `refine` adds replicates only to the latter, with a tolerance of differences that do not matter. `confirm` evaluates the selected designs with new replicates, which removes the optimism of selecting the best of many nearly equal designs.\n", "* Statistics other than means (such as a `Quantile` or the `Probability` of meeting a threshold) state how reliably a design performs, including with failures of satellites (`remove_failures`), and `Requirement`s on them are output constraints. `sensitivity` finds the design variables that drive each objective.\n", "* `screen` evaluates every design with a cheap study and the best with the full one, which finds the front at a fraction of the cost if the cheap study ranks designs as the full one does.\n", "* `optimize_optuna` and `optimize_pymoo` search spaces too large to enumerate, and find most of the front with a fraction of the designs.\n", diff --git a/src/tatc/tradespace/__init__.py b/src/tatc/tradespace/__init__.py index a62d38ef..b084913b 100644 --- a/src/tatc/tradespace/__init__.py +++ b/src/tatc/tradespace/__init__.py @@ -4,7 +4,8 @@ trade studies that evaluate their designs (with caches of analyses by satellite, in parallel), statistics of replicates and requirements on them, Pareto efficiency (with the uncertainty of replicates), -adaptive replication, persistent stores of results, sensitivity analysis, +adaptive replication, confirmation of selected designs with new replicates, +persistent stores of results (keyed by fingerprints of studies), sensitivity analysis, screening with analyses of increasing fidelity, and searches with optimizers (Optuna and pymoo, optional dependencies). @@ -12,6 +13,7 @@ """ from .cache import SatelliteCache, get_satellite_key +from .confirmation import Confirmation, confirm from .constellations import ( build_constellation, count_planes, @@ -38,6 +40,7 @@ optimize_optuna, optimize_pymoo, ) +from .fingerprint import get_fingerprint from .pareto import hypervolume, pareto_front, pareto_probability, pareto_ranks from .refinement import Refinement, refine from .screening import Screening, screen @@ -63,6 +66,7 @@ "Categorical", "Choice", "ChoiceValues", + "Confirmation", "Derived", "Design", "DesignSpace", @@ -92,8 +96,10 @@ "Variable", "aggregate", "build_constellation", + "confirm", "count_planes", "count_satellites", + "get_fingerprint", "get_satellite_key", "hours_to_time", "hypervolume", diff --git a/src/tatc/tradespace/cache.py b/src/tatc/tradespace/cache.py index 9f9062d0..857f33da 100644 --- a/src/tatc/tradespace/cache.py +++ b/src/tatc/tradespace/cache.py @@ -26,6 +26,7 @@ import pandas as pd from ..schemas import Satellite +from .fingerprint import get_fingerprint def get_satellite_key(satellite: Satellite) -> str: @@ -60,10 +61,12 @@ class SatelliteCache: A cache on disk (`directory`) persists between sessions and is shared by the parallel workers of a trade study (see `Study`), each of which - otherwise has its own cache in memory. Its `namespace` must identify the - analysis (the function and its fixed arguments), as results in the - directory are only keyed by the namespace and the satellite: change it - whenever the analysis changes. + otherwise has its own cache in memory. Results in the directory are keyed + by the satellite, the fingerprint of the function (its code, the plain + values it closes over or refers to, and the version of TAT-C, see + `Study.fingerprint`), and the `namespace`, which must identify what the + fingerprint cannot see: the data the function uses (such as its targets) + and the code of other modules it calls. Change it whenever these change. Args: function (Callable): The analysis of one satellite. @@ -84,6 +87,8 @@ def __init__( self.function = function self.directory = None if directory is None else Path(directory) self.namespace = namespace + self.fingerprint = get_fingerprint(function) if directory is not None else "" + """str: The fingerprint of the function, which keys results on disk.""" self.hits = 0 """int: The number of results retrieved from the cache.""" self.misses = 0 @@ -99,7 +104,9 @@ def __getstate__(self) -> dict: return state def _path(self, key: str) -> Path: - name = hashlib.sha1(f"{self.namespace}/{key}".encode()).hexdigest() + name = hashlib.sha1( + f"{self.namespace}/{self.fingerprint}/{key}".encode() + ).hexdigest() return self.directory / f"{name}.pkl" def _load(self, key: str) -> Any: diff --git a/src/tatc/tradespace/confirmation.py b/src/tatc/tradespace/confirmation.py new file mode 100644 index 00000000..3ecc4e28 --- /dev/null +++ b/src/tatc/tradespace/confirmation.py @@ -0,0 +1,153 @@ +""" +Confirmation of selected designs with replicates that did not select them, +which removes the optimism of selection (the winner's curse). + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +from collections.abc import Mapping, Sequence +from dataclasses import dataclass + +import numpy as np +import pandas as pd + +from .criteria import Requirement, Statistic, _get_statistics, aggregate +from .pareto import Tolerance, pareto_front +from .space import Design +from .study import Study + + +@dataclass +class Confirmation: + """ + The outcome of a confirmation (see `confirm`). + """ + + results: pd.DataFrame + """pandas.DataFrame: The results of the new replicates (see `Study.run`).""" + summary: pd.DataFrame + """pandas.DataFrame: A row per design (and group): the statistics of + the new replicates, those of the replicates that selected the design + (` selected`), the number of new `replicates`, and whether + the design meets the requirements (`meets_requirements`) and is + efficient among the confirmed designs that do (`pareto`), by the new + replicates.""" + + def optimism(self, objectives: Mapping[str, str]) -> pd.Series: + """ + Gets the optimism of selection: the mean amount by which the selecting + replicates made the designs look better than the new replicates do, + in each objective (positive if they looked better). + + Args: + objectives (Mapping[str, str]): The objectives and their + directions (`"min"` or `"max"`). + + Returns: + pandas.Series: the optimism of each objective, in its units + """ + return pd.Series( + { + name: float( + np.nanmean( + (self.summary[f"{name} selected"] - self.summary[name]) + * (1.0 if direction == "max" else -1.0) + ) + ) + for name, direction in objectives.items() + } + ) + + +def confirm( + study: Study, + designs: Sequence[Design], + results: pd.DataFrame, + objectives: Mapping[str, str], + replicates: int | None = None, + statistics: Mapping[str, Statistic | str] | None = None, + requirements: Sequence[Requirement] = (), + by: Sequence[str] = (), + tolerance: Mapping[str, Tolerance] | None = None, +) -> Confirmation: + """ + Confirms selected designs (such as a Pareto front, or the best designs + of an optimizer) with new replicates. + + Designs selected for their outcomes in some replicates are selected in + part for the luck of those replicates: among many designs, the best + looking are likely to have drawn favorable uncertain parameters, so + their statistics in the replicates that selected them are optimistic + (the winner's curse), even if each design's statistics are unbiased + before selection. Replicates that played no part in the selection give + unbiased statistics of the selected designs. They are the replicates + after every replicate of the `results` (of any design), the same for + every design, so that common random numbers still pair the designs (see + `Design.realize`). + + Args: + study (Study): The study that evaluates designs. + designs (Sequence[Design]): The selected designs. + results (pandas.DataFrame): Every result that informed the selection + (see `Study.run`), such as those of an enumeration, refinement, + or search. + objectives (Mapping[str, str]): The objectives: statistics (or + metrics) and their directions (`"min"` or `"max"`). + replicates (int | None): The number of new replicates, or `None` for + the study's number. + statistics (Mapping[str, Statistic | str] | None): Statistics, by + name, of objectives and requirements that are not means. + requirements (Sequence[Requirement]): Requirements on statistics. + by (Sequence[str]): Columns that group records of an evaluation (such + as a sensor), whose fronts are found separately. + tolerance (Mapping[str, float | str] | None): The tolerances of + objectives (see `pareto_front`). + + Returns: + Confirmation: the new results and the summary of each design + """ + count = study.replicates if replicates is None else replicates + if count < 1: + raise ValueError("replicates must be at least 1") + designs = list({design.key: design for design in designs}.values()) + keys = {design.key for design in designs} + start = int(results["replicate"].max()) + 1 if len(results) > 0 else 0 + fresh = study.run(designs, replicates=range(start, start + count)) + names = list(dict.fromkeys([*objectives, *(r.name for r in requirements)])) + resolved = _get_statistics(names, statistics) + resolved = {name: resolved[name] for name in names} + columns = ["design", *by] + selected = aggregate( + results[results["design"].isin(keys)], + resolved, + requirements, + by=by, + design_columns=[], + ) + confirmed = aggregate(fresh, resolved, requirements, by=by, design_columns=[]) + summary = confirmed[[*columns, *names, "replicates", "meets_requirements"]] + summary = summary.merge( + selected[[*columns, *names]].rename( + columns={name: f"{name} selected" for name in names} + ), + on=columns, + how="left", + ) + summary = summary[ + [ + *columns, + *(c for name in names for c in (name, f"{name} selected")), + "replicates", + "meets_requirements", + ] + ] + summary["pareto"] = False + groups = summary.groupby(list(by), sort=False) if by else [((), summary)] + for _, group in groups: + candidates = group[group["meets_requirements"]].dropna(subset=list(objectives)) + if len(candidates) > 0: + efficient = pareto_front(candidates, objectives, tolerance) + summary.loc[efficient.index, "pareto"] = efficient + return Confirmation(results=fresh, summary=summary) diff --git a/src/tatc/tradespace/fingerprint.py b/src/tatc/tradespace/fingerprint.py new file mode 100644 index 00000000..138161e0 --- /dev/null +++ b/src/tatc/tradespace/fingerprint.py @@ -0,0 +1,234 @@ +""" +Fingerprints of the definitions of trade studies (design spaces, functions, +and settings), which key persistent results so that results computed with +other definitions are not reused. + +A fingerprint describes values by their content where it can: plain values +(numbers, strings, dates and times, and their containers), pydantic models +(such as satellites and instruments), small arrays, the nodes of design +spaces, and functions, by their code, the values they close over and their +defaults, and the plain values and functions of the same module that they +refer to as globals. Other objects (such as data frames) are described by +their type only: identify them by a namespace (see `ResultStore` and +`SatelliteCache`). Functions of other modules (such as TAT-C's) are +described by their names, as the version of TAT-C is part of a fingerprint. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +import functools +import hashlib +import json +import types +from datetime import date, datetime, time, timedelta +from typing import Any + +import numpy as np +from pydantic import BaseModel + +_MAX_DEPTH = 24 +"""The deepest nesting described, beyond which values are described by type.""" + +_MAX_ITEMS = 1000 +"""The most items of a container (or array) described one by one.""" + + +def _type(value: Any) -> dict: + kind = type(value) + return {"type": f"{kind.__module__}.{kind.__qualname__}"} + + +def _sort_key(value: Any) -> str: + return json.dumps(value, sort_keys=True, default=str) + + +def _code(code: types.CodeType, depth: int, seen: set) -> dict: + """ + Describes compiled code by its instructions, constants, and names (not + its file or line numbers, which change as code moves). + """ + return { + "code": code.co_code.hex(), + "constants": [_describe(c, depth + 1, seen) for c in code.co_consts], + "names": list(code.co_names), + } + + +def _function(function: types.FunctionType, depth: int, seen: set) -> dict: + """ + Describes a function: its code, the values it closes over, its defaults, + and the plain values and functions of its module it refers to as globals. + """ + if id(function) in seen: + return {"function": function.__qualname__, "recursive": True} + seen = seen | {id(function)} + closure = [ + _describe(cell.cell_contents, depth + 1, seen) + for cell in (function.__closure__ or ()) + if _has_contents(cell) + ] + referenced = {} + module = function.__module__ + for name in _global_names(function.__code__): + if name not in function.__globals__: + continue + value = function.__globals__[name] + if isinstance(value, types.FunctionType): + if value.__module__ == module: + referenced[name] = _function(value, depth + 1, seen) + elif _is_plain(value): + referenced[name] = _describe(value, depth + 1, seen) + return { + "function": function.__qualname__, + **_code(function.__code__, depth, seen), + "closure": closure, + "defaults": _describe(function.__defaults__, depth + 1, seen), + "keyword defaults": _describe(function.__kwdefaults__, depth + 1, seen), + "globals": referenced, + } + + +def _has_contents(cell: Any) -> bool: + try: + cell.cell_contents # pylint: disable=pointless-statement + except ValueError: # an empty cell + return False + return True + + +def _global_names(code: types.CodeType) -> list[str]: + """ + Gets the names a code (and its nested code) refers to. + """ + names = list(code.co_names) + for constant in code.co_consts: + if isinstance(constant, types.CodeType): + names.extend(_global_names(constant)) + return list(dict.fromkeys(names)) + + +_PLAIN = (type(None), bool, int, float, str, bytes, date, time, timedelta, np.generic) + + +def _is_plain(value: Any, depth: int = 0) -> bool: + """ + Whether a value is plain: a number, string, date or time, or a (small) + container of them. + """ + if isinstance(value, _PLAIN): + return True + if depth > 3: + return False + if isinstance(value, (list, tuple, set, frozenset)): + return len(value) <= _MAX_ITEMS and all(_is_plain(v, depth + 1) for v in value) + if isinstance(value, dict): + return len(value) <= _MAX_ITEMS and all( + _is_plain(k, depth + 1) and _is_plain(v, depth + 1) + for k, v in value.items() + ) + return False + + +def _describe(value: Any, depth: int = 0, seen: set | None = None) -> Any: + """ + Describes a value as plain data (see the module). + """ + # pylint: disable=too-many-return-statements,too-many-branches,import-outside-toplevel + seen = set() if seen is None else seen + if depth > _MAX_DEPTH: + return _type(value) + if value is None or isinstance(value, (bool, int, str)): + return value + if isinstance(value, float): + return repr(value) + if isinstance(value, np.generic): + return _describe(value.item(), depth, seen) + if isinstance(value, bytes): + return hashlib.sha1(value).hexdigest() + if isinstance(value, (datetime, date, time)): + return value.isoformat() + if isinstance(value, timedelta): + return {"timedelta": value.total_seconds()} + if isinstance(value, BaseModel): + return {**_type(value), **value.model_dump(mode="json")} + if isinstance(value, np.ndarray): + if value.dtype == object: + return {**_type(value), "shape": list(value.shape)} + return { + "array": str(value.dtype), + "shape": list(value.shape), + "data": hashlib.sha1(np.ascontiguousarray(value).tobytes()).hexdigest(), + } + if isinstance(value, (list, tuple)): + if len(value) > _MAX_ITEMS: + return {**_type(value), "length": len(value)} + return [_describe(v, depth + 1, seen) for v in value] + if isinstance(value, (set, frozenset)): + if len(value) > _MAX_ITEMS: + return {**_type(value), "length": len(value)} + return sorted((_describe(v, depth + 1, seen) for v in value), key=_sort_key) + if isinstance(value, dict): + if len(value) > _MAX_ITEMS: + return {**_type(value), "length": len(value)} + return sorted( + ( + [_describe(k, depth + 1, seen), _describe(v, depth + 1, seen)] + for k, v in value.items() + ), + key=_sort_key, + ) + if isinstance(value, types.CodeType): + return _code(value, depth, seen) + if isinstance(value, types.FunctionType): + return _function(value, depth, seen) + if isinstance(value, types.MethodType): + return { + "method": _describe(value.__func__, depth + 1, seen), + "self": _describe(value.__self__, depth + 1, seen), + } + if isinstance(value, functools.partial): + return { + "partial": _describe(value.func, depth + 1, seen), + "arguments": _describe(value.args, depth + 1, seen), + "keywords": _describe(value.keywords, depth + 1, seen), + } + if isinstance(value, (types.BuiltinFunctionType, type)): + return {"name": f"{value.__module__}.{value.__qualname__}"} + from .nodes import Node + + if isinstance(value, Node): + if id(value) in seen: + return {**_type(value), "recursive": True} + return { + **_type(value), + **{ + name: _describe(attribute, depth + 1, seen | {id(value)}) + for name, attribute in sorted(vars(value).items()) + }, + } + return _type(value) + + +def get_fingerprint(*values: Any) -> str: + """ + Gets a fingerprint of values (such as a design space and the functions + of a study) and of the version of TAT-C: a key that changes if their + definitions do (see the module for what it describes). + + Args: + *values (Any): The values. + + Returns: + str: the fingerprint + """ + # pylint: disable=import-outside-toplevel + from .. import __version__ + + text = json.dumps( + {"tatc": __version__, "values": [_describe(value) for value in values]}, + sort_keys=True, + default=str, + ) + return hashlib.sha1(text.encode()).hexdigest()[:16] diff --git a/src/tatc/tradespace/refinement.py b/src/tatc/tradespace/refinement.py index 101f7247..b2ec70da 100644 --- a/src/tatc/tradespace/refinement.py +++ b/src/tatc/tradespace/refinement.py @@ -7,6 +7,7 @@ from __future__ import annotations +import warnings from collections.abc import Mapping, Sequence from dataclasses import dataclass, field @@ -38,7 +39,8 @@ class Refinement: @property def uncertain(self) -> pd.DataFrame: """pandas.DataFrame: The rows of `probability` whose efficiency is - still uncertain (as of the bounds of `refine`).""" + still uncertain (as of the bounds of `refine`, or with fewer than + its least replicates).""" return self.probability[self.probability["uncertain"]] @@ -53,6 +55,7 @@ def refine( bounds: tuple[float, float] = (0.05, 0.95), step: int | None = None, max_replicates: int | None = None, + min_replicates: int = 5, max_rounds: int = 10, n_resamples: int = 500, seed: int = 0, @@ -67,6 +70,12 @@ def refine( `max_replicates`. Rounds end when no design is uncertain (or can be refined), or after `max_rounds`. + A bootstrap of few replicates has few distinct resamples, and can find a + design surely inefficient (or efficient) by the luck of its replicates: + with two replicates, designs as good as the front can be efficient in + none of the resamples. Designs with fewer than `min_replicates` are + therefore uncertain whatever their probability, and are refined first. + Replicates are added in order (the next indices after a design's replicates), so that designs refined together share their uncertain parameters (with common random numbers, see `Design.realize`). Designs @@ -76,7 +85,8 @@ def refine( Designs that differ by less than any number of replicates could separate (such as designs near saturation) stay uncertain: give a `tolerance` of the objectives within which differences do not matter, - so that such designs are all efficient (see `pareto_probability`). + so that such designs are all efficient (see `pareto_probability`). A + warning is given if designs remain uncertain without a tolerance. Args: study (Study): The study that evaluates designs. @@ -96,6 +106,8 @@ def refine( round, or `None` for the study's number of replicates. max_replicates (int | None): The most replicates of a design, if limited. + min_replicates (int): The fewest replicates with which a design's + efficiency can be settled. max_rounds (int): The most rounds. n_resamples (int): The number of resamples of each bootstrap. seed (int): The seed of the bootstraps. @@ -112,6 +124,8 @@ def refine( step = study.replicates if step is None else step if step < 1: raise ValueError("step must be at least 1") + if max_replicates is not None and max_replicates < min_replicates: + raise ValueError("max_replicates must be at least min_replicates") by_key = {design.key: design for design in designs} frames = [results] history = [] @@ -127,9 +141,10 @@ def estimate(round_: int) -> pd.DataFrame: requirements=requirements, tolerance=tolerance, ) - probability["uncertain"] = (probability["pareto_probability"] > low) & ( - probability["pareto_probability"] < high - ) + probability["uncertain"] = ( + (probability["pareto_probability"] > low) + & (probability["pareto_probability"] < high) + ) | (probability["replicates"] < min_replicates) return probability for round_ in range(max_rounds): @@ -139,12 +154,17 @@ def estimate(round_: int) -> pd.DataFrame: combined = pd.concat(frames, ignore_index=True) # the next replicate of each uncertain design following = combined.groupby("design")["replicate"].max() + 1 - refined = [ - key + # the replicates added to each uncertain design (fewer at the limit) + added_to = { + key: ( + step + if max_replicates is None + else min(step, max_replicates - int(following[key])) + ) for key in uncertain if key in by_key - and (max_replicates is None or following[key] + step <= max_replicates) - ] + } + refined = [key for key, count in added_to.items() if count > 0] if not refined: history.append( { @@ -156,11 +176,18 @@ def estimate(round_: int) -> pd.DataFrame: ) break added = 0 - # designs with the same next replicate are evaluated together - for start, keys in pd.Series(following[refined]).groupby(following[refined]): + # designs with the same next replicates are evaluated together + plan = pd.DataFrame( + { + "start": following[refined].astype(int), + "count": [added_to[key] for key in refined], + }, + index=refined, + ) + for (start, count), keys in plan.groupby(["start", "count"]): new = study.run( [by_key[key] for key in keys.index], - replicates=range(int(start), int(start) + step), + replicates=range(int(start), int(start) + int(count)), ) frames.append(new) added += new.groupby(["design", "replicate"]).ngroups @@ -174,6 +201,14 @@ def estimate(round_: int) -> pd.DataFrame: ) else: probability = estimate(max_rounds) + remaining = probability.loc[probability["uncertain"], "design"].nunique() + if remaining > 0 and not tolerance: + warnings.warn( + f"{remaining} designs remain uncertain: designs that differ by less " + + "than replicates separate stay uncertain without a tolerance of " + + "the objectives (see pareto_front)", + stacklevel=2, + ) return Refinement( results=pd.concat(frames, ignore_index=True), probability=probability, diff --git a/src/tatc/tradespace/sensitivity.py b/src/tatc/tradespace/sensitivity.py index 8cd9fb83..29eb874b 100644 --- a/src/tatc/tradespace/sensitivity.py +++ b/src/tatc/tradespace/sensitivity.py @@ -56,13 +56,24 @@ def sensitivity( variables: Sequence[str], metrics: Sequence[str], max_levels: int = 10, + adjusted: bool = True, ) -> pd.DataFrame: """ Computes the sensitivity of metrics to design variables: for each variable and metric, the share of the variance of the metric explained - by the levels of the variable (the correlation ratio, eta squared, of a - one-way analysis of variance), among the designs in which the variable is - active, and the share of the designs in which it is (`active`). + by the levels of the variable (of a one-way analysis of variance), among + the designs in which the variable is active, and the share of the designs + in which it is (`active`). + + The share of explained variance of a sample (the correlation ratio, eta + squared) is biased upward: with `k` levels and `n` designs, a variable + that does not affect a metric explains `(k - 1) / (n - 1)` of its + variance on average, as the means of its levels differ by chance (0.47 + for 10 levels and 20 designs). The adjusted share (epsilon squared) + removes this bias: it subtracts the variance between levels that chance + explains (the variance within levels, times `k - 1`), and is near 0 for + such a variable (it is clipped at 0, and is `NaN` with no more designs + than levels). A share near 1 means that the variable alone determines the metric; a share near 0, that the metric hardly depends on it. The shares of a full @@ -80,6 +91,8 @@ def sensitivity( metrics (Sequence[str]): The columns of the metrics. max_levels (int): The most levels of a numeric variable, beyond which its values are grouped in bins of equal counts. + adjusted (bool): `True` for the adjusted shares, `False` for the + correlation ratios. Returns: pandas.DataFrame: a row per variable: the share of each metric's @@ -100,7 +113,16 @@ def sensitivity( continue levels = _levels(subset[variable], max_levels) means = values.groupby(levels).transform("mean") - row[metric] = float(((means - values.mean()) ** 2).sum()) / total + between = float(((means - values.mean()) ** 2).sum()) + if not adjusted: + row[metric] = between / total + continue + k, n = int(pd.Series(levels).nunique()), len(subset) + if n <= k: + row[metric] = np.nan + continue + within = (total - between) / (n - k) + row[metric] = max((between - (k - 1) * within) / total, 0.0) rows.append(row) result = pd.DataFrame(rows).set_index("variable") result = result[[*metrics, "active"]] diff --git a/src/tatc/tradespace/store.py b/src/tatc/tradespace/store.py index 61534b60..ade31f8c 100644 --- a/src/tatc/tradespace/store.py +++ b/src/tatc/tradespace/store.py @@ -21,11 +21,16 @@ class ResultStore: A store of the records of the evaluations of a study (see `Study.run`), by the key of each design and its replicate, in a SQLite database file. - The `namespace` identifies the study: its design space's build and - evaluation functions and their fixed inputs (such as the targets and the - period of the analysis), as the records are only keyed by the namespace, - the design, and the replicate. Change it whenever the study changes. - Several studies may share a file, in their own namespaces. + Records are also keyed by a `context`: a study gives its fingerprint + (see `Study.fingerprint`), which changes with its seed, its use of + common random numbers, the definitions of its design space and its build + and evaluation functions (their code, and the plain values they refer + to), and the version of TAT-C, so that records computed with other + definitions are not reused. The `namespace` identifies what a + fingerprint cannot see: the data the functions use (such as the targets + of the analysis) and the code of other modules they call. Change it + whenever these change. Several studies may share a file, in their own + namespaces. Args: path (str | os.PathLike): The database file (created if needed). @@ -40,21 +45,25 @@ def __init__(self, path: str | os.PathLike, namespace: str): with closing(self._connect()) as connection: with connection: connection.execute( - "CREATE TABLE IF NOT EXISTS results (namespace TEXT, design TEXT, " - + "replicate INTEGER, records BLOB, " - + "PRIMARY KEY (namespace, design, replicate))" + "CREATE TABLE IF NOT EXISTS evaluations (namespace TEXT, " + + "context TEXT, design TEXT, replicate INTEGER, records BLOB, " + + "PRIMARY KEY (namespace, context, design, replicate))" ) def _connect(self) -> sqlite3.Connection: return sqlite3.connect(self.path, timeout=60) - def get(self, keys: Iterable[tuple[str, int]]) -> dict[tuple[str, int], list[dict]]: + def get( + self, keys: Iterable[tuple[str, int]], context: str = "" + ) -> dict[tuple[str, int], list[dict]]: """ Gets the stored records of evaluations. Args: keys (Iterable[tuple[str, int]]): The evaluations: the key of a design and its replicate. + context (str): The context of the evaluations (such as the + fingerprint of a study). Returns: dict: the records of each stored evaluation (others are omitted) @@ -67,9 +76,9 @@ def get(self, keys: Iterable[tuple[str, int]]) -> dict[tuple[str, int], list[dic designs = sorted({design for design, _ in part}) marks = ",".join("?" * len(designs)) rows = connection.execute( - "SELECT design, replicate, records FROM results " - + f"WHERE namespace = ? AND design IN ({marks})", - [self.namespace, *designs], + "SELECT design, replicate, records FROM evaluations " + + f"WHERE namespace = ? AND context = ? AND design IN ({marks})", + [self.namespace, context, *designs], ).fetchall() wanted = set(part) for design, replicate, blob in rows: @@ -77,40 +86,56 @@ def get(self, keys: Iterable[tuple[str, int]]) -> dict[tuple[str, int], list[dic found[design, replicate] = pickle.loads(blob) return found - def put(self, items: Iterable[tuple[str, int, list[dict]]]) -> None: + def put( + self, items: Iterable[tuple[str, int, list[dict]]], context: str = "" + ) -> None: """ Stores the records of evaluations, replacing any stored before. Args: items (Iterable[tuple[str, int, list[dict]]]): The evaluations: the key of a design, its replicate, and its records. + context (str): The context of the evaluations (such as the + fingerprint of a study). """ rows = [ - (self.namespace, design, int(replicate), pickle.dumps(records)) + (self.namespace, context, design, int(replicate), pickle.dumps(records)) for design, replicate, records in items ] if rows: with closing(self._connect()) as connection: with connection: connection.executemany( - "INSERT OR REPLACE INTO results VALUES (?, ?, ?, ?)", rows + "INSERT OR REPLACE INTO evaluations VALUES (?, ?, ?, ?, ?)", + rows, ) - def __len__(self) -> int: + def contexts(self) -> dict[str, int]: + """ + Gets the contexts of the namespace's stored evaluations. + + Returns: + dict[str, int]: the number of evaluations of each context + """ with closing(self._connect()) as connection: - (count,) = connection.execute( - "SELECT COUNT(*) FROM results WHERE namespace = ?", [self.namespace] - ).fetchone() - return count + rows = connection.execute( + "SELECT context, COUNT(*) FROM evaluations WHERE namespace = ? " + + "GROUP BY context", + [self.namespace], + ).fetchall() + return dict(rows) + + def __len__(self) -> int: + return sum(self.contexts().values()) def clear(self) -> None: """ - Removes the stored records of the namespace. + Removes the stored records of the namespace (of every context). """ with closing(self._connect()) as connection: with connection: connection.execute( - "DELETE FROM results WHERE namespace = ?", [self.namespace] + "DELETE FROM evaluations WHERE namespace = ?", [self.namespace] ) def __repr__(self) -> str: diff --git a/src/tatc/tradespace/study.py b/src/tatc/tradespace/study.py index e668e5ea..d4d5e882 100644 --- a/src/tatc/tradespace/study.py +++ b/src/tatc/tradespace/study.py @@ -10,6 +10,7 @@ import math import os import time +import warnings from collections.abc import Callable, Iterable, Sequence from concurrent.futures import Executor, as_completed from typing import Any @@ -17,6 +18,7 @@ import numpy as np import pandas as pd +from .fingerprint import get_fingerprint from .space import Design, DesignSpace from .store import ResultStore @@ -94,7 +96,8 @@ class Study: instead of worker processes. chunks_per_job (int): The number of chunks of evaluations per worker. store (ResultStore | None): A store of the records of evaluations, from - which evaluations stored before are taken rather than evaluated + which evaluations stored before (by a study of the same + fingerprint, see `fingerprint`) are taken rather than evaluated again, and to which new ones are added as they complete (see `ResultStore`). """ @@ -156,6 +159,24 @@ def _run_chunk(self, tasks: list[tuple[int, Design, int]]) -> list[list[dict]]: """ return [self._evaluate(design, replicate) for _, design, replicate in tasks] + @property + def fingerprint(self) -> str: + """str: A key of the definition of the study, which changes with its + seed, its use of common random numbers, its design space (including + fixed values and the distributions of uncertain parameters), its + build and evaluation functions (their code, the values they close + over, and the plain values and functions of their module they refer + to), and the version of TAT-C. It keys the records of a store (see + `ResultStore`); data that it cannot describe (such as data frames) + must be identified by the store's namespace.""" + return get_fingerprint( + self.seed, + self.common_random_numbers, + self.space, + self.build, + self.evaluate, + ) + @property def workers(self) -> int: """int: The number of workers that evaluate designs (1 in this process).""" @@ -209,9 +230,26 @@ def run( for i, design in enumerate(unique) ] results: list[tuple[int, int, list[dict]]] = [] + context = "" if self.store is not None: # evaluations stored before (by an interrupted or earlier run) - stored = self.store.get((d.key, replicate) for _, d, replicate in tasks) + context = self.fingerprint + stored = self.store.get( + ((d.key, replicate) for _, d, replicate in tasks), context + ) + others = { + other: count + for other, count in self.store.contexts().items() + if other != context + } + if tasks and not stored and others: + warnings.warn( + f"the store has {sum(others.values())} evaluations of namespace " + + f"{self.store.namespace!r} by studies of other definitions " + + "(seed, design space, functions, or version of TAT-C), " + + "which are not reused (see Study.fingerprint)", + stacklevel=2, + ) results.extend( (i, replicate, stored[design.key, replicate]) for i, design, replicate in tasks @@ -224,7 +262,7 @@ def run( records = self._evaluate(design, replicate) results.append((i, replicate, records)) if self.store is not None: - self.store.put([(design.key, replicate, records)]) + self.store.put([(design.key, replicate, records)], context) if progress is not None: progress(done, total) elif tasks: @@ -243,8 +281,11 @@ def run( results.append((i, replicate, records)) if self.store is not None: self.store.put( - (design.key, replicate, records) - for (_, design, replicate), records in zip(chunk, evaluated) + ( + (design.key, replicate, records) + for (_, design, replicate), records in zip(chunk, evaluated) + ), + context, ) done += len(chunk) if progress is not None: diff --git a/tests/tradespace/test_cache.py b/tests/tradespace/test_cache.py index fd566545..d3849937 100644 --- a/tests/tradespace/test_cache.py +++ b/tests/tradespace/test_cache.py @@ -111,6 +111,20 @@ def test_disk_cache(self): self.assertEqual(other.misses, 1) self.assertEqual(self.calls, ["a", "c"]) + def test_disk_cache_of_other_functions(self): + """Results on disk are not shared by functions of other definitions.""" + with tempfile.TemporaryDirectory() as directory: + for rows in (1, 1, 2): + cache = SatelliteCache( + lambda satellite, rows=rows: pd.DataFrame( + {"satellite": [satellite.name] * rows} + ), + directory, + namespace="x", + ) + self.assertEqual(len(cache(_satellite("a"))), rows) + self.assertEqual(len(list(Path(directory).iterdir())), 2) + def test_unreadable_file(self): """A result that cannot be read from disk is computed again.""" with tempfile.TemporaryDirectory() as directory: diff --git a/tests/tradespace/test_confirmation.py b/tests/tradespace/test_confirmation.py new file mode 100644 index 00000000..81ec2cf0 --- /dev/null +++ b/tests/tradespace/test_confirmation.py @@ -0,0 +1,102 @@ +""" +Unit tests for the confirmation of selected designs. + +@author Paul T. Grogan +""" + +import unittest + +import numpy as np + +from tatc.tradespace import ( + DesignSpace, + Integer, + Probability, + Requirement, + Study, + Uncertain, + confirm, + pareto_front, + summarize, +) + +OBJECTIVES = {"cost": "min", "value": "max"} + + +def _study(replicates=3): + """Designs of equal true values (but for the cost), with independent noise.""" + space = DesignSpace( + cost=Integer(1, 2), variant=Integer(0, 49), noise=Uncertain.normal(0, 1) + ) + return Study( + space, + lambda d: d, + lambda d: {"cost": d.cost, "value": d.cost + d.noise}, + replicates=replicates, + common_random_numbers=False, + ) + + +class TestConfirm(unittest.TestCase): + """ + Unit tests for confirmation. + """ + + def setUp(self): + self.study = _study() + self.designs = self.study.space.enumerate() + self.results = self.study.run(self.designs) + summary = summarize(self.results, list(OBJECTIVES), design_columns=[]) + # the best looking designs of each cost + best = summary.sort_values("value", ascending=False).groupby( + summary.design.map({d.key: d.cost for d in self.designs}) + ) + self.selected_keys = set(best.head(5).design) + self.selected = [d for d in self.designs if d.key in self.selected_keys] + + def test_removes_optimism(self): + """New replicates remove the optimism of selection.""" + confirmation = confirm( + self.study, self.selected, self.results, OBJECTIVES, replicates=20 + ) + self.assertEqual(set(confirmation.summary.design), self.selected_keys) + self.assertTrue((confirmation.summary.replicates == 20).all()) + # the new replicates follow every replicate of the results + self.assertEqual(set(confirmation.results.replicate), set(range(3, 23))) + optimism = confirmation.optimism(OBJECTIVES) + self.assertAlmostEqual(optimism["cost"], 0) + # the 5 best of 50 designs of 3 replicates look better by about a + # standard deviation of their means (0.58), which the new ones remove + self.assertGreater(optimism["value"], 0.6) + # the confirmed values are unbiased (their true values are the costs) + errors = confirmation.summary.value - confirmation.summary.design.map( + {d.key: d.cost for d in self.designs} + ) + self.assertLess(abs(errors.mean()), 0.15) + + def test_front(self): + """The front is found among the confirmed designs by the new replicates.""" + confirmation = confirm(self.study, self.selected, self.results, OBJECTIVES) + summary = confirmation.summary + np.testing.assert_array_equal( + summary.pareto, pareto_front(summary, OBJECTIVES).to_numpy() + ) + + def test_requirements(self): + """Requirements are judged by the new replicates.""" + confirmation = confirm( + self.study, + self.selected, + self.results, + OBJECTIVES, + statistics={"reliability": Probability("value", ">=", 1.5)}, + requirements=[Requirement("reliability", ">=", 0.5)], + ) + summary = confirmation.summary + self.assertIn("reliability selected", summary.columns) + np.testing.assert_array_equal( + summary.meets_requirements, summary.reliability >= 0.5 + ) + self.assertFalse((summary.pareto & ~summary.meets_requirements).any()) + with self.assertRaises(ValueError): + confirm(self.study, self.selected, self.results, OBJECTIVES, replicates=0) diff --git a/tests/tradespace/test_fingerprint.py b/tests/tradespace/test_fingerprint.py new file mode 100644 index 00000000..cbc7257f --- /dev/null +++ b/tests/tradespace/test_fingerprint.py @@ -0,0 +1,140 @@ +""" +Unit tests for fingerprints of the definitions of trade studies. + +@author Paul T. Grogan +""" + +import os +import subprocess +import sys +import unittest +from datetime import datetime, timedelta, timezone +from functools import partial + +import numpy as np +import pandas as pd + +from tatc.schemas import Instrument +from tatc.tradespace import ( + DesignSpace, + Integer, + Real, + Study, + Uncertain, + get_fingerprint, +) + +THRESHOLD = 4 + + +def _helper(x): + return x * THRESHOLD + + +def _uses_helper(d): + return {"value": _helper(d.a)} + + +def _space(high=4, fixed=1.0, spread=1.0): + return DesignSpace( + a=Integer(1, high), + b=Real(0, lambda d: d.a * 2, step=0.5), + fixed=fixed, + noise=Uncertain.normal(0, spread), + ) + + +_SCRIPT = """ +from tatc.tradespace import DesignSpace, Integer, Study, Uncertain +space = DesignSpace(a=Integer(1, 4), names={"x", "y", "z"}, noise=Uncertain.uniform(0, 1)) +study = Study(space, lambda d: d, lambda d: {"v": d.a in {"p", "q"}}) +print(study.fingerprint) +""" + + +class TestFingerprint(unittest.TestCase): + """ + Unit tests for fingerprints. + """ + + def test_same_definitions(self): + """Separately made definitions that are the same have the same fingerprint.""" + self.assertEqual(get_fingerprint(_space()), get_fingerprint(_space())) + self.assertEqual( + get_fingerprint(lambda d: d.a + 1), get_fingerprint(lambda d: d.a + 1) + ) + + def test_space_definitions(self): + """Bounds, fixed values, and distributions change the fingerprint.""" + base = get_fingerprint(_space()) + self.assertNotEqual(base, get_fingerprint(_space(high=5))) + self.assertNotEqual(base, get_fingerprint(_space(fixed=2.0))) + self.assertNotEqual(base, get_fingerprint(_space(spread=2.0))) + + def test_functions(self): + """Code, closures, defaults, and plain globals change the fingerprint.""" + self.assertNotEqual( + get_fingerprint(lambda d: d.a + 1), get_fingerprint(lambda d: d.a + 2) + ) + fingerprints = set() + for scale in (1, 2): + fingerprints.add(get_fingerprint(lambda d, s=scale: d.a * s)) + fingerprints.add(get_fingerprint(partial(max, scale))) + self.assertEqual(len(fingerprints), 4) + global THRESHOLD # pylint: disable=global-statement + before = get_fingerprint(_uses_helper) + THRESHOLD = 5 + try: + # a plain global of a function of the same module that it calls + self.assertNotEqual(before, get_fingerprint(_uses_helper)) + finally: + THRESHOLD = 4 + + def test_values(self): + """Plain values, models, and arrays are described by content.""" + start = datetime(2026, 1, 1, tzinfo=timezone.utc) + self.assertNotEqual( + get_fingerprint(start), get_fingerprint(start + timedelta(seconds=1)) + ) + self.assertNotEqual( + get_fingerprint(Instrument(name="a", field_of_regard=30)), + get_fingerprint(Instrument(name="a", field_of_regard=40)), + ) + self.assertNotEqual( + get_fingerprint(np.arange(3)), get_fingerprint(np.arange(3) + 1) + ) + self.assertEqual(get_fingerprint({1, 2, 3}), get_fingerprint({3, 2, 1})) + # other objects are described by their type only + self.assertEqual( + get_fingerprint(pd.DataFrame({"a": [1]})), + get_fingerprint(pd.DataFrame({"a": [2]})), + ) + + def test_study(self): + """A study's fingerprint changes with its seed and random numbers.""" + + def study(**kwargs): + return Study(_space(), lambda d: d, lambda d: {"value": d.a}, **kwargs) + + fingerprints = { + study().fingerprint, + study(seed=1).fingerprint, + study(common_random_numbers=False).fingerprint, + } + self.assertEqual(len(fingerprints), 3) + # but not with the settings of its execution + self.assertEqual(study().fingerprint, study(n_jobs=2).fingerprint) + + def test_stable_between_sessions(self): + """Fingerprints do not change between sessions (with other hash seeds).""" + prints = set() + for seed in ("1", "2"): + output = subprocess.run( + [sys.executable, "-c", _SCRIPT], + capture_output=True, + text=True, + check=True, + env={**os.environ, "PYTHONHASHSEED": seed}, + ) + prints.add(output.stdout.strip()) + self.assertEqual(len(prints), 1) diff --git a/tests/tradespace/test_refinement.py b/tests/tradespace/test_refinement.py index 5af910d6..f052855c 100644 --- a/tests/tradespace/test_refinement.py +++ b/tests/tradespace/test_refinement.py @@ -5,6 +5,7 @@ """ import unittest +import warnings import numpy as np @@ -141,3 +142,53 @@ def test_tolerance(self): self.assertGreaterEqual( settled.sum(), (tolerant.pareto_probability >= 0.95).sum() ) + + def test_min_replicates(self): + """Designs with few replicates are refined whatever their probability.""" + space = DesignSpace( + x=Integer(0, 9), a=Uncertain.normal(0, 1), b=Uncertain.normal(0, 1) + ) + # equal designs, of which two replicates find some surely inefficient + study = Study( + space, + lambda d: d, + lambda d: {"a": d.a, "b": d.b}, + replicates=2, + common_random_numbers=False, + ) + designs = space.enumerate() + results = study.run(designs) + objectives = {"a": "min", "b": "min"} + before = pareto_probability(results, objectives, n_resamples=200) + self.assertTrue((before.pareto_probability == 0).any()) + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + refinement = refine( + study, designs, results, objectives, step=3, max_rounds=1 + ) + replicates = refinement.results.groupby("design").replicate.nunique() + self.assertTrue((replicates >= 5).all()) + with self.assertRaises(ValueError): + refine(study, designs, results, objectives, max_replicates=3) + + def test_partial_step(self): + """The last step of a design adds the replicates left to its limit.""" + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + refinement = refine( + self.study, + self.designs, + self.results, + OBJECTIVES, + step=4, + max_replicates=7, + max_rounds=3, + ) + replicates = refinement.results.groupby("design").replicate.nunique() + self.assertEqual(replicates.max(), 7) + self.assertTrue(set(replicates) <= {5, 7}) + + def test_warns_without_tolerance(self): + """Designs that remain uncertain without a tolerance give a warning.""" + with self.assertWarns(UserWarning): + refine(self.study, self.designs, self.results, OBJECTIVES, max_rounds=1) diff --git a/tests/tradespace/test_sensitivity.py b/tests/tradespace/test_sensitivity.py index d2512726..d614b139 100644 --- a/tests/tradespace/test_sensitivity.py +++ b/tests/tradespace/test_sensitivity.py @@ -47,6 +47,11 @@ def test_shares(self): self.assertEqual(result.loc["a", "active"], 1.0) # a variable with one level where active explains nothing within it self.assertAlmostEqual(result.loc["branch", "metric"], 0) + # the correlation ratios are no smaller than the adjusted shares + ratios = sensitivity(self.frame, ["a", "b", "c"], ["metric"], adjusted=False) + self.assertTrue( + (ratios.metric >= result.loc[ratios.index, "metric"] - 1e-12).all() + ) def test_main_effects(self): """Main effects are the means of the metric at each level.""" @@ -55,3 +60,22 @@ def test_main_effects(self): self.assertEqual(list(effects["count"]), [50] * 4) binned = main_effects(self.frame, "c", "metric", max_levels=4) self.assertEqual(len(binned), 4) + + def test_irrelevant_variable(self): + """The adjusted share of a variable that does not matter is near 0.""" + rng = np.random.default_rng(1) + adjusted, ratios = [], [] + for _ in range(100): + frame = pd.DataFrame( + {"v": rng.integers(0, 10, 20), "m": rng.normal(size=20)} + ) + adjusted.append(sensitivity(frame, ["v"], ["m"]).loc["v", "m"]) + ratios.append( + sensitivity(frame, ["v"], ["m"], adjusted=False).loc["v", "m"] + ) + # (k - 1) / (n - 1) = 9 / 19 by chance alone + self.assertGreater(np.mean(ratios), 0.35) + self.assertLess(np.mean(adjusted), 0.1) + # no more designs than levels + frame = pd.DataFrame({"v": [1, 2, 3], "m": [1.0, 2.0, 4.0]}) + self.assertTrue(np.isnan(sensitivity(frame, ["v"], ["m"]).loc["v", "m"])) diff --git a/tests/tradespace/test_store.py b/tests/tradespace/test_store.py index 4157881a..33975e09 100644 --- a/tests/tradespace/test_store.py +++ b/tests/tradespace/test_store.py @@ -27,13 +27,14 @@ def setUp(self): self.path = Path(self.directory.name) / "results.sqlite" self.space = DesignSpace(a=Integer(1, 4), noise=Uncertain.uniform(0, 1)) self.calls = [] + self.fail_at = None def tearDown(self): self.directory.cleanup() - def _study(self, store, fail_at=None, **kwargs): + def _study(self, store, **kwargs): def evaluate(d): - if fail_at is not None and len(self.calls) == fail_at: + if self.fail_at is not None and len(self.calls) == self.fail_at: raise _Interrupt() self.calls.append((d.a, d.noise)) return {"value": d.a + d.noise} @@ -48,6 +49,11 @@ def test_store_and_get(self): store.put([("d1", 0, [{"value": 1}]), ("d1", 1, [{"value": 2}])]) self.assertEqual(len(store), 2) self.assertEqual(store.get([("d1", 1), ("d2", 0)]), {("d1", 1): [{"value": 2}]}) + # records of another context are separate + store.put([("d1", 1, [{"value": 3}])], context="c") + self.assertEqual(store.get([("d1", 1)], "c"), {("d1", 1): [{"value": 3}]}) + self.assertEqual(store.get([("d1", 1)])[("d1", 1)], [{"value": 2}]) + self.assertEqual(store.contexts(), {"": 2, "c": 1}) other = ResultStore(self.path, "y") self.assertEqual(len(other), 0) store.clear() @@ -58,9 +64,11 @@ def test_store_and_get(self): def test_resume(self): """An interrupted study resumes, evaluating only what is not stored.""" store = ResultStore(self.path, "study") + self.fail_at = 5 with self.assertRaises(_Interrupt): - self._study(store, fail_at=5).run() + self._study(store).run() self.assertEqual(len(store), 5) + self.fail_at = None resumed = self._study(store).run() self.assertEqual(len(self.calls), 12) # 5 before, 7 after complete = self._study(None).run() @@ -95,3 +103,34 @@ def test_parallel(self): self.assertEqual(len(store), 12) again = study.run() pd.testing.assert_frame_equal(results, again) + + def test_other_definitions(self): + """Records of studies of other definitions are not reused.""" + store = ResultStore(self.path, "study") + self._study(store).run() + self.calls.clear() + self._study(store).run() + self.assertEqual(self.calls, []) + # another seed draws other uncertain values + with self.assertWarns(UserWarning): + reseeded = self._study(store, seed=1).run() + self.assertEqual(len(self.calls), 12) + self.assertNotEqual( + reseeded.noise.tolist(), self._study(None).run().noise.tolist() + ) + # another fixed value of the design space + self.calls.clear() + self.space = DesignSpace(a=Integer(1, 4), b=2.0, noise=Uncertain.uniform(0, 1)) + with self.assertWarns(UserWarning): + self._study(store).run() + self.assertEqual(len(self.calls), 12) + # another value that the evaluation closes over + self.calls.clear() + for offset in (0.0, 1.0): + Study( + self.space, + lambda d: d, + lambda d, offset=offset: self.calls.append(1) or {"value": offset}, + store=ResultStore(self.path, "closure"), + ).run() + self.assertEqual(len(self.calls), 8) From 802db3b910b5a875e1c9e779d53a0c9a07424d29 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Tue, 10 Nov 2026 21:38:49 -0700 Subject: [PATCH 07/52] support dynamic categorical options and design budgets in Optuna searches, record evaluation errors, enumerate unordered items once, and sweep large Pareto fronts --- CHANGELOG.md | 1 + docs/api_reference/tradespace.rst | 2 +- src/tatc/tradespace/nodes.py | 17 +++- src/tatc/tradespace/optimization.py | 115 +++++++++++++++++--------- src/tatc/tradespace/pareto.py | 40 ++++++++- src/tatc/tradespace/space.py | 78 +++++++++++++---- src/tatc/tradespace/study.py | 52 +++++++++++- tests/tradespace/test_optimization.py | 78 +++++++++++++++++ tests/tradespace/test_pareto.py | 25 ++++++ tests/tradespace/test_space.py | 62 ++++++++++++++ tests/tradespace/test_study.py | 53 +++++++++++- 11 files changed, 455 insertions(+), 68 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 5c695c6a..1f242569 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -21,6 +21,7 @@ Added: - Function `tradespace.screen` (and class `Screening`), which screens designs with studies of increasing fidelity, keeping whole fronts of the best designs of each stage for the next. - Searches of design spaces with optional optimizers: `tradespace.optimize_optuna` suggests designs with Optuna trials (`DesignSpace.suggest`, define-by-run over the hierarchical space), and `optimize_pymoo` and `make_pymoo_problem` search the unit hypercube that encodes a design space (`DesignSpace.unit_paths`, `encode`, and `decode`) with pymoo. Each design is evaluated once, and the designs proposed together are evaluated together, in parallel if the study is. Constraints of a design space may return the amount of their violation (`Infeasible.violation`), which Optuna's trials record (`set_constraint`) for its constraint-aware samplers, and which is the constraint value of pymoo problems. Optional dependencies `tradespace` (joblib, Optuna, and pymoo). - Function `tradespace.confirm` (and class `Confirmation`), which evaluates selected designs (such as a front) with new replicates that played no part in their selection, removing the optimism of the selection (the winner's curse, `Confirmation.optimism`). `ResultStore` keys evaluations by the fingerprint of a study (`Study.fingerprint`, see `get_fingerprint`: its seed, use of common random numbers, design space, and build and evaluation functions, and the version of TAT-C), warning if it holds evaluations of other definitions, which are not reused; `SatelliteCache` keys results on disk by the fingerprint of its function. `refine` treats designs with fewer than `min_replicates` (5) as uncertain whatever their probability, adds the replicates left to `max_replicates` in a last partial step, and warns if designs remain uncertain without a tolerance. `sensitivity` gives adjusted shares (epsilon squared) by default, without the share that the levels of a variable explain by chance (`adjusted=False` for correlation ratios). + - Searches with Optuna accept categorical options that depend on earlier decisions (a parameter for each set of options), use TPE with a constant liar in batches by default (which spreads the trials of a batch), and stop after `max_designs` designs evaluated (trials that suggest designs evaluated before are told their objectives without evaluating them again). A design infeasible in some of its replicates violates its feasibility by their share (`Evaluations.infeasibility`), and the first design evaluated in a search is evaluated alone, to check that evaluations give one record each. `Study` records errors of evaluations as infeasible, without storing them, with `errors="record"`. Enumeration walks the items of unordered repetitions in one order only (the same designs, in the same order, four times faster for three sun-synchronous planes), and `DesignSpace.size` counts designs without keeping them. Pareto fronts of many designs (4,096 or more, without tolerances) are found by a sweep (20,000 designs in 0.2 s rather than 17 s), and comparisons of every pair use blocks of bounded memory. - Example `SearchTradeSpace`, which searches a hierarchical trade space of constellations for the designs that sample points sufficiently: by evaluating every design, ranking them with the uncertainty of their replicates, screening, and searching with Optuna and pymoo. - The `RunOSSEMonsoon` example declares its constellation trade as a design space, caches the looks of each satellite, evaluates its replicates in parallel, and finds its Pareto-efficient designs. diff --git a/docs/api_reference/tradespace.rst b/docs/api_reference/tradespace.rst index 1d28b133..d4e6691c 100644 --- a/docs/api_reference/tradespace.rst +++ b/docs/api_reference/tradespace.rst @@ -175,4 +175,4 @@ Optimizers .. autofunction:: tatc.tradespace.make_pymoo_problem .. autoclass:: tatc.tradespace.Evaluations - :members: evaluate, results + :members: evaluate, results, worst diff --git a/src/tatc/tradespace/nodes.py b/src/tatc/tradespace/nodes.py index 387d6c13..6c6d9cd3 100644 --- a/src/tatc/tradespace/nodes.py +++ b/src/tatc/tradespace/nodes.py @@ -7,6 +7,8 @@ from __future__ import annotations +import hashlib +import json import math from collections.abc import Callable, Sequence from dataclasses import dataclass @@ -61,7 +63,8 @@ class _Domain: """ The values a variable may take where it is decided: a finite list of levels, or a continuous interval. The kind (`"real"`, `"integer"`, or - `"categorical"`) and the step between levels inform optimizers. + `"categorical"`) and the step between levels inform optimizers, as does + whether categorical levels depend on earlier decisions (`dynamic`). """ levels: list | None = None @@ -70,6 +73,7 @@ class _Domain: log: bool = False kind: str = "categorical" step: float | None = None + dynamic: bool = False def from_unit(self, u: float) -> Any: """ @@ -105,9 +109,16 @@ def to_unit(self, value: Any) -> float: def suggest(self, trial: Any, name: str) -> Any: """ - Suggests a value of the domain with an Optuna trial. + Suggests a value of the domain with an Optuna trial. Optuna requires + the same options of a categorical parameter in every trial, so the + options of a categorical variable that depend on earlier decisions + are a parameter of their own for each set of options (named by the + path and a hash of the options). """ if self.kind == "categorical": + if self.dynamic: + text = json.dumps(self.levels, sort_keys=True, default=str) + name = f"{name}#{hashlib.sha1(text.encode()).hexdigest()[:8]}" return trial.suggest_categorical(name, self.levels) if self.kind == "integer": return trial.suggest_int( @@ -244,7 +255,7 @@ def domain(self, scope: Scope) -> _Domain: options = list(_resolve(self.options, scope)) if len(options) == 0: raise Infeasible("no options") - return _Domain(levels=options) + return _Domain(levels=options, dynamic=callable(self.options)) def __repr__(self) -> str: return f"Categorical({self.options!r})" diff --git a/src/tatc/tradespace/optimization.py b/src/tatc/tradespace/optimization.py index f76ead7d..369deae7 100644 --- a/src/tatc/tradespace/optimization.py +++ b/src/tatc/tradespace/optimization.py @@ -73,7 +73,12 @@ def __init__( self.violations: dict[str, tuple[float, ...] | None] = {} """dict: The violation of each requirement by each evaluated design (by key), or `None` if it is infeasible.""" + self.infeasibility: dict[str, float] = {} + """dict: The share of the replicates of each evaluated design (by + key) that are infeasible (0 for a feasible design), the violation of + its feasibility for constraint-aware optimizers.""" self._records: list[pd.DataFrame] = [] + self._checked = False @property def results(self) -> pd.DataFrame: @@ -86,7 +91,10 @@ def results(self) -> pd.DataFrame: def evaluate(self, designs: list[Design]) -> list[tuple[float, ...] | None]: """ Gets the objectives of designs, evaluating those not yet evaluated - together (see also `violations`). + together (see also `violations`). A design is infeasible if any of + its replicates is (see `infeasibility`). The first design evaluated + is evaluated alone, to check that the study's evaluations give one + record each before evaluating others. Args: designs (list[Design]): The designs. @@ -96,32 +104,44 @@ def evaluate(self, designs: list[Design]) -> list[tuple[float, ...] | None]: the order of the objectives, or `None` if it is infeasible """ new = list({d.key: d for d in designs if d.key not in self.values}.values()) + if new and not self._checked: + self._run(new[:1]) + new = new[1:] if new: - records = self.study.run(new) - self._records.append(records) - if records.groupby(["design", "replicate"]).size().max() > 1: - raise ValueError( - "objectives need one record per evaluation: make the " - + "study's evaluate function return a mapping of metrics" - ) - infeasible = set(records.loc[~records["feasible"], "design"]) - for key in infeasible: - self.values[key] = self.violations[key] = None - feasible = records[~records["design"].isin(infeasible)] - if len(feasible) > 0: - metrics = sorted({s.column for s in self.statistics.values()}) - keys, _, matrices = _get_matrices(feasible, metrics) - values, _ = _evaluate(self.statistics, [], matrices) - for i, key in enumerate(keys): - self.values[key] = tuple( - float(values[name][i]) for name in self.objectives - ) - self.violations[key] = tuple( - float(requirement.violation(values[requirement.name][i])) - for requirement in self.requirements - ) + self._run(new) return [self.values[d.key] for d in designs] + def _run(self, designs: list[Design]) -> None: + """ + Evaluates designs, recording their objectives and violations. + """ + records = self.study.run(designs) + self._records.append(records) + if records.groupby(["design", "replicate"]).size().max() > 1: + raise ValueError( + "objectives need one record per evaluation: make the " + + "study's evaluate function return a mapping of metrics" + ) + self._checked = self._checked or bool(records["feasible"].any()) + shares = 1.0 - records.groupby("design")["feasible"].mean() + self.infeasibility.update(shares.astype(float).to_dict()) + infeasible = set(shares.index[shares > 0]) + for key in infeasible: + self.values[key] = self.violations[key] = None + feasible = records[~records["design"].isin(infeasible)] + if len(feasible) > 0: + metrics = sorted({s.column for s in self.statistics.values()}) + keys, _, matrices = _get_matrices(feasible, metrics) + values, _ = _evaluate(self.statistics, [], matrices) + for i, key in enumerate(keys): + self.values[key] = tuple( + float(values[name][i]) for name in self.objectives + ) + self.violations[key] = tuple( + float(requirement.violation(values[requirement.name][i])) + for requirement in self.requirements + ) + def worst(self) -> list[float]: """ Gets the worst value of each objective of the feasible designs @@ -154,6 +174,7 @@ def optimize_optuna( constraints: bool = True, statistics: Mapping[str, Statistic | str] | None = None, requirements: Sequence[Requirement] = (), + max_designs: int | None = None, ) -> tuple[Any, pd.DataFrame]: """ Searches a study's design space with Optuna: each trial suggests a design @@ -163,8 +184,8 @@ def optimize_optuna( With `constraints`, each trial records the violation of the constraints of its design (`trial.set_constraint`, under the name `"feasibility"`): 0 for a feasible design, the amount by which it violates a constraint of - the design space (see `DesignSpace`), or 1 if the study finds it - infeasible. Optuna's constraint-aware samplers (such as TPE and NSGA-II) + the design space (see `DesignSpace`), or the share of its replicates + that the study finds infeasible. Optuna's constraint-aware samplers (such as TPE and NSGA-II) then prefer feasible designs, and infeasible designs that violate their constraints less. An infeasible trial is told the worst objectives of the feasible designs evaluated before it, which these samplers do not use to @@ -177,16 +198,26 @@ def optimize_optuna( Trials are asked in batches, whose designs are evaluated together (in parallel, if the study is) before they are told. A batch defaults to one - trial per worker of the study. + trial per worker of the study. The default sampler is TPE, which, in + batches, tells its pending trials the worst values evaluated so far + (`constant_liar`), so that a batch spreads its trials rather than + suggesting nearly the same design several times. + + Samplers suggest designs evaluated before, especially in small design + spaces: such trials are told the objectives of the design without + evaluating it again. The trials (`n_trials`) are then a poor measure of + the cost of a search; `max_designs` limits the designs evaluated + instead (the search stops once it has evaluated as many, or after + `n_trials`). Args: study (Study): The study that evaluates designs. objectives (Mapping[str, str]): The objectives: columns of the results and their directions (`"min"` or `"max"`). n_trials (int): The number of trials. - sampler (optuna.samplers.BaseSampler | None): The sampler, if not - Optuna's default (TPE with one objective, NSGA-II with several); - ignored with an `optuna_study`. + sampler (optuna.samplers.BaseSampler | None): The sampler, or `None` + for TPE (with a constant liar in batches); ignored with an + `optuna_study`. optuna_study (optuna.Study | None): A study to continue, whose directions are those of the objectives. batch_size (int | None): The number of trials evaluated together. @@ -195,6 +226,7 @@ def optimize_optuna( statistics (Mapping[str, Statistic | str] | None): Statistics, by name, of objectives and requirements that are not means. requirements (Sequence[Requirement]): Requirements on statistics. + max_designs (int | None): The most designs to evaluate, if limited. Returns: tuple[optuna.Study, pandas.DataFrame]: the Optuna study, and the @@ -212,9 +244,11 @@ def optimize_optuna( "minimize" if direction == "min" else "maximize" for direction in evaluations.objectives.values() ] + batch_size = batch_size or study.workers if optuna_study is None: + if sampler is None: + sampler = optuna.samplers.TPESampler(constant_liar=batch_size > 1) optuna_study = optuna.create_study(directions=directions, sampler=sampler) - batch_size = batch_size or study.workers constrained = constraints and hasattr(optuna.trial.Trial, "set_constraint") if requirements and not constrained: raise ValueError("requirements need constraints (and Optuna 5 or later)") @@ -234,8 +268,13 @@ def infeasible(trial: Any, violation: float) -> None: remaining = n_trials while remaining > 0: + size = min(batch_size, remaining) + if max_designs is not None: + size = min(size, max_designs - len(evaluations.values)) + if size <= 0: + break trials, designs = [], [] - for _ in range(min(batch_size, remaining)): + for _ in range(size): trial = optuna_study.ask() try: design = study.space.suggest(trial) @@ -246,12 +285,12 @@ def infeasible(trial: Any, violation: float) -> None: trial.set_user_attr("design", design.key) trials.append(trial) designs.append(design) - remaining -= min(batch_size, remaining) + remaining -= size for trial, design, values in zip( trials, designs, evaluations.evaluate(designs) ): if values is None: - infeasible(trial, 1.0) + infeasible(trial, evaluations.infeasibility[design.key]) else: if constrained: violations = evaluations.violations[design.key] @@ -275,9 +314,9 @@ def make_pymoo_problem( objectives are negated), and its constraint (`G <= 0`) is violated by designs that violate a constraint of the design space (by the amount of the violation, see `DesignSpace`) or that the study finds infeasible (by - 1). Each requirement is a further constraint, whose value is its - violation (see `Requirement.violation`). The designs of a population are - evaluated together. + the share of their infeasible replicates). Each requirement is a further + constraint, whose value is its violation (see `Requirement.violation`). + The designs of a population are evaluated together. The problem keeps its evaluations (`evaluations`, see `Evaluations`), whose `results` are those of every evaluation (see `Study.run`). @@ -338,6 +377,8 @@ def _evaluate(self, x, out, *args, **kwargs): unmet = np.zeros((len(designs), n_requirements)) for i, design in enumerate(designs): value = None if design is None else next(values) + if design is not None and value is None: + violation[i] = max(evaluations.infeasibility[design.key], 1e-9) if value is not None: value = np.where(np.isnan(value), evaluations.worst(), value) costs[i] = signs * np.asarray(value) diff --git a/src/tatc/tradespace/pareto.py b/src/tatc/tradespace/pareto.py index 77a659bc..62df688b 100644 --- a/src/tatc/tradespace/pareto.py +++ b/src/tatc/tradespace/pareto.py @@ -97,17 +97,49 @@ def _get_tolerances( return values -def _dominated( - costs: np.ndarray, tolerances: np.ndarray | None = None, block: int = 512 -) -> np.ndarray: +_BLOCK_ELEMENTS = 2_000_000 +"""The most elements of the temporary arrays of a block of comparisons.""" + +_SWEEP_POINTS = 4096 +"""The fewest points whose dominance (without tolerances) is found by a sweep.""" + + +def _dominated_sweep(costs: np.ndarray) -> np.ndarray: + """ + Finds the points dominated by another (without tolerances) by a sweep in + lexicographic order, in which a point can only be dominated by points + before it, and is dominated by one if it is by any (dominance is + transitive), so that each point is compared only with the efficient + points before it. + """ + order = np.lexsort(costs.T[::-1]) + dominated = np.zeros(len(costs), dtype=bool) + efficient = np.empty((0, costs.shape[1])) + for index in order: + point = costs[index] + if len(efficient) > 0 and np.any( + np.all(efficient <= point, axis=1) & np.any(efficient < point, axis=1) + ): + dominated[index] = True + else: + efficient = np.vstack([efficient, point]) + return dominated + + +def _dominated(costs: np.ndarray, tolerances: np.ndarray | None = None) -> np.ndarray: """ Finds the points (rows of costs) dominated by another, even if the other is penalized by the tolerances: no worse in every cost, and better in at least one, by at least its tolerance (absolute, plus a share of the magnitude of the cost of the point it would dominate, see - `_get_tolerances`). + `_get_tolerances`). Points are compared with every other in blocks, + whose temporary arrays are limited to a few million elements, or, for + many points without tolerances, by a sweep (see `_dominated_sweep`). """ n = len(costs) + if n >= _SWEEP_POINTS and (tolerances is None or not np.any(tolerances)): + return _dominated_sweep(costs) + block = max(1, min(n, _BLOCK_ELEMENTS // max(n * costs.shape[1], 1))) tolerances = np.zeros((2, costs.shape[1])) if tolerances is None else tolerances absolute, relative = tolerances dominated = np.zeros(n, dtype=bool) diff --git a/src/tatc/tradespace/space.py b/src/tatc/tradespace/space.py index 1887915c..fb425f31 100644 --- a/src/tatc/tradespace/space.py +++ b/src/tatc/tradespace/space.py @@ -25,7 +25,7 @@ import hashlib import json import zlib -from collections.abc import Callable, Sequence +from collections.abc import Callable, Iterator, Sequence from functools import partial from typing import Any @@ -83,7 +83,8 @@ class _Context: decides a variable, `draw(path, node)` draws an uncertain parameter (or `None` for nominal values), and `check` enables constraints. If given, `record(path, domain, value)` is called with every decision, chosen or - prescribed. + prescribed. With an `odometer` (of an enumeration), the items of + unordered repetitions are only walked in the order of their levels. """ def __init__( @@ -92,9 +93,10 @@ def __init__( draw: Callable[[str, Uncertain], Any] | None = None, check: bool = True, record: Callable[[str, _Domain, Any], None] | None = None, + odometer: _Odometer | None = None, ): self.choose, self.draw, self.check = choose, draw, check - self.record = record + self.record, self.odometer = record, odometer def decide(self, path: str, domain: _Domain, prescribed: Any) -> Any: """ @@ -109,6 +111,13 @@ def decide(self, path: str, domain: _Domain, prescribed: Any) -> Any: return value +class _Unsorted(Infeasible): + """ + Raised while enumerating a walk whose unordered items are not in the + order of their levels: another walk gives the same design. + """ + + def _join(path: str, name: str) -> str: return f"{path}.{name}" if path else name @@ -254,20 +263,33 @@ def _walk_items( if publish is not None: publish(result) decisions = [] + # with an odometer, permutations of unordered items give the same design: + # enumerate only the first, whose items are in the order of their levels + odometer = ctx.odometer if prescribed is _ABSENT and not node.ordered else None + previous: list[int] | None = None for k in range(count): sub = _ABSENT if prescribed is _ABSENT else prescribed[k] - value, decision = _walk( - node.item, - f"{path}[{k}]", - scope.push({}, k), - ctx, - _ABSENT if sub is None else sub, - result.items.append, - ) + start = 0 if odometer is None else odometer.position + if odometer is not None and previous is not None: + odometer.floors.append((start, previous)) + try: + value, decision = _walk( + node.item, + f"{path}[{k}]", + scope.push({}, k), + ctx, + _ABSENT if sub is None else sub, + result.items.append, + ) + finally: + if odometer is not None and previous is not None: + odometer.floors.pop() if len(result.items) == k: # a value that is not a container is not published result.items.append(value) decisions.append(None if decision is _ABSENT else decision) + if odometer is not None: + previous = odometer.indices[start : odometer.position] return result, decisions @@ -445,11 +467,16 @@ def __init__(self): self.indices: list[int] = [] self.sizes: list[int] = [] self.position = 0 + self.floors: list[tuple[int, list[int]]] = [] + """The levels of the previous unordered items (and where the + current items' levels start), which the current items must not + precede.""" def choose(self, path: str, domain: _Domain) -> Any: """ Chooses the level of the current digit of the odometer (adding a - digit, at the first level, if the walk is longer than before). + digit, at the first level, if the walk is longer than before), and + stops a walk whose unordered items precede the previous ones. """ if domain.levels is None: raise ValueError( @@ -462,6 +489,10 @@ def choose(self, path: str, domain: _Domain) -> Any: self.sizes.append(len(domain.levels)) level = domain.levels[self.indices[self.position]] self.position += 1 + for start, previous in self.floors: + current = self.indices[start : self.position] + if current < previous[: len(current)]: + raise _Unsorted() return level def advance(self) -> bool: @@ -471,6 +502,7 @@ def advance(self) -> bool: """ del self.indices[self.position :], self.sizes[self.position :] self.position = 0 + self.floors.clear() while self.indices: if self.indices[-1] + 1 < self.sizes[-1]: self.indices[-1] += 1 @@ -556,26 +588,36 @@ def enumerate(self) -> list[Design]: Raises: ValueError: if a design variable is continuous. """ + return list(self._iterate()) + + def _iterate(self) -> Iterator[Design]: + """ + Iterates over every feasible design (see `enumerate`). The items of + unordered repetitions are walked in only one of their orders, so + that their permutations are not walked. + """ odometer = _Odometer() - ctx = _Context(choose=odometer.choose) - designs: dict[str, Design] = {} + ctx = _Context(choose=odometer.choose, odometer=odometer) + keys: set[str] = set() while True: try: design = self._design(ctx) - designs.setdefault(design.key, design) + if design.key not in keys: + keys.add(design.key) + yield design except Infeasible: pass if not odometer.advance(): - return list(designs.values()) + return def size(self) -> int: """ - Counts the feasible designs (see `enumerate`). + Counts the feasible designs (see `enumerate`), without keeping them. Returns: int: the number of designs """ - return len(self.enumerate()) + return sum(1 for _ in self._iterate()) def sample( self, diff --git a/src/tatc/tradespace/study.py b/src/tatc/tradespace/study.py index d4d5e882..412041fd 100644 --- a/src/tatc/tradespace/study.py +++ b/src/tatc/tradespace/study.py @@ -25,6 +25,10 @@ _STATUS_COLUMNS = ["design", "replicate", "feasible", "error", "seconds"] """Columns of the results of a study that are neither design values nor metrics.""" +_FAILED = "_failed" +"""A key of the records of evaluations that failed (with `errors="record"`), which +are not stored.""" + def _get_executor(n_jobs: int) -> Executor: """ @@ -67,7 +71,11 @@ class Study: A design that `build` rejects with a `ValueError` (which includes the validation errors of TAT-C's schemas) is recorded as infeasible, with - the error, rather than raised. + the error, rather than raised. Other errors of `build` or `evaluate` + are raised, which stops the study, unless `errors` is `"record"`: then + the evaluation is recorded as infeasible, with the type of the error and + its message, and is not kept in the study's store, so that a later run + evaluates it again. Evaluations run in parallel with `n_jobs` worker processes (or an `executor` with the interface of `concurrent.futures.Executor`). They are @@ -95,6 +103,9 @@ class Study: executor (concurrent.futures.Executor | None): An executor to use instead of worker processes. chunks_per_job (int): The number of chunks of evaluations per worker. + errors (str): `"raise"` to raise the errors of evaluations (other than + those of designs that `build` rejects), or `"record"` to record + them as infeasible evaluations. store (ResultStore | None): A store of the records of evaluations, from which evaluations stored before (by a study of the same fingerprint, see `fingerprint`) are taken rather than evaluated @@ -114,7 +125,10 @@ def __init__( executor: Executor | None = None, chunks_per_job: int = 2, store: ResultStore | None = None, + errors: str = "raise", ): + if errors not in ("raise", "record"): + raise ValueError(f"errors must be 'raise' or 'record', not {errors!r}") if replicates < 1: raise ValueError("replicates must be at least 1") if n_jobs == 0 or n_jobs < -1: @@ -127,6 +141,7 @@ def __init__( self.n_jobs, self.executor = n_jobs, executor self.chunks_per_job = chunks_per_job self.store = store + self.errors = errors def __getstate__(self) -> dict: # an executor and a store are not sent to workers @@ -145,7 +160,16 @@ def _evaluate(self, design: Design, replicate: int) -> list[dict]: built = self.build(realized) except ValueError as error: return [{**base, "feasible": False, "error": str(error)}] - outcome = self.evaluate(built) + except Exception as error: # pylint: disable=broad-exception-caught + if self.errors == "raise": + raise + return [self._failure(base, error)] + try: + outcome = self.evaluate(built) + except Exception as error: # pylint: disable=broad-exception-caught + if self.errors == "raise": + raise + return [self._failure(base, error)] base.update(feasible=True, seconds=time.perf_counter() - began) if isinstance(outcome, pd.DataFrame): named = any(name is not None for name in outcome.index.names) @@ -153,6 +177,14 @@ def _evaluate(self, design: Design, replicate: int) -> list[dict]: return [{**base, **record} for record in frame.to_dict("records")] return [{**base, **dict(outcome)}] + @staticmethod + def _failure(base: dict, error: Exception) -> dict: + """ + Gets the record of an evaluation that failed. + """ + message = f"{type(error).__name__}: {error}" + return {**base, "feasible": False, "error": message, _FAILED: True} + def _run_chunk(self, tasks: list[tuple[int, Design, int]]) -> list[list[dict]]: """ Evaluates a chunk of tasks (index, design, replicate) in turn. @@ -261,7 +293,7 @@ def run( for done, (i, design, replicate) in enumerate(tasks, 1): records = self._evaluate(design, replicate) results.append((i, replicate, records)) - if self.store is not None: + if self.store is not None and not _failed(records): self.store.put([(design.key, replicate, records)], context) if progress is not None: progress(done, total) @@ -284,6 +316,7 @@ def run( ( (design.key, replicate, records) for (_, design, replicate), records in zip(chunk, evaluated) + if not _failed(records) ), context, ) @@ -292,10 +325,21 @@ def run( progress(done, total) results.sort(key=lambda result: (result[0], result[1])) return pd.DataFrame.from_records( - [record for _, _, records in results for record in records] + [ + {k: v for k, v in record.items() if k != _FAILED} + for _, _, records in results + for record in records + ] ) +def _failed(records: list[dict]) -> bool: + """ + Whether the records are of an evaluation that failed. + """ + return any(record.get(_FAILED, False) for record in records) + + def summarize( results: pd.DataFrame, metrics: Sequence[str], diff --git a/tests/tradespace/test_optimization.py b/tests/tradespace/test_optimization.py index 85d26b09..bdfccf30 100644 --- a/tests/tradespace/test_optimization.py +++ b/tests/tradespace/test_optimization.py @@ -372,3 +372,81 @@ def test_pymoo(self): requirements=self.REQUIREMENTS, ) self.assertEqual(result.pop.get("G").shape[1], 2) + + +@unittest.skipUnless(HAS_OPTUNA, "optuna is not installed") +class TestOptunaSearch(unittest.TestCase): + """ + Unit tests for searches with Optuna: dynamic options, batches, and budgets. + """ + + def test_dynamic_options(self): + """Categorical options that depend on earlier decisions are searched.""" + import optuna # pylint: disable=import-outside-toplevel + + space = DesignSpace( + kind=Categorical(["a", "b"]), + option=Categorical(lambda d: ["x", "y"] if d.kind == "a" else ["z"]), + ) + study = Study(space, lambda d: d, lambda d: {"f": float(d.option == "x")}) + optuna_study, results = optimize_optuna( + study, + {"f": "max"}, + n_trials=20, + sampler=optuna.samplers.RandomSampler(seed=1), + ) + self.assertEqual(set(results.option), {"x", "y", "z"}) + self.assertEqual(optuna_study.best_value, 1.0) + + def test_default_sampler(self): + """The default sampler lies about pending trials in batches.""" + study = Study(DesignSpace(x=Integer(0, 9)), lambda d: d, lambda d: {"f": d.x}) + batched, _ = optimize_optuna(study, {"f": "min"}, n_trials=4, batch_size=2) + single, _ = optimize_optuna(study, {"f": "min"}, n_trials=2, batch_size=1) + # pylint: disable=protected-access + self.assertTrue(batched.sampler._constant_liar) + self.assertFalse(single.sampler._constant_liar) + + def test_max_designs(self): + """The search stops once it has evaluated the most designs.""" + study = Study(DesignSpace(x=Integer(0, 2)), lambda d: d, lambda d: {"f": d.x}) + optuna_study, results = optimize_optuna( + study, {"f": "min"}, n_trials=50, max_designs=2, batch_size=1 + ) + self.assertEqual(results.design.nunique(), 2) + self.assertLessEqual(len(optuna_study.trials), 50) + + def test_partially_infeasible(self): + """A design infeasible in some replicates violates by their share.""" + space = DesignSpace(x=Integer(0, 1), noise=Uncertain.uniform(0, 1)) + + def build(d): + if d.x == 1 and d.noise < 0.5: + raise ValueError("unlucky") + return d + + study = Study(space, build, lambda d: {"f": d.x}, replicates=8) + evaluations = Evaluations(study, {"f": "max"}) + values = evaluations.evaluate(space.enumerate()) + self.assertIsNotNone(values[0]) + self.assertIsNone(values[1]) + share = evaluations.infeasibility[space.enumerate()[1].key] + self.assertGreater(share, 0) + self.assertLess(share, 1) + optuna_study, _ = optimize_optuna(study, {"f": "max"}, n_trials=6) + for trial in optuna_study.trials: + if trial.params.get("x") == 1: + self.assertAlmostEqual(trial.constraints["feasibility"], share) + + def test_records_checked_first(self): + """A study of several records per evaluation fails after one design.""" + calls = [] + + def evaluate(d): + calls.append(d.x) + return pd.DataFrame({"f": [d.x, d.x]}, index=pd.Index([0, 1], name="k")) + + study = Study(DesignSpace(x=Integer(0, 9)), lambda d: d, evaluate) + with self.assertRaises(ValueError): + Evaluations(study, {"f": "min"}).evaluate(study.space.enumerate()) + self.assertEqual(len(calls), 1) diff --git a/tests/tradespace/test_pareto.py b/tests/tradespace/test_pareto.py index 66d67080..d5eceab7 100644 --- a/tests/tradespace/test_pareto.py +++ b/tests/tradespace/test_pareto.py @@ -187,3 +187,28 @@ def test_groups(self): self.assertEqual( sorted(zip(winners.sensor, winners.design)), [("a", "d1"), ("b", "d0")] ) + + +class TestManyPoints(unittest.TestCase): + """ + Unit tests for the dominance of many points. + """ + + def test_sweep(self): + """A sweep finds the same dominated points as comparisons of every pair.""" + # pylint: disable=import-outside-toplevel,protected-access + from tatc.tradespace import pareto + + rng = np.random.default_rng(3) + for costs in ( + rng.random((500, 3)), + rng.integers(0, 4, (500, 3)).astype(float), + np.vstack([rng.random((100, 2))] * 3), + ): + np.testing.assert_array_equal( + pareto._dominated_sweep(costs), pareto._dominated(costs) + ) + many = rng.random((pareto._SWEEP_POINTS + 10, 3)) + frame = pd.DataFrame(many, columns=["a", "b", "c"]) + front = pareto_front(frame, {"a": "min", "b": "min", "c": "min"}) + np.testing.assert_array_equal(~front.to_numpy(), pareto._dominated_sweep(many)) diff --git a/tests/tradespace/test_space.py b/tests/tradespace/test_space.py index 7bbffd1a..a3a8a3aa 100644 --- a/tests/tradespace/test_space.py +++ b/tests/tradespace/test_space.py @@ -231,3 +231,65 @@ def test_uncertain_choice(self): design = space.enumerate()[0] self.assertIsNone(design.epoch) self.assertEqual({design.realize(r).epoch for r in range(20)}, {"jan", "jul"}) + + +class TestEnumeration(unittest.TestCase): + """ + Unit tests for the enumeration of unordered repetitions, which walks only + one order of their items. + """ + + @staticmethod + def _every_walk(space): + """Enumerates by walking every order of the items.""" + # pylint: disable=import-outside-toplevel,protected-access + from tatc.tradespace.space import _Context, _Odometer + + odometer = _Odometer() + ctx = _Context(choose=odometer.choose) + designs = {} + while True: + try: + design = space._design(ctx) + designs.setdefault(design.key, design) + except Infeasible: + pass + if not odometer.advance(): + return list(designs.values()) + + def test_same_designs(self): + """Walking one order of unordered items gives the same designs.""" + spaces = [ + DesignSpace( + items=Repeat( + DesignSpace( + kind=Choice( + a=DesignSpace(x=Integer(0, 2)), + b=DesignSpace(y=Categorical(["p", "q"]), z=Integer(5, 12)), + ) + ), + count=Integer(0, 3), + ordered=False, + ) + ), + DesignSpace( + outer=Repeat( + DesignSpace( + inner=Repeat( + DesignSpace(v=Integer(0, 2)), + count=Integer(1, 2), + ordered=False, + ) + ), + count=Integer(1, 2), + ordered=False, + ), + constraints=[lambda d: len(d.outer) < 2 or d.outer[0].inner[0].v != 1], + ), + ] + for space in spaces: + expected = self._every_walk(space) + designs = space.enumerate() + self.assertEqual([d.key for d in designs], [d.key for d in expected]) + self.assertEqual([d.flat() for d in designs], [d.flat() for d in expected]) + self.assertEqual(space.size(), len(expected)) diff --git a/tests/tradespace/test_study.py b/tests/tradespace/test_study.py index 3d68cce3..eb5e69db 100644 --- a/tests/tradespace/test_study.py +++ b/tests/tradespace/test_study.py @@ -4,7 +4,9 @@ @author Paul T. Grogan """ +import tempfile import unittest +from pathlib import Path from concurrent.futures import ThreadPoolExecutor from datetime import datetime, timezone @@ -12,7 +14,15 @@ import pandas as pd from tatc.schemas import CircularOrbit, Satellite, WalkerConstellation -from tatc.tradespace import DesignSpace, Integer, Real, Study, Uncertain, summarize +from tatc.tradespace import ( + DesignSpace, + Integer, + Real, + ResultStore, + Study, + Uncertain, + summarize, +) class TestStudy(unittest.TestCase): @@ -168,3 +178,44 @@ def test_summarize_by(self): self.assertEqual(len(summary), 18) b = summary[(summary.sensor == "b") & (summary.planes == 3)] self.assertTrue((b.value == 6).all()) + + +class TestErrors(unittest.TestCase): + """ + Unit tests for errors of evaluations. + """ + + def setUp(self): + self.space = DesignSpace(a=Integer(1, 4)) + self.fail = True + + def _evaluate(self, d): + if self.fail and d.a == 3: + raise RuntimeError("diverged") + return {"value": d.a} + + def test_raise(self): + """Errors other than rejections of designs are raised by default.""" + with self.assertRaises(RuntimeError): + Study(self.space, lambda d: d, self._evaluate).run() + with self.assertRaises(ValueError): + Study(self.space, lambda d: d, self._evaluate, errors="ignore") + + def test_record(self): + """Errors are recorded as infeasible evaluations, which are not stored.""" + with tempfile.TemporaryDirectory() as directory: + store = ResultStore(Path(directory) / "results.sqlite", "errors") + study = Study( + self.space, lambda d: d, self._evaluate, errors="record", store=store + ) + results = study.run() + failed = results[~results.feasible] + self.assertEqual(list(failed.a), [3]) + self.assertEqual(failed.error.iloc[0], "RuntimeError: diverged") + self.assertNotIn("_failed", results.columns) + self.assertEqual(len(store), 3) + # a later run evaluates the failed evaluation again + self.fail = False + again = study.run() + self.assertTrue(again.feasible.all()) + self.assertEqual(len(store), 4) From dea6787128594b577ef42503f6c09c916b050225 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Tue, 10 Nov 2026 22:16:53 -0700 Subject: [PATCH 08/52] add phase and node fractions of the lead satellite of Walker layouts --- CHANGELOG.md | 2 +- src/tatc/tradespace/constellations.py | 55 +++++++++++++-- tests/tradespace/test_constellations.py | 89 +++++++++++++++++++++++++ 3 files changed, 140 insertions(+), 6 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 1f242569..d8a46b1e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,7 +17,7 @@ Added: - Statistics of metrics over replicates (`tradespace.Mean`, `StandardDeviation`, `Minimum`, `Maximum`, `Quantile`, and `Probability`, the share of replicates that meet a threshold) and requirements on them (`Requirement`, output constraints that designs meet or violate by an amount once evaluated). `aggregate` gives the statistics and violations of each design; objectives and requirements of `pareto_probability` (which also gives the probability of meeting the requirements), `screen` (which ranks designs that miss requirements after those that meet them), `optimize_optuna` (a constraint of each trial for each requirement), and `optimize_pymoo` (a constraint for each requirement) name statistics, or metrics whose means they are. - Function `tradespace.refine` (and class `Refinement`), which adds replicates only to the designs whose Pareto efficiency is uncertain, until it is settled, optionally with a tolerance of differences that do not matter (also of `pareto_probability`); `Study.run` evaluates given replicates (`replicates`). - Class `tradespace.ResultStore`, a persistent store (SQLite) of the evaluations of a study (argument `store` of `Study`), from which a study that is interrupted or extended takes the evaluations stored before. Function `tradespace.sensitivity` (and `main_effects`), the share of the variance of metrics explained by each design variable where it is active. Tolerances of objectives may be percentages of their values (such as `"5%"`). `Uncertain.seed` draws a seed of random numbers for each replicate, and `remove_failures` removes the satellites that fail, the same in every design. - - Building blocks of constellations: fragments of design spaces of Walker constellations (`tradespace.walker_space`) and planes of sun-synchronous orbits (`sso_planes_space`, whose planes have different crossing times), `build_constellation`, which builds the satellites of either with instruments or entries of the instrument catalog (with their validated attitudes, and several entries on one satellite), and `count_satellites` and `count_planes`. + - Building blocks of constellations: fragments of design spaces of Walker constellations (`tradespace.walker_space`) and planes of sun-synchronous orbits (`sso_planes_space`, whose planes have different crossing times), `build_constellation`, which builds the satellites of either with instruments or entries of the instrument catalog (with their validated attitudes, and several entries on one satellite), and `count_satellites` and `count_planes`. The phase and node of the lead satellite of a Walker constellation (`phase_fraction` and `node_fraction`, design variables or uncertain parameters) are fractions of the intervals over which they give distinct constellations (`360 / per_plane` degrees of phase, and `360 / planes` degrees of node for a delta configuration or 360 for a star), so that a search does not evaluate the same constellation at several phases or nodes. - Function `tradespace.screen` (and class `Screening`), which screens designs with studies of increasing fidelity, keeping whole fronts of the best designs of each stage for the next. - Searches of design spaces with optional optimizers: `tradespace.optimize_optuna` suggests designs with Optuna trials (`DesignSpace.suggest`, define-by-run over the hierarchical space), and `optimize_pymoo` and `make_pymoo_problem` search the unit hypercube that encodes a design space (`DesignSpace.unit_paths`, `encode`, and `decode`) with pymoo. Each design is evaluated once, and the designs proposed together are evaluated together, in parallel if the study is. Constraints of a design space may return the amount of their violation (`Infeasible.violation`), which Optuna's trials record (`set_constraint`) for its constraint-aware samplers, and which is the constraint value of pymoo problems. Optional dependencies `tradespace` (joblib, Optuna, and pymoo). - Function `tradespace.confirm` (and class `Confirmation`), which evaluates selected designs (such as a front) with new replicates that played no part in their selection, removing the optimism of the selection (the winner's curse, `Confirmation.optimism`). `ResultStore` keys evaluations by the fingerprint of a study (`Study.fingerprint`, see `get_fingerprint`: its seed, use of common random numbers, design space, and build and evaluation functions, and the version of TAT-C), warning if it holds evaluations of other definitions, which are not reused; `SatelliteCache` keys results on disk by the fingerprint of its function. `refine` treats designs with fewer than `min_replicates` (5) as uncertain whatever their probability, adds the replicates left to `max_replicates` in a last partial step, and warns if designs remain uncertain without a tolerance. `sensitivity` gives adjusted shares (epsilon squared) by default, without the share that the levels of a variable explain by chance (`adjusted=False` for correlation ratios). diff --git a/src/tatc/tradespace/constellations.py b/src/tatc/tradespace/constellations.py index 1ff02300..b0b3d1ad 100644 --- a/src/tatc/tradespace/constellations.py +++ b/src/tatc/tradespace/constellations.py @@ -40,7 +40,7 @@ def build(d): SunSynchronousOrbit, WalkerConstellation, ) -from .nodes import Fixed, Integer, Real, Repeat +from .nodes import Derived, Fixed, Integer, Real, Repeat from .space import DesignSpace from .values import ChoiceValues, Scope, Values @@ -62,15 +62,35 @@ def walker_space( relative_spacing: Any = None, altitude: Any = None, configuration: Any = "delta", + phase_fraction: Any = 0.0, + node_fraction: Any = 0.0, constraints: Sequence[Callable[[Scope], Any]] = (), ) -> DesignSpace: """ Gets a fragment of a design space of Walker constellations (see `tatc.schemas.WalkerConstellation`): their inclination (degrees), number of planes, number of satellites in each plane, relative spacing of - satellites between planes, and (optionally, if not given to - `build_constellation`) altitude (meters). Each is a node of a design - space (such as a design variable) or a value. + satellites between planes, the phase and node of the lead satellite, and + (optionally, if not given to `build_constellation`) altitude (meters). + Each is a node of a design space (such as a design variable) or a value. + + The phase (true anomaly) and node (right ascension of the ascending + node) of the lead satellite are given as fractions of the intervals over + which they give distinct constellations: shifting every satellite's + phase by `360 / per_plane` degrees moves each onto the next in its plane, + and shifting every plane's node by `360 / planes` degrees (of a delta + configuration) moves each onto the next plane, which, with the shift of + phase between planes (`360 * relative_spacing / satellites`), gives the + same constellation. Fractions in [0, 1) of both therefore give every + distinct constellation once, without searching the same constellation + at several phases or nodes. A star configuration has no such symmetry of + its nodes (its planes span 180 degrees, and the next plane after the + last is the first, in the opposite direction), so its fraction of the + node is of 360 degrees. The fractions may be design variables (such as + `Real(0, 0.75, step=0.25)`, without 1, which is the same as 0) or + uncertain parameters (such as `Uncertain.uniform(0, 1)`), and the + fragment derives the lead satellite's `true_anomaly` and `right_ascension` + (degrees) from them. Args: inclination (Any): The inclination, by default a variable from 30 to @@ -82,6 +102,11 @@ def walker_space( from 0 to the number of planes less 1. altitude (Any): The altitude, if part of the layout. configuration (Any): The configuration (`"delta"` or `"star"`). + phase_fraction (Any): The phase of the lead satellite, as a fraction + of `360 / per_plane` degrees. + node_fraction (Any): The node of the lead satellite, as a fraction of + `360 / planes` degrees (delta configuration) or 360 degrees (star + configuration). constraints (Sequence[Callable]): Constraints of the fragment. Returns: @@ -94,12 +119,28 @@ def walker_space( "planes": _node(planes, Integer(1, 6)), "per_plane": _node(per_plane, Integer(1, 6)), "relative_spacing": _node(relative_spacing, Integer(0, lambda d: d.planes - 1)), + "phase_fraction": phase_fraction, + "node_fraction": node_fraction, } if altitude is not None: children["altitude"] = altitude + children["true_anomaly"] = Derived(_lead_true_anomaly) + children["right_ascension"] = Derived(_lead_right_ascension) return DesignSpace(constraints=constraints, **children) +def _lead_true_anomaly(d: Scope) -> float: + """The true anomaly (degrees) of the lead satellite of a Walker layout.""" + return float(d.phase_fraction) * 360 / d.per_plane % 360 + + +def _lead_right_ascension(d: Scope) -> float: + """The right ascension of the ascending node (degrees) of the lead + satellite of a Walker layout.""" + period = 360 if d.configuration == "star" else 360 / d.planes + return float(d.node_fraction) * period % 360 + + def _distinct_crossings(d: Scope) -> bool: """Whether the planes of a layout have different crossing times.""" crossings = [round(plane.crossing, 6) for plane in d.planes] @@ -323,7 +364,11 @@ def build_constellation( name=name, configuration=layout.configuration, orbit=CircularOrbit( - altitude=altitude, inclination=layout.inclination, epoch=epoch + altitude=altitude, + inclination=layout.inclination, + true_anomaly=getattr(layout, "true_anomaly", 0.0), + right_ascension_ascending_node=getattr(layout, "right_ascension", 0.0), + epoch=epoch, ), number_planes=layout.planes, number_satellites=layout.planes * layout.per_plane, diff --git a/tests/tradespace/test_constellations.py b/tests/tradespace/test_constellations.py index 394fdaaf..2701838c 100644 --- a/tests/tradespace/test_constellations.py +++ b/tests/tradespace/test_constellations.py @@ -234,3 +234,92 @@ def _orbit(): return SunSynchronousOrbit( altitude=700e3, equator_crossing_time="10:30", epoch=EPOCH ) + + +def _walker(**kwargs): + """The satellites of a Walker layout (on its own) of given values.""" + values = { + "inclination": 55.0, + "planes": 3, + "per_plane": 4, + "relative_spacing": 1, + "configuration": "delta", + **kwargs, + } + space = DesignSpace(layout=walker_space(**values)) + (design,) = space.enumerate() + return design, build_constellation( + design.layout, IMAGER, epoch=EPOCH, altitude=700e3 + ) + + +def _orbits(satellites): + """The (node, anomaly) of each satellite, as a set, ignoring names.""" + return { + ( + round(s.orbit.right_ascension_ascending_node % 360, 6) % 360, + round(s.orbit.true_anomaly % 360, 6) % 360, + ) + for s in satellites + } + + +class TestWalkerPhase(unittest.TestCase): + """ + Unit tests for the phase and node of the lead satellite of Walker layouts. + """ + + def test_default(self): + """The lead satellite is at the origin by default.""" + design, satellites = _walker() + self.assertEqual(design.layout.true_anomaly, 0) + self.assertEqual(design.layout.right_ascension, 0) + self.assertEqual(satellites[0].orbit.true_anomaly, 0) + self.assertEqual(satellites[0].orbit.right_ascension_ascending_node, 0) + + def test_fractions(self): + """Fractions give angles of the intervals of distinct constellations.""" + design, satellites = _walker(phase_fraction=0.5, node_fraction=0.25) + self.assertAlmostEqual(design.layout.true_anomaly, 0.5 * 360 / 4) + self.assertAlmostEqual(design.layout.right_ascension, 0.25 * 360 / 3) + self.assertAlmostEqual(satellites[0].orbit.true_anomaly, 45) + self.assertAlmostEqual(satellites[0].orbit.right_ascension_ascending_node, 30) + star, _ = _walker(configuration="star", node_fraction=0.25) + self.assertAlmostEqual(star.layout.right_ascension, 90) + + def test_symmetries(self): + """A whole interval of phase or node gives the same constellation.""" + _, base = _walker() + _, phased = _walker(phase_fraction=1.0) + self.assertEqual(_orbits(phased), _orbits(base)) + # a shift of node by 360 / planes is a shift of phase by + # -360 * relative_spacing / satellites (a fraction of -1 / planes) + _, noded = _walker(node_fraction=1.0) + _, shifted = _walker(phase_fraction=-1 / 3) + self.assertEqual(_orbits(noded), _orbits(shifted)) + self.assertNotEqual(_orbits(noded), _orbits(base)) + # fractions within the intervals give other constellations + _, half = _walker(phase_fraction=0.5) + self.assertNotEqual(_orbits(half), _orbits(base)) + + def test_uncertain_and_designed(self): + """Fractions are design variables or uncertain parameters.""" + space = DesignSpace( + layout=walker_space( + inclination=55.0, + planes=Integer(1, 2), + per_plane=2, + relative_spacing=0, + phase_fraction=Uncertain.uniform(0, 1), + node_fraction=Real(0, 0.5, step=0.5), + ) + ) + designs = space.enumerate() + self.assertEqual(len(designs), 4) + realized = designs[-1].realize(0) + fraction = realized.layout.phase_fraction + self.assertTrue(0 <= fraction < 1) + self.assertAlmostEqual(realized.layout.true_anomaly, fraction * 180) + self.assertAlmostEqual(realized.layout.right_ascension, 0.5 * 180) + # the same draw in every design (common random numbers) + self.assertEqual(designs[0].realize(0).layout.phase_fraction, fraction) From 5dca91ce88d5a76fe4fb03f6b831cd5d97a827c2 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Tue, 10 Nov 2026 22:37:42 -0700 Subject: [PATCH 09/52] add trains, planes of inclined orbits, mixed layouts, and phase fractions of planes --- CHANGELOG.md | 2 +- docs/api_reference/tradespace.rst | 2 + src/tatc/tradespace/__init__.py | 2 + src/tatc/tradespace/constellations.py | 291 ++++++++++++++++++++---- tests/tradespace/test_constellations.py | 193 +++++++++++++++- 5 files changed, 447 insertions(+), 43 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index d8a46b1e..68b3be08 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,7 +17,7 @@ Added: - Statistics of metrics over replicates (`tradespace.Mean`, `StandardDeviation`, `Minimum`, `Maximum`, `Quantile`, and `Probability`, the share of replicates that meet a threshold) and requirements on them (`Requirement`, output constraints that designs meet or violate by an amount once evaluated). `aggregate` gives the statistics and violations of each design; objectives and requirements of `pareto_probability` (which also gives the probability of meeting the requirements), `screen` (which ranks designs that miss requirements after those that meet them), `optimize_optuna` (a constraint of each trial for each requirement), and `optimize_pymoo` (a constraint for each requirement) name statistics, or metrics whose means they are. - Function `tradespace.refine` (and class `Refinement`), which adds replicates only to the designs whose Pareto efficiency is uncertain, until it is settled, optionally with a tolerance of differences that do not matter (also of `pareto_probability`); `Study.run` evaluates given replicates (`replicates`). - Class `tradespace.ResultStore`, a persistent store (SQLite) of the evaluations of a study (argument `store` of `Study`), from which a study that is interrupted or extended takes the evaluations stored before. Function `tradespace.sensitivity` (and `main_effects`), the share of the variance of metrics explained by each design variable where it is active. Tolerances of objectives may be percentages of their values (such as `"5%"`). `Uncertain.seed` draws a seed of random numbers for each replicate, and `remove_failures` removes the satellites that fail, the same in every design. - - Building blocks of constellations: fragments of design spaces of Walker constellations (`tradespace.walker_space`) and planes of sun-synchronous orbits (`sso_planes_space`, whose planes have different crossing times), `build_constellation`, which builds the satellites of either with instruments or entries of the instrument catalog (with their validated attitudes, and several entries on one satellite), and `count_satellites` and `count_planes`. The phase and node of the lead satellite of a Walker constellation (`phase_fraction` and `node_fraction`, design variables or uncertain parameters) are fractions of the intervals over which they give distinct constellations (`360 / per_plane` degrees of phase, and `360 / planes` degrees of node for a delta configuration or 360 for a star), so that a search does not evaluate the same constellation at several phases or nodes. + - Building blocks of constellations: fragments of design spaces of Walker constellations (`tradespace.walker_space`) and planes of sun-synchronous orbits (`sso_planes_space`, whose planes have different crossing times), `build_constellation`, which builds the satellites of either with instruments or entries of the instrument catalog (with their validated attitudes, and several entries on one satellite), and `count_satellites` and `count_planes`. The phase and node of the lead satellite of a Walker constellation (`phase_fraction` and `node_fraction`, design variables or uncertain parameters) are fractions of the intervals over which they give distinct constellations (`360 / per_plane` degrees of phase, and `360 / planes` degrees of node for a delta configuration or 360 for a star), so that a search does not evaluate the same constellation at several phases or nodes. Planes of inclined orbits (`planes_space`), each with its own inclination and node (uncertain by default, as of satellites launched as secondary payloads). The satellites of the planes of `sso_planes_space` and `planes_space` are evenly spaced, or follow each other in a train at an `interval` (minutes), on the same ground track or in the same plane (`repeat_ground_track`). The phase of each plane (`phase_fraction`, which replaces `phase` of `sso_planes_space`) is a fraction of the interval over which it gives distinct planes (`360 / satellites` degrees for evenly spaced satellites, 360 for a train), from which each fragment derives the plane's `true_anomaly`, as for the lead satellite of a Walker constellation. `build_constellation`, `count_satellites`, and `count_planes` take several layouts (a list, or a `Repeat` of a `Choice` of layouts), such as the shells of a mixed constellation. - Function `tradespace.screen` (and class `Screening`), which screens designs with studies of increasing fidelity, keeping whole fronts of the best designs of each stage for the next. - Searches of design spaces with optional optimizers: `tradespace.optimize_optuna` suggests designs with Optuna trials (`DesignSpace.suggest`, define-by-run over the hierarchical space), and `optimize_pymoo` and `make_pymoo_problem` search the unit hypercube that encodes a design space (`DesignSpace.unit_paths`, `encode`, and `decode`) with pymoo. Each design is evaluated once, and the designs proposed together are evaluated together, in parallel if the study is. Constraints of a design space may return the amount of their violation (`Infeasible.violation`), which Optuna's trials record (`set_constraint`) for its constraint-aware samplers, and which is the constraint value of pymoo problems. Optional dependencies `tradespace` (joblib, Optuna, and pymoo). - Function `tradespace.confirm` (and class `Confirmation`), which evaluates selected designs (such as a front) with new replicates that played no part in their selection, removing the optimism of the selection (the winner's curse, `Confirmation.optimism`). `ResultStore` keys evaluations by the fingerprint of a study (`Study.fingerprint`, see `get_fingerprint`: its seed, use of common random numbers, design space, and build and evaluation functions, and the version of TAT-C), warning if it holds evaluations of other definitions, which are not reused; `SatelliteCache` keys results on disk by the fingerprint of its function. `refine` treats designs with fewer than `min_replicates` (5) as uncertain whatever their probability, adds the replicates left to `max_replicates` in a last partial step, and warns if designs remain uncertain without a tolerance. `sensitivity` gives adjusted shares (epsilon squared) by default, without the share that the levels of a variable explain by chance (`adjusted=False` for correlation ratios). diff --git a/docs/api_reference/tradespace.rst b/docs/api_reference/tradespace.rst index d4e6691c..7297d82a 100644 --- a/docs/api_reference/tradespace.rst +++ b/docs/api_reference/tradespace.rst @@ -57,6 +57,8 @@ Constellations .. autofunction:: tatc.tradespace.sso_planes_space +.. autofunction:: tatc.tradespace.planes_space + .. autofunction:: tatc.tradespace.build_constellation .. autofunction:: tatc.tradespace.count_satellites diff --git a/src/tatc/tradespace/__init__.py b/src/tatc/tradespace/__init__.py index b084913b..cf58a620 100644 --- a/src/tatc/tradespace/__init__.py +++ b/src/tatc/tradespace/__init__.py @@ -19,6 +19,7 @@ count_planes, count_satellites, hours_to_time, + planes_space, remove_failures, sso_planes_space, walker_space, @@ -110,6 +111,7 @@ "pareto_front", "pareto_probability", "pareto_ranks", + "planes_space", "refine", "remove_failures", "screen", diff --git a/src/tatc/tradespace/constellations.py b/src/tatc/tradespace/constellations.py index b0b3d1ad..4dc2bdbf 100644 --- a/src/tatc/tradespace/constellations.py +++ b/src/tatc/tradespace/constellations.py @@ -1,7 +1,9 @@ """ Building blocks of trade studies of constellations: fragments of design -spaces for common constellation layouts (Walker constellations and planes of -sun-synchronous orbits), a builder of the satellites of a layout with a +spaces for common constellation layouts (Walker constellations, planes of +sun-synchronous orbits, and planes of inclined orbits, whose satellites are +evenly spaced or follow each other in trains), a builder of the satellites of +a layout (or of several, such as the shells of a mixed constellation) with a payload (instruments, or entries of the instrument catalog), and counts of satellites and planes for objectives and constraints. @@ -22,13 +24,18 @@ def build(d): d.layout, d.sounder, epoch=START, altitude=d.altitude ) +A mixed constellation combines layouts, such as an inclined Walker +constellation and planes of sun-synchronous orbits (each layout a child of +the design space, or the items of a `Repeat` of a `Choice` of layouts), whose +satellites `build_constellation` builds together. + @author: Paul T. Grogan """ from __future__ import annotations from collections.abc import Callable, Sequence -from datetime import datetime, time +from datetime import datetime, time, timedelta from typing import Any import numpy as np @@ -38,16 +45,19 @@ def build(d): Instrument, Satellite, SunSynchronousOrbit, + TrainConstellation, WalkerConstellation, ) -from .nodes import Derived, Fixed, Integer, Real, Repeat +from .nodes import Derived, Fixed, Integer, Real, Repeat, Uncertain from .space import DesignSpace -from .values import ChoiceValues, Scope, Values +from .values import ChoiceValues, RepeatValues, Scope, Values WALKER = "walker" """The kind of the layouts of `walker_space`.""" SSO_PLANES = "sso planes" """The kind of the layouts of `sso_planes_space`.""" +PLANES = "planes" +"""The kind of the layouts of `planes_space`.""" def _node(value: Any, default: Any) -> Any: @@ -141,6 +151,12 @@ def _lead_right_ascension(d: Scope) -> float: return float(d.node_fraction) * period % 360 +def _plane_true_anomaly(d: Scope) -> float: + """The true anomaly (degrees) of the first satellite of a plane.""" + period = 360 if d.interval is not None else 360 / d.satellites + return float(d.phase_fraction) * period % 360 + + def _distinct_crossings(d: Scope) -> bool: """Whether the planes of a layout have different crossing times.""" crossings = [round(plane.crossing, 6) for plane in d.planes] @@ -152,9 +168,11 @@ def sso_planes_space( crossing: Any = None, satellites: Any = None, count: Any = None, - phase: Any = 0.0, + phase_fraction: Any = 0.0, + interval: Any = None, altitude: Any = None, ascending: Any = True, + repeat_ground_track: Any = True, ordered: bool = False, distinct: bool = True, constraints: Sequence[Callable[[Scope], Any]] = (), @@ -162,12 +180,34 @@ def sso_planes_space( """ Gets a fragment of a design space of planes of sun-synchronous orbits (see `tatc.schemas.SunSynchronousOrbit`), each with its own equator - crossing time (local solar time, in hours), number of satellites (evenly - spaced in the plane), and phase (the true anomaly of its first satellite, - degrees), and (optionally, if not given to `build_constellation`) their - altitude (meters). Each is a node of a design space (such as a design - variable, a value derived from the index of the plane, or an uncertain - parameter) or a value. + crossing time (local solar time, in hours), number of satellites, + spacing of its satellites, and phase (see below), and (optionally, if not + given to + `build_constellation`) their altitude (meters). Each is a node of a + design space (such as a design variable, a value derived from the index + of the plane, or an uncertain parameter) or a value. + + The satellites of a plane are evenly spaced around its orbit if its + `interval` is `None`, or follow each other in a train (see + `tatc.schemas.TrainConstellation`) at an `interval` (minutes): each + crosses the equator the interval after the one ahead of it, on the same + ground track (if `repeat_ground_track`, with its node shifted by the + Earth's rotation, which delays its local crossing time by the interval) + or in the same plane. Evenly spaced satellites revisit at intervals of + the orbital period divided by their number; a train revisits within + minutes, then not until the next orbit. The interval may be a design + variable whose options include `None`, such as `Categorical([None, 5, + 15])`. + + The phase of each plane is a fraction of the interval over which it + gives distinct planes (as that of a Walker constellation, see + `walker_space`): `360 / satellites` degrees of true anomaly if its + satellites are evenly spaced (a shift by which moves each onto the next), + or 360 degrees if they are a train. Fractions in [0, 1) therefore give + every distinct plane once, may be design variables or uncertain + parameters (such as `Uncertain.uniform(0, 1)`) whatever the spacing, and + the fragment derives the true anomaly of the plane's first satellite + (`true_anomaly`, degrees) from them. The planes are unordered by default: designs whose planes differ only in their order are the same design (which requires that their values do @@ -181,10 +221,16 @@ def sso_planes_space( satellites (Any): The number of satellites of each plane, by default a variable from 1 to 4. count (Any): The number of planes, by default a variable from 1 to 3. - phase (Any): The phase of each plane (an uncertain parameter, such as - `Uncertain.uniform(0, 360)`, if it is not designed). + phase_fraction (Any): The phase of each plane, as a fraction of + `360 / satellites` degrees (evenly spaced) or 360 degrees (a + train): an uncertain parameter, such as `Uncertain.uniform(0, 1)`, + if it is not designed. + interval (Any): The interval (minutes) between the satellites of a + train in each plane, or `None` for evenly spaced satellites. altitude (Any): The altitude, if part of the layout. ascending (Any): Whether the crossing times are of ascending nodes. + repeat_ground_track (Any): Whether the satellites of a train follow + the same ground track (or the same plane). ordered (bool): `True` if the planes are ordered (for example, if their values depend on their index). distinct (bool): `True` to require different crossing times. @@ -196,11 +242,14 @@ def sso_planes_space( plane = DesignSpace( crossing=_node(crossing, Real(6, 18, step=1.5)), satellites=_node(satellites, Integer(1, 4)), - phase=phase, + interval=Fixed(None) if interval is None else interval, + phase_fraction=phase_fraction, + true_anomaly=Derived(_plane_true_anomaly), ) children = { "kind": Fixed(SSO_PLANES), "ascending": ascending, + "repeat_ground_track": repeat_ground_track, "planes": Repeat(plane, count=_node(count, Integer(1, 3)), ordered=ordered), } if altitude is not None: @@ -209,6 +258,87 @@ def sso_planes_space( return DesignSpace(constraints=constraints, **children) +def planes_space( + *, + inclination: Any = None, + node: Any = None, + satellites: Any = None, + count: Any = None, + phase_fraction: Any = 0.0, + interval: Any = None, + altitude: Any = None, + repeat_ground_track: Any = True, + ordered: bool = False, + constraints: Sequence[Callable[[Scope], Any]] = (), +) -> DesignSpace: + """ + Gets a fragment of a design space of planes of circular orbits (see + `tatc.schemas.CircularOrbit`), each with its own inclination (degrees), + node (right ascension of the ascending node at the epoch, degrees), + number of satellites, spacing of its satellites (evenly spaced, or a + train at an `interval`), and phase (a fraction, see `sso_planes_space`), + and (optionally, if not given to + `build_constellation`) their altitude (meters). Each is a node of a + design space (such as a design variable, a value derived from the index + of the plane, or an uncertain parameter) or a value. + + Unlike a Walker constellation, whose planes are evenly spaced in node, + the planes may have any nodes and inclinations, as those of satellites + launched as secondary payloads, whose nodes are chosen by the launches + of the primary payloads: the node of each plane is therefore uncertain + by default (uniform from 0 to 360 degrees), drawn for each replicate. + The planes are unordered by default (see `sso_planes_space`). + + Args: + inclination (Any): The inclination of each plane, by default a + variable from 30 to 90 degrees in steps of 15. + node (Any): The node of each plane, by default uncertain (uniform + from 0 to 360 degrees). + satellites (Any): The number of satellites of each plane, by default a + variable from 1 to 4. + count (Any): The number of planes, by default a variable from 1 to 3. + phase_fraction (Any): The phase of each plane, as a fraction of + `360 / satellites` degrees (evenly spaced) or 360 degrees (a + train). + interval (Any): The interval (minutes) between the satellites of a + train in each plane, or `None` for evenly spaced satellites. + altitude (Any): The altitude, if part of the layout. + repeat_ground_track (Any): Whether the satellites of a train follow + the same ground track (or the same plane). + ordered (bool): `True` if the planes are ordered. + constraints (Sequence[Callable]): Constraints of the fragment. + + Returns: + DesignSpace: the fragment + """ + plane = DesignSpace( + inclination=_node(inclination, Real(30, 90, step=15)), + node=_node(node, Uncertain.uniform(0, 360)), + satellites=_node(satellites, Integer(1, 4)), + interval=Fixed(None) if interval is None else interval, + phase_fraction=phase_fraction, + true_anomaly=Derived(_plane_true_anomaly), + ) + children = { + "kind": Fixed(PLANES), + "repeat_ground_track": repeat_ground_track, + "planes": Repeat(plane, count=_node(count, Integer(1, 3)), ordered=ordered), + } + if altitude is not None: + children["altitude"] = altitude + return DesignSpace(constraints=constraints, **children) + + +def _layouts(layout: Any) -> list[Any] | None: + """ + Gets the layouts of several (a list or a repetition of layouts), or + `None` for a single layout. + """ + if isinstance(layout, (list, tuple, RepeatValues)): + return list(layout) + return None + + def _layout(layout: Any) -> Any: """Gets the values of a layout (the chosen branch of a choice).""" return layout.value if isinstance(layout, ChoiceValues) else layout @@ -219,22 +349,27 @@ def _kind(layout: Any) -> str: return layout.kind except AttributeError: raise ValueError( - "a layout must be the values of walker_space or sso_planes_space" + "a layout must be the values of walker_space, sso_planes_space, " + + "or planes_space" ) from None def count_satellites(layout: Any) -> int: """ - Counts the satellites of a layout (the values of `walker_space` or - `sso_planes_space`, or of a choice of them), for objectives and + Counts the satellites of a layout (the values of `walker_space`, + `sso_planes_space`, or `planes_space`, or of a choice of them), or of + several (a list or a repetition of layouts), for objectives and constraints. Args: - layout (Any): The values of the layout. + layout (Any): The values of the layout (or layouts). Returns: int: the number of satellites """ + several = _layouts(layout) + if several is not None: + return sum(count_satellites(item) for item in several) layout = _layout(layout) if _kind(layout) == WALKER: return int(layout.planes * layout.per_plane) @@ -243,16 +378,20 @@ def count_satellites(layout: Any) -> int: def count_planes(layout: Any) -> int: """ - Counts the orbit planes of a layout (the values of `walker_space` or - `sso_planes_space`, or of a choice of them), each of which needs its own + Counts the orbit planes of a layout (the values of `walker_space`, + `sso_planes_space`, or `planes_space`, or of a choice of them), or of + several (a list or a repetition of layouts), each of which needs its own launch. Args: - layout (Any): The values of the layout. + layout (Any): The values of the layout (or layouts). Returns: int: the number of planes """ + several = _layouts(layout) + if several is not None: + return sum(count_planes(item) for item in several) layout = _layout(layout) if _kind(layout) == WALKER: return int(layout.planes) @@ -313,8 +452,42 @@ def _make_satellite( return Satellite(name=name, orbit=orbit, instruments=instruments, attitude=attitude) +def _plane_orbits( + make: Callable[[float], Any], + plane: Any, + repeat_ground_track: bool, +) -> list[Any]: + """ + Gets the orbits of the satellites of a plane: evenly spaced from the + true anomaly of its first satellite, or a train at its interval (see + `sso_planes_space`), with `make` the orbit of a satellite at a true + anomaly. + """ + interval = getattr(plane, "interval", None) + count = int(plane.satellites) + if interval is None: + return [ + make((plane.true_anomaly + 360 * s / count) % 360) for s in range(count) + ] + interval = ( + interval + if isinstance(interval, timedelta) + else timedelta(minutes=float(interval)) + ) + if interval <= timedelta(0): + raise ValueError("the interval of a train must be positive") + train = TrainConstellation( + name="train", + orbit=make(plane.true_anomaly % 360), + number_satellites=count, + interval=interval, + repeat_ground_track=bool(repeat_ground_track), + ) + return [member.orbit for member in train.generate_members()] + + def build_constellation( - layout: Values | ChoiceValues, + layout: Values | ChoiceValues | Sequence[Values | ChoiceValues] | RepeatValues, payload: Payload, *, epoch: datetime, @@ -323,9 +496,9 @@ def build_constellation( time_step: float | None = None, ) -> list[Satellite]: """ - Builds the satellites of a layout: the values of `walker_space` or - `sso_planes_space` in a design (or of a choice of them), at the - layout's altitude (or the given one), each with a payload: + Builds the satellites of a layout: the values of `walker_space`, + `sso_planes_space`, or `planes_space` in a design (or of a choice of + them), at the layout's altitude (or the given one), each with a payload: * an `Instrument` (or a list of instruments); * the identifier of an entry of the instrument catalog (see @@ -338,11 +511,17 @@ def build_constellation( * a function of a name and an orbit that builds a satellite. Satellites of Walker constellations are named `" "`, and - those of sun-synchronous planes `"

-"` (plane `p`, - satellite `s`). + those of planes `"

-"` (plane `p`, satellite `s`). + + Several layouts (a list or a repetition of layouts, such as the shells + of a mixed constellation) are built in turn, with the same payload, and + the names of their satellites are prefixed by a letter for each layout + (`" A 1"`, `" B 1-1"`). Build layouts with different + payloads in separate calls, with different names. Args: - layout (Values | ChoiceValues): The values of the layout. + layout (Values | ChoiceValues | Sequence): The values of the layout + (or layouts). payload (Payload): The payload of each satellite. epoch (datetime.datetime): The epoch of the orbits. altitude (float | None): The altitude (meters), if the layout does @@ -354,6 +533,20 @@ def build_constellation( Returns: list[Satellite]: the satellites """ + several = _layouts(layout) + if several is not None: + return [ + satellite + for k, item in enumerate(several) + for satellite in build_constellation( + item, + payload, + epoch=epoch, + altitude=altitude, + name=f"{name} {chr(65 + k) if k < 26 else k + 1}", + time_step=time_step, + ) + ] layout = _layout(layout) kind = _kind(layout) altitude = getattr(layout, "altitude", None) if altitude is None else altitude @@ -380,17 +573,35 @@ def build_constellation( ] satellites = [] for p, plane in enumerate(layout.planes): - for s in range(plane.satellites): - orbit = SunSynchronousOrbit( - altitude=altitude, - equator_crossing_time=hours_to_time(plane.crossing), - equator_crossing_ascending=layout.ascending, - epoch=epoch, - true_anomaly=(plane.phase + 360 * s / plane.satellites) % 360, - ) - satellites.append( - _make_satellite(payload, f"{name} {p + 1}-{s + 1}", orbit, time_step) - ) + if kind == SSO_PLANES: + + def make(anomaly, plane=plane): + return SunSynchronousOrbit( + altitude=altitude, + equator_crossing_time=hours_to_time(plane.crossing), + equator_crossing_ascending=layout.ascending, + epoch=epoch, + true_anomaly=anomaly, + ) + + else: + + def make(anomaly, plane=plane): + return CircularOrbit( + altitude=altitude, + inclination=plane.inclination, + right_ascension_ascending_node=float(plane.node) % 360, + epoch=epoch, + true_anomaly=anomaly, + ) + + orbits = _plane_orbits( + make, plane, getattr(layout, "repeat_ground_track", True) + ) + satellites.extend( + _make_satellite(payload, f"{name} {p + 1}-{s + 1}", orbit, time_step) + for s, orbit in enumerate(orbits) + ) return satellites diff --git a/tests/tradespace/test_constellations.py b/tests/tradespace/test_constellations.py index 2701838c..50c096a1 100644 --- a/tests/tradespace/test_constellations.py +++ b/tests/tradespace/test_constellations.py @@ -17,11 +17,13 @@ DesignSpace, Integer, Real, + Repeat, Uncertain, build_constellation, count_planes, count_satellites, hours_to_time, + planes_space, remove_failures, sso_planes_space, walker_space, @@ -124,7 +126,7 @@ def test_sso(self): crossing=13.5, satellites=4, count=1, - phase=Uncertain.uniform(0, 360), + phase_fraction=Uncertain.uniform(0, 1), altitude=700e3, ), ) @@ -137,7 +139,10 @@ def test_sso(self): gaps = np.diff(np.unwrap(np.radians(anomalies))) np.testing.assert_allclose(np.degrees(gaps) % 360, 90) self.assertEqual(satellites[0].orbit.equator_crossing_time, time(13, 30)) - self.assertAlmostEqual(anomalies[0], design.layout.planes[0].phase) + plane = design.layout.planes[0] + self.assertAlmostEqual(anomalies[0], plane.true_anomaly) + # a fraction of the 90 degrees between 4 evenly spaced satellites + self.assertAlmostEqual(plane.true_anomaly, plane.phase_fraction * 90) def test_derived_planes(self): """Plane values may be derived from their index and enclosing values.""" @@ -323,3 +328,187 @@ def test_uncertain_and_designed(self): self.assertAlmostEqual(realized.layout.right_ascension, 0.5 * 180) # the same draw in every design (common random numbers) self.assertEqual(designs[0].realize(0).layout.phase_fraction, fraction) + + +def _minutes(value): + """Minutes of a time of day.""" + return value.hour * 60 + value.minute + value.second / 60 + + +def _single(space): + """The only design of a design space.""" + (design,) = space.enumerate() + return design + + +class TestTrains(unittest.TestCase): + """ + Unit tests for trains of satellites in planes. + """ + + def _build(self, **kwargs): + space = DesignSpace( + layout=sso_planes_space(crossing=13.5, satellites=3, count=1, **kwargs) + ) + return build_constellation( + _single(space).layout, IMAGER, epoch=EPOCH, altitude=700e3 + ) + + def test_evenly_spaced(self): + """Without an interval, satellites are evenly spaced.""" + satellites = self._build() + anomalies = [s.orbit.true_anomaly for s in satellites] + np.testing.assert_allclose(anomalies, [0, 120, 240]) + + def test_same_ground_track(self): + """A train on the same ground track crosses at later local times.""" + satellites = self._build(interval=10) + crossings = [_minutes(s.orbit.equator_crossing_time) for s in satellites] + np.testing.assert_allclose(np.diff(crossings), [10, 10], atol=0.05) + # each trails the one ahead by 10 minutes of a ~99 minute orbit + anomalies = [s.orbit.true_anomaly for s in satellites] + lags = np.mod(-np.diff(anomalies), 360) + np.testing.assert_allclose(lags, 360 * 10 / 98.8, rtol=0.01) + self.assertEqual( + [s.name for s in satellites], [f"satellite 1-{k}" for k in (1, 2, 3)] + ) + + def test_same_plane(self): + """A train in the same plane crosses at the same local time.""" + satellites = self._build(interval=10, repeat_ground_track=False) + crossings = {_minutes(s.orbit.equator_crossing_time) for s in satellites} + self.assertEqual(len(crossings), 1) + + def test_phase_fraction(self): + """Phases are fractions of the interval of distinct planes.""" + even = self._build(phase_fraction=0.25) + self.assertAlmostEqual(even[0].orbit.true_anomaly, 0.25 * 120) + # a whole interval moves each satellite onto the next + shifted = self._build(phase_fraction=1.0) + self.assertEqual( + sorted(round(s.orbit.true_anomaly % 360, 6) for s in shifted), + sorted(round(s.orbit.true_anomaly % 360, 6) for s in self._build()), + ) + # a train has no such symmetry: its interval is 360 degrees + train = self._build(phase_fraction=0.25, interval=10) + self.assertAlmostEqual(train[0].orbit.true_anomaly, 90) + + def test_interval_variable(self): + """The interval is a design variable that may be evenly spaced.""" + space = DesignSpace( + layout=sso_planes_space( + crossing=13.5, satellites=2, count=1, interval=Categorical([None, 5]) + ) + ) + designs = space.enumerate() + self.assertEqual(len(designs), 2) + built = [ + build_constellation(d.layout, IMAGER, epoch=EPOCH, altitude=700e3) + for d in designs + ] + self.assertAlmostEqual(built[0][1].orbit.true_anomaly, 180) + self.assertLess(np.mod(-built[1][1].orbit.true_anomaly, 360), 30) + with self.assertRaises(ValueError): + self._build(interval=0) + + +class TestPlanes(unittest.TestCase): + """ + Unit tests for planes of inclined orbits. + """ + + def test_uncertain_nodes(self): + """Nodes are uncertain by default, drawn for each replicate.""" + space = DesignSpace( + layout=planes_space(inclination=30.0, satellites=2, count=Integer(1, 3)), + constraints=[lambda d: count_satellites(d.layout) <= 4], + ) + designs = space.enumerate() + self.assertEqual(len(designs), 2) + realized = designs[1].realize(3) + nodes = [plane.node for plane in realized.layout.planes] + self.assertTrue(all(0 <= node < 360 for node in nodes)) + self.assertNotEqual(nodes[0], nodes[1]) + satellites = build_constellation( + realized.layout, IMAGER, epoch=EPOCH, altitude=550e3 + ) + self.assertEqual(len(satellites), 4) + self.assertEqual(count_planes(realized.layout), 2) + self.assertAlmostEqual( + satellites[2].orbit.right_ascension_ascending_node, nodes[1] + ) + self.assertEqual(satellites[0].orbit.inclination, 30) + + def test_designed_nodes_and_trains(self): + """Nodes may be designed, and planes may be trains.""" + space = DesignSpace( + layout=planes_space( + inclination=Real(30, 60, step=30), + node=Real(0, 90, step=90), + satellites=2, + count=1, + interval=5, + repeat_ground_track=False, + ) + ) + designs = space.enumerate() + self.assertEqual(len(designs), 4) + satellites = build_constellation( + designs[-1].layout, IMAGER, epoch=EPOCH, altitude=550e3 + ) + self.assertEqual( + {s.orbit.right_ascension_ascending_node for s in satellites}, {90} + ) + self.assertEqual({s.orbit.inclination for s in satellites}, {60}) + + +class TestMixedLayouts(unittest.TestCase): + """ + Unit tests for constellations of several layouts. + """ + + def test_list_of_layouts(self): + """Several layouts are built and counted together.""" + space = DesignSpace( + inclined=walker_space( + inclination=65.0, planes=1, per_plane=2, relative_spacing=0 + ), + polar=sso_planes_space( + crossing=13.5, satellites=1, count=2, distinct=False + ), + ) + design = _single(space) + layouts = [design.inclined, design.polar] + satellites = build_constellation(layouts, IMAGER, epoch=EPOCH, altitude=700e3) + self.assertEqual( + [s.name for s in satellites], + ["satellite A 1", "satellite A 2", "satellite B 1-1", "satellite B 2-1"], + ) + self.assertEqual(count_satellites(layouts), 4) + self.assertEqual(count_planes(layouts), 3) + + def test_repeat_of_choice(self): + """A repetition of a choice of layouts is a variable mix of shells.""" + space = DesignSpace( + shells=Repeat( + Choice( + walker=walker_space( + inclination=65.0, planes=1, per_plane=2, relative_spacing=0 + ), + sso=sso_planes_space(crossing=13.5, satellites=1, count=1), + ), + count=Integer(1, 2), + ) + ) + designs = space.enumerate() + self.assertEqual(len(designs), 2 + 4) + mixed = [ + d for d in designs if [s.choice for s in d.shells] == ["walker", "sso"] + ] + (design,) = mixed + satellites = build_constellation( + design.shells, IMAGER, epoch=EPOCH, altitude=700e3 + ) + self.assertEqual(len(satellites), 3) + self.assertEqual(count_satellites(design.shells), 3) + self.assertEqual(count_planes(design.shells), 2) From c1de3c1af18eab5afff16b83061fe1f72668d8a0 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Wed, 11 Nov 2026 06:40:24 -0700 Subject: [PATCH 10/52] add life-cycle cost models of constellations, and fingerprints of dataclasses without mutable globals --- CHANGELOG.md | 1 + docs/api_reference/tradespace.rst | 22 ++ docs/examples/SearchTradeSpace.ipynb | 457 ++++++++++++++++++++++----- src/tatc/tradespace/__init__.py | 16 +- src/tatc/tradespace/cost.py | 356 +++++++++++++++++++++ src/tatc/tradespace/fingerprint.py | 50 ++- tests/tradespace/test_cost.py | 239 ++++++++++++++ tests/tradespace/test_fingerprint.py | 34 ++ 8 files changed, 1076 insertions(+), 99 deletions(-) create mode 100644 src/tatc/tradespace/cost.py create mode 100644 tests/tradespace/test_cost.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 68b3be08..dec5c687 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -20,6 +20,7 @@ Added: - Building blocks of constellations: fragments of design spaces of Walker constellations (`tradespace.walker_space`) and planes of sun-synchronous orbits (`sso_planes_space`, whose planes have different crossing times), `build_constellation`, which builds the satellites of either with instruments or entries of the instrument catalog (with their validated attitudes, and several entries on one satellite), and `count_satellites` and `count_planes`. The phase and node of the lead satellite of a Walker constellation (`phase_fraction` and `node_fraction`, design variables or uncertain parameters) are fractions of the intervals over which they give distinct constellations (`360 / per_plane` degrees of phase, and `360 / planes` degrees of node for a delta configuration or 360 for a star), so that a search does not evaluate the same constellation at several phases or nodes. Planes of inclined orbits (`planes_space`), each with its own inclination and node (uncertain by default, as of satellites launched as secondary payloads). The satellites of the planes of `sso_planes_space` and `planes_space` are evenly spaced, or follow each other in a train at an `interval` (minutes), on the same ground track or in the same plane (`repeat_ground_track`). The phase of each plane (`phase_fraction`, which replaces `phase` of `sso_planes_space`) is a fraction of the interval over which it gives distinct planes (`360 / satellites` degrees for evenly spaced satellites, 360 for a train), from which each fragment derives the plane's `true_anomaly`, as for the lead satellite of a Walker constellation. `build_constellation`, `count_satellites`, and `count_planes` take several layouts (a list, or a `Repeat` of a `Choice` of layouts), such as the shells of a mixed constellation. - Function `tradespace.screen` (and class `Screening`), which screens designs with studies of increasing fidelity, keeping whole fronts of the best designs of each stage for the next. - Searches of design spaces with optional optimizers: `tradespace.optimize_optuna` suggests designs with Optuna trials (`DesignSpace.suggest`, define-by-run over the hierarchical space), and `optimize_pymoo` and `make_pymoo_problem` search the unit hypercube that encodes a design space (`DesignSpace.unit_paths`, `encode`, and `decode`) with pymoo. Each design is evaluated once, and the designs proposed together are evaluated together, in parallel if the study is. Constraints of a design space may return the amount of their violation (`Infeasible.violation`), which Optuna's trials record (`set_constraint`) for its constraint-aware samplers, and which is the constraint value of pymoo problems. Optional dependencies `tradespace` (joblib, Optuna, and pymoo). + - Life-cycle costs of constellations for trade studies (`tradespace.CostModel`): the development of each type of satellite, the production of its units on a learning curve (`SatelliteCost`), launches (dedicated launches of each plane, up to a capacity in number or mass, or prices per satellite and kg, `LaunchCost`), operations (`OperationsCost`), replenishment at the end of a design life, and spares in orbit, from the layouts of a design (`plane_sizes`), with growth factors for cost risk (such as uncertain parameters, whose quantiles over replicates give the cost at a confidence level). TAT-C does not include cost-estimating relationships: the costs are given by the study. Fingerprints describe dataclasses (such as cost models) by their fields. - Function `tradespace.confirm` (and class `Confirmation`), which evaluates selected designs (such as a front) with new replicates that played no part in their selection, removing the optimism of the selection (the winner's curse, `Confirmation.optimism`). `ResultStore` keys evaluations by the fingerprint of a study (`Study.fingerprint`, see `get_fingerprint`: its seed, use of common random numbers, design space, and build and evaluation functions, and the version of TAT-C), warning if it holds evaluations of other definitions, which are not reused; `SatelliteCache` keys results on disk by the fingerprint of its function. `refine` treats designs with fewer than `min_replicates` (5) as uncertain whatever their probability, adds the replicates left to `max_replicates` in a last partial step, and warns if designs remain uncertain without a tolerance. `sensitivity` gives adjusted shares (epsilon squared) by default, without the share that the levels of a variable explain by chance (`adjusted=False` for correlation ratios). - Searches with Optuna accept categorical options that depend on earlier decisions (a parameter for each set of options), use TPE with a constant liar in batches by default (which spreads the trials of a batch), and stop after `max_designs` designs evaluated (trials that suggest designs evaluated before are told their objectives without evaluating them again). A design infeasible in some of its replicates violates its feasibility by their share (`Evaluations.infeasibility`), and the first design evaluated in a search is evaluated alone, to check that evaluations give one record each. `Study` records errors of evaluations as infeasible, without storing them, with `errors="record"`. Enumeration walks the items of unordered repetitions in one order only (the same designs, in the same order, four times faster for three sun-synchronous planes), and `DesignSpace.size` counts designs without keeping them. Pareto fronts of many designs (4,096 or more, without tolerances) are found by a sweep (20,000 designs in 0.2 s rather than 17 s), and comparisons of every pair use blocks of bounded memory. - Example `SearchTradeSpace`, which searches a hierarchical trade space of constellations for the designs that sample points sufficiently: by evaluating every design, ranking them with the uncertainty of their replicates, screening, and searching with Optuna and pymoo. diff --git a/docs/api_reference/tradespace.rst b/docs/api_reference/tradespace.rst index 7297d82a..12eadc49 100644 --- a/docs/api_reference/tradespace.rst +++ b/docs/api_reference/tradespace.rst @@ -69,6 +69,28 @@ Constellations .. autofunction:: tatc.tradespace.remove_failures +Costs +----- + +.. automodule:: tatc.tradespace.cost + :no-members: + +.. autoclass:: tatc.tradespace.CostModel + :members: estimate, generations + +.. autoclass:: tatc.tradespace.SatelliteCost + :members: production + +.. autoclass:: tatc.tradespace.LaunchCost + :members: launches + +.. autoclass:: tatc.tradespace.OperationsCost + +.. autoclass:: tatc.tradespace.CostEstimate + :members: total, metrics + +.. autofunction:: tatc.tradespace.plane_sizes + Trade Studies ------------- diff --git a/docs/examples/SearchTradeSpace.ipynb b/docs/examples/SearchTradeSpace.ipynb index 62345cf9..4f744f41 100644 --- a/docs/examples/SearchTradeSpace.ipynb +++ b/docs/examples/SearchTradeSpace.ipynb @@ -28,10 +28,10 @@ "id": "c3d2e5f4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T03:30:47.336314Z", - "iopub.status.busy": "2026-11-11T03:30:47.336057Z", - "iopub.status.idle": "2026-11-11T03:30:48.389377Z", - "shell.execute_reply": "2026-11-11T03:30:48.388372Z" + "iopub.execute_input": "2026-11-11T06:53:52.022308Z", + "iopub.status.busy": "2026-11-11T06:53:52.022073Z", + "iopub.status.idle": "2026-11-11T06:53:52.737609Z", + "shell.execute_reply": "2026-11-11T06:53:52.736859Z" } }, "outputs": [], @@ -68,7 +68,7 @@ "* a **Walker delta** constellation (`walker_space`), with an inclination, a number of planes, a number of satellites in each plane, and the relative spacing of the satellites between planes (whose upper bound depends on the number of planes), or\n", "* one or two **sun-synchronous** planes (`sso_planes_space`, a `Repeat` of planes), each with its own equator crossing time and number of satellites. The planes are unordered: two planes in either order are the same design. A constraint of the building block requires the planes to have different crossing times (otherwise, they would be the same plane).\n", "\n", - "The points sampled in each replicate are an `Uncertain` parameter (the seed of a random sample, `Uncertain.seed`), drawn for each replicate rather than designed, as are the failures of satellites (used below). The replicates use common random numbers: every design samples the same points in the same replicate, so that differences between designs are not differences between their samples.\n", + "The points sampled in each replicate are an `Uncertain` parameter (the seed of a random sample, `Uncertain.seed`), drawn for each replicate rather than designed, as are the failures of satellites and the growth of the cost of developing the satellites (both used below). The replicates use common random numbers: every design samples the same points in the same replicate, so that differences between designs are not differences between their samples.\n", "\n", "The constraint on the number of satellites returns the number in excess of the limit (a number that is not positive if the design satisfies it), rather than `True` or `False`, so that optimizers can tell how far an infeasible design is from a feasible one." ] @@ -79,10 +79,10 @@ "id": "e5f4a7b6", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T03:30:48.391487Z", - "iopub.status.busy": "2026-11-11T03:30:48.391145Z", - "iopub.status.idle": "2026-11-11T03:30:49.633458Z", - "shell.execute_reply": "2026-11-11T03:30:49.632460Z" + "iopub.execute_input": "2026-11-11T06:53:52.739656Z", + "iopub.status.busy": "2026-11-11T06:53:52.739331Z", + "iopub.status.idle": "2026-11-11T06:53:53.864061Z", + "shell.execute_reply": "2026-11-11T06:53:53.863266Z" } }, "outputs": [ @@ -116,6 +116,7 @@ " ),\n", " points_seed=Uncertain.seed(),\n", " failure_seed=Uncertain.seed(),\n", + " cost_growth=Uncertain(lambda rng: float(rng.triangular(0.9, 1.0, 1.6))), # of development, for cost risk\n", " constraints=[lambda d: count_satellites(d.layout) - MAX_SATELLITES],\n", ")\n", "designs = space.enumerate()\n", @@ -133,7 +134,7 @@ "\n", "The evaluation computes both objectives: the share of points with at least four samples, and the share whose sampling error (`tatc.analysis.estimate_sampling_error`, for an exponential correlation in time with a decorrelation time of 3 hours) is at most half the field's standard deviation. A `ResultStore` keeps the records of the evaluations in a file, so that running the notebook again (or resuming it after an interruption) takes them from the file rather than evaluating them again.\n", "\n", - "`make_study` makes studies of other durations, numbers of replicates, and probabilities that satellites fail, as for screening and robustness (below). Each evaluation also reports its cost (`satellite_days`, the satellites times the days analyzed), which measures the computation independently of the cache." + "`make_study` makes studies of other durations, numbers of replicates, and probabilities that satellites fail, as for screening and robustness (below). Each evaluation also estimates the life-cycle cost of the design (`CostModel`, used below), and reports the cost of its computation (`satellite_days`, the satellites times the days analyzed), which measures the computation independently of the cache." ] }, { @@ -142,10 +143,10 @@ "id": "a7b6c9d8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T03:30:49.635457Z", - "iopub.status.busy": "2026-11-11T03:30:49.635158Z", - "iopub.status.idle": "2026-11-11T03:30:49.642567Z", - "shell.execute_reply": "2026-11-11T03:30:49.641760Z" + "iopub.execute_input": "2026-11-11T06:53:53.865992Z", + "iopub.status.busy": "2026-11-11T06:53:53.865668Z", + "iopub.status.idle": "2026-11-11T06:53:53.874286Z", + "shell.execute_reply": "2026-11-11T06:53:53.873513Z" } }, "outputs": [], @@ -153,7 +154,30 @@ "from tatc.analysis import collect_observations, estimate_sampling_error\n", "from tatc.generation import generate_points_random\n", "from tatc.schemas import Instrument\n", - "from tatc.tradespace import ResultStore, SatelliteCache, Study, build_constellation, count_planes, remove_failures\n", + "from tatc.tradespace import (\n", + " CostModel,\n", + " LaunchCost,\n", + " OperationsCost,\n", + " ResultStore,\n", + " SatelliteCache,\n", + " SatelliteCost,\n", + " Study,\n", + " build_constellation,\n", + " count_planes,\n", + " remove_failures,\n", + ")\n", + "\n", + "# illustrative costs (millions of dollars), not estimates of any mission: satellites with an imager of each field of\n", + "# regard, a small launcher for every 3 satellites of a plane, and 5 years of operations\n", + "COST_MODEL = CostModel(\n", + " satellites={\n", + " 30: SatelliteCost(development=40, first_unit=12, learning_rate=0.9, mass=60),\n", + " 60: SatelliteCost(development=60, first_unit=18, learning_rate=0.9, mass=90),\n", + " },\n", + " launch=LaunchCost(per_launch=8, capacity=3),\n", + " operations=OperationsCost(per_year=3, per_satellite_year=0.5),\n", + " years=5,\n", + ")\n", "\n", "CACHE_DIRECTORY = Path(tempfile.gettempdir()) / \"tatc-search-trade-space\"\n", "caches = {}\n", @@ -184,6 +208,8 @@ " def evaluate(built):\n", " d, members, working = built\n", " counts = {\"satellites\": len(members), \"planes\": count_planes(d.layout)}\n", + " cost = COST_MODEL.estimate(d.layout, kind=d.field_of_regard, growth={\"development\": d.cost_growth})\n", + " counts.update(cost.metrics())\n", " if not working: # every satellite failed\n", " return {**counts, \"sufficient\": 0.0, \"accurate\": 0.0, \"satellite_days\": 0.0}\n", " observations = get_cache(d.points_seed, duration)(working)\n", @@ -224,10 +250,10 @@ "id": "c9d8e1f0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T03:30:49.644249Z", - "iopub.status.busy": "2026-11-11T03:30:49.644008Z", - "iopub.status.idle": "2026-11-11T03:31:34.138996Z", - "shell.execute_reply": "2026-11-11T03:31:34.138057Z" + "iopub.execute_input": "2026-11-11T06:53:53.876015Z", + "iopub.status.busy": "2026-11-11T06:53:53.875753Z", + "iopub.status.idle": "2026-11-11T06:53:54.274551Z", + "shell.execute_reply": "2026-11-11T06:53:54.273876Z" } }, "outputs": [ @@ -350,8 +376,9 @@ "\n", "# the values of each design, and the means of its objectives over the replicates\n", "values = results.drop_duplicates(\"design\").set_index(\"design\").drop(\n", - " columns=[\"replicate\", \"points_seed\", \"failure_seed\", \"seconds\", \"sufficient\", \"accurate\", \"feasible\"]\n", + " columns=[\"replicate\", \"points_seed\", \"failure_seed\", \"cost_growth\", \"seconds\", \"sufficient\", \"accurate\", \"feasible\"]\n", ")\n", + "values = values.drop(columns=[column for column in values.columns if column.startswith(\"cost\")])\n", "summary = summarize(results, list(OBJECTIVES), design_columns=[])\n", "summary[\"pareto\"] = pareto_front(summary, OBJECTIVES)\n", "exact_hypervolume = hypervolume(summary, OBJECTIVES, REFERENCE)\n", @@ -384,10 +411,10 @@ "id": "d0e9f2a1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T03:31:34.141405Z", - "iopub.status.busy": "2026-11-11T03:31:34.140980Z", - "iopub.status.idle": "2026-11-11T03:31:34.519059Z", - "shell.execute_reply": "2026-11-11T03:31:34.517870Z" + "iopub.execute_input": "2026-11-11T06:53:54.276261Z", + "iopub.status.busy": "2026-11-11T06:53:54.276019Z", + "iopub.status.idle": "2026-11-11T06:53:54.474008Z", + "shell.execute_reply": "2026-11-11T06:53:54.473243Z" } }, "outputs": [ @@ -468,10 +495,10 @@ "id": "a2b3c4d5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T03:31:34.521466Z", - "iopub.status.busy": "2026-11-11T03:31:34.521132Z", - "iopub.status.idle": "2026-11-11T03:31:34.729723Z", - "shell.execute_reply": "2026-11-11T03:31:34.728457Z" + "iopub.execute_input": "2026-11-11T06:53:54.475636Z", + "iopub.status.busy": "2026-11-11T06:53:54.475393Z", + "iopub.status.idle": "2026-11-11T06:53:54.594211Z", + "shell.execute_reply": "2026-11-11T06:53:54.593433Z" } }, "outputs": [ @@ -668,10 +695,10 @@ "id": "b3c4d5e6", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T03:31:34.732260Z", - "iopub.status.busy": "2026-11-11T03:31:34.731999Z", - "iopub.status.idle": "2026-11-11T03:31:34.943955Z", - "shell.execute_reply": "2026-11-11T03:31:34.943100Z" + "iopub.execute_input": "2026-11-11T06:53:54.596336Z", + "iopub.status.busy": "2026-11-11T06:53:54.595986Z", + "iopub.status.idle": "2026-11-11T06:53:54.735542Z", + "shell.execute_reply": "2026-11-11T06:53:54.734838Z" } }, "outputs": [ @@ -721,10 +748,10 @@ "id": "d5e6f7a8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T03:31:34.946427Z", - "iopub.status.busy": "2026-11-11T03:31:34.946141Z", - "iopub.status.idle": "2026-11-11T03:31:35.174596Z", - "shell.execute_reply": "2026-11-11T03:31:35.173717Z" + "iopub.execute_input": "2026-11-11T06:53:54.737156Z", + "iopub.status.busy": "2026-11-11T06:53:54.736980Z", + "iopub.status.idle": "2026-11-11T06:53:54.911745Z", + "shell.execute_reply": "2026-11-11T06:53:54.910949Z" } }, "outputs": [ @@ -871,10 +898,10 @@ "id": "a8b9c0d1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T03:31:35.176631Z", - "iopub.status.busy": "2026-11-11T03:31:35.176436Z", - "iopub.status.idle": "2026-11-11T03:31:35.212416Z", - "shell.execute_reply": "2026-11-11T03:31:35.211420Z" + "iopub.execute_input": "2026-11-11T06:53:54.913416Z", + "iopub.status.busy": "2026-11-11T06:53:54.913159Z", + "iopub.status.idle": "2026-11-11T06:53:54.938936Z", + "shell.execute_reply": "2026-11-11T06:53:54.938120Z" } }, "outputs": [ @@ -1022,10 +1049,10 @@ "id": "a3b2c5d4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T03:31:35.214523Z", - "iopub.status.busy": "2026-11-11T03:31:35.214231Z", - "iopub.status.idle": "2026-11-11T03:32:37.303506Z", - "shell.execute_reply": "2026-11-11T03:32:37.302802Z" + "iopub.execute_input": "2026-11-11T06:53:54.940726Z", + "iopub.status.busy": "2026-11-11T06:53:54.940474Z", + "iopub.status.idle": "2026-11-11T06:54:43.635205Z", + "shell.execute_reply": "2026-11-11T06:54:43.634447Z" } }, "outputs": [ @@ -1274,10 +1301,10 @@ "id": "b5d3f7a9", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T03:32:37.305165Z", - "iopub.status.busy": "2026-11-11T03:32:37.304909Z", - "iopub.status.idle": "2026-11-11T03:44:27.663743Z", - "shell.execute_reply": "2026-11-11T03:44:27.662985Z" + "iopub.execute_input": "2026-11-11T06:54:43.636771Z", + "iopub.status.busy": "2026-11-11T06:54:43.636542Z", + "iopub.status.idle": "2026-11-11T07:03:45.057029Z", + "shell.execute_reply": "2026-11-11T07:03:45.056269Z" } }, "outputs": [ @@ -1427,10 +1454,10 @@ "id": "c6e4a8b0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T03:44:27.665482Z", - "iopub.status.busy": "2026-11-11T03:44:27.665237Z", - "iopub.status.idle": "2026-11-11T03:44:27.722198Z", - "shell.execute_reply": "2026-11-11T03:44:27.721509Z" + "iopub.execute_input": "2026-11-11T07:03:45.058622Z", + "iopub.status.busy": "2026-11-11T07:03:45.058393Z", + "iopub.status.idle": "2026-11-11T07:03:45.119948Z", + "shell.execute_reply": "2026-11-11T07:03:45.119262Z" } }, "outputs": [ @@ -1980,10 +2007,10 @@ "id": "f2a3b4c5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T03:44:27.723683Z", - "iopub.status.busy": "2026-11-11T03:44:27.723445Z", - "iopub.status.idle": "2026-11-11T03:44:44.343617Z", - "shell.execute_reply": "2026-11-11T03:44:44.342858Z" + "iopub.execute_input": "2026-11-11T07:03:45.121457Z", + "iopub.status.busy": "2026-11-11T07:03:45.121224Z", + "iopub.status.idle": "2026-11-11T07:03:45.181905Z", + "shell.execute_reply": "2026-11-11T07:03:45.180859Z" } }, "outputs": [ @@ -2485,10 +2512,10 @@ "id": "f9b7d1e3", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T03:44:44.345307Z", - "iopub.status.busy": "2026-11-11T03:44:44.345039Z", - "iopub.status.idle": "2026-11-11T03:45:29.659955Z", - "shell.execute_reply": "2026-11-11T03:45:29.659266Z" + "iopub.execute_input": "2026-11-11T07:03:45.183711Z", + "iopub.status.busy": "2026-11-11T07:03:45.183501Z", + "iopub.status.idle": "2026-11-11T07:04:28.742292Z", + "shell.execute_reply": "2026-11-11T07:04:28.741584Z" } }, "outputs": [ @@ -2718,10 +2745,10 @@ "id": "d1e2f3a4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T03:45:29.661723Z", - "iopub.status.busy": "2026-11-11T03:45:29.661476Z", - "iopub.status.idle": "2026-11-11T03:45:38.414811Z", - "shell.execute_reply": "2026-11-11T03:45:38.414116Z" + "iopub.execute_input": "2026-11-11T07:04:28.743856Z", + "iopub.status.busy": "2026-11-11T07:04:28.743636Z", + "iopub.status.idle": "2026-11-11T07:04:28.799811Z", + "shell.execute_reply": "2026-11-11T07:04:28.799147Z" } }, "outputs": [ @@ -2919,6 +2946,271 @@ "Designs that are equally accurate without failures differ with them. Nine satellites in three planes hardly change (98% accurate, and at least 96% in the worst 10% of the replicates), as the failure of a satellite leaves others in its plane. Six satellites in three planes lose 7 points on average, and four in two sun-synchronous planes 9 points, with as little as 51% in the worst 10% of the replicates. Two satellites in two planes lose 5 points on average, but nearly everything in the worst replicates, in which one of the two fails. The worst case, as a quantile over replicates with failures, is a criterion for the robustness of a design that its mean hides." ] }, + { + "cell_type": "markdown", + "id": "b1c2d3e4", + "metadata": {}, + "source": [ + "## Trade Cost Against Sufficiency\n", + "\n", + "The numbers of satellites and planes are proxies of cost. A `CostModel` estimates the life-cycle cost of each design from the costs of its satellites (the development of each type, and the production of its units on a learning curve), launches (here, a small launcher for every three satellites of a plane), and operations, given by the study (TAT-C does not include cost-estimating relationships). The costs here are illustrative, in millions of dollars. The evaluation adds the cost and its elements to each record, for the satellites of each design's imager (`kind`): a wider field of regard costs more to develop and build.\n", + "\n", + "The growth of the cost of development is uncertain (an `Uncertain` parameter, from 0.9 to 1.6 times the estimate, most likely 1), drawn for each replicate, so that statistics over the replicates give the cost at a confidence level: here, the 0.7 quantile (`cost p70`), as budgets are often set. A requirement keeps the designs whose cost at 70% confidence is within a budget, and the front trades this cost against the share of points sufficiently sampled. (Cost depends only on the design, so a constraint of the design space could exclude designs over a budget before they are evaluated, with the cost without growth.)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "c2d3e4f5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-11T07:04:28.801300Z", + "iopub.status.busy": "2026-11-11T07:04:28.801061Z", + "iopub.status.idle": "2026-11-11T07:05:20.806375Z", + "shell.execute_reply": "2026-11-11T07:05:20.805699Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "520 of 1096 designs cost at most 150 at 70% confidence, of which 34 are efficient in at least half of the resamples\n" + ] + }, + { + "data": { + "text/html": [ + "

\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanescost p70cost developmentcost productioncost launchcost operationssufficientpareto_probability
913800 km, 30 deg FOR, SSO: 1 at 12:001183.644.412.08.017.51.01.0
912800 km, 30 deg FOR, SSO: 2 at 09:002196.944.422.88.020.03.20.9
826800 km, 30 deg FOR, Walker 45 deg: 2 x 1 (spac...22104.944.422.816.020.07.81.0
922800 km, 30 deg FOR, SSO: 2 at 12:00, 1 at 06:0032117.644.433.016.022.57.80.7
835800 km, 30 deg FOR, Walker 45 deg: 3 x 1 (spac...33125.644.433.024.022.512.00.8
828800 km, 30 deg FOR, Walker 45 deg: 2 x 2 (spac...42129.844.442.716.025.020.00.9
963800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...22139.466.734.216.020.028.61.0
845800 km, 30 deg FOR, Walker 45 deg: 4 x 1 (spac...44145.844.442.732.025.029.00.8
961800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...31149.166.749.48.022.537.00.6
\n", + "
" + ], + "text/plain": [ + " description satellites planes \\\n", + "913 800 km, 30 deg FOR, SSO: 1 at 12:00 1 1 \n", + "912 800 km, 30 deg FOR, SSO: 2 at 09:00 2 1 \n", + "826 800 km, 30 deg FOR, Walker 45 deg: 2 x 1 (spac... 2 2 \n", + "922 800 km, 30 deg FOR, SSO: 2 at 12:00, 1 at 06:00 3 2 \n", + "835 800 km, 30 deg FOR, Walker 45 deg: 3 x 1 (spac... 3 3 \n", + "828 800 km, 30 deg FOR, Walker 45 deg: 2 x 2 (spac... 4 2 \n", + "963 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2 2 \n", + "845 800 km, 30 deg FOR, Walker 45 deg: 4 x 1 (spac... 4 4 \n", + "961 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3 1 \n", + "\n", + " cost p70 cost development cost production cost launch \\\n", + "913 83.6 44.4 12.0 8.0 \n", + "912 96.9 44.4 22.8 8.0 \n", + "826 104.9 44.4 22.8 16.0 \n", + "922 117.6 44.4 33.0 16.0 \n", + "835 125.6 44.4 33.0 24.0 \n", + "828 129.8 44.4 42.7 16.0 \n", + "963 139.4 66.7 34.2 16.0 \n", + "845 145.8 44.4 42.7 32.0 \n", + "961 149.1 66.7 49.4 8.0 \n", + "\n", + " cost operations sufficient pareto_probability \n", + "913 17.5 1.0 1.0 \n", + "912 20.0 3.2 0.9 \n", + "826 20.0 7.8 1.0 \n", + "922 22.5 7.8 0.7 \n", + "835 22.5 12.0 0.8 \n", + "828 25.0 20.0 0.9 \n", + "963 20.0 28.6 1.0 \n", + "845 25.0 29.0 0.8 \n", + "961 22.5 37.0 0.6 " + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "BUDGET = 150 # millions of dollars, at 70% confidence\n", + "COST_STATISTICS = {\"cost p70\": Quantile(\"cost\", 0.7)}\n", + "COST_OBJECTIVES = {\"cost p70\": \"min\", \"sufficient\": \"max\"}\n", + "ELEMENTS = [\"cost development\", \"cost production\", \"cost launch\", \"cost operations\"]\n", + "\n", + "costed = pareto_probability(\n", + " refinement.results,\n", + " COST_OBJECTIVES,\n", + " n_resamples=1000,\n", + " statistics=COST_STATISTICS,\n", + " requirements=[Requirement(\"cost p70\", \"<=\", BUDGET)],\n", + " tolerance=TOLERANCE,\n", + ")\n", + "elements = aggregate(refinement.results, ELEMENTS).set_index(\"design\")[ELEMENTS]\n", + "costed = costed.join(values[[\"satellites\", \"planes\"]], on=\"design\").join(elements, on=\"design\")\n", + "costed[\"description\"] = [describe(values.loc[key]) for key in costed.design]\n", + "efficient = costed[costed.pareto_probability >= 0.5]\n", + "print(\n", + " f\"{costed.meets_requirements.sum()} of {len(costed)} designs cost at most {BUDGET} at 70% confidence, \"\n", + " + f\"of which {len(efficient)} are efficient in at least half of the resamples\"\n", + ")\n", + "# the most sufficient of these at each cost\n", + "efficient.sort_values([\"cost p70\", \"sufficient\"], ascending=[True, False]).drop_duplicates(\"cost p70\")[\n", + " [\"description\", \"satellites\", \"planes\", \"cost p70\", *ELEMENTS, \"sufficient\", \"pareto_probability\"]\n", + "].round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "d3e4f5a6", + "metadata": {}, + "source": [ + "520 of the 1,096 designs cost at most 150 million dollars at 70% confidence. Along the front, money buys sufficiency in steps: one satellite (84 million at 70% confidence, of which 44 million on average develops it) samples 1% of the points sufficiently; a second satellite in its plane, 3%, and in a second plane, 8%; four satellites in two Walker planes (130 million), 20%. The planes now have a price: four satellites in four planes sample more points sufficiently than in two (29% against 20%, as more planes spread the samples in time), at twice the cost of launches (32 million against 16). The wider field of regard joins the front only near the budget, where its development (67 million against 44) is worth its swath: two satellites with the wider imager sample 29% of the points for 139 million, as many as four with the narrower one, and three of them 37% for 149 million, the most within the budget. The designs that sample nearly every point (six to nine satellites) cost more than the budget.\n", + "\n", + "The growth of the cost of development affects every design alike in a replicate (common random numbers), so it shifts the costs at 70% confidence more for designs whose development costs more, here those of the wider imager. With five replicates of most designs, the 0.7 quantile of their costs is a coarse estimate: an evaluation that costs little more than the cost model (unlike the analysis of sampling) could draw more replicates of the cost alone." + ] + }, { "cell_type": "markdown", "id": "c5d4e7f6", @@ -2933,14 +3225,14 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "id": "d6e5f8a7", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T03:45:38.416476Z", - "iopub.status.busy": "2026-11-11T03:45:38.416250Z", - "iopub.status.idle": "2026-11-11T03:45:56.306968Z", - "shell.execute_reply": "2026-11-11T03:45:56.306286Z" + "iopub.execute_input": "2026-11-11T07:05:20.808106Z", + "iopub.status.busy": "2026-11-11T07:05:20.807880Z", + "iopub.status.idle": "2026-11-11T07:05:23.630842Z", + "shell.execute_reply": "2026-11-11T07:05:23.630162Z" } }, "outputs": [ @@ -3039,7 +3331,7 @@ "3 24.8 " ] }, - "execution_count": 16, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -3096,14 +3388,14 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "id": "a9b8c1d0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T03:45:56.308635Z", - "iopub.status.busy": "2026-11-11T03:45:56.308378Z", - "iopub.status.idle": "2026-11-11T03:46:01.482988Z", - "shell.execute_reply": "2026-11-11T03:46:01.482221Z" + "iopub.execute_input": "2026-11-11T07:05:23.632534Z", + "iopub.status.busy": "2026-11-11T07:05:23.632284Z", + "iopub.status.idle": "2026-11-11T07:05:27.100651Z", + "shell.execute_reply": "2026-11-11T07:05:27.099955Z" } }, "outputs": [ @@ -3159,7 +3451,7 @@ "Latin hypercube sample 176.0 80.3" ] }, - "execution_count": 17, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -3210,14 +3502,14 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "id": "b0c9d2e1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T03:46:01.484554Z", - "iopub.status.busy": "2026-11-11T03:46:01.484367Z", - "iopub.status.idle": "2026-11-11T03:46:01.616512Z", - "shell.execute_reply": "2026-11-11T03:46:01.615805Z" + "iopub.execute_input": "2026-11-11T07:05:27.102481Z", + "iopub.status.busy": "2026-11-11T07:05:27.102076Z", + "iopub.status.idle": "2026-11-11T07:05:27.225400Z", + "shell.execute_reply": "2026-11-11T07:05:27.224651Z" } }, "outputs": [ @@ -3271,9 +3563,10 @@ "* The front of the means of the replicates is uncertain: `pareto_probability` finds the designs whose efficiency the replicates settle, and those that are equally good candidates, and `refine` adds replicates only to the latter, with a tolerance of differences that do not matter. `confirm` evaluates the selected designs with new replicates, which removes the optimism of selecting the best of many nearly equal designs.\n", "* Statistics other than means (such as a `Quantile` or the `Probability` of meeting a threshold) state how reliably a design performs, including with failures of satellites (`remove_failures`), and `Requirement`s on them are output constraints. `sensitivity` finds the design variables that drive each objective.\n", "* `screen` evaluates every design with a cheap study and the best with the full one, which finds the front at a fraction of the cost if the cheap study ranks designs as the full one does.\n", + "* A `CostModel` estimates the life-cycle cost of each design from the costs of its satellites, launches, and operations (given by the study), with uncertain growth whose quantiles give the cost at a confidence level, as an objective or a requirement in place of the numbers of satellites and planes.\n", "* `optimize_optuna` and `optimize_pymoo` search spaces too large to enumerate, and find most of the front with a fraction of the designs.\n", "\n", - "The sampling error here is that of a model of the field (an exponential correlation in time with a decorrelation time of 3 hours); with a simulation of the field (a nature run), `tatc.analysis.sample_field` and `compare_sampled_means` measure it directly. The numbers of satellites and planes are proxies of cost. The uncertainties are those of the sample of points and the failures of satellites; others (such as the phase of the satellites or the period of the analysis) are further `Uncertain` parameters of the design space." + "The sampling error here is that of a model of the field (an exponential correlation in time with a decorrelation time of 3 hours); with a simulation of the field (a nature run), `tatc.analysis.sample_field` and `compare_sampled_means` measure it directly. The costs are illustrative, and the numbers of satellites and planes, proxies of cost in the other sections. The uncertainties are those of the sample of points and the failures of satellites; others (such as the phase of the satellites or the period of the analysis) are further `Uncertain` parameters of the design space." ] } ], diff --git a/src/tatc/tradespace/__init__.py b/src/tatc/tradespace/__init__.py index cf58a620..e4e4b4e0 100644 --- a/src/tatc/tradespace/__init__.py +++ b/src/tatc/tradespace/__init__.py @@ -1,6 +1,6 @@ """ Trade space analysis: design spaces of (hierarchical) design variables and -uncertain parameters, building blocks of constellations, +uncertain parameters, building blocks of constellations (and their life-cycle cost), trade studies that evaluate their designs (with caches of analyses by satellite, in parallel), statistics of replicates and requirements on them, Pareto efficiency (with the uncertainty of replicates), @@ -14,6 +14,14 @@ from .cache import SatelliteCache, get_satellite_key from .confirmation import Confirmation, confirm +from .cost import ( + CostEstimate, + CostModel, + LaunchCost, + OperationsCost, + SatelliteCost, + plane_sizes, +) from .constellations import ( build_constellation, count_planes, @@ -68,6 +76,8 @@ "Choice", "ChoiceValues", "Confirmation", + "CostEstimate", + "CostModel", "Derived", "Design", "DesignSpace", @@ -75,9 +85,11 @@ "Fixed", "Infeasible", "Integer", + "LaunchCost", "Maximum", "Mean", "Minimum", + "OperationsCost", "Probability", "Quantile", "Real", @@ -87,6 +99,7 @@ "Requirement", "ResultStore", "SatelliteCache", + "SatelliteCost", "Scope", "Screening", "StandardDeviation", @@ -111,6 +124,7 @@ "pareto_front", "pareto_probability", "pareto_ranks", + "plane_sizes", "planes_space", "refine", "remove_failures", diff --git a/src/tatc/tradespace/cost.py b/src/tatc/tradespace/cost.py new file mode 100644 index 00000000..19273299 --- /dev/null +++ b/src/tatc/tradespace/cost.py @@ -0,0 +1,356 @@ +""" +Life-cycle cost of constellations for trade studies: the development, +production, launch, and operations of the satellites of their layouts (see +`walker_space`, `sso_planes_space`, and `planes_space`), with learning in +production, replenishment over the mission, and spares. + +TAT-C does not include cost-estimating relationships, whose common forms are +restricted or need calibration to an organization's experience: the costs of +each type of satellite (such as the satellites of each payload) and of +launches and operations are given, as values or functions of a design (such +as a mass-based relationship), in a currency of the user's choice and +constant-year amounts. Cost risk enters as uncertain growth factors (see +`CostModel.estimate`), drawn for each replicate like other uncertain +parameters, so that statistics of the cost over replicates (such as a 0.7 +`Quantile`) are objectives or requirements. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +import math +from collections.abc import Mapping +from dataclasses import dataclass, field +from typing import Any + +import numpy as np + +from .constellations import PLANES, SSO_PLANES, WALKER, _kind, _layout, _layouts +from .values import Values + +ELEMENTS = ("development", "production", "launch", "operations") +"""The elements of the cost of a constellation.""" + + +def plane_sizes(layout: Any) -> list[int]: + """ + Gets the number of satellites of each orbit plane of a layout (the + values of `walker_space`, `sso_planes_space`, or `planes_space`, or of a + choice of them), or of several (a list or a repetition of layouts). + + Args: + layout (Any): The values of the layout (or layouts). + + Returns: + list[int]: the number of satellites of each plane + """ + several = _layouts(layout) + if several is not None: + return [size for item in several for size in plane_sizes(item)] + layout = _layout(layout) + kind = _kind(layout) + if kind == WALKER: + return [int(layout.per_plane)] * int(layout.planes) + if kind in (SSO_PLANES, PLANES): + return [int(plane.satellites) for plane in layout.planes] + raise ValueError(f"unknown layout {kind!r}") + + +@dataclass(frozen=True) +class SatelliteCost: + """ + The cost of a type of satellite (bus and payload): a nonrecurring + `development` cost, and the recurring cost of its units, from that of + the first (`first_unit`, the theoretical first unit) by a learning curve: + unit `k` costs `first_unit * k ** log2(learning_rate)`, so that each + doubling of the units built costs `learning_rate` times as much per unit + (typically 0.85 to 0.95 for satellites, 1 for no learning). + + Args: + development (float): The nonrecurring cost. + first_unit (float): The recurring cost of the first unit. + learning_rate (float): The learning rate, in (0, 1]. + mass (float | None): The mass (kg), for launches priced by mass. + """ + + development: float = 0.0 + first_unit: float = 0.0 + learning_rate: float = 1.0 + mass: float | None = None + + def __post_init__(self): + if not 0 < self.learning_rate <= 1: + raise ValueError("learning_rate must be in (0, 1]") + if self.development < 0 or self.first_unit < 0: + raise ValueError("costs must not be negative") + + def production(self, units: int) -> float: + """ + Gets the recurring cost of building units (the sum of the costs of + units 1 to `units` on the learning curve). + + Args: + units (int): The number of units. + + Returns: + float: the cost + """ + if units <= 0: + return 0.0 + exponent = math.log2(self.learning_rate) + return float(self.first_unit * np.sum(np.arange(1, units + 1) ** exponent)) + + +@dataclass(frozen=True) +class LaunchCost: + """ + The cost of launching satellites: dedicated launches of each plane (as + many as it takes to carry its satellites, given a `capacity` in number + or mass), and prices per satellite and per kg (as of rideshares). Give + the fields of the launch service of a study and leave the others zero. + + Args: + per_launch (float): The cost of a dedicated launch. + capacity (int | None): The most satellites of a dedicated launch, if + limited. + mass_capacity (float | None): The most mass (kg) of a dedicated + launch, if limited. + per_satellite (float): The cost of launching each satellite. + per_kg (float): The cost of launching each kg of satellite. + """ + + per_launch: float = 0.0 + capacity: int | None = None + mass_capacity: float | None = None + per_satellite: float = 0.0 + per_kg: float = 0.0 + + def launches(self, satellites: int, mass: float | None) -> int: + """ + Gets the dedicated launches of a plane of satellites (0 without a + cost per launch). + + Args: + satellites (int): The number of satellites of the plane. + mass (float | None): The mass (kg) of each satellite. + + Returns: + int: the number of launches + """ + if self.per_launch == 0 or satellites <= 0: + return 0 + count = 1 + if self.capacity is not None: + count = max(count, math.ceil(satellites / self.capacity)) + if self.mass_capacity is not None: + if mass is None: + raise ValueError("a launch capacity in mass requires masses") + per_launch = math.floor(self.mass_capacity / mass) + if per_launch < 1: + raise ValueError("a satellite exceeds the mass capacity of a launch") + count = max(count, math.ceil(satellites / per_launch)) + return count + + +@dataclass(frozen=True) +class OperationsCost: + """ + The cost of operating a constellation: a fixed cost per year (such as + the mission operations center) and a cost per satellite and year. + + Args: + per_year (float): The fixed cost of each year. + per_satellite_year (float): The cost of each satellite in each year. + """ + + per_year: float = 0.0 + per_satellite_year: float = 0.0 + + +@dataclass +class CostEstimate: + """ + An estimate of the life-cycle cost of a constellation (see + `CostModel.estimate`). + """ + + development: float = 0.0 + """float: The nonrecurring cost of the types of satellites.""" + production: float = 0.0 + """float: The recurring cost of the units built.""" + launch: float = 0.0 + """float: The cost of launches.""" + operations: float = 0.0 + """float: The cost of operations.""" + units: dict[str, int] = field(default_factory=dict) + """dict: The units built of each type of satellite (including + replacements and spares).""" + launches: int = 0 + """int: The dedicated launches.""" + + @property + def total(self) -> float: + """float: The total cost.""" + return self.development + self.production + self.launch + self.operations + + def metrics(self, prefix: str = "cost") -> dict[str, float]: + """ + Gets the cost as metrics of an evaluation (see `Study`): the total + (``) and each element (` development`, ` + production`, ` launch`, and ` operations`). + + Args: + prefix (str): The name of the total, and prefix of the elements. + + Returns: + dict[str, float]: the metrics + """ + return { + prefix: self.total, + **{f"{prefix} {element}": getattr(self, element) for element in ELEMENTS}, + } + + +Growth = float | Mapping[str, float] +"""Growth factors of costs: one for every element, or by element (see +`ELEMENTS`, others 1).""" + + +@dataclass(frozen=True) +class CostModel: + """ + A model of the life-cycle cost of constellations: the costs of their + types of satellites, launches, and operations over a mission of `years`. + + Satellites are replaced at the end of their `design_life`: a mission of + 6 years with satellites of a design life of 3 years builds and launches + two generations of each satellite, whose units continue the learning + curve of the first. + + Args: + satellites (SatelliteCost | Mapping[str, SatelliteCost]): The cost of + the satellites, or of each type of satellite (by name). + launch (LaunchCost): The cost of launches. + operations (OperationsCost): The cost of operations. + years (float): The duration of the mission. + design_life (float | None): The design life of the satellites, or + `None` if they last the mission. + """ + + satellites: SatelliteCost | Mapping[str, SatelliteCost] + launch: LaunchCost = LaunchCost() + operations: OperationsCost = OperationsCost() + years: float = 1.0 + design_life: float | None = None + + def __post_init__(self): + if self.years <= 0: + raise ValueError("years must be positive") + if self.design_life is not None and self.design_life <= 0: + raise ValueError("design_life must be positive") + + @property + def generations(self) -> int: + """int: The generations of satellites built over the mission.""" + if self.design_life is None: + return 1 + return max(1, math.ceil(self.years / self.design_life - 1e-9)) + + def _get_type(self, kind: str | None) -> SatelliteCost: + if isinstance(self.satellites, SatelliteCost): + return self.satellites + if kind is None: + raise ValueError("a model of several types of satellites needs a kind") + if kind not in self.satellites: + raise ValueError(f"no cost of satellites of kind {kind!r}") + return self.satellites[kind] + + def estimate( + self, + layout: Any, + kind: str | None = None, + spares: int = 0, + growth: Growth = 1.0, + ) -> CostEstimate: + """ + Estimates the life-cycle cost of a constellation: the layout (or + layouts) of its satellites (see `plane_sizes`), of one type (`kind`, + if the model has several), or a mapping of types to layouts (such as + the shells of a mixed constellation, each of its own payload). + + Each plane has `spares` more satellites (spares in orbit, built, + launched, and operated with it). Each type of satellite is developed + once; its units (of every generation) follow its learning curve; + each plane is launched (by dedicated launches, or per satellite or + kg) in each generation; and every satellite is operated for the + mission. + + Growth factors multiply the estimate, such as uncertain parameters of + cost growth drawn for each replicate (for example, + `Uncertain(lambda rng: rng.triangular(0.9, 1.0, 1.5))`), whose + statistics over the replicates give the cost at a confidence level + (such as the 0.7 `Quantile`). Do not use uncertain growth in + constraints of a design space, which see their nominal values + (`NaN`). + + Args: + layout (Any): The layout (or layouts) of the satellites, or a + mapping of types of satellites to layouts. + kind (str | None): The type of the satellites of a layout, if the + model has several types. + spares (int): The spares in orbit in each plane. + growth (float | Mapping[str, float]): A growth factor of the + cost, or of each element (`"development"`, `"production"`, + `"launch"`, or `"operations"`; others 1). + + Returns: + CostEstimate: the estimate + """ + if spares < 0: + raise ValueError("spares must not be negative") + # a mapping of types to layouts (the values of a layout are a mapping too) + if isinstance(layout, Mapping) and not isinstance(layout, Values): + fleets = {name: plane_sizes(item) for name, item in layout.items()} + else: + fleets = {kind: plane_sizes(layout)} + estimate = CostEstimate() + operated = 0 + for name, sizes in fleets.items(): + cost = self._get_type(name) + sizes = [size + spares for size in sizes if size > 0] + if not sizes: + continue + units = self.generations * sum(sizes) + estimate.units["satellites" if name is None else str(name)] = units + estimate.development += cost.development + estimate.production += cost.production(units) + launches = self.generations * sum( + self.launch.launches(size, cost.mass) for size in sizes + ) + estimate.launches += launches + if self.launch.per_kg > 0 and cost.mass is None: + raise ValueError("launches priced by mass require masses") + estimate.launch += launches * self.launch.per_launch + units * ( + self.launch.per_satellite + self.launch.per_kg * (cost.mass or 0.0) + ) + operated += sum(sizes) + estimate.operations = self.years * ( + self.operations.per_year + self.operations.per_satellite_year * operated + ) + factors = _get_growth(growth) + for element in ELEMENTS: + setattr(estimate, element, getattr(estimate, element) * factors[element]) + return estimate + + +def _get_growth(growth: Growth) -> dict[str, float]: + """ + Gets the growth factor of each element of cost. + """ + if isinstance(growth, Mapping): + unknown = set(growth) - set(ELEMENTS) + if unknown: + raise ValueError(f"growth of unknown elements: {sorted(unknown)}") + return {element: float(growth.get(element, 1.0)) for element in ELEMENTS} + return {element: float(growth) for element in ELEMENTS} diff --git a/src/tatc/tradespace/fingerprint.py b/src/tatc/tradespace/fingerprint.py index 138161e0..c30ba5d0 100644 --- a/src/tatc/tradespace/fingerprint.py +++ b/src/tatc/tradespace/fingerprint.py @@ -6,18 +6,22 @@ A fingerprint describes values by their content where it can: plain values (numbers, strings, dates and times, and their containers), pydantic models (such as satellites and instruments), small arrays, the nodes of design -spaces, and functions, by their code, the values they close over and their -defaults, and the plain values and functions of the same module that they -refer to as globals. Other objects (such as data frames) are described by -their type only: identify them by a namespace (see `ResultStore` and -`SatelliteCache`). Functions of other modules (such as TAT-C's) are -described by their names, as the version of TAT-C is part of a fingerprint. +spaces, dataclasses (such as cost models) by their fields, and functions, by +their code, the values they close over and their defaults, and the +constants (numbers, strings, dates and times, and tuples of them), +dataclasses, and functions of the same module that they refer to as globals +(not mutable containers, which are often state, such as caches). Other +objects (such as data frames) are described by their type only: identify +them by a namespace (see `ResultStore` and `SatelliteCache`). Functions of +other modules (such as TAT-C's) are described by their names, as the version +of TAT-C is part of a fingerprint. @author: Paul T. Grogan """ from __future__ import annotations +import dataclasses import functools import hashlib import json @@ -59,7 +63,8 @@ def _code(code: types.CodeType, depth: int, seen: set) -> dict: def _function(function: types.FunctionType, depth: int, seen: set) -> dict: """ Describes a function: its code, the values it closes over, its defaults, - and the plain values and functions of its module it refers to as globals. + and the constants, dataclasses, and functions of its module it refers to + as globals. """ if id(function) in seen: return {"function": function.__qualname__, "recursive": True} @@ -78,7 +83,7 @@ def _function(function: types.FunctionType, depth: int, seen: set) -> dict: if isinstance(value, types.FunctionType): if value.__module__ == module: referenced[name] = _function(value, depth + 1, seen) - elif _is_plain(value): + elif _is_constant(value) or _is_dataclass(value): referenced[name] = _describe(value, depth + 1, seen) return { "function": function.__qualname__, @@ -90,6 +95,11 @@ def _function(function: types.FunctionType, depth: int, seen: set) -> dict: } +def _is_dataclass(value: Any) -> bool: + """Whether a value is an instance of a dataclass (such as a cost model).""" + return dataclasses.is_dataclass(value) and not isinstance(value, type) + + def _has_contents(cell: Any) -> bool: try: cell.cell_contents # pylint: disable=pointless-statement @@ -112,21 +122,21 @@ def _global_names(code: types.CodeType) -> list[str]: _PLAIN = (type(None), bool, int, float, str, bytes, date, time, timedelta, np.generic) -def _is_plain(value: Any, depth: int = 0) -> bool: +def _is_constant(value: Any, depth: int = 0) -> bool: """ - Whether a value is plain: a number, string, date or time, or a (small) - container of them. + Whether a value is a constant: a number, string, date or time, or a + (small) tuple or frozen set of them. Mutable containers (lists, + dictionaries, and sets) are not constants: as globals, they are often + state (such as caches) rather than definitions, whose contents change + as a study runs. """ if isinstance(value, _PLAIN): return True if depth > 3: return False - if isinstance(value, (list, tuple, set, frozenset)): - return len(value) <= _MAX_ITEMS and all(_is_plain(v, depth + 1) for v in value) - if isinstance(value, dict): + if isinstance(value, (tuple, frozenset)): return len(value) <= _MAX_ITEMS and all( - _is_plain(k, depth + 1) and _is_plain(v, depth + 1) - for k, v in value.items() + _is_constant(v, depth + 1) for v in value ) return False @@ -151,6 +161,14 @@ def _describe(value: Any, depth: int = 0, seen: set | None = None) -> Any: return value.isoformat() if isinstance(value, timedelta): return {"timedelta": value.total_seconds()} + if _is_dataclass(value): + return { + **_type(value), + **{ + item.name: _describe(getattr(value, item.name), depth + 1, seen) + for item in dataclasses.fields(value) + }, + } if isinstance(value, BaseModel): return {**_type(value), **value.model_dump(mode="json")} if isinstance(value, np.ndarray): diff --git a/tests/tradespace/test_cost.py b/tests/tradespace/test_cost.py new file mode 100644 index 00000000..e230f216 --- /dev/null +++ b/tests/tradespace/test_cost.py @@ -0,0 +1,239 @@ +""" +Unit tests for life-cycle costs of constellations. + +@author Paul T. Grogan +""" + +import unittest + +import numpy as np + +from tatc.tradespace import ( + Categorical, + CostModel, + DesignSpace, + Integer, + LaunchCost, + OperationsCost, + Quantile, + SatelliteCost, + Study, + Uncertain, + aggregate, + count_satellites, + plane_sizes, + planes_space, + sso_planes_space, + walker_space, +) + + +def _design(**children): + """The only design of a design space.""" + (design,) = DesignSpace(**children).enumerate() + return design + + +def _walker(planes=3, per_plane=4): + return _design( + layout=walker_space( + inclination=55.0, planes=planes, per_plane=per_plane, relative_spacing=0 + ) + ).layout + + +class TestSatelliteCost(unittest.TestCase): + """ + Unit tests for costs of satellites. + """ + + def test_learning_curve(self): + """Each doubling of units costs the learning rate times as much per unit.""" + flat = SatelliteCost(first_unit=10) + self.assertEqual(flat.production(5), 50) + learning = SatelliteCost(first_unit=10, learning_rate=0.9) + self.assertAlmostEqual(learning.production(1), 10) + self.assertAlmostEqual(learning.production(2), 10 + 9) + self.assertAlmostEqual(learning.production(4) - learning.production(3), 8.1) + self.assertEqual(learning.production(0), 0) + with self.assertRaises(ValueError): + SatelliteCost(first_unit=10, learning_rate=1.2) + with self.assertRaises(ValueError): + SatelliteCost(development=-1) + + +class TestPlaneSizes(unittest.TestCase): + """ + Unit tests for the satellites of each plane of layouts. + """ + + def test_layouts(self): + """Plane sizes of each layout, and of several.""" + walker = _walker(planes=2, per_plane=3) + sso = _design( + layout=sso_planes_space(crossing=13.5, satellites=2, count=1) + ).layout + inclined = _design( + layout=planes_space(inclination=30.0, node=0.0, satellites=4, count=2) + ).layout + self.assertEqual(plane_sizes(walker), [3, 3]) + self.assertEqual(plane_sizes(sso), [2]) + self.assertEqual(plane_sizes(inclined), [4, 4]) + self.assertEqual(plane_sizes([walker, sso]), [3, 3, 2]) + + +class TestCostModel(unittest.TestCase): + """ + Unit tests for life-cycle costs. + """ + + def setUp(self): + self.satellite = SatelliteCost( + development=100, first_unit=10, learning_rate=0.9, mass=50 + ) + + def test_dedicated_launches(self): + """Planes are launched in as many launches as their capacity requires.""" + model = CostModel( + self.satellite, + launch=LaunchCost(per_launch=30, capacity=3), + operations=OperationsCost(per_year=5, per_satellite_year=1), + years=6, + design_life=3, + ) + self.assertEqual(model.generations, 2) + estimate = model.estimate(_walker(planes=3, per_plane=4)) + # two generations of 3 planes of 4 satellites, 2 launches each + self.assertEqual(estimate.units, {"satellites": 24}) + self.assertEqual(estimate.launches, 12) + self.assertEqual(estimate.development, 100) + self.assertAlmostEqual(estimate.production, self.satellite.production(24)) + self.assertEqual(estimate.launch, 12 * 30) + self.assertEqual(estimate.operations, 6 * (5 + 12)) + self.assertAlmostEqual( + estimate.total, + 100 + self.satellite.production(24) + 360 + 102, + ) + metrics = estimate.metrics() + self.assertEqual( + list(metrics), + [ + "cost", + "cost development", + "cost production", + "cost launch", + "cost operations", + ], + ) + self.assertEqual(metrics["cost"], estimate.total) + + def test_rideshare(self): + """Rideshares are priced per satellite and per kg.""" + model = CostModel( + self.satellite, launch=LaunchCost(per_satellite=2, per_kg=0.1) + ) + estimate = model.estimate(_walker(planes=1, per_plane=4)) + self.assertEqual(estimate.launches, 0) + self.assertAlmostEqual(estimate.launch, 4 * (2 + 0.1 * 50)) + with self.assertRaises(ValueError): + CostModel(SatelliteCost(), launch=LaunchCost(per_kg=1)).estimate(_walker()) + + def test_mass_capacity(self): + """A launch carries as many satellites as its mass capacity allows.""" + model = CostModel( + self.satellite, launch=LaunchCost(per_launch=30, mass_capacity=120) + ) + # 2 satellites of 50 kg per launch: 2 launches for each plane of 4 + self.assertEqual(model.estimate(_walker(planes=2, per_plane=4)).launches, 4) + with self.assertRaises(ValueError): + CostModel( + self.satellite, launch=LaunchCost(per_launch=30, mass_capacity=40) + ).estimate(_walker()) + + def test_spares(self): + """Spares in orbit are built, launched, and operated with each plane.""" + model = CostModel( + self.satellite, + launch=LaunchCost(per_launch=30, capacity=4), + operations=OperationsCost(per_satellite_year=1), + ) + estimate = model.estimate(_walker(planes=2, per_plane=4), spares=1) + self.assertEqual(estimate.units["satellites"], 10) + self.assertEqual(estimate.launches, 4) + self.assertEqual(estimate.operations, 10) + + def test_types(self): + """Types of satellites are developed once each, with their own curves.""" + small = SatelliteCost(development=10, first_unit=1) + model = CostModel({"large": self.satellite, "small": small}) + walker, sso = ( + _walker(planes=1, per_plane=2), + _design( + layout=sso_planes_space(crossing=13.5, satellites=3, count=1) + ).layout, + ) + mixed = model.estimate({"large": walker, "small": sso}) + self.assertEqual(mixed.units, {"large": 2, "small": 3}) + self.assertEqual(mixed.development, 110) + self.assertAlmostEqual(mixed.production, self.satellite.production(2) + 3) + one = model.estimate(walker, kind="small") + self.assertEqual(one.development, 10) + with self.assertRaises(ValueError): + model.estimate(walker) + with self.assertRaises(ValueError): + model.estimate(walker, kind="medium") + + def test_growth(self): + """Growth factors multiply the cost, or its elements.""" + model = CostModel( + self.satellite, operations=OperationsCost(per_year=5), years=2 + ) + base = model.estimate(_walker()) + grown = model.estimate(_walker(), growth=1.5) + self.assertAlmostEqual(grown.total, 1.5 * base.total) + partial = model.estimate(_walker(), growth={"development": 2.0}) + self.assertAlmostEqual(partial.development, 200) + self.assertAlmostEqual(partial.operations, base.operations) + with self.assertRaises(ValueError): + model.estimate(_walker(), growth={"insurance": 1.1}) + + def test_trade_study(self): + """Costs are constraints of design spaces and metrics of studies.""" + model = CostModel( + { + "narrow": SatelliteCost(development=50, first_unit=10), + "wide": SatelliteCost(development=80, first_unit=16), + }, + launch=LaunchCost(per_launch=20), + ) + budget = 200 + space = DesignSpace( + imager=Categorical(["narrow", "wide"]), + layout=walker_space( + inclination=55.0, + planes=Integer(1, 3), + per_plane=Integer(1, 3), + relative_spacing=0, + ), + growth=Uncertain(lambda rng: float(rng.triangular(0.9, 1.0, 1.5))), + constraints=[ + lambda d: model.estimate(d.layout, kind=d.imager).total - budget + ], + ) + designs = space.enumerate() + nominal = [model.estimate(d.layout, kind=d.imager).total for d in designs] + self.assertTrue(all(cost <= budget for cost in nominal)) + self.assertLess(len(designs), 2 * 9) + + def evaluate(d): + cost = model.estimate(d.layout, kind=d.imager, growth=d.growth) + return {**cost.metrics(), "satellites": count_satellites(d.layout)} + + results = Study(space, lambda d: d, evaluate, replicates=20).run(designs) + summary = aggregate( + results, {"cost": "cost", "cost p70": Quantile("cost", 0.7)} + ) + # the 0.7 quantile of a growth skewed upward exceeds the mean + self.assertTrue((summary["cost p70"] > summary["cost"]).all()) + ratio = summary["cost"] / np.array(nominal) + np.testing.assert_allclose(ratio, ratio.iloc[0]) # common random numbers diff --git a/tests/tradespace/test_fingerprint.py b/tests/tradespace/test_fingerprint.py index cbc7257f..79921bac 100644 --- a/tests/tradespace/test_fingerprint.py +++ b/tests/tradespace/test_fingerprint.py @@ -16,9 +16,11 @@ from tatc.schemas import Instrument from tatc.tradespace import ( + CostModel, DesignSpace, Integer, Real, + SatelliteCost, Study, Uncertain, get_fingerprint, @@ -35,6 +37,20 @@ def _uses_helper(d): return {"value": _helper(d.a)} +MODEL = None +CACHES = {} + + +def _uses_cache(d): + if d not in CACHES: + CACHES[d] = object() + return CACHES[d] + + +def _uses_model(d): + return {"cost": MODEL.estimate(d.layout).total} + + def _space(high=4, fixed=1.0, spread=1.0): return DesignSpace( a=Integer(1, high), @@ -110,6 +126,24 @@ def test_values(self): get_fingerprint(pd.DataFrame({"a": [2]})), ) + def test_global_state(self): + """Mutable globals (such as caches) do not change the fingerprint.""" + before = get_fingerprint(_uses_cache) + _uses_cache(1) + self.assertEqual(before, get_fingerprint(_uses_cache)) + + def test_dataclasses(self): + """Dataclasses, such as cost models, are described by their fields.""" + cheap = CostModel(SatelliteCost(first_unit=10)) + dear = CostModel(SatelliteCost(first_unit=12)) + self.assertNotEqual(get_fingerprint(cheap), get_fingerprint(dear)) + global MODEL # pylint: disable=global-statement + MODEL = cheap + before = get_fingerprint(_uses_model) + MODEL = dear + # a dataclass that a function refers to as a global + self.assertNotEqual(before, get_fingerprint(_uses_model)) + def test_study(self): """A study's fingerprint changes with its seed and random numbers.""" From 390733b35c0ae69c7c834ba6aaf5af64c4308335 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Wed, 11 Nov 2026 07:05:46 -0700 Subject: [PATCH 11/52] speed up Pareto fronts with tolerances, sweeps, and quantiles of replicates --- CHANGELOG.md | 2 +- src/tatc/tradespace/criteria.py | 16 +++++- src/tatc/tradespace/pareto.py | 91 ++++++++++++++++++++----------- tests/tradespace/test_criteria.py | 14 +++++ tests/tradespace/test_pareto.py | 60 +++++++++++++++----- 5 files changed, 134 insertions(+), 49 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index dec5c687..07938b2a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -22,7 +22,7 @@ Added: - Searches of design spaces with optional optimizers: `tradespace.optimize_optuna` suggests designs with Optuna trials (`DesignSpace.suggest`, define-by-run over the hierarchical space), and `optimize_pymoo` and `make_pymoo_problem` search the unit hypercube that encodes a design space (`DesignSpace.unit_paths`, `encode`, and `decode`) with pymoo. Each design is evaluated once, and the designs proposed together are evaluated together, in parallel if the study is. Constraints of a design space may return the amount of their violation (`Infeasible.violation`), which Optuna's trials record (`set_constraint`) for its constraint-aware samplers, and which is the constraint value of pymoo problems. Optional dependencies `tradespace` (joblib, Optuna, and pymoo). - Life-cycle costs of constellations for trade studies (`tradespace.CostModel`): the development of each type of satellite, the production of its units on a learning curve (`SatelliteCost`), launches (dedicated launches of each plane, up to a capacity in number or mass, or prices per satellite and kg, `LaunchCost`), operations (`OperationsCost`), replenishment at the end of a design life, and spares in orbit, from the layouts of a design (`plane_sizes`), with growth factors for cost risk (such as uncertain parameters, whose quantiles over replicates give the cost at a confidence level). TAT-C does not include cost-estimating relationships: the costs are given by the study. Fingerprints describe dataclasses (such as cost models) by their fields. - Function `tradespace.confirm` (and class `Confirmation`), which evaluates selected designs (such as a front) with new replicates that played no part in their selection, removing the optimism of the selection (the winner's curse, `Confirmation.optimism`). `ResultStore` keys evaluations by the fingerprint of a study (`Study.fingerprint`, see `get_fingerprint`: its seed, use of common random numbers, design space, and build and evaluation functions, and the version of TAT-C), warning if it holds evaluations of other definitions, which are not reused; `SatelliteCache` keys results on disk by the fingerprint of its function. `refine` treats designs with fewer than `min_replicates` (5) as uncertain whatever their probability, adds the replicates left to `max_replicates` in a last partial step, and warns if designs remain uncertain without a tolerance. `sensitivity` gives adjusted shares (epsilon squared) by default, without the share that the levels of a variable explain by chance (`adjusted=False` for correlation ratios). - - Searches with Optuna accept categorical options that depend on earlier decisions (a parameter for each set of options), use TPE with a constant liar in batches by default (which spreads the trials of a batch), and stop after `max_designs` designs evaluated (trials that suggest designs evaluated before are told their objectives without evaluating them again). A design infeasible in some of its replicates violates its feasibility by their share (`Evaluations.infeasibility`), and the first design evaluated in a search is evaluated alone, to check that evaluations give one record each. `Study` records errors of evaluations as infeasible, without storing them, with `errors="record"`. Enumeration walks the items of unordered repetitions in one order only (the same designs, in the same order, four times faster for three sun-synchronous planes), and `DesignSpace.size` counts designs without keeping them. Pareto fronts of many designs (4,096 or more, without tolerances) are found by a sweep (20,000 designs in 0.2 s rather than 17 s), and comparisons of every pair use blocks of bounded memory. + - Searches with Optuna accept categorical options that depend on earlier decisions (a parameter for each set of options), use TPE with a constant liar in batches by default (which spreads the trials of a batch), and stop after `max_designs` designs evaluated (trials that suggest designs evaluated before are told their objectives without evaluating them again). A design infeasible in some of its replicates violates its feasibility by their share (`Evaluations.infeasibility`), and the first design evaluated in a search is evaluated alone, to check that evaluations give one record each. `Study` records errors of evaluations as infeasible, without storing them, with `errors="record"`. Enumeration walks the items of unordered repetitions in one order only (the same designs, in the same order, four times faster for three sun-synchronous planes), and `DesignSpace.size` counts designs without keeping them. Pareto fronts are found by a vectorized sweep in lexicographic order that compares designs only with the efficient designs before them, and fronts with tolerances by comparing designs only with the efficient designs without tolerances (which dominate every design that any design dominates within the tolerances), in blocks of bounded memory: 20,000 designs in 0.05 s (0.11 s with tolerances) rather than 17 s, and the bootstraps of `pareto_probability` (and so `refine`) about 20 times faster. - Example `SearchTradeSpace`, which searches a hierarchical trade space of constellations for the designs that sample points sufficiently: by evaluating every design, ranking them with the uncertainty of their replicates, screening, and searching with Optuna and pymoo. - The `RunOSSEMonsoon` example declares its constellation trade as a design space, caches the looks of each satellite, evaluates its replicates in parallel, and finds its Pareto-efficient designs. diff --git a/src/tatc/tradespace/criteria.py b/src/tatc/tradespace/criteria.py index 50643edc..c8fbd967 100644 --- a/src/tatc/tradespace/criteria.py +++ b/src/tatc/tradespace/criteria.py @@ -133,7 +133,21 @@ def __init__(self, column: str, q: float): self.q = q def reduce(self, values: np.ndarray) -> np.ndarray: - return _nan_reduce(lambda v, axis: np.nanquantile(v, self.q, axis=axis), values) + # numpy's nanquantile, vectorized: sort each row (missing values + # last), and interpolate linearly between the values around the + # quantile's position among each row's values + ordered = np.sort(values, axis=1) + counts = np.sum(~np.isnan(values), axis=1) + position = self.q * np.maximum(counts - 1, 0) + below = np.floor(position).astype(int) + above = np.minimum(below + 1, np.maximum(counts - 1, 0)) + rows = np.arange(len(values)) + weight = position - below + with np.errstate(invalid="ignore"): + result = (1 - weight) * ordered[rows, below] + weight * ordered[rows, above] + result[weight == 0] = ordered[rows, below][weight == 0] + result[counts == 0] = np.nan + return result def __repr__(self) -> str: return f"Quantile({self.column!r}, {self.q!r})" diff --git a/src/tatc/tradespace/pareto.py b/src/tatc/tradespace/pareto.py index 62df688b..87f37d86 100644 --- a/src/tatc/tradespace/pareto.py +++ b/src/tatc/tradespace/pareto.py @@ -100,29 +100,61 @@ def _get_tolerances( _BLOCK_ELEMENTS = 2_000_000 """The most elements of the temporary arrays of a block of comparisons.""" -_SWEEP_POINTS = 4096 -"""The fewest points whose dominance (without tolerances) is found by a sweep.""" +_CHUNK = 64 +"""The points of each chunk of a sweep (see `_dominated_plain`).""" -def _dominated_sweep(costs: np.ndarray) -> np.ndarray: +def _dominated_by( + points: np.ndarray, others: np.ndarray, tolerances: np.ndarray | None = None +) -> np.ndarray: + """ + Finds the points dominated by any of others, even if the other is + penalized by the tolerances (see `_dominated`), comparing them in blocks + whose temporary arrays are limited to a few million elements. + """ + dominated = np.zeros(len(points), dtype=bool) + if len(points) == 0 or len(others) == 0: + return dominated + if tolerances is None: + tolerances = np.zeros((2, points.shape[1])) + absolute, relative = tolerances + penalties = np.any(tolerances) + block = max(1, _BLOCK_ELEMENTS // max(len(others) * points.shape[1], 1)) + for start in range(0, len(points), block): + part = points[start : start + block] + # [i, j]: other j dominates point i of the block + penalized = others[None, :, :] + if penalties: + penalized = penalized + absolute + relative * np.abs(part[:, None, :]) + no_worse = np.all(penalized <= part[:, None, :], axis=2) + better = np.any(penalized < part[:, None, :], axis=2) + dominated[start : start + block] = np.any(no_worse & better, axis=1) + return dominated + + +def _dominated_plain(costs: np.ndarray) -> np.ndarray: """ Finds the points dominated by another (without tolerances) by a sweep in lexicographic order, in which a point can only be dominated by points - before it, and is dominated by one if it is by any (dominance is - transitive), so that each point is compared only with the efficient - points before it. + before it, and is dominated by one if it is by any of the efficient + points before it (dominance is transitive). The sweep compares each + chunk of points with the efficient points before it, then those it does + not dominate with each other. """ + n = len(costs) order = np.lexsort(costs.T[::-1]) - dominated = np.zeros(len(costs), dtype=bool) + ordered = costs[order] + dominated = np.zeros(n, dtype=bool) efficient = np.empty((0, costs.shape[1])) - for index in order: - point = costs[index] - if len(efficient) > 0 and np.any( - np.all(efficient <= point, axis=1) & np.any(efficient < point, axis=1) - ): - dominated[index] = True - else: - efficient = np.vstack([efficient, point]) + for start in range(0, n, _CHUNK): + part = ordered[start : start + _CHUNK] + beaten = _dominated_by(part, efficient) + # a point that an earlier efficient point dominates dominates nothing + # that it does not: compare only the others with each other + survivors = part[~beaten] + beaten[~beaten] = _dominated_by(survivors, survivors) + dominated[order[start : start + _CHUNK]] = beaten + efficient = np.vstack([efficient, part[~beaten]]) return dominated @@ -132,25 +164,18 @@ def _dominated(costs: np.ndarray, tolerances: np.ndarray | None = None) -> np.nd is penalized by the tolerances: no worse in every cost, and better in at least one, by at least its tolerance (absolute, plus a share of the magnitude of the cost of the point it would dominate, see - `_get_tolerances`). Points are compared with every other in blocks, - whose temporary arrays are limited to a few million elements, or, for - many points without tolerances, by a sweep (see `_dominated_sweep`). + `_get_tolerances`). + + A point that is dominated with tolerances is also dominated by a point + that is efficient without them: the penalty depends only on the point + dominated, so any point no worse than its dominator in every cost (as + some efficient point is) dominates it too. Points are therefore compared + only with the efficient points (see `_dominated_plain`), which are few. """ - n = len(costs) - if n >= _SWEEP_POINTS and (tolerances is None or not np.any(tolerances)): - return _dominated_sweep(costs) - block = max(1, min(n, _BLOCK_ELEMENTS // max(n * costs.shape[1], 1))) - tolerances = np.zeros((2, costs.shape[1])) if tolerances is None else tolerances - absolute, relative = tolerances - dominated = np.zeros(n, dtype=bool) - for start in range(0, n, block): - part = costs[start : start + block] - # [i, j]: point j dominates point i of the block - penalized = costs[None, :, :] + absolute + relative * np.abs(part[:, None, :]) - no_worse = np.all(penalized <= part[:, None, :], axis=2) - better = np.any(penalized < part[:, None, :], axis=2) - dominated[start : start + block] = np.any(no_worse & better, axis=1) - return dominated + plain = _dominated_plain(costs) + if tolerances is None or not np.any(tolerances): + return plain + return _dominated_by(costs, costs[~plain], tolerances) def pareto_front( diff --git a/tests/tradespace/test_criteria.py b/tests/tradespace/test_criteria.py index 970c803b..43ff82c1 100644 --- a/tests/tradespace/test_criteria.py +++ b/tests/tradespace/test_criteria.py @@ -5,6 +5,7 @@ """ import unittest +import warnings import numpy as np import pandas as pd @@ -52,6 +53,19 @@ def test_reductions(self): Probability("x", "<", 2).reduce(VALUES), [1 / 3, 0, np.nan] ) + def test_quantiles_with_missing_values(self): + """Quantiles are numpy's, of the values of each design.""" + rng = np.random.default_rng(5) + values = rng.normal(size=(200, 12)) + values[rng.random(values.shape) < 0.4] = np.nan + values[0] = np.nan + values[1, 1:] = np.nan + for q in (0, 0.1, 0.5, 0.7, 1): + with warnings.catch_warnings(): + warnings.simplefilter("ignore", RuntimeWarning) + expected = np.nanquantile(values, q, axis=1) + np.testing.assert_allclose(Quantile("x", q).reduce(values), expected) + def test_invalid(self): """Quantiles and operators are checked.""" with self.assertRaises(ValueError): diff --git a/tests/tradespace/test_pareto.py b/tests/tradespace/test_pareto.py index d5eceab7..e429eb54 100644 --- a/tests/tradespace/test_pareto.py +++ b/tests/tradespace/test_pareto.py @@ -194,21 +194,53 @@ class TestManyPoints(unittest.TestCase): Unit tests for the dominance of many points. """ - def test_sweep(self): - """A sweep finds the same dominated points as comparisons of every pair.""" + @staticmethod + def _every_pair(costs, tolerances=None): + """Dominance by comparing every pair of points.""" + absolute, relative = ( + np.zeros((2, costs.shape[1])) if tolerances is None else tolerances + ) + dominated = np.zeros(len(costs), dtype=bool) + for i, point in enumerate(costs): + penalized = costs + absolute + relative * np.abs(point) + no_worse = np.all(penalized <= point, axis=1) + better = np.any(penalized < point, axis=1) + dominated[i] = np.any(no_worse & better) + return dominated + + def test_matches_every_pair(self): + """Dominance, with or without tolerances, is that of every pair.""" # pylint: disable=import-outside-toplevel,protected-access from tatc.tradespace import pareto rng = np.random.default_rng(3) - for costs in ( - rng.random((500, 3)), - rng.integers(0, 4, (500, 3)).astype(float), - np.vstack([rng.random((100, 2))] * 3), - ): - np.testing.assert_array_equal( - pareto._dominated_sweep(costs), pareto._dominated(costs) - ) - many = rng.random((pareto._SWEEP_POINTS + 10, 3)) - frame = pd.DataFrame(many, columns=["a", "b", "c"]) - front = pareto_front(frame, {"a": "min", "b": "min", "c": "min"}) - np.testing.assert_array_equal(~front.to_numpy(), pareto._dominated_sweep(many)) + sets = ( + rng.random((700, 3)), + rng.integers(0, 4, (700, 3)).astype(float), + np.vstack([rng.random((150, 2))] * 3), + np.column_stack([rng.integers(1, 11, 900), rng.normal(0, 30, 900)]), + ) + tolerances = ( + None, + np.array([[0.0, 0.0, 0.1], [0.0, 0.0, 0.0]]), + np.array([[0.0, 0.0, 0.0], [0.05, 0.0, 0.1]]), + ) + for costs in sets: + for tolerance in tolerances: + if tolerance is not None: + tolerance = tolerance[:, : costs.shape[1]] + np.testing.assert_array_equal( + pareto._dominated(costs, tolerance), + self._every_pair(costs, tolerance), + ) + + def test_many_points(self): + """Fronts of many points are found quickly.""" + rng = np.random.default_rng(4) + frame = pd.DataFrame(rng.random((20_000, 3)), columns=["a", "b", "c"]) + front = pareto_front(frame, {"a": "min", "b": "min", "c": "max"}) + self.assertGreater(front.sum(), 0) + tolerant = pareto_front( + frame, {"a": "min", "b": "min", "c": "max"}, tolerance={"c": "5%"} + ) + self.assertTrue((tolerant >= front).all()) From 5ca9e3343566f404db4b92dc49bed78a0376eb94 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Wed, 11 Nov 2026 07:05:46 -0700 Subject: [PATCH 12/52] add cost schedules with present values and annual costs --- CHANGELOG.md | 2 +- docs/api_reference/tradespace.rst | 5 +- docs/examples/SearchTradeSpace.ipynb | 255 +++++++++++++++------------ src/tatc/tradespace/__init__.py | 2 + src/tatc/tradespace/cost.py | 216 ++++++++++++++++++++++- tests/tradespace/test_cost.py | 91 ++++++++++ 6 files changed, 458 insertions(+), 113 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 07938b2a..16ad9edd 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -20,7 +20,7 @@ Added: - Building blocks of constellations: fragments of design spaces of Walker constellations (`tradespace.walker_space`) and planes of sun-synchronous orbits (`sso_planes_space`, whose planes have different crossing times), `build_constellation`, which builds the satellites of either with instruments or entries of the instrument catalog (with their validated attitudes, and several entries on one satellite), and `count_satellites` and `count_planes`. The phase and node of the lead satellite of a Walker constellation (`phase_fraction` and `node_fraction`, design variables or uncertain parameters) are fractions of the intervals over which they give distinct constellations (`360 / per_plane` degrees of phase, and `360 / planes` degrees of node for a delta configuration or 360 for a star), so that a search does not evaluate the same constellation at several phases or nodes. Planes of inclined orbits (`planes_space`), each with its own inclination and node (uncertain by default, as of satellites launched as secondary payloads). The satellites of the planes of `sso_planes_space` and `planes_space` are evenly spaced, or follow each other in a train at an `interval` (minutes), on the same ground track or in the same plane (`repeat_ground_track`). The phase of each plane (`phase_fraction`, which replaces `phase` of `sso_planes_space`) is a fraction of the interval over which it gives distinct planes (`360 / satellites` degrees for evenly spaced satellites, 360 for a train), from which each fragment derives the plane's `true_anomaly`, as for the lead satellite of a Walker constellation. `build_constellation`, `count_satellites`, and `count_planes` take several layouts (a list, or a `Repeat` of a `Choice` of layouts), such as the shells of a mixed constellation. - Function `tradespace.screen` (and class `Screening`), which screens designs with studies of increasing fidelity, keeping whole fronts of the best designs of each stage for the next. - Searches of design spaces with optional optimizers: `tradespace.optimize_optuna` suggests designs with Optuna trials (`DesignSpace.suggest`, define-by-run over the hierarchical space), and `optimize_pymoo` and `make_pymoo_problem` search the unit hypercube that encodes a design space (`DesignSpace.unit_paths`, `encode`, and `decode`) with pymoo. Each design is evaluated once, and the designs proposed together are evaluated together, in parallel if the study is. Constraints of a design space may return the amount of their violation (`Infeasible.violation`), which Optuna's trials record (`set_constraint`) for its constraint-aware samplers, and which is the constraint value of pymoo problems. Optional dependencies `tradespace` (joblib, Optuna, and pymoo). - - Life-cycle costs of constellations for trade studies (`tradespace.CostModel`): the development of each type of satellite, the production of its units on a learning curve (`SatelliteCost`), launches (dedicated launches of each plane, up to a capacity in number or mass, or prices per satellite and kg, `LaunchCost`), operations (`OperationsCost`), replenishment at the end of a design life, and spares in orbit, from the layouts of a design (`plane_sizes`), with growth factors for cost risk (such as uncertain parameters, whose quantiles over replicates give the cost at a confidence level). TAT-C does not include cost-estimating relationships: the costs are given by the study. Fingerprints describe dataclasses (such as cost models) by their fields. + - Life-cycle costs of constellations for trade studies (`tradespace.CostModel`): the development of each type of satellite, the production of its units on a learning curve (`SatelliteCost`), launches (dedicated launches of each plane, up to a capacity in number or mass, or prices per satellite and kg, `LaunchCost`), operations (`OperationsCost`), replenishment at the end of a design life, and spares in orbit, from the layouts of a design (`plane_sizes`), with growth factors for cost risk (such as uncertain parameters, whose quantiles over replicates give the cost at a confidence level). An optional schedule (`CostSchedule`) dates the costs (development before the first deployment, production before each deployment, planes deployed at intervals and replaced at the end of their design life, and operations from deployment to the end of the mission), for their present value at a discount rate (`CostEstimate.present_value`, metric `cost present`) and annual costs (`CostEstimate.annual`, metric `cost peak annual`). TAT-C does not include cost-estimating relationships: the costs are given by the study. Fingerprints describe dataclasses (such as cost models) by their fields. - Function `tradespace.confirm` (and class `Confirmation`), which evaluates selected designs (such as a front) with new replicates that played no part in their selection, removing the optimism of the selection (the winner's curse, `Confirmation.optimism`). `ResultStore` keys evaluations by the fingerprint of a study (`Study.fingerprint`, see `get_fingerprint`: its seed, use of common random numbers, design space, and build and evaluation functions, and the version of TAT-C), warning if it holds evaluations of other definitions, which are not reused; `SatelliteCache` keys results on disk by the fingerprint of its function. `refine` treats designs with fewer than `min_replicates` (5) as uncertain whatever their probability, adds the replicates left to `max_replicates` in a last partial step, and warns if designs remain uncertain without a tolerance. `sensitivity` gives adjusted shares (epsilon squared) by default, without the share that the levels of a variable explain by chance (`adjusted=False` for correlation ratios). - Searches with Optuna accept categorical options that depend on earlier decisions (a parameter for each set of options), use TPE with a constant liar in batches by default (which spreads the trials of a batch), and stop after `max_designs` designs evaluated (trials that suggest designs evaluated before are told their objectives without evaluating them again). A design infeasible in some of its replicates violates its feasibility by their share (`Evaluations.infeasibility`), and the first design evaluated in a search is evaluated alone, to check that evaluations give one record each. `Study` records errors of evaluations as infeasible, without storing them, with `errors="record"`. Enumeration walks the items of unordered repetitions in one order only (the same designs, in the same order, four times faster for three sun-synchronous planes), and `DesignSpace.size` counts designs without keeping them. Pareto fronts are found by a vectorized sweep in lexicographic order that compares designs only with the efficient designs before them, and fronts with tolerances by comparing designs only with the efficient designs without tolerances (which dominate every design that any design dominates within the tolerances), in blocks of bounded memory: 20,000 designs in 0.05 s (0.11 s with tolerances) rather than 17 s, and the bootstraps of `pareto_probability` (and so `refine`) about 20 times faster. - Example `SearchTradeSpace`, which searches a hierarchical trade space of constellations for the designs that sample points sufficiently: by evaluating every design, ranking them with the uncertainty of their replicates, screening, and searching with Optuna and pymoo. diff --git a/docs/api_reference/tradespace.rst b/docs/api_reference/tradespace.rst index 12eadc49..b9eeaa5c 100644 --- a/docs/api_reference/tradespace.rst +++ b/docs/api_reference/tradespace.rst @@ -86,8 +86,11 @@ Costs .. autoclass:: tatc.tradespace.OperationsCost +.. autoclass:: tatc.tradespace.CostSchedule + :members: discount + .. autoclass:: tatc.tradespace.CostEstimate - :members: total, metrics + :members: total, present_value, annual, metrics .. autofunction:: tatc.tradespace.plane_sizes diff --git a/docs/examples/SearchTradeSpace.ipynb b/docs/examples/SearchTradeSpace.ipynb index 4f744f41..fc10d947 100644 --- a/docs/examples/SearchTradeSpace.ipynb +++ b/docs/examples/SearchTradeSpace.ipynb @@ -28,10 +28,10 @@ "id": "c3d2e5f4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T06:53:52.022308Z", - "iopub.status.busy": "2026-11-11T06:53:52.022073Z", - "iopub.status.idle": "2026-11-11T06:53:52.737609Z", - "shell.execute_reply": "2026-11-11T06:53:52.736859Z" + "iopub.execute_input": "2026-11-11T13:54:55.415203Z", + "iopub.status.busy": "2026-11-11T13:54:55.415028Z", + "iopub.status.idle": "2026-11-11T13:54:56.123863Z", + "shell.execute_reply": "2026-11-11T13:54:56.122927Z" } }, "outputs": [], @@ -79,10 +79,10 @@ "id": "e5f4a7b6", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T06:53:52.739656Z", - "iopub.status.busy": "2026-11-11T06:53:52.739331Z", - "iopub.status.idle": "2026-11-11T06:53:53.864061Z", - "shell.execute_reply": "2026-11-11T06:53:53.863266Z" + "iopub.execute_input": "2026-11-11T13:54:56.125809Z", + "iopub.status.busy": "2026-11-11T13:54:56.125463Z", + "iopub.status.idle": "2026-11-11T13:54:57.284278Z", + "shell.execute_reply": "2026-11-11T13:54:57.283499Z" } }, "outputs": [ @@ -143,10 +143,10 @@ "id": "a7b6c9d8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T06:53:53.865992Z", - "iopub.status.busy": "2026-11-11T06:53:53.865668Z", - "iopub.status.idle": "2026-11-11T06:53:53.874286Z", - "shell.execute_reply": "2026-11-11T06:53:53.873513Z" + "iopub.execute_input": "2026-11-11T13:54:57.286192Z", + "iopub.status.busy": "2026-11-11T13:54:57.285825Z", + "iopub.status.idle": "2026-11-11T13:54:57.293668Z", + "shell.execute_reply": "2026-11-11T13:54:57.292785Z" } }, "outputs": [], @@ -156,6 +156,7 @@ "from tatc.schemas import Instrument\n", "from tatc.tradespace import (\n", " CostModel,\n", + " CostSchedule,\n", " LaunchCost,\n", " OperationsCost,\n", " ResultStore,\n", @@ -168,7 +169,8 @@ ")\n", "\n", "# illustrative costs (millions of dollars), not estimates of any mission: satellites with an imager of each field of\n", - "# regard, a small launcher for every 3 satellites of a plane, and 5 years of operations\n", + "# regard, a small launcher for every 3 satellites of a plane, and 5 years of operations, dated over 3 years of\n", + "# development and planes deployed half a year apart, discounted at 3% a year\n", "COST_MODEL = CostModel(\n", " satellites={\n", " 30: SatelliteCost(development=40, first_unit=12, learning_rate=0.9, mass=60),\n", @@ -177,6 +179,7 @@ " launch=LaunchCost(per_launch=8, capacity=3),\n", " operations=OperationsCost(per_year=3, per_satellite_year=0.5),\n", " years=5,\n", + " schedule=CostSchedule(discount_rate=0.03, development_years=3, production_lead=1, deployment_interval=0.5),\n", ")\n", "\n", "CACHE_DIRECTORY = Path(tempfile.gettempdir()) / \"tatc-search-trade-space\"\n", @@ -250,10 +253,10 @@ "id": "c9d8e1f0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T06:53:53.876015Z", - "iopub.status.busy": "2026-11-11T06:53:53.875753Z", - "iopub.status.idle": "2026-11-11T06:53:54.274551Z", - "shell.execute_reply": "2026-11-11T06:53:54.273876Z" + "iopub.execute_input": "2026-11-11T13:54:57.295347Z", + "iopub.status.busy": "2026-11-11T13:54:57.295082Z", + "iopub.status.idle": "2026-11-11T13:55:13.817714Z", + "shell.execute_reply": "2026-11-11T13:55:13.816983Z" } }, "outputs": [ @@ -411,10 +414,10 @@ "id": "d0e9f2a1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T06:53:54.276261Z", - "iopub.status.busy": "2026-11-11T06:53:54.276019Z", - "iopub.status.idle": "2026-11-11T06:53:54.474008Z", - "shell.execute_reply": "2026-11-11T06:53:54.473243Z" + "iopub.execute_input": "2026-11-11T13:55:13.819402Z", + "iopub.status.busy": "2026-11-11T13:55:13.819150Z", + "iopub.status.idle": "2026-11-11T13:55:14.022238Z", + "shell.execute_reply": "2026-11-11T13:55:14.021499Z" } }, "outputs": [ @@ -495,10 +498,10 @@ "id": "a2b3c4d5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T06:53:54.475636Z", - "iopub.status.busy": "2026-11-11T06:53:54.475393Z", - "iopub.status.idle": "2026-11-11T06:53:54.594211Z", - "shell.execute_reply": "2026-11-11T06:53:54.593433Z" + "iopub.execute_input": "2026-11-11T13:55:14.024119Z", + "iopub.status.busy": "2026-11-11T13:55:14.023875Z", + "iopub.status.idle": "2026-11-11T13:55:14.092351Z", + "shell.execute_reply": "2026-11-11T13:55:14.091620Z" } }, "outputs": [ @@ -695,10 +698,10 @@ "id": "b3c4d5e6", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T06:53:54.596336Z", - "iopub.status.busy": "2026-11-11T06:53:54.595986Z", - "iopub.status.idle": "2026-11-11T06:53:54.735542Z", - "shell.execute_reply": "2026-11-11T06:53:54.734838Z" + "iopub.execute_input": "2026-11-11T13:55:14.094106Z", + "iopub.status.busy": "2026-11-11T13:55:14.093845Z", + "iopub.status.idle": "2026-11-11T13:55:14.228630Z", + "shell.execute_reply": "2026-11-11T13:55:14.227859Z" } }, "outputs": [ @@ -748,10 +751,10 @@ "id": "d5e6f7a8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T06:53:54.737156Z", - "iopub.status.busy": "2026-11-11T06:53:54.736980Z", - "iopub.status.idle": "2026-11-11T06:53:54.911745Z", - "shell.execute_reply": "2026-11-11T06:53:54.910949Z" + "iopub.execute_input": "2026-11-11T13:55:14.230509Z", + "iopub.status.busy": "2026-11-11T13:55:14.230235Z", + "iopub.status.idle": "2026-11-11T13:55:14.421726Z", + "shell.execute_reply": "2026-11-11T13:55:14.420991Z" } }, "outputs": [ @@ -898,10 +901,10 @@ "id": "a8b9c0d1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T06:53:54.913416Z", - "iopub.status.busy": "2026-11-11T06:53:54.913159Z", - "iopub.status.idle": "2026-11-11T06:53:54.938936Z", - "shell.execute_reply": "2026-11-11T06:53:54.938120Z" + "iopub.execute_input": "2026-11-11T13:55:14.423574Z", + "iopub.status.busy": "2026-11-11T13:55:14.423201Z", + "iopub.status.idle": "2026-11-11T13:55:14.449259Z", + "shell.execute_reply": "2026-11-11T13:55:14.448507Z" } }, "outputs": [ @@ -1049,10 +1052,10 @@ "id": "a3b2c5d4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T06:53:54.940726Z", - "iopub.status.busy": "2026-11-11T06:53:54.940474Z", - "iopub.status.idle": "2026-11-11T06:54:43.635205Z", - "shell.execute_reply": "2026-11-11T06:54:43.634447Z" + "iopub.execute_input": "2026-11-11T13:55:14.450870Z", + "iopub.status.busy": "2026-11-11T13:55:14.450632Z", + "iopub.status.idle": "2026-11-11T13:55:16.024101Z", + "shell.execute_reply": "2026-11-11T13:55:16.023280Z" } }, "outputs": [ @@ -1301,10 +1304,10 @@ "id": "b5d3f7a9", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T06:54:43.636771Z", - "iopub.status.busy": "2026-11-11T06:54:43.636542Z", - "iopub.status.idle": "2026-11-11T07:03:45.057029Z", - "shell.execute_reply": "2026-11-11T07:03:45.056269Z" + "iopub.execute_input": "2026-11-11T13:55:16.026196Z", + "iopub.status.busy": "2026-11-11T13:55:16.025803Z", + "iopub.status.idle": "2026-11-11T13:55:44.920239Z", + "shell.execute_reply": "2026-11-11T13:55:44.919485Z" } }, "outputs": [ @@ -1454,10 +1457,10 @@ "id": "c6e4a8b0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T07:03:45.058622Z", - "iopub.status.busy": "2026-11-11T07:03:45.058393Z", - "iopub.status.idle": "2026-11-11T07:03:45.119948Z", - "shell.execute_reply": "2026-11-11T07:03:45.119262Z" + "iopub.execute_input": "2026-11-11T13:55:44.921881Z", + "iopub.status.busy": "2026-11-11T13:55:44.921645Z", + "iopub.status.idle": "2026-11-11T13:55:44.982851Z", + "shell.execute_reply": "2026-11-11T13:55:44.981996Z" } }, "outputs": [ @@ -2007,10 +2010,10 @@ "id": "f2a3b4c5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T07:03:45.121457Z", - "iopub.status.busy": "2026-11-11T07:03:45.121224Z", - "iopub.status.idle": "2026-11-11T07:03:45.181905Z", - "shell.execute_reply": "2026-11-11T07:03:45.180859Z" + "iopub.execute_input": "2026-11-11T13:55:44.984383Z", + "iopub.status.busy": "2026-11-11T13:55:44.984200Z", + "iopub.status.idle": "2026-11-11T13:55:47.637159Z", + "shell.execute_reply": "2026-11-11T13:55:47.636479Z" } }, "outputs": [ @@ -2512,10 +2515,10 @@ "id": "f9b7d1e3", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T07:03:45.183711Z", - "iopub.status.busy": "2026-11-11T07:03:45.183501Z", - "iopub.status.idle": "2026-11-11T07:04:28.742292Z", - "shell.execute_reply": "2026-11-11T07:04:28.741584Z" + "iopub.execute_input": "2026-11-11T13:55:47.639007Z", + "iopub.status.busy": "2026-11-11T13:55:47.638772Z", + "iopub.status.idle": "2026-11-11T13:55:49.004341Z", + "shell.execute_reply": "2026-11-11T13:55:49.003550Z" } }, "outputs": [ @@ -2745,10 +2748,10 @@ "id": "d1e2f3a4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T07:04:28.743856Z", - "iopub.status.busy": "2026-11-11T07:04:28.743636Z", - "iopub.status.idle": "2026-11-11T07:04:28.799811Z", - "shell.execute_reply": "2026-11-11T07:04:28.799147Z" + "iopub.execute_input": "2026-11-11T13:55:49.005995Z", + "iopub.status.busy": "2026-11-11T13:55:49.005752Z", + "iopub.status.idle": "2026-11-11T13:55:50.064039Z", + "shell.execute_reply": "2026-11-11T13:55:50.063367Z" } }, "outputs": [ @@ -2953,7 +2956,7 @@ "source": [ "## Trade Cost Against Sufficiency\n", "\n", - "The numbers of satellites and planes are proxies of cost. A `CostModel` estimates the life-cycle cost of each design from the costs of its satellites (the development of each type, and the production of its units on a learning curve), launches (here, a small launcher for every three satellites of a plane), and operations, given by the study (TAT-C does not include cost-estimating relationships). The costs here are illustrative, in millions of dollars. The evaluation adds the cost and its elements to each record, for the satellites of each design's imager (`kind`): a wider field of regard costs more to develop and build.\n", + "The numbers of satellites and planes are proxies of cost. A `CostModel` estimates the life-cycle cost of each design from the costs of its satellites (the development of each type, and the production of its units on a learning curve), launches (here, a small launcher for every three satellites of a plane), and operations, given by the study (TAT-C does not include cost-estimating relationships). The costs here are illustrative, in millions of dollars. The evaluation adds the cost and its elements to each record, for the satellites of each design's imager (`kind`): a wider field of regard costs more to develop and build. A schedule (`CostSchedule`) dates the costs: development over three years before the first plane is deployed, the production of each plane's satellites in the year before it, planes deployed half a year apart, and operations from each plane's deployment to the end of the mission. The dated costs give the present value of the cost (`cost present`, discounted at 3% a year) and the cost of the most expensive year (`cost peak annual`), for annual budgets.\n", "\n", "The growth of the cost of development is uncertain (an `Uncertain` parameter, from 0.9 to 1.6 times the estimate, most likely 1), drawn for each replicate, so that statistics over the replicates give the cost at a confidence level: here, the 0.7 quantile (`cost p70`), as budgets are often set. A requirement keeps the designs whose cost at 70% confidence is within a budget, and the front trades this cost against the share of points sufficiently sampled. (Cost depends only on the design, so a constraint of the design space could exclude designs over a budget before they are evaluated, with the cost without growth.)" ] @@ -2964,10 +2967,10 @@ "id": "c2d3e4f5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T07:04:28.801300Z", - "iopub.status.busy": "2026-11-11T07:04:28.801061Z", - "iopub.status.idle": "2026-11-11T07:05:20.806375Z", - "shell.execute_reply": "2026-11-11T07:05:20.805699Z" + "iopub.execute_input": "2026-11-11T13:55:50.065685Z", + "iopub.status.busy": "2026-11-11T13:55:50.065449Z", + "iopub.status.idle": "2026-11-11T13:55:51.686402Z", + "shell.execute_reply": "2026-11-11T13:55:51.685688Z" } }, "outputs": [ @@ -3007,6 +3010,8 @@ " cost production\n", " cost launch\n", " cost operations\n", + " cost present\n", + " cost peak annual\n", " sufficient\n", " pareto_probability\n", " \n", @@ -3022,6 +3027,8 @@ " 12.0\n", " 8.0\n", " 17.5\n", + " 75.9\n", + " 26.8\n", " 1.0\n", " 1.0\n", " \n", @@ -3035,6 +3042,8 @@ " 22.8\n", " 8.0\n", " 20.0\n", + " 88.0\n", + " 37.6\n", " 3.2\n", " 0.9\n", " \n", @@ -3043,11 +3052,13 @@ " 800 km, 30 deg FOR, Walker 45 deg: 2 x 1 (spac...\n", " 2\n", " 2\n", - " 104.9\n", + " 104.7\n", " 44.4\n", " 22.8\n", " 16.0\n", - " 20.0\n", + " 19.8\n", + " 94.9\n", + " 30.3\n", " 7.8\n", " 1.0\n", " \n", @@ -3056,11 +3067,13 @@ " 800 km, 30 deg FOR, SSO: 2 at 12:00, 1 at 06:00\n", " 3\n", " 2\n", - " 117.6\n", + " 117.3\n", " 44.4\n", " 33.0\n", " 16.0\n", - " 22.5\n", + " 22.2\n", + " 106.4\n", + " 37.6\n", " 7.8\n", " 0.7\n", " \n", @@ -3069,11 +3082,13 @@ " 800 km, 30 deg FOR, Walker 45 deg: 3 x 1 (spac...\n", " 3\n", " 3\n", - " 125.6\n", + " 124.8\n", " 44.4\n", " 33.0\n", " 24.0\n", - " 22.5\n", + " 21.8\n", + " 112.8\n", + " 40.5\n", " 12.0\n", " 0.8\n", " \n", @@ -3082,11 +3097,13 @@ " 800 km, 30 deg FOR, Walker 45 deg: 2 x 2 (spac...\n", " 4\n", " 2\n", - " 129.8\n", + " 129.3\n", " 44.4\n", " 42.7\n", " 16.0\n", - " 25.0\n", + " 24.5\n", + " 117.2\n", + " 39.9\n", " 20.0\n", " 0.9\n", " \n", @@ -3095,11 +3112,13 @@ " 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...\n", " 2\n", " 2\n", - " 139.4\n", + " 139.2\n", " 66.7\n", " 34.2\n", " 16.0\n", - " 20.0\n", + " 19.8\n", + " 126.7\n", + " 40.2\n", " 28.6\n", " 1.0\n", " \n", @@ -3108,11 +3127,13 @@ " 800 km, 30 deg FOR, Walker 45 deg: 4 x 1 (spac...\n", " 4\n", " 4\n", - " 145.8\n", + " 144.3\n", " 44.4\n", " 42.7\n", " 32.0\n", - " 25.0\n", + " 23.5\n", + " 129.9\n", + " 40.5\n", " 29.0\n", " 0.8\n", " \n", @@ -3126,6 +3147,8 @@ " 49.4\n", " 8.0\n", " 22.5\n", + " 136.2\n", + " 71.7\n", " 37.0\n", " 0.6\n", " \n", @@ -3148,24 +3171,35 @@ " cost p70 cost development cost production cost launch \\\n", "913 83.6 44.4 12.0 8.0 \n", "912 96.9 44.4 22.8 8.0 \n", - "826 104.9 44.4 22.8 16.0 \n", - "922 117.6 44.4 33.0 16.0 \n", - "835 125.6 44.4 33.0 24.0 \n", - "828 129.8 44.4 42.7 16.0 \n", - "963 139.4 66.7 34.2 16.0 \n", - "845 145.8 44.4 42.7 32.0 \n", + "826 104.7 44.4 22.8 16.0 \n", + "922 117.3 44.4 33.0 16.0 \n", + "835 124.8 44.4 33.0 24.0 \n", + "828 129.3 44.4 42.7 16.0 \n", + "963 139.2 66.7 34.2 16.0 \n", + "845 144.3 44.4 42.7 32.0 \n", "961 149.1 66.7 49.4 8.0 \n", "\n", - " cost operations sufficient pareto_probability \n", - "913 17.5 1.0 1.0 \n", - "912 20.0 3.2 0.9 \n", - "826 20.0 7.8 1.0 \n", - "922 22.5 7.8 0.7 \n", - "835 22.5 12.0 0.8 \n", - "828 25.0 20.0 0.9 \n", - "963 20.0 28.6 1.0 \n", - "845 25.0 29.0 0.8 \n", - "961 22.5 37.0 0.6 " + " cost operations cost present cost peak annual sufficient \\\n", + "913 17.5 75.9 26.8 1.0 \n", + "912 20.0 88.0 37.6 3.2 \n", + "826 19.8 94.9 30.3 7.8 \n", + "922 22.2 106.4 37.6 7.8 \n", + "835 21.8 112.8 40.5 12.0 \n", + "828 24.5 117.2 39.9 20.0 \n", + "963 19.8 126.7 40.2 28.6 \n", + "845 23.5 129.9 40.5 29.0 \n", + "961 22.5 136.2 71.7 37.0 \n", + "\n", + " pareto_probability \n", + "913 1.0 \n", + "912 0.9 \n", + "826 1.0 \n", + "922 0.7 \n", + "835 0.8 \n", + "828 0.9 \n", + "963 1.0 \n", + "845 0.8 \n", + "961 0.6 " ] }, "execution_count": 16, @@ -3187,7 +3221,8 @@ " requirements=[Requirement(\"cost p70\", \"<=\", BUDGET)],\n", " tolerance=TOLERANCE,\n", ")\n", - "elements = aggregate(refinement.results, ELEMENTS).set_index(\"design\")[ELEMENTS]\n", + "DATED = [\"cost present\", \"cost peak annual\"]\n", + "elements = aggregate(refinement.results, [*ELEMENTS, *DATED]).set_index(\"design\")[[*ELEMENTS, *DATED]]\n", "costed = costed.join(values[[\"satellites\", \"planes\"]], on=\"design\").join(elements, on=\"design\")\n", "costed[\"description\"] = [describe(values.loc[key]) for key in costed.design]\n", "efficient = costed[costed.pareto_probability >= 0.5]\n", @@ -3197,7 +3232,7 @@ ")\n", "# the most sufficient of these at each cost\n", "efficient.sort_values([\"cost p70\", \"sufficient\"], ascending=[True, False]).drop_duplicates(\"cost p70\")[\n", - " [\"description\", \"satellites\", \"planes\", \"cost p70\", *ELEMENTS, \"sufficient\", \"pareto_probability\"]\n", + " [\"description\", \"satellites\", \"planes\", \"cost p70\", *ELEMENTS, *DATED, \"sufficient\", \"pareto_probability\"]\n", "].round(1)" ] }, @@ -3206,7 +3241,9 @@ "id": "d3e4f5a6", "metadata": {}, "source": [ - "520 of the 1,096 designs cost at most 150 million dollars at 70% confidence. Along the front, money buys sufficiency in steps: one satellite (84 million at 70% confidence, of which 44 million on average develops it) samples 1% of the points sufficiently; a second satellite in its plane, 3%, and in a second plane, 8%; four satellites in two Walker planes (130 million), 20%. The planes now have a price: four satellites in four planes sample more points sufficiently than in two (29% against 20%, as more planes spread the samples in time), at twice the cost of launches (32 million against 16). The wider field of regard joins the front only near the budget, where its development (67 million against 44) is worth its swath: two satellites with the wider imager sample 29% of the points for 139 million, as many as four with the narrower one, and three of them 37% for 149 million, the most within the budget. The designs that sample nearly every point (six to nine satellites) cost more than the budget.\n", + "520 of the 1,096 designs cost at most 150 million dollars at 70% confidence. Along the front, money buys sufficiency in steps: one satellite (84 million at 70% confidence, of which 44 million on average develops it) samples 1% of the points sufficiently; a second satellite in its plane, 3%, and in a second plane, 8%; four satellites in two Walker planes (129 million), 20%. The planes now have a price: four satellites in four planes sample more points sufficiently than in two (29% against 20%, as more planes spread the samples in time), at twice the cost of launches (32 million against 16). The wider field of regard joins the front only near the budget, where its development (67 million against 44) is worth its swath: two satellites with the wider imager sample 29% of the points for 139 million, as many as four with the narrower one, and three of them 37% for 149 million, the most within the budget. The designs that sample nearly every point (six to nine satellites) cost more than the budget.\n", + "\n", + "Dated, the costs are worth 7 to 9% less at present (at 3% a year), as most are incurred three or more years from now, and the schedule shows when they are incurred: three satellites with the wider imager in one plane need 72 million in the last year of development, when all of them are produced, nearly twice the peak of the designs whose planes are deployed half a year apart (30 to 41 million), which spread their production over more years. A budget of annual funding would favor designs of several planes.\n", "\n", "The growth of the cost of development affects every design alike in a replicate (common random numbers), so it shifts the costs at 70% confidence more for designs whose development costs more, here those of the wider imager. With five replicates of most designs, the 0.7 quantile of their costs is a coarse estimate: an evaluation that costs little more than the cost model (unlike the analysis of sampling) could draw more replicates of the cost alone." ] @@ -3229,10 +3266,10 @@ "id": "d6e5f8a7", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T07:05:20.808106Z", - "iopub.status.busy": "2026-11-11T07:05:20.807880Z", - "iopub.status.idle": "2026-11-11T07:05:23.630842Z", - "shell.execute_reply": "2026-11-11T07:05:23.630162Z" + "iopub.execute_input": "2026-11-11T13:55:51.688002Z", + "iopub.status.busy": "2026-11-11T13:55:51.687765Z", + "iopub.status.idle": "2026-11-11T13:55:56.559498Z", + "shell.execute_reply": "2026-11-11T13:55:56.558673Z" } }, "outputs": [ @@ -3392,10 +3429,10 @@ "id": "a9b8c1d0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T07:05:23.632534Z", - "iopub.status.busy": "2026-11-11T07:05:23.632284Z", - "iopub.status.idle": "2026-11-11T07:05:27.100651Z", - "shell.execute_reply": "2026-11-11T07:05:27.099955Z" + "iopub.execute_input": "2026-11-11T13:55:56.561364Z", + "iopub.status.busy": "2026-11-11T13:55:56.561098Z", + "iopub.status.idle": "2026-11-11T13:55:57.745919Z", + "shell.execute_reply": "2026-11-11T13:55:57.745136Z" } }, "outputs": [ @@ -3506,10 +3543,10 @@ "id": "b0c9d2e1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T07:05:27.102481Z", - "iopub.status.busy": "2026-11-11T07:05:27.102076Z", - "iopub.status.idle": "2026-11-11T07:05:27.225400Z", - "shell.execute_reply": "2026-11-11T07:05:27.224651Z" + "iopub.execute_input": "2026-11-11T13:55:57.747657Z", + "iopub.status.busy": "2026-11-11T13:55:57.747319Z", + "iopub.status.idle": "2026-11-11T13:55:57.877603Z", + "shell.execute_reply": "2026-11-11T13:55:57.876923Z" } }, "outputs": [ diff --git a/src/tatc/tradespace/__init__.py b/src/tatc/tradespace/__init__.py index e4e4b4e0..fff3401b 100644 --- a/src/tatc/tradespace/__init__.py +++ b/src/tatc/tradespace/__init__.py @@ -17,6 +17,7 @@ from .cost import ( CostEstimate, CostModel, + CostSchedule, LaunchCost, OperationsCost, SatelliteCost, @@ -78,6 +79,7 @@ "Confirmation", "CostEstimate", "CostModel", + "CostSchedule", "Derived", "Design", "DesignSpace", diff --git a/src/tatc/tradespace/cost.py b/src/tatc/tradespace/cost.py index 19273299..ed2325ba 100644 --- a/src/tatc/tradespace/cost.py +++ b/src/tatc/tradespace/cost.py @@ -14,6 +14,13 @@ parameters, so that statistics of the cost over replicates (such as a 0.7 `Quantile`) are objectives or requirements. +An optional schedule (`CostSchedule`) dates the costs: development before +the first launch, the production of each plane's satellites before it is +deployed, the deployment of planes at intervals (and of replacements at the +end of their design life), and operations from deployment to the end of the +mission. The dated costs give the present value of the cost at a discount +rate, and the cost of each year (such as its peak, for annual budgets). + @author: Paul T. Grogan """ @@ -25,6 +32,7 @@ from typing import Any import numpy as np +import pandas as pd from .constellations import PLANES, SSO_PLANES, WALKER, _kind, _layout, _layouts from .values import Values @@ -168,6 +176,82 @@ class OperationsCost: per_satellite_year: float = 0.0 +@dataclass(frozen=True) +class CostSchedule: + """ + A schedule of the costs of a constellation, and the discount rate of + their present value. + + Times are in years from the start of development, which begins + `start` years after the present (the date of present values). + Development spreads its cost evenly over `development_years`, at the end + of which the first plane is deployed; the others follow at intervals of + `deployment_interval` (in the order of the layouts' planes), and their + replacements at the end of each design life. The satellites of each + deployment (units, in the order of the learning curve) are paid for + evenly over the `production_lead` before it, and its launch when it is + deployed. Operations cost a fixed amount in each year of the mission + (its `years` after the first deployment), and each satellite from its + deployment to the end of the mission. Costs spread over a period are + dated at the middle of each of its years. + + A cost at time `t` has a present value of `cost / (1 + discount_rate) + ** (start + t)`. + + Args: + discount_rate (float): The annual discount rate (such as 0.03). + development_years (float): The duration of development, before the + first deployment. + production_lead (float): The duration of the production of the + satellites of a deployment, before it. + deployment_interval (float): The years between the deployments of + successive planes. + start (float): The years from the present to the start of + development. + """ + + discount_rate: float = 0.0 + development_years: float = 3.0 + production_lead: float = 1.0 + deployment_interval: float = 0.0 + start: float = 0.0 + + def __post_init__(self): + if self.discount_rate <= -1: + raise ValueError("discount_rate must be greater than -1") + for name in ("development_years", "production_lead", "deployment_interval"): + if getattr(self, name) < 0: + raise ValueError(f"{name} must not be negative") + + def discount(self, time: float) -> float: + """ + Gets the factor of the present value of a cost at a time. + + Args: + time (float): The time (years from the start of development). + + Returns: + float: the factor + """ + return float((1 + self.discount_rate) ** -(self.start + time)) + + +def _spread(amount: float, begin: float, end: float) -> list[tuple[float, float]]: + """ + Spreads an amount evenly from `begin` to `end` (years), dated at the + middle of each of its years (or at `begin`, if it has no duration). + """ + if end <= begin: + return [(begin, amount)] + flows = [] + time = begin + while time < end - 1e-12: + step = min(1.0, end - time) + flows.append((time + step / 2, amount * step / (end - begin))) + time += step + return flows + + @dataclass class CostEstimate: """ @@ -188,17 +272,52 @@ class CostEstimate: replacements and spares).""" launches: int = 0 """int: The dedicated launches.""" + flows: list[tuple[float, str, float]] = field(default_factory=list) + """list: The dated costs, with a schedule (see `CostSchedule`): the time + (years from the start of development), element, and amount of each.""" + present: dict[str, float] | None = None + """dict | None: The present value of each element, with a schedule.""" @property def total(self) -> float: """float: The total cost.""" return self.development + self.production + self.launch + self.operations + @property + def present_value(self) -> float | None: + """float | None: The present value of the total cost, with a + schedule.""" + return None if self.present is None else sum(self.present.values()) + + def annual(self) -> pd.DataFrame: + """ + Gets the cost of each year (from the start of development), by + element and in total, with a schedule. + + Returns: + pandas.DataFrame: a row per year, a column per element, and the + `total` + """ + if not self.flows: + raise ValueError("annual costs require a schedule (see CostSchedule)") + frame = pd.DataFrame(self.flows, columns=["time", "element", "amount"]) + frame["year"] = np.floor(frame["time"]).astype(int) + table = frame.pivot_table( + index="year", columns="element", values="amount", aggfunc="sum" + ) + table = table.reindex(columns=list(ELEMENTS)).fillna(0.0) + table = table.reindex(range(table.index.min(), table.index.max() + 1)) + table = table.fillna(0.0) + table["total"] = table.sum(axis=1) + return table + def metrics(self, prefix: str = "cost") -> dict[str, float]: """ Gets the cost as metrics of an evaluation (see `Study`): the total (``) and each element (` development`, ` - production`, ` launch`, and ` operations`). + production`, ` launch`, and ` operations`), and, with + a schedule, the present value of the total (` present`) and + the cost of its most expensive year (` peak annual`). Args: prefix (str): The name of the total, and prefix of the elements. @@ -206,10 +325,14 @@ def metrics(self, prefix: str = "cost") -> dict[str, float]: Returns: dict[str, float]: the metrics """ - return { + metrics = { prefix: self.total, **{f"{prefix} {element}": getattr(self, element) for element in ELEMENTS}, } + if self.present is not None: + metrics[f"{prefix} present"] = self.present_value + metrics[f"{prefix} peak annual"] = float(self.annual()["total"].max()) + return metrics Growth = float | Mapping[str, float] @@ -236,6 +359,8 @@ class CostModel: years (float): The duration of the mission. design_life (float | None): The design life of the satellites, or `None` if they last the mission. + schedule (CostSchedule | None): The schedule of the costs (for their + present value and annual costs), if any. """ satellites: SatelliteCost | Mapping[str, SatelliteCost] @@ -243,6 +368,7 @@ class CostModel: operations: OperationsCost = OperationsCost() years: float = 1.0 design_life: float | None = None + schedule: CostSchedule | None = None def __post_init__(self): if self.years <= 0: @@ -286,6 +412,11 @@ def estimate( kg) in each generation; and every satellite is operated for the mission. + With a schedule (see `CostSchedule`), the estimate dates its costs, + and gives their present value and annual costs; satellites deployed + after the first are operated for less of the mission, which + lowers the cost of operations. + Growth factors multiply the estimate, such as uncertain parameters of cost growth drawn for each replicate (for example, `Uncertain(lambda rng: rng.triangular(0.9, 1.0, 1.5))`), whose @@ -314,6 +445,8 @@ def estimate( fleets = {name: plane_sizes(item) for name, item in layout.items()} else: fleets = {kind: plane_sizes(layout)} + if self.schedule is not None: + return self._estimate_scheduled(fleets, spares, _get_growth(growth)) estimate = CostEstimate() operated = 0 for name, sizes in fleets.items(): @@ -343,6 +476,85 @@ def estimate( setattr(estimate, element, getattr(estimate, element) * factors[element]) return estimate + def _estimate_scheduled( + self, fleets: dict, spares: int, factors: dict[str, float] + ) -> CostEstimate: + """ + Estimates the dated costs of the planes of each type of satellite + (see `estimate` and `CostSchedule`). + """ + schedule = self.schedule + estimate = CostEstimate() + flows: list[tuple[float, str, float]] = [] + + def add(element: str, amounts: list[tuple[float, float]]) -> None: + flows.extend( + (time, element, amount * factors[element]) for time, amount in amounts + ) + + first = schedule.development_years + end = first + self.years + if self.launch.per_kg > 0 and any( + self._get_type(name).mass is None for name in fleets + ): + raise ValueError("launches priced by mass require masses") + plane = 0 + for name, sizes in fleets.items(): + cost = self._get_type(name) + sizes = [size + spares for size in sizes if size > 0] + if not sizes: + continue + add("development", _spread(cost.development, 0.0, first)) + built = 0 + for size in sizes: + deployed = first + plane * schedule.deployment_interval + plane += 1 + for generation in range(self.generations): + time = deployed + generation * (self.design_life or 0.0) + production = cost.production(built + size) - cost.production(built) + built += size + add( + "production", + _spread(production, time - schedule.production_lead, time), + ) + launches = self.launch.launches(size, cost.mass) + estimate.launches += launches + launch = launches * self.launch.per_launch + size * ( + self.launch.per_satellite + + self.launch.per_kg * (cost.mass or 0.0) + ) + add("launch", [(time, launch)]) + operated = max(end - deployed, 0.0) + add( + "operations", + _spread( + self.operations.per_satellite_year * size * operated, + deployed, + end, + ), + ) + estimate.units["satellites" if name is None else str(name)] = built + add("operations", _spread(self.operations.per_year * self.years, first, end)) + flows = [flow for flow in flows if flow[2] != 0] + estimate.flows = sorted(flows) + for element in ELEMENTS: + setattr( + estimate, + element, + float(sum(amount for _, kind, amount in flows if kind == element)), + ) + estimate.present = { + element: float( + sum( + amount * schedule.discount(time) + for time, kind, amount in flows + if kind == element + ) + ) + for element in ELEMENTS + } + return estimate + def _get_growth(growth: Growth) -> dict[str, float]: """ diff --git a/tests/tradespace/test_cost.py b/tests/tradespace/test_cost.py index e230f216..94bbc8e6 100644 --- a/tests/tradespace/test_cost.py +++ b/tests/tradespace/test_cost.py @@ -11,6 +11,7 @@ from tatc.tradespace import ( Categorical, CostModel, + CostSchedule, DesignSpace, Integer, LaunchCost, @@ -237,3 +238,93 @@ def evaluate(d): self.assertTrue((summary["cost p70"] > summary["cost"]).all()) ratio = summary["cost"] / np.array(nominal) np.testing.assert_allclose(ratio, ratio.iloc[0]) # common random numbers + + +class TestCostSchedule(unittest.TestCase): + """ + Unit tests for dated costs and their present value. + """ + + def setUp(self): + self.terms = { + "satellites": SatelliteCost( + development=90, first_unit=10, learning_rate=0.9 + ), + "launch": LaunchCost(per_launch=30, capacity=3), + "operations": OperationsCost(per_year=5, per_satellite_year=1), + "years": 6, + "design_life": 3, + } + self.layout = _walker(planes=3, per_plane=4) + + def _estimate(self, **schedule): + model = CostModel(**self.terms, schedule=CostSchedule(**schedule)) + return model.estimate(self.layout) + + def test_undiscounted(self): + """Without discounting or intervals, dated costs are the estimate's.""" + nominal = CostModel(**self.terms).estimate(self.layout) + dated = self._estimate() + for element in ("development", "production", "launch", "operations"): + self.assertAlmostEqual(getattr(dated, element), getattr(nominal, element)) + self.assertAlmostEqual(dated.present_value, nominal.total) + self.assertEqual(dated.units, nominal.units) + self.assertEqual(dated.launches, nominal.launches) + self.assertIsNone(nominal.present_value) + self.assertNotIn("cost present", nominal.metrics()) + + def test_present_value(self): + """Costs are discounted from the present to their dates.""" + dated = self._estimate(discount_rate=0.1, development_years=3) + # development of 90, evenly over 3 years, dated at mid-year + expected = sum(30 / 1.1 ** (year + 0.5) for year in range(3)) + self.assertAlmostEqual(dated.present["development"], expected) + # launches of the first generation at year 3, the second at year 6 + self.assertAlmostEqual(dated.present["launch"], 180 / 1.1**3 + 180 / 1.1**6) + later = self._estimate(discount_rate=0.1, development_years=3, start=2) + self.assertAlmostEqual(later.present_value, dated.present_value / 1.1**2) + metrics = dated.metrics() + self.assertAlmostEqual(metrics["cost present"], dated.present_value) + self.assertLess(metrics["cost present"], metrics["cost"]) + + def test_deployment_plan(self): + """Planes deployed at intervals are launched later and operated less.""" + dated = self._estimate(development_years=2, deployment_interval=1) + launches = [(t, a) for t, element, a in dated.flows if element == "launch"] + # 3 planes a year apart, and their replacements 3 years later + self.assertEqual([t for t, _ in launches], [2, 3, 4, 5, 6, 7]) + # the second and third planes miss 1 and 2 years of 4 satellites + nominal = CostModel(**self.terms).estimate(self.layout) + self.assertAlmostEqual(dated.operations, nominal.operations - 4 * (1 + 2)) + # production is paid in the year before each deployment, units in order + production = [ + (t, a) for t, element, a in dated.flows if element == "production" + ] + self.assertEqual(production[0][0], 1.5) + self.assertAlmostEqual(production[0][1], self.terms["satellites"].production(4)) + + def test_annual(self): + """Annual costs add to the total, and their peak is a metric.""" + dated = self._estimate(development_years=2, deployment_interval=1) + annual = dated.annual() + self.assertAlmostEqual(annual["total"].sum(), dated.total) + self.assertEqual(list(annual.index), list(range(0, 8))) + self.assertAlmostEqual( + dated.metrics()["cost peak annual"], annual["total"].max() + ) + with self.assertRaises(ValueError): + CostModel(**self.terms).estimate(self.layout).annual() + + def test_growth_and_validation(self): + """Growth multiplies dated costs, and schedules are validated.""" + model = CostModel(**self.terms, schedule=CostSchedule(discount_rate=0.05)) + base = model.estimate(self.layout) + grown = model.estimate(self.layout, growth={"development": 2.0}) + self.assertAlmostEqual( + grown.present["development"], 2 * base.present["development"] + ) + self.assertAlmostEqual(grown.present["launch"], base.present["launch"]) + with self.assertRaises(ValueError): + CostSchedule(production_lead=-1) + with self.assertRaises(ValueError): + CostSchedule(discount_rate=-1) From 8cf6a4e75c6f2cd1ae215f5a81cbc11899d3cc43 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Wed, 11 Nov 2026 07:27:52 -0700 Subject: [PATCH 13/52] schedule costs from production rates, launch cadence, and development times of each type --- CHANGELOG.md | 2 +- docs/api_reference/tradespace.rst | 4 +- docs/examples/SearchTradeSpace.ipynb | 250 ++++++++++++++------------- src/tatc/tradespace/cost.py | 224 +++++++++++++++++------- tests/tradespace/test_cost.py | 85 ++++++--- 5 files changed, 355 insertions(+), 210 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 16ad9edd..bb591141 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -20,7 +20,7 @@ Added: - Building blocks of constellations: fragments of design spaces of Walker constellations (`tradespace.walker_space`) and planes of sun-synchronous orbits (`sso_planes_space`, whose planes have different crossing times), `build_constellation`, which builds the satellites of either with instruments or entries of the instrument catalog (with their validated attitudes, and several entries on one satellite), and `count_satellites` and `count_planes`. The phase and node of the lead satellite of a Walker constellation (`phase_fraction` and `node_fraction`, design variables or uncertain parameters) are fractions of the intervals over which they give distinct constellations (`360 / per_plane` degrees of phase, and `360 / planes` degrees of node for a delta configuration or 360 for a star), so that a search does not evaluate the same constellation at several phases or nodes. Planes of inclined orbits (`planes_space`), each with its own inclination and node (uncertain by default, as of satellites launched as secondary payloads). The satellites of the planes of `sso_planes_space` and `planes_space` are evenly spaced, or follow each other in a train at an `interval` (minutes), on the same ground track or in the same plane (`repeat_ground_track`). The phase of each plane (`phase_fraction`, which replaces `phase` of `sso_planes_space`) is a fraction of the interval over which it gives distinct planes (`360 / satellites` degrees for evenly spaced satellites, 360 for a train), from which each fragment derives the plane's `true_anomaly`, as for the lead satellite of a Walker constellation. `build_constellation`, `count_satellites`, and `count_planes` take several layouts (a list, or a `Repeat` of a `Choice` of layouts), such as the shells of a mixed constellation. - Function `tradespace.screen` (and class `Screening`), which screens designs with studies of increasing fidelity, keeping whole fronts of the best designs of each stage for the next. - Searches of design spaces with optional optimizers: `tradespace.optimize_optuna` suggests designs with Optuna trials (`DesignSpace.suggest`, define-by-run over the hierarchical space), and `optimize_pymoo` and `make_pymoo_problem` search the unit hypercube that encodes a design space (`DesignSpace.unit_paths`, `encode`, and `decode`) with pymoo. Each design is evaluated once, and the designs proposed together are evaluated together, in parallel if the study is. Constraints of a design space may return the amount of their violation (`Infeasible.violation`), which Optuna's trials record (`set_constraint`) for its constraint-aware samplers, and which is the constraint value of pymoo problems. Optional dependencies `tradespace` (joblib, Optuna, and pymoo). - - Life-cycle costs of constellations for trade studies (`tradespace.CostModel`): the development of each type of satellite, the production of its units on a learning curve (`SatelliteCost`), launches (dedicated launches of each plane, up to a capacity in number or mass, or prices per satellite and kg, `LaunchCost`), operations (`OperationsCost`), replenishment at the end of a design life, and spares in orbit, from the layouts of a design (`plane_sizes`), with growth factors for cost risk (such as uncertain parameters, whose quantiles over replicates give the cost at a confidence level). An optional schedule (`CostSchedule`) dates the costs (development before the first deployment, production before each deployment, planes deployed at intervals and replaced at the end of their design life, and operations from deployment to the end of the mission), for their present value at a discount rate (`CostEstimate.present_value`, metric `cost present`) and annual costs (`CostEstimate.annual`, metric `cost peak annual`). TAT-C does not include cost-estimating relationships: the costs are given by the study. Fingerprints describe dataclasses (such as cost models) by their fields. + - Life-cycle costs of constellations for trade studies (`tradespace.CostModel`): the development of each type of satellite, the production of its units on a learning curve (`SatelliteCost`), launches (dedicated launches of each plane, up to a capacity in number or mass, or prices per satellite and kg, `LaunchCost`), operations (`OperationsCost`), replenishment at the end of a design life, and spares in orbit, from the layouts of a design (`plane_sizes`), with growth factors for cost risk (such as uncertain parameters, whose quantiles over replicates give the cost at a confidence level). An optional schedule (`CostSchedule`) dates the costs from rates, so that each design's schedule follows from its satellites and planes (development of each type of satellite, over its own duration if given, `SatelliteCost.development_years`; production on a line at a `production_rate`; launches as planes are ready, at most one every `launch_interval`; replacements at the end of their design life; and operations from launch to the end of the mission), for its deployments (`CostEstimate.deployments` and `deployed`), their present value at a discount rate (`CostEstimate.present_value`, metric `cost present`) and annual costs (`CostEstimate.annual`, metric `cost peak annual`). TAT-C does not include cost-estimating relationships: the costs are given by the study. Fingerprints describe dataclasses (such as cost models) by their fields. - Function `tradespace.confirm` (and class `Confirmation`), which evaluates selected designs (such as a front) with new replicates that played no part in their selection, removing the optimism of the selection (the winner's curse, `Confirmation.optimism`). `ResultStore` keys evaluations by the fingerprint of a study (`Study.fingerprint`, see `get_fingerprint`: its seed, use of common random numbers, design space, and build and evaluation functions, and the version of TAT-C), warning if it holds evaluations of other definitions, which are not reused; `SatelliteCache` keys results on disk by the fingerprint of its function. `refine` treats designs with fewer than `min_replicates` (5) as uncertain whatever their probability, adds the replicates left to `max_replicates` in a last partial step, and warns if designs remain uncertain without a tolerance. `sensitivity` gives adjusted shares (epsilon squared) by default, without the share that the levels of a variable explain by chance (`adjusted=False` for correlation ratios). - Searches with Optuna accept categorical options that depend on earlier decisions (a parameter for each set of options), use TPE with a constant liar in batches by default (which spreads the trials of a batch), and stop after `max_designs` designs evaluated (trials that suggest designs evaluated before are told their objectives without evaluating them again). A design infeasible in some of its replicates violates its feasibility by their share (`Evaluations.infeasibility`), and the first design evaluated in a search is evaluated alone, to check that evaluations give one record each. `Study` records errors of evaluations as infeasible, without storing them, with `errors="record"`. Enumeration walks the items of unordered repetitions in one order only (the same designs, in the same order, four times faster for three sun-synchronous planes), and `DesignSpace.size` counts designs without keeping them. Pareto fronts are found by a vectorized sweep in lexicographic order that compares designs only with the efficient designs before them, and fronts with tolerances by comparing designs only with the efficient designs without tolerances (which dominate every design that any design dominates within the tolerances), in blocks of bounded memory: 20,000 designs in 0.05 s (0.11 s with tolerances) rather than 17 s, and the bootstraps of `pareto_probability` (and so `refine`) about 20 times faster. - Example `SearchTradeSpace`, which searches a hierarchical trade space of constellations for the designs that sample points sufficiently: by evaluating every design, ranking them with the uncertainty of their replicates, screening, and searching with Optuna and pymoo. diff --git a/docs/api_reference/tradespace.rst b/docs/api_reference/tradespace.rst index b9eeaa5c..236da4ed 100644 --- a/docs/api_reference/tradespace.rst +++ b/docs/api_reference/tradespace.rst @@ -87,10 +87,10 @@ Costs .. autoclass:: tatc.tradespace.OperationsCost .. autoclass:: tatc.tradespace.CostSchedule - :members: discount + :members: discount, producing .. autoclass:: tatc.tradespace.CostEstimate - :members: total, present_value, annual, metrics + :members: total, present_value, deployed, annual, metrics .. autofunction:: tatc.tradespace.plane_sizes diff --git a/docs/examples/SearchTradeSpace.ipynb b/docs/examples/SearchTradeSpace.ipynb index fc10d947..2f932ace 100644 --- a/docs/examples/SearchTradeSpace.ipynb +++ b/docs/examples/SearchTradeSpace.ipynb @@ -28,10 +28,10 @@ "id": "c3d2e5f4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T13:54:55.415203Z", - "iopub.status.busy": "2026-11-11T13:54:55.415028Z", - "iopub.status.idle": "2026-11-11T13:54:56.123863Z", - "shell.execute_reply": "2026-11-11T13:54:56.122927Z" + "iopub.execute_input": "2026-11-11T14:20:59.320749Z", + "iopub.status.busy": "2026-11-11T14:20:59.320573Z", + "iopub.status.idle": "2026-11-11T14:21:00.037474Z", + "shell.execute_reply": "2026-11-11T14:21:00.036501Z" } }, "outputs": [], @@ -79,10 +79,10 @@ "id": "e5f4a7b6", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T13:54:56.125809Z", - "iopub.status.busy": "2026-11-11T13:54:56.125463Z", - "iopub.status.idle": "2026-11-11T13:54:57.284278Z", - "shell.execute_reply": "2026-11-11T13:54:57.283499Z" + "iopub.execute_input": "2026-11-11T14:21:00.039434Z", + "iopub.status.busy": "2026-11-11T14:21:00.039143Z", + "iopub.status.idle": "2026-11-11T14:21:01.198568Z", + "shell.execute_reply": "2026-11-11T14:21:01.197773Z" } }, "outputs": [ @@ -143,10 +143,10 @@ "id": "a7b6c9d8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T13:54:57.286192Z", - "iopub.status.busy": "2026-11-11T13:54:57.285825Z", - "iopub.status.idle": "2026-11-11T13:54:57.293668Z", - "shell.execute_reply": "2026-11-11T13:54:57.292785Z" + "iopub.execute_input": "2026-11-11T14:21:01.200348Z", + "iopub.status.busy": "2026-11-11T14:21:01.199999Z", + "iopub.status.idle": "2026-11-11T14:21:01.208508Z", + "shell.execute_reply": "2026-11-11T14:21:01.207809Z" } }, "outputs": [], @@ -170,7 +170,7 @@ "\n", "# illustrative costs (millions of dollars), not estimates of any mission: satellites with an imager of each field of\n", "# regard, a small launcher for every 3 satellites of a plane, and 5 years of operations, dated over 3 years of\n", - "# development and planes deployed half a year apart, discounted at 3% a year\n", + "# development, a production line of 4 satellites a year, and a launch at most every half year, discounted at 3% a year\n", "COST_MODEL = CostModel(\n", " satellites={\n", " 30: SatelliteCost(development=40, first_unit=12, learning_rate=0.9, mass=60),\n", @@ -179,7 +179,7 @@ " launch=LaunchCost(per_launch=8, capacity=3),\n", " operations=OperationsCost(per_year=3, per_satellite_year=0.5),\n", " years=5,\n", - " schedule=CostSchedule(discount_rate=0.03, development_years=3, production_lead=1, deployment_interval=0.5),\n", + " schedule=CostSchedule(discount_rate=0.03, development_years=3, production_rate=4, launch_interval=0.5),\n", ")\n", "\n", "CACHE_DIRECTORY = Path(tempfile.gettempdir()) / \"tatc-search-trade-space\"\n", @@ -253,10 +253,10 @@ "id": "c9d8e1f0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T13:54:57.295347Z", - "iopub.status.busy": "2026-11-11T13:54:57.295082Z", - "iopub.status.idle": "2026-11-11T13:55:13.817714Z", - "shell.execute_reply": "2026-11-11T13:55:13.816983Z" + "iopub.execute_input": "2026-11-11T14:21:01.210039Z", + "iopub.status.busy": "2026-11-11T14:21:01.209797Z", + "iopub.status.idle": "2026-11-11T14:21:11.899228Z", + "shell.execute_reply": "2026-11-11T14:21:11.898438Z" } }, "outputs": [ @@ -414,10 +414,10 @@ "id": "d0e9f2a1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T13:55:13.819402Z", - "iopub.status.busy": "2026-11-11T13:55:13.819150Z", - "iopub.status.idle": "2026-11-11T13:55:14.022238Z", - "shell.execute_reply": "2026-11-11T13:55:14.021499Z" + "iopub.execute_input": "2026-11-11T14:21:11.900833Z", + "iopub.status.busy": "2026-11-11T14:21:11.900607Z", + "iopub.status.idle": "2026-11-11T14:21:12.104949Z", + "shell.execute_reply": "2026-11-11T14:21:12.103935Z" } }, "outputs": [ @@ -498,10 +498,10 @@ "id": "a2b3c4d5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T13:55:14.024119Z", - "iopub.status.busy": "2026-11-11T13:55:14.023875Z", - "iopub.status.idle": "2026-11-11T13:55:14.092351Z", - "shell.execute_reply": "2026-11-11T13:55:14.091620Z" + "iopub.execute_input": "2026-11-11T14:21:12.106575Z", + "iopub.status.busy": "2026-11-11T14:21:12.106321Z", + "iopub.status.idle": "2026-11-11T14:21:12.175920Z", + "shell.execute_reply": "2026-11-11T14:21:12.174966Z" } }, "outputs": [ @@ -698,10 +698,10 @@ "id": "b3c4d5e6", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T13:55:14.094106Z", - "iopub.status.busy": "2026-11-11T13:55:14.093845Z", - "iopub.status.idle": "2026-11-11T13:55:14.228630Z", - "shell.execute_reply": "2026-11-11T13:55:14.227859Z" + "iopub.execute_input": "2026-11-11T14:21:12.177660Z", + "iopub.status.busy": "2026-11-11T14:21:12.177404Z", + "iopub.status.idle": "2026-11-11T14:21:12.317148Z", + "shell.execute_reply": "2026-11-11T14:21:12.316316Z" } }, "outputs": [ @@ -751,10 +751,10 @@ "id": "d5e6f7a8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T13:55:14.230509Z", - "iopub.status.busy": "2026-11-11T13:55:14.230235Z", - "iopub.status.idle": "2026-11-11T13:55:14.421726Z", - "shell.execute_reply": "2026-11-11T13:55:14.420991Z" + "iopub.execute_input": "2026-11-11T14:21:12.318895Z", + "iopub.status.busy": "2026-11-11T14:21:12.318662Z", + "iopub.status.idle": "2026-11-11T14:21:12.499119Z", + "shell.execute_reply": "2026-11-11T14:21:12.498438Z" } }, "outputs": [ @@ -901,10 +901,10 @@ "id": "a8b9c0d1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T13:55:14.423574Z", - "iopub.status.busy": "2026-11-11T13:55:14.423201Z", - "iopub.status.idle": "2026-11-11T13:55:14.449259Z", - "shell.execute_reply": "2026-11-11T13:55:14.448507Z" + "iopub.execute_input": "2026-11-11T14:21:12.500851Z", + "iopub.status.busy": "2026-11-11T14:21:12.500597Z", + "iopub.status.idle": "2026-11-11T14:21:12.527749Z", + "shell.execute_reply": "2026-11-11T14:21:12.527019Z" } }, "outputs": [ @@ -1052,10 +1052,10 @@ "id": "a3b2c5d4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T13:55:14.450870Z", - "iopub.status.busy": "2026-11-11T13:55:14.450632Z", - "iopub.status.idle": "2026-11-11T13:55:16.024101Z", - "shell.execute_reply": "2026-11-11T13:55:16.023280Z" + "iopub.execute_input": "2026-11-11T14:21:12.529556Z", + "iopub.status.busy": "2026-11-11T14:21:12.529357Z", + "iopub.status.idle": "2026-11-11T14:21:14.108496Z", + "shell.execute_reply": "2026-11-11T14:21:14.107637Z" } }, "outputs": [ @@ -1304,10 +1304,10 @@ "id": "b5d3f7a9", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T13:55:16.026196Z", - "iopub.status.busy": "2026-11-11T13:55:16.025803Z", - "iopub.status.idle": "2026-11-11T13:55:44.920239Z", - "shell.execute_reply": "2026-11-11T13:55:44.919485Z" + "iopub.execute_input": "2026-11-11T14:21:14.110249Z", + "iopub.status.busy": "2026-11-11T14:21:14.109987Z", + "iopub.status.idle": "2026-11-11T14:21:41.491363Z", + "shell.execute_reply": "2026-11-11T14:21:41.490574Z" } }, "outputs": [ @@ -1457,10 +1457,10 @@ "id": "c6e4a8b0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T13:55:44.921881Z", - "iopub.status.busy": "2026-11-11T13:55:44.921645Z", - "iopub.status.idle": "2026-11-11T13:55:44.982851Z", - "shell.execute_reply": "2026-11-11T13:55:44.981996Z" + "iopub.execute_input": "2026-11-11T14:21:41.492994Z", + "iopub.status.busy": "2026-11-11T14:21:41.492802Z", + "iopub.status.idle": "2026-11-11T14:21:41.556683Z", + "shell.execute_reply": "2026-11-11T14:21:41.555878Z" } }, "outputs": [ @@ -2010,10 +2010,10 @@ "id": "f2a3b4c5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T13:55:44.984383Z", - "iopub.status.busy": "2026-11-11T13:55:44.984200Z", - "iopub.status.idle": "2026-11-11T13:55:47.637159Z", - "shell.execute_reply": "2026-11-11T13:55:47.636479Z" + "iopub.execute_input": "2026-11-11T14:21:41.558273Z", + "iopub.status.busy": "2026-11-11T14:21:41.558048Z", + "iopub.status.idle": "2026-11-11T14:21:42.470012Z", + "shell.execute_reply": "2026-11-11T14:21:42.469220Z" } }, "outputs": [ @@ -2515,10 +2515,10 @@ "id": "f9b7d1e3", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T13:55:47.639007Z", - "iopub.status.busy": "2026-11-11T13:55:47.638772Z", - "iopub.status.idle": "2026-11-11T13:55:49.004341Z", - "shell.execute_reply": "2026-11-11T13:55:49.003550Z" + "iopub.execute_input": "2026-11-11T14:21:42.471527Z", + "iopub.status.busy": "2026-11-11T14:21:42.471293Z", + "iopub.status.idle": "2026-11-11T14:21:43.834209Z", + "shell.execute_reply": "2026-11-11T14:21:43.833462Z" } }, "outputs": [ @@ -2748,10 +2748,10 @@ "id": "d1e2f3a4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T13:55:49.005995Z", - "iopub.status.busy": "2026-11-11T13:55:49.005752Z", - "iopub.status.idle": "2026-11-11T13:55:50.064039Z", - "shell.execute_reply": "2026-11-11T13:55:50.063367Z" + "iopub.execute_input": "2026-11-11T14:21:43.835835Z", + "iopub.status.busy": "2026-11-11T14:21:43.835590Z", + "iopub.status.idle": "2026-11-11T14:21:44.634525Z", + "shell.execute_reply": "2026-11-11T14:21:44.633716Z" } }, "outputs": [ @@ -2956,7 +2956,7 @@ "source": [ "## Trade Cost Against Sufficiency\n", "\n", - "The numbers of satellites and planes are proxies of cost. A `CostModel` estimates the life-cycle cost of each design from the costs of its satellites (the development of each type, and the production of its units on a learning curve), launches (here, a small launcher for every three satellites of a plane), and operations, given by the study (TAT-C does not include cost-estimating relationships). The costs here are illustrative, in millions of dollars. The evaluation adds the cost and its elements to each record, for the satellites of each design's imager (`kind`): a wider field of regard costs more to develop and build. A schedule (`CostSchedule`) dates the costs: development over three years before the first plane is deployed, the production of each plane's satellites in the year before it, planes deployed half a year apart, and operations from each plane's deployment to the end of the mission. The dated costs give the present value of the cost (`cost present`, discounted at 3% a year) and the cost of the most expensive year (`cost peak annual`), for annual budgets.\n", + "The numbers of satellites and planes are proxies of cost. A `CostModel` estimates the life-cycle cost of each design from the costs of its satellites (the development of each type, and the production of its units on a learning curve), launches (here, a small launcher for every three satellites of a plane), and operations, given by the study (TAT-C does not include cost-estimating relationships). The costs here are illustrative, in millions of dollars. The evaluation adds the cost and its elements to each record, for the satellites of each design's imager (`kind`): a wider field of regard costs more to develop and build. A schedule (`CostSchedule`) dates the costs from rates, so that each design's schedule follows from its satellites and planes: development over three years, then the production of the satellites on one line at four a year, plane by plane, each plane launched when its satellites are ready (at most one launch every half year), and operations from each launch to the end of the mission (five years after the first launch). The dated costs give the present value of the cost (`cost present`, discounted at 3% a year) and the cost of the most expensive year (`cost peak annual`), for annual budgets.\n", "\n", "The growth of the cost of development is uncertain (an `Uncertain` parameter, from 0.9 to 1.6 times the estimate, most likely 1), drawn for each replicate, so that statistics over the replicates give the cost at a confidence level: here, the 0.7 quantile (`cost p70`), as budgets are often set. A requirement keeps the designs whose cost at 70% confidence is within a budget, and the front trades this cost against the share of points sufficiently sampled. (Cost depends only on the design, so a constraint of the design space could exclude designs over a budget before they are evaluated, with the cost without growth.)" ] @@ -2967,10 +2967,10 @@ "id": "c2d3e4f5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T13:55:50.065685Z", - "iopub.status.busy": "2026-11-11T13:55:50.065449Z", - "iopub.status.idle": "2026-11-11T13:55:51.686402Z", - "shell.execute_reply": "2026-11-11T13:55:51.685688Z" + "iopub.execute_input": "2026-11-11T14:21:44.636162Z", + "iopub.status.busy": "2026-11-11T14:21:44.635918Z", + "iopub.status.idle": "2026-11-11T14:21:46.344648Z", + "shell.execute_reply": "2026-11-11T14:21:46.343920Z" } }, "outputs": [ @@ -3005,6 +3005,7 @@ " description\n", " satellites\n", " planes\n", + " deployed\n", " cost p70\n", " cost development\n", " cost production\n", @@ -3022,13 +3023,14 @@ " 800 km, 30 deg FOR, SSO: 1 at 12:00\n", " 1\n", " 1\n", + " 3.2\n", " 83.6\n", " 44.4\n", " 12.0\n", " 8.0\n", " 17.5\n", - " 75.9\n", - " 26.8\n", + " 75.5\n", + " 23.5\n", " 1.0\n", " 1.0\n", " \n", @@ -3037,13 +3039,14 @@ " 800 km, 30 deg FOR, SSO: 2 at 09:00\n", " 2\n", " 1\n", + " 3.5\n", " 96.9\n", " 44.4\n", " 22.8\n", " 8.0\n", " 20.0\n", - " 88.0\n", - " 37.6\n", + " 87.2\n", + " 30.8\n", " 3.2\n", " 0.9\n", " \n", @@ -3052,13 +3055,14 @@ " 800 km, 30 deg FOR, Walker 45 deg: 2 x 1 (spac...\n", " 2\n", " 2\n", + " 3.8\n", " 104.7\n", " 44.4\n", " 22.8\n", " 16.0\n", " 19.8\n", - " 94.9\n", - " 30.3\n", + " 94.3\n", + " 42.3\n", " 7.8\n", " 1.0\n", " \n", @@ -3067,13 +3071,14 @@ " 800 km, 30 deg FOR, SSO: 2 at 12:00, 1 at 06:00\n", " 3\n", " 2\n", + " 4.0\n", " 117.3\n", " 44.4\n", " 33.0\n", " 16.0\n", " 22.2\n", - " 106.4\n", - " 37.6\n", + " 105.3\n", + " 41.0\n", " 7.8\n", " 0.7\n", " \n", @@ -3082,13 +3087,14 @@ " 800 km, 30 deg FOR, Walker 45 deg: 3 x 1 (spac...\n", " 3\n", " 3\n", + " 4.2\n", " 124.8\n", " 44.4\n", " 33.0\n", " 24.0\n", " 21.8\n", - " 112.8\n", - " 40.5\n", + " 112.2\n", + " 52.5\n", " 12.0\n", " 0.8\n", " \n", @@ -3097,13 +3103,14 @@ " 800 km, 30 deg FOR, Walker 45 deg: 2 x 2 (spac...\n", " 4\n", " 2\n", + " 4.0\n", " 129.3\n", " 44.4\n", " 42.7\n", " 16.0\n", " 24.5\n", - " 117.2\n", - " 39.9\n", + " 115.9\n", + " 50.7\n", " 20.0\n", " 0.9\n", " \n", @@ -3112,13 +3119,14 @@ " 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...\n", " 2\n", " 2\n", + " 3.8\n", " 139.2\n", " 66.7\n", " 34.2\n", " 16.0\n", " 19.8\n", - " 126.7\n", - " 40.2\n", + " 126.0\n", + " 53.7\n", " 28.6\n", " 1.0\n", " \n", @@ -3127,13 +3135,14 @@ " 800 km, 30 deg FOR, Walker 45 deg: 4 x 1 (spac...\n", " 4\n", " 4\n", + " 4.8\n", " 144.3\n", " 44.4\n", " 42.7\n", " 32.0\n", " 23.5\n", - " 129.9\n", - " 40.5\n", + " 129.2\n", + " 62.2\n", " 29.0\n", " 0.8\n", " \n", @@ -3142,13 +3151,14 @@ " 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...\n", " 3\n", " 1\n", + " 3.8\n", " 149.1\n", " 66.7\n", " 49.4\n", " 8.0\n", " 22.5\n", - " 136.2\n", - " 71.7\n", + " 134.4\n", + " 57.4\n", " 37.0\n", " 0.6\n", " \n", @@ -3168,27 +3178,27 @@ "845 800 km, 30 deg FOR, Walker 45 deg: 4 x 1 (spac... 4 4 \n", "961 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3 1 \n", "\n", - " cost p70 cost development cost production cost launch \\\n", - "913 83.6 44.4 12.0 8.0 \n", - "912 96.9 44.4 22.8 8.0 \n", - "826 104.7 44.4 22.8 16.0 \n", - "922 117.3 44.4 33.0 16.0 \n", - "835 124.8 44.4 33.0 24.0 \n", - "828 129.3 44.4 42.7 16.0 \n", - "963 139.2 66.7 34.2 16.0 \n", - "845 144.3 44.4 42.7 32.0 \n", - "961 149.1 66.7 49.4 8.0 \n", + " deployed cost p70 cost development cost production cost launch \\\n", + "913 3.2 83.6 44.4 12.0 8.0 \n", + "912 3.5 96.9 44.4 22.8 8.0 \n", + "826 3.8 104.7 44.4 22.8 16.0 \n", + "922 4.0 117.3 44.4 33.0 16.0 \n", + "835 4.2 124.8 44.4 33.0 24.0 \n", + "828 4.0 129.3 44.4 42.7 16.0 \n", + "963 3.8 139.2 66.7 34.2 16.0 \n", + "845 4.8 144.3 44.4 42.7 32.0 \n", + "961 3.8 149.1 66.7 49.4 8.0 \n", "\n", " cost operations cost present cost peak annual sufficient \\\n", - "913 17.5 75.9 26.8 1.0 \n", - "912 20.0 88.0 37.6 3.2 \n", - "826 19.8 94.9 30.3 7.8 \n", - "922 22.2 106.4 37.6 7.8 \n", - "835 21.8 112.8 40.5 12.0 \n", - "828 24.5 117.2 39.9 20.0 \n", - "963 19.8 126.7 40.2 28.6 \n", - "845 23.5 129.9 40.5 29.0 \n", - "961 22.5 136.2 71.7 37.0 \n", + "913 17.5 75.5 23.5 1.0 \n", + "912 20.0 87.2 30.8 3.2 \n", + "826 19.8 94.3 42.3 7.8 \n", + "922 22.2 105.3 41.0 7.8 \n", + "835 21.8 112.2 52.5 12.0 \n", + "828 24.5 115.9 50.7 20.0 \n", + "963 19.8 126.0 53.7 28.6 \n", + "845 23.5 129.2 62.2 29.0 \n", + "961 22.5 134.4 57.4 37.0 \n", "\n", " pareto_probability \n", "913 1.0 \n", @@ -3225,6 +3235,10 @@ "elements = aggregate(refinement.results, [*ELEMENTS, *DATED]).set_index(\"design\")[[*ELEMENTS, *DATED]]\n", "costed = costed.join(values[[\"satellites\", \"planes\"]], on=\"design\").join(elements, on=\"design\")\n", "costed[\"description\"] = [describe(values.loc[key]) for key in costed.design]\n", + "# the years from the start of development to the launch of every plane, from each design's schedule\n", + "costed[\"deployed\"] = [\n", + " COST_MODEL.estimate(by_key[key].layout, kind=by_key[key].field_of_regard).deployed for key in costed.design\n", + "]\n", "efficient = costed[costed.pareto_probability >= 0.5]\n", "print(\n", " f\"{costed.meets_requirements.sum()} of {len(costed)} designs cost at most {BUDGET} at 70% confidence, \"\n", @@ -3232,7 +3246,7 @@ ")\n", "# the most sufficient of these at each cost\n", "efficient.sort_values([\"cost p70\", \"sufficient\"], ascending=[True, False]).drop_duplicates(\"cost p70\")[\n", - " [\"description\", \"satellites\", \"planes\", \"cost p70\", *ELEMENTS, *DATED, \"sufficient\", \"pareto_probability\"]\n", + " [\"description\", \"satellites\", \"planes\", \"deployed\", \"cost p70\", *ELEMENTS, *DATED, \"sufficient\", \"pareto_probability\"]\n", "].round(1)" ] }, @@ -3243,7 +3257,7 @@ "source": [ "520 of the 1,096 designs cost at most 150 million dollars at 70% confidence. Along the front, money buys sufficiency in steps: one satellite (84 million at 70% confidence, of which 44 million on average develops it) samples 1% of the points sufficiently; a second satellite in its plane, 3%, and in a second plane, 8%; four satellites in two Walker planes (129 million), 20%. The planes now have a price: four satellites in four planes sample more points sufficiently than in two (29% against 20%, as more planes spread the samples in time), at twice the cost of launches (32 million against 16). The wider field of regard joins the front only near the budget, where its development (67 million against 44) is worth its swath: two satellites with the wider imager sample 29% of the points for 139 million, as many as four with the narrower one, and three of them 37% for 149 million, the most within the budget. The designs that sample nearly every point (six to nine satellites) cost more than the budget.\n", "\n", - "Dated, the costs are worth 7 to 9% less at present (at 3% a year), as most are incurred three or more years from now, and the schedule shows when they are incurred: three satellites with the wider imager in one plane need 72 million in the last year of development, when all of them are produced, nearly twice the peak of the designs whose planes are deployed half a year apart (30 to 41 million), which spread their production over more years. A budget of annual funding would favor designs of several planes.\n", + "Each design's schedule follows from its satellites and planes (`deployed`, years from the start of development to the launch of its last plane): one satellite is launched 3.2 years after development starts; four satellites in two planes take a year to produce, and are deployed after 4.0 years; and four satellites in four planes, after 4.8 years, as each plane takes a launch and launches are half a year apart. Dated, the costs are worth 8 to 9% less at present (at 3% a year), as most are incurred three or more years from now. The most expensive year is the one after development, in which the satellites are produced and the first are launched: four satellites in four planes need 62 million in that year, and one satellite 24 million. A budget of annual funding would limit the satellites produced in a year, which a slower production rate would spread over more years, at the cost of deploying later.\n", "\n", "The growth of the cost of development affects every design alike in a replicate (common random numbers), so it shifts the costs at 70% confidence more for designs whose development costs more, here those of the wider imager. With five replicates of most designs, the 0.7 quantile of their costs is a coarse estimate: an evaluation that costs little more than the cost model (unlike the analysis of sampling) could draw more replicates of the cost alone." ] @@ -3266,10 +3280,10 @@ "id": "d6e5f8a7", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T13:55:51.688002Z", - "iopub.status.busy": "2026-11-11T13:55:51.687765Z", - "iopub.status.idle": "2026-11-11T13:55:56.559498Z", - "shell.execute_reply": "2026-11-11T13:55:56.558673Z" + "iopub.execute_input": "2026-11-11T14:21:46.346336Z", + "iopub.status.busy": "2026-11-11T14:21:46.346103Z", + "iopub.status.idle": "2026-11-11T14:21:48.775764Z", + "shell.execute_reply": "2026-11-11T14:21:48.775036Z" } }, "outputs": [ @@ -3429,10 +3443,10 @@ "id": "a9b8c1d0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T13:55:56.561364Z", - "iopub.status.busy": "2026-11-11T13:55:56.561098Z", - "iopub.status.idle": "2026-11-11T13:55:57.745919Z", - "shell.execute_reply": "2026-11-11T13:55:57.745136Z" + "iopub.execute_input": "2026-11-11T14:21:48.777426Z", + "iopub.status.busy": "2026-11-11T14:21:48.777179Z", + "iopub.status.idle": "2026-11-11T14:21:49.981232Z", + "shell.execute_reply": "2026-11-11T14:21:49.980627Z" } }, "outputs": [ @@ -3543,10 +3557,10 @@ "id": "b0c9d2e1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T13:55:57.747657Z", - "iopub.status.busy": "2026-11-11T13:55:57.747319Z", - "iopub.status.idle": "2026-11-11T13:55:57.877603Z", - "shell.execute_reply": "2026-11-11T13:55:57.876923Z" + "iopub.execute_input": "2026-11-11T14:21:49.983152Z", + "iopub.status.busy": "2026-11-11T14:21:49.982934Z", + "iopub.status.idle": "2026-11-11T14:21:50.110916Z", + "shell.execute_reply": "2026-11-11T14:21:50.110192Z" } }, "outputs": [ diff --git a/src/tatc/tradespace/cost.py b/src/tatc/tradespace/cost.py index ed2325ba..e3db6d24 100644 --- a/src/tatc/tradespace/cost.py +++ b/src/tatc/tradespace/cost.py @@ -14,12 +14,21 @@ parameters, so that statistics of the cost over replicates (such as a 0.7 `Quantile`) are objectives or requirements. -An optional schedule (`CostSchedule`) dates the costs: development before -the first launch, the production of each plane's satellites before it is -deployed, the deployment of planes at intervals (and of replacements at the -end of their design life), and operations from deployment to the end of the -mission. The dated costs give the present value of the cost at a discount -rate, and the cost of each year (such as its peak, for annual budgets). +An optional schedule (`CostSchedule`) dates the costs from rates, so that +each design's schedule follows from its satellites and planes: development +of each type of satellite, the production of its satellites on a line at a +production rate, launches at a cadence as satellites are ready, replacements +at the end of their design life, and operations from launch to the end of +the mission. The dated costs give the present value of the cost at a +discount rate, and the cost of each year (such as its peak, for annual +budgets). A schedule that is itself a decision (such as the launch cadence) +is a design variable, with the model built for each design:: + + def evaluate(built): + d, satellites = built + schedule = dataclasses.replace(SCHEDULE, launch_interval=d.launch_interval) + model = dataclasses.replace(MODEL, schedule=schedule) + return model.estimate(d.layout).metrics() @author: Paul T. Grogan """ @@ -80,18 +89,23 @@ class SatelliteCost: first_unit (float): The recurring cost of the first unit. learning_rate (float): The learning rate, in (0, 1]. mass (float | None): The mass (kg), for launches priced by mass. + development_years (float | None): The duration of its development, + with a schedule (see `CostSchedule`), if not the schedule's. """ development: float = 0.0 first_unit: float = 0.0 learning_rate: float = 1.0 mass: float | None = None + development_years: float | None = None def __post_init__(self): if not 0 < self.learning_rate <= 1: raise ValueError("learning_rate must be in (0, 1]") if self.development < 0 or self.first_unit < 0: raise ValueError("costs must not be negative") + if self.development_years is not None and self.development_years < 0: + raise ValueError("development_years must not be negative") def production(self, units: int) -> float: """ @@ -179,49 +193,72 @@ class OperationsCost: @dataclass(frozen=True) class CostSchedule: """ - A schedule of the costs of a constellation, and the discount rate of - their present value. - - Times are in years from the start of development, which begins - `start` years after the present (the date of present values). - Development spreads its cost evenly over `development_years`, at the end - of which the first plane is deployed; the others follow at intervals of - `deployment_interval` (in the order of the layouts' planes), and their - replacements at the end of each design life. The satellites of each - deployment (units, in the order of the learning curve) are paid for - evenly over the `production_lead` before it, and its launch when it is - deployed. Operations cost a fixed amount in each year of the mission - (its `years` after the first deployment), and each satellite from its - deployment to the end of the mission. Costs spread over a period are - dated at the middle of each of its years. - - A cost at time `t` has a present value of `cost / (1 + discount_rate) - ** (start + t)`. + A schedule of the costs of a constellation, from rates, and the discount + rate of their present value. + + Times are in years from the start of development, which begins `start` + years after the present (the date of present values). The schedule of a + design follows from its satellites and planes: + + * Each type of satellite is developed over `development_years` (or its + own, see `SatelliteCost`), its cost spread evenly. + * Its satellites are then produced on one line, in the order of the + planes, at `production_rate` satellites a year (or at once, if + `None`), each plane's paid for evenly while they are produced. + * Planes are launched in the order they are ready, at most one launch + every `launch_interval` years: a plane of several dedicated launches + (see `LaunchCost`) takes several, and its satellites are spread over + them. A launch is paid for when it flies. + * The mission lasts `years` (see `CostModel`) from the first launch. + Each satellite is replaced at the end of its design life (if before + the end of the mission), its replacement produced at the production + rate just before it is needed and launched then. + * Operations cost a fixed amount in each year of the mission, and each + satellite from its launch to the end of the mission. + + Costs spread over a period are dated at the middle of each of its + years. A cost at time `t` has a present value of `cost / (1 + + discount_rate) ** (start + t)`. Args: discount_rate (float): The annual discount rate (such as 0.03). - development_years (float): The duration of development, before the - first deployment. - production_lead (float): The duration of the production of the - satellites of a deployment, before it. - deployment_interval (float): The years between the deployments of - successive planes. + development_years (float): The duration of development, before + production. + production_rate (float | None): The satellites of each type produced + a year, or `None` for production that takes no time. + launch_interval (float): The least time (years) between launches. start (float): The years from the present to the start of development. """ discount_rate: float = 0.0 development_years: float = 3.0 - production_lead: float = 1.0 - deployment_interval: float = 0.0 + production_rate: float | None = None + launch_interval: float = 0.0 start: float = 0.0 def __post_init__(self): if self.discount_rate <= -1: raise ValueError("discount_rate must be greater than -1") - for name in ("development_years", "production_lead", "deployment_interval"): + for name in ("development_years", "launch_interval"): if getattr(self, name) < 0: raise ValueError(f"{name} must not be negative") + if self.production_rate is not None and self.production_rate <= 0: + raise ValueError("production_rate must be positive") + + def producing(self, satellites: int) -> float: + """ + Gets the time to produce satellites on one line. + + Args: + satellites (int): The number of satellites. + + Returns: + float: the time (years) + """ + return ( + 0.0 if self.production_rate is None else satellites / self.production_rate + ) def discount(self, time: float) -> float: """ @@ -277,6 +314,16 @@ class CostEstimate: (years from the start of development), element, and amount of each.""" present: dict[str, float] | None = None """dict | None: The present value of each element, with a schedule.""" + deployments: list[tuple[float, int]] = field(default_factory=list) + """list: The launches of the first satellites of the planes, with a + schedule: the time (years from the start of development) and number of + satellites of each.""" + + @property + def deployed(self) -> float | None: + """float | None: The time (years from the start of development) by + which every plane is deployed, with a schedule.""" + return max((time for time, _ in self.deployments), default=None) @property def total(self) -> float: @@ -413,9 +460,9 @@ def estimate( mission. With a schedule (see `CostSchedule`), the estimate dates its costs, - and gives their present value and annual costs; satellites deployed - after the first are operated for less of the mission, which - lowers the cost of operations. + and gives their present value, annual costs, and deployments: + satellites launched after the first are operated, and may be + replaced, for less of the mission, which lowers their costs. Growth factors multiply the estimate, such as uncertain parameters of cost growth drawn for each replicate (for example, @@ -483,6 +530,7 @@ def _estimate_scheduled( Estimates the dated costs of the planes of each type of satellite (see `estimate` and `CostSchedule`). """ + # pylint: disable=too-many-locals schedule = self.schedule estimate = CostEstimate() flows: list[tuple[float, str, float]] = [] @@ -492,51 +540,93 @@ def add(element: str, amounts: list[tuple[float, float]]) -> None: (time, element, amount * factors[element]) for time, amount in amounts ) - first = schedule.development_years - end = first + self.years if self.launch.per_kg > 0 and any( self._get_type(name).mass is None for name in fleets ): raise ValueError("launches priced by mass require masses") - plane = 0 + # development, then production of each type's planes on its line + planes = [] # (ready, name, cost, satellites) + batches: dict[Any, list[tuple[float, float, int]]] = {} for name, sizes in fleets.items(): cost = self._get_type(name) sizes = [size + spares for size in sizes if size > 0] if not sizes: continue - add("development", _spread(cost.development, 0.0, first)) - built = 0 + developed = ( + schedule.development_years + if cost.development_years is None + else cost.development_years + ) + add("development", _spread(cost.development, 0.0, developed)) + line = developed for size in sizes: - deployed = first + plane * schedule.deployment_interval - plane += 1 - for generation in range(self.generations): - time = deployed + generation * (self.design_life or 0.0) - production = cost.production(built + size) - cost.production(built) - built += size - add( - "production", - _spread(production, time - schedule.production_lead, time), + ready = line + schedule.producing(size) + batches.setdefault(name, []).append((line, ready, size)) + planes.append((ready, name, cost, size)) + line = ready + if not planes: + estimate.flows, estimate.present = [], dict.fromkeys(ELEMENTS, 0.0) + return estimate + # launches in the order planes are ready, at the launch cadence + launches = [] # (time, name, cost, satellites, dedicated) + cadence = -math.inf + for ready, name, cost, size in sorted(planes, key=lambda plane: plane[0]): + count = self.launch.launches(size, cost.mass) or 1 + first = max(ready, cadence) + for j in range(count): + carried = size // count + (1 if j < size % count else 0) + launches.append( + ( + first + j * schedule.launch_interval, + name, + cost, + carried, + self.launch.per_launch > 0, ) - launches = self.launch.launches(size, cost.mass) - estimate.launches += launches - launch = launches * self.launch.per_launch + size * ( - self.launch.per_satellite - + self.launch.per_kg * (cost.mass or 0.0) - ) - add("launch", [(time, launch)]) - operated = max(end - deployed, 0.0) - add( - "operations", - _spread( - self.operations.per_satellite_year * size * operated, - deployed, - end, - ), ) + cadence = first + count * schedule.launch_interval + estimate.deployments.append((first, size)) + originals = list(launches) + begin = min(time for time, *_ in launches) + end = begin + self.years + # replacements at the end of each design life, before the end + for time, name, cost, carried, dedicated in originals: + if self.design_life is None: + break + need = time + self.design_life + while need < end - 1e-9: + produced = need - schedule.producing(carried) + batches.setdefault(name, []).append((produced, need, carried)) + launches.append((need, name, cost, carried, dedicated)) + need += self.design_life + # production in order along each type's learning curve + for name, items in batches.items(): + cost = self._get_type(name) + built = 0 + for produced, ready, size in sorted(items, key=lambda item: item[0]): + amount = cost.production(built + size) - cost.production(built) + built += size + add("production", _spread(amount, produced, ready)) estimate.units["satellites" if name is None else str(name)] = built - add("operations", _spread(self.operations.per_year * self.years, first, end)) + for time, name, cost, carried, dedicated in launches: + estimate.launches += int(dedicated) + price = (self.launch.per_launch if dedicated else 0.0) + carried * ( + self.launch.per_satellite + self.launch.per_kg * (cost.mass or 0.0) + ) + add("launch", [(time, price)]) + # operations of the mission, and of each satellite from its launch + add("operations", _spread(self.operations.per_year * self.years, begin, end)) + for time, _, _, carried, _ in originals: + add( + "operations", + _spread( + self.operations.per_satellite_year * carried * (end - time), + time, + end, + ), + ) flows = [flow for flow in flows if flow[2] != 0] - estimate.flows = sorted(flows) + estimate.flows = sorted(flows, key=lambda flow: (flow[0], flow[1])) for element in ELEMENTS: setattr( estimate, diff --git a/tests/tradespace/test_cost.py b/tests/tradespace/test_cost.py index 94bbc8e6..5e7c2e88 100644 --- a/tests/tradespace/test_cost.py +++ b/tests/tradespace/test_cost.py @@ -257,12 +257,12 @@ def setUp(self): } self.layout = _walker(planes=3, per_plane=4) - def _estimate(self, **schedule): + def _estimate(self, layout=None, **schedule): model = CostModel(**self.terms, schedule=CostSchedule(**schedule)) - return model.estimate(self.layout) + return model.estimate(self.layout if layout is None else layout) def test_undiscounted(self): - """Without discounting or intervals, dated costs are the estimate's.""" + """Without rates, intervals, or discounting, dated costs are the estimate's.""" nominal = CostModel(**self.terms).estimate(self.layout) dated = self._estimate() for element in ("development", "production", "launch", "operations"): @@ -270,7 +270,9 @@ def test_undiscounted(self): self.assertAlmostEqual(dated.present_value, nominal.total) self.assertEqual(dated.units, nominal.units) self.assertEqual(dated.launches, nominal.launches) + self.assertEqual(dated.deployments, [(3.0, 4)] * 3) self.assertIsNone(nominal.present_value) + self.assertIsNone(nominal.deployed) self.assertNotIn("cost present", nominal.metrics()) def test_present_value(self): @@ -287,25 +289,61 @@ def test_present_value(self): self.assertAlmostEqual(metrics["cost present"], dated.present_value) self.assertLess(metrics["cost present"], metrics["cost"]) - def test_deployment_plan(self): - """Planes deployed at intervals are launched later and operated less.""" - dated = self._estimate(development_years=2, deployment_interval=1) - launches = [(t, a) for t, element, a in dated.flows if element == "launch"] - # 3 planes a year apart, and their replacements 3 years later - self.assertEqual([t for t, _ in launches], [2, 3, 4, 5, 6, 7]) - # the second and third planes miss 1 and 2 years of 4 satellites + def test_production_rate(self): + """A production line deploys planes as their satellites are built.""" + dated = self._estimate(development_years=2, production_rate=8) + # 4 satellites a plane at 8 a year: ready every half year + self.assertEqual([time for time, _ in dated.deployments], [2.5, 3.0, 3.5]) + self.assertAlmostEqual(dated.deployed, 3.5) + production = [f for f in dated.flows if f[1] == "production"] + self.assertAlmostEqual(production[0][0], 2.25) # middle of [2, 2.5) + self.assertAlmostEqual(production[0][2], self.terms["satellites"].production(4)) + # more satellites take longer to deploy + larger = self._estimate( + _walker(planes=3, per_plane=6), development_years=2, production_rate=8 + ) + self.assertGreater(larger.deployed, dated.deployed) + + def test_launch_cadence(self): + """Launches are at least an interval apart, a plane taking several.""" + dated = self._estimate(development_years=2, launch_interval=1) + launches = sorted(t for t, element, _ in dated.flows if element == "launch") + # 2 launches of each plane (a capacity of 3 satellites), a year apart, + # and the replacements 3 years later of those before the end of the + # mission (6 years after the first launch, at year 8) + self.assertEqual(launches, [2, 3, 4, 5, 5, 6, 6, 7, 7]) + self.assertEqual([time for time, _ in dated.deployments], [2, 4, 6]) + self.assertEqual(dated.launches, 6 + 3) + # satellites launched later are operated for less of the mission nominal = CostModel(**self.terms).estimate(self.layout) - self.assertAlmostEqual(dated.operations, nominal.operations - 4 * (1 + 2)) - # production is paid in the year before each deployment, units in order - production = [ - (t, a) for t, element, a in dated.flows if element == "production" - ] - self.assertEqual(production[0][0], 1.5) - self.assertAlmostEqual(production[0][1], self.terms["satellites"].production(4)) + self.assertLess(dated.operations, nominal.operations) + expected = 5 * 6 + sum(2 * (8 - t) for t in [2, 3, 4, 5, 6, 7]) + self.assertAlmostEqual(dated.operations, expected) + + def test_development_by_type(self): + """Types of satellites are developed over their own durations.""" + model = CostModel( + { + "new": SatelliteCost(development=50, first_unit=5, development_years=5), + "heritage": SatelliteCost(development=10, first_unit=5), + }, + schedule=CostSchedule(development_years=2), + ) + dated = model.estimate( + { + "new": _walker(planes=1, per_plane=2), + "heritage": _walker(planes=1, per_plane=2), + } + ) + self.assertEqual(sorted(dated.deployments), [(2.0, 2), (5.0, 2)]) + development = [f for f in dated.flows if f[1] == "development"] + self.assertEqual(max(time for time, *_ in development), 4.5) + with self.assertRaises(ValueError): + SatelliteCost(development_years=-1) def test_annual(self): """Annual costs add to the total, and their peak is a metric.""" - dated = self._estimate(development_years=2, deployment_interval=1) + dated = self._estimate(development_years=2, launch_interval=1) annual = dated.annual() self.assertAlmostEqual(annual["total"].sum(), dated.total) self.assertEqual(list(annual.index), list(range(0, 8))) @@ -324,7 +362,10 @@ def test_growth_and_validation(self): grown.present["development"], 2 * base.present["development"] ) self.assertAlmostEqual(grown.present["launch"], base.present["launch"]) - with self.assertRaises(ValueError): - CostSchedule(production_lead=-1) - with self.assertRaises(ValueError): - CostSchedule(discount_rate=-1) + for invalid in ( + {"production_rate": 0}, + {"launch_interval": -1}, + {"discount_rate": -1}, + ): + with self.assertRaises(ValueError): + CostSchedule(**invalid) From b35ceb44de9c6b6c545a1736e5db4933b1644ae7 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Wed, 11 Nov 2026 07:48:51 -0700 Subject: [PATCH 14/52] separate deployment from costs, and evaluate capability over the phases of deployment --- CHANGELOG.md | 3 +- docs/api_reference/tradespace.rst | 33 +- docs/examples/SearchTradeSpace.ipynb | 419 ++++++++++++++----- src/tatc/tradespace/__init__.py | 23 +- src/tatc/tradespace/cost.py | 461 +++++---------------- src/tatc/tradespace/deployment.py | 575 +++++++++++++++++++++++++++ tests/tradespace/test_cost.py | 192 +++------ tests/tradespace/test_deployment.py | 203 ++++++++++ 8 files changed, 1310 insertions(+), 599 deletions(-) create mode 100644 src/tatc/tradespace/deployment.py create mode 100644 tests/tradespace/test_deployment.py diff --git a/CHANGELOG.md b/CHANGELOG.md index bb591141..6e8b45a2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -20,7 +20,8 @@ Added: - Building blocks of constellations: fragments of design spaces of Walker constellations (`tradespace.walker_space`) and planes of sun-synchronous orbits (`sso_planes_space`, whose planes have different crossing times), `build_constellation`, which builds the satellites of either with instruments or entries of the instrument catalog (with their validated attitudes, and several entries on one satellite), and `count_satellites` and `count_planes`. The phase and node of the lead satellite of a Walker constellation (`phase_fraction` and `node_fraction`, design variables or uncertain parameters) are fractions of the intervals over which they give distinct constellations (`360 / per_plane` degrees of phase, and `360 / planes` degrees of node for a delta configuration or 360 for a star), so that a search does not evaluate the same constellation at several phases or nodes. Planes of inclined orbits (`planes_space`), each with its own inclination and node (uncertain by default, as of satellites launched as secondary payloads). The satellites of the planes of `sso_planes_space` and `planes_space` are evenly spaced, or follow each other in a train at an `interval` (minutes), on the same ground track or in the same plane (`repeat_ground_track`). The phase of each plane (`phase_fraction`, which replaces `phase` of `sso_planes_space`) is a fraction of the interval over which it gives distinct planes (`360 / satellites` degrees for evenly spaced satellites, 360 for a train), from which each fragment derives the plane's `true_anomaly`, as for the lead satellite of a Walker constellation. `build_constellation`, `count_satellites`, and `count_planes` take several layouts (a list, or a `Repeat` of a `Choice` of layouts), such as the shells of a mixed constellation. - Function `tradespace.screen` (and class `Screening`), which screens designs with studies of increasing fidelity, keeping whole fronts of the best designs of each stage for the next. - Searches of design spaces with optional optimizers: `tradespace.optimize_optuna` suggests designs with Optuna trials (`DesignSpace.suggest`, define-by-run over the hierarchical space), and `optimize_pymoo` and `make_pymoo_problem` search the unit hypercube that encodes a design space (`DesignSpace.unit_paths`, `encode`, and `decode`) with pymoo. Each design is evaluated once, and the designs proposed together are evaluated together, in parallel if the study is. Constraints of a design space may return the amount of their violation (`Infeasible.violation`), which Optuna's trials record (`set_constraint`) for its constraint-aware samplers, and which is the constraint value of pymoo problems. Optional dependencies `tradespace` (joblib, Optuna, and pymoo). - - Life-cycle costs of constellations for trade studies (`tradespace.CostModel`): the development of each type of satellite, the production of its units on a learning curve (`SatelliteCost`), launches (dedicated launches of each plane, up to a capacity in number or mass, or prices per satellite and kg, `LaunchCost`), operations (`OperationsCost`), replenishment at the end of a design life, and spares in orbit, from the layouts of a design (`plane_sizes`), with growth factors for cost risk (such as uncertain parameters, whose quantiles over replicates give the cost at a confidence level). An optional schedule (`CostSchedule`) dates the costs from rates, so that each design's schedule follows from its satellites and planes (development of each type of satellite, over its own duration if given, `SatelliteCost.development_years`; production on a line at a `production_rate`; launches as planes are ready, at most one every `launch_interval`; replacements at the end of their design life; and operations from launch to the end of the mission), for its deployments (`CostEstimate.deployments` and `deployed`), their present value at a discount rate (`CostEstimate.present_value`, metric `cost present`) and annual costs (`CostEstimate.annual`, metric `cost peak annual`). TAT-C does not include cost-estimating relationships: the costs are given by the study. Fingerprints describe dataclasses (such as cost models) by their fields. + - Deployment of constellations (`tradespace.DeploymentSchedule`): from the rates and durations of a study (the mission and design life, the development of each type of satellite, its production on a line at a production rate, and launches at a cadence and capacity, in number or mass, optionally in an order of planes), each design's deployment (`DeploymentSchedule.plan`, a `Deployment` of its `Production`, `Launch`es, and replacements), so that a design of more satellites and planes takes longer to deploy. Its launches divide the mission into phases of constant sets of operating satellites (`Deployment.phases`, optionally with failures until their replacement, `draw_failures`), evaluated over the study's representative period from the observations of the full constellation (`evaluate_phases`) and combined over the mission (`summarize_phases`: the time-weighted mean of each metric and the time until it first meets a requirement). + - Life-cycle costs of deployments for trade studies (`tradespace.CostModel`): the development of each type of satellite, the production of its units on a learning curve (`SatelliteCost`), launches (per launch, or prices per satellite and kg, `LaunchCost`), operations (`OperationsCost`), replacements, and spares in orbit, dated by the deployment for their present value at a discount rate (`CostEstimate.present_value`, metric `cost present`) and annual costs (`CostEstimate.annual`, metric `cost peak annual`), with growth factors for cost risk (such as uncertain parameters, whose quantiles over replicates give the cost at a confidence level). TAT-C does not include cost-estimating relationships: the costs are given by the study. Fingerprints describe dataclasses (such as cost models) by their fields. - Function `tradespace.confirm` (and class `Confirmation`), which evaluates selected designs (such as a front) with new replicates that played no part in their selection, removing the optimism of the selection (the winner's curse, `Confirmation.optimism`). `ResultStore` keys evaluations by the fingerprint of a study (`Study.fingerprint`, see `get_fingerprint`: its seed, use of common random numbers, design space, and build and evaluation functions, and the version of TAT-C), warning if it holds evaluations of other definitions, which are not reused; `SatelliteCache` keys results on disk by the fingerprint of its function. `refine` treats designs with fewer than `min_replicates` (5) as uncertain whatever their probability, adds the replicates left to `max_replicates` in a last partial step, and warns if designs remain uncertain without a tolerance. `sensitivity` gives adjusted shares (epsilon squared) by default, without the share that the levels of a variable explain by chance (`adjusted=False` for correlation ratios). - Searches with Optuna accept categorical options that depend on earlier decisions (a parameter for each set of options), use TPE with a constant liar in batches by default (which spreads the trials of a batch), and stop after `max_designs` designs evaluated (trials that suggest designs evaluated before are told their objectives without evaluating them again). A design infeasible in some of its replicates violates its feasibility by their share (`Evaluations.infeasibility`), and the first design evaluated in a search is evaluated alone, to check that evaluations give one record each. `Study` records errors of evaluations as infeasible, without storing them, with `errors="record"`. Enumeration walks the items of unordered repetitions in one order only (the same designs, in the same order, four times faster for three sun-synchronous planes), and `DesignSpace.size` counts designs without keeping them. Pareto fronts are found by a vectorized sweep in lexicographic order that compares designs only with the efficient designs before them, and fronts with tolerances by comparing designs only with the efficient designs without tolerances (which dominate every design that any design dominates within the tolerances), in blocks of bounded memory: 20,000 designs in 0.05 s (0.11 s with tolerances) rather than 17 s, and the bootstraps of `pareto_probability` (and so `refine`) about 20 times faster. - Example `SearchTradeSpace`, which searches a hierarchical trade space of constellations for the designs that sample points sufficiently: by evaluating every design, ranking them with the uncertainty of their replicates, screening, and searching with Optuna and pymoo. diff --git a/docs/api_reference/tradespace.rst b/docs/api_reference/tradespace.rst index 236da4ed..c3ed1e9a 100644 --- a/docs/api_reference/tradespace.rst +++ b/docs/api_reference/tradespace.rst @@ -69,6 +69,31 @@ Constellations .. autofunction:: tatc.tradespace.remove_failures +Deployment +---------- + +.. automodule:: tatc.tradespace.deployment + :no-members: + +.. autoclass:: tatc.tradespace.DeploymentSchedule + :members: plan, launches_of + +.. autoclass:: tatc.tradespace.Deployment + :members: phases, begin, end, deployed, units + +.. autoclass:: tatc.tradespace.Launch + +.. autoclass:: tatc.tradespace.Production + +.. autoclass:: tatc.tradespace.Phase + :members: duration + +.. autofunction:: tatc.tradespace.evaluate_phases + +.. autofunction:: tatc.tradespace.summarize_phases + +.. autofunction:: tatc.tradespace.draw_failures + Costs ----- @@ -76,21 +101,17 @@ Costs :no-members: .. autoclass:: tatc.tradespace.CostModel - :members: estimate, generations + :members: estimate, discount .. autoclass:: tatc.tradespace.SatelliteCost :members: production .. autoclass:: tatc.tradespace.LaunchCost - :members: launches .. autoclass:: tatc.tradespace.OperationsCost -.. autoclass:: tatc.tradespace.CostSchedule - :members: discount, producing - .. autoclass:: tatc.tradespace.CostEstimate - :members: total, present_value, deployed, annual, metrics + :members: total, present_value, annual, metrics .. autofunction:: tatc.tradespace.plane_sizes diff --git a/docs/examples/SearchTradeSpace.ipynb b/docs/examples/SearchTradeSpace.ipynb index 2f932ace..f45ce3ff 100644 --- a/docs/examples/SearchTradeSpace.ipynb +++ b/docs/examples/SearchTradeSpace.ipynb @@ -28,10 +28,10 @@ "id": "c3d2e5f4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:20:59.320749Z", - "iopub.status.busy": "2026-11-11T14:20:59.320573Z", - "iopub.status.idle": "2026-11-11T14:21:00.037474Z", - "shell.execute_reply": "2026-11-11T14:21:00.036501Z" + "iopub.execute_input": "2026-11-11T14:40:37.247741Z", + "iopub.status.busy": "2026-11-11T14:40:37.247465Z", + "iopub.status.idle": "2026-11-11T14:40:37.981230Z", + "shell.execute_reply": "2026-11-11T14:40:37.980406Z" } }, "outputs": [], @@ -79,10 +79,10 @@ "id": "e5f4a7b6", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:21:00.039434Z", - "iopub.status.busy": "2026-11-11T14:21:00.039143Z", - "iopub.status.idle": "2026-11-11T14:21:01.198568Z", - "shell.execute_reply": "2026-11-11T14:21:01.197773Z" + "iopub.execute_input": "2026-11-11T14:40:37.983212Z", + "iopub.status.busy": "2026-11-11T14:40:37.982872Z", + "iopub.status.idle": "2026-11-11T14:40:39.177541Z", + "shell.execute_reply": "2026-11-11T14:40:39.176735Z" } }, "outputs": [ @@ -134,7 +134,7 @@ "\n", "The evaluation computes both objectives: the share of points with at least four samples, and the share whose sampling error (`tatc.analysis.estimate_sampling_error`, for an exponential correlation in time with a decorrelation time of 3 hours) is at most half the field's standard deviation. A `ResultStore` keeps the records of the evaluations in a file, so that running the notebook again (or resuming it after an interruption) takes them from the file rather than evaluating them again.\n", "\n", - "`make_study` makes studies of other durations, numbers of replicates, and probabilities that satellites fail, as for screening and robustness (below). Each evaluation also estimates the life-cycle cost of the design (`CostModel`, used below), and reports the cost of its computation (`satellite_days`, the satellites times the days analyzed), which measures the computation independently of the cache." + "`make_study` makes studies of other durations, numbers of replicates, and probabilities that satellites fail, as for screening and robustness (below). Each evaluation also plans the deployment of the design (`DeploymentSchedule`) and estimates its life-cycle cost (`CostModel`, both used below), and reports the cost of its computation (`satellite_days`, the satellites times the days analyzed), which measures the computation independently of the cache." ] }, { @@ -143,10 +143,10 @@ "id": "a7b6c9d8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:21:01.200348Z", - "iopub.status.busy": "2026-11-11T14:21:01.199999Z", - "iopub.status.idle": "2026-11-11T14:21:01.208508Z", - "shell.execute_reply": "2026-11-11T14:21:01.207809Z" + "iopub.execute_input": "2026-11-11T14:40:39.179365Z", + "iopub.status.busy": "2026-11-11T14:40:39.178987Z", + "iopub.status.idle": "2026-11-11T14:40:39.187656Z", + "shell.execute_reply": "2026-11-11T14:40:39.186867Z" } }, "outputs": [], @@ -156,30 +156,34 @@ "from tatc.schemas import Instrument\n", "from tatc.tradespace import (\n", " CostModel,\n", - " CostSchedule,\n", + " DeploymentSchedule,\n", " LaunchCost,\n", " OperationsCost,\n", + " Requirement,\n", " ResultStore,\n", " SatelliteCache,\n", " SatelliteCost,\n", " Study,\n", " build_constellation,\n", " count_planes,\n", + " evaluate_phases,\n", " remove_failures,\n", + " summarize_phases,\n", ")\n", "\n", + "# the deployment of each design: 3 years of development, a production line of 4 satellites a year, launches of up to 3\n", + "# satellites at most every half year, and 5 years of operations from the first launch\n", + "SCHEDULE = DeploymentSchedule(years=5, development_years=3, production_rate=4, launch_interval=0.5, launch_capacity=3)\n", "# illustrative costs (millions of dollars), not estimates of any mission: satellites with an imager of each field of\n", - "# regard, a small launcher for every 3 satellites of a plane, and 5 years of operations, dated over 3 years of\n", - "# development, a production line of 4 satellites a year, and a launch at most every half year, discounted at 3% a year\n", + "# regard, small launchers, and operations, discounted at 3% a year\n", "COST_MODEL = CostModel(\n", " satellites={\n", " 30: SatelliteCost(development=40, first_unit=12, learning_rate=0.9, mass=60),\n", " 60: SatelliteCost(development=60, first_unit=18, learning_rate=0.9, mass=90),\n", " },\n", - " launch=LaunchCost(per_launch=8, capacity=3),\n", + " launch=LaunchCost(per_launch=8),\n", " operations=OperationsCost(per_year=3, per_satellite_year=0.5),\n", - " years=5,\n", - " schedule=CostSchedule(discount_rate=0.03, development_years=3, production_rate=4, launch_interval=0.5),\n", + " discount_rate=0.03,\n", ")\n", "\n", "CACHE_DIRECTORY = Path(tempfile.gettempdir()) / \"tatc-search-trade-space\"\n", @@ -198,11 +202,23 @@ " return caches[seed, duration]\n", "\n", "\n", - "def make_study(duration=DURATION, replicates=N_REPLICATES, failure_probability=0.0):\n", + "def make_study(duration=DURATION, replicates=N_REPLICATES, failure_probability=0.0, phased=False):\n", " \"\"\"A study of the shares (%) of points sampled sufficiently and accurately over a duration, by the satellites\n", - " of each design that do not fail.\"\"\"\n", + " of each design that do not fail, and (if phased) their means over the phases of the mission as the satellites are\n", + " deployed, and the time until half of the points are sampled sufficiently.\"\"\"\n", " threshold = SAMPLES_PER_DAY * duration / timedelta(days=1)\n", "\n", + " def sample(observations):\n", + " \"\"\"The shares (%) of points sampled sufficiently and accurately by observations.\"\"\"\n", + " if len(observations) == 0: # no satellites\n", + " return {\"sufficient\": 0.0, \"accurate\": 0.0}\n", + " samples = observations.groupby(\"target_hash\").size()\n", + " error = estimate_sampling_error(observations, START, START + duration, DECORRELATION_TIME)\n", + " return {\n", + " \"sufficient\": 100 * (samples >= threshold).sum() / N_POINTS,\n", + " \"accurate\": 100 * (error.relative_error <= MAX_RELATIVE_ERROR).sum() / N_POINTS,\n", + " }\n", + "\n", " def build(d):\n", " imager = Instrument(name=\"imager\", field_of_regard=d.field_of_regard)\n", " members = build_constellation(d.layout, imager, epoch=START, altitude=d.altitude)\n", @@ -210,20 +226,15 @@ "\n", " def evaluate(built):\n", " d, members, working = built\n", - " counts = {\"satellites\": len(members), \"planes\": count_planes(d.layout)}\n", - " cost = COST_MODEL.estimate(d.layout, kind=d.field_of_regard, growth={\"development\": d.cost_growth})\n", - " counts.update(cost.metrics())\n", - " if not working: # every satellite failed\n", - " return {**counts, \"sufficient\": 0.0, \"accurate\": 0.0, \"satellite_days\": 0.0}\n", - " observations = get_cache(d.points_seed, duration)(working)\n", - " samples = observations.groupby(\"target_hash\").size()\n", - " error = estimate_sampling_error(observations, START, START + duration, DECORRELATION_TIME)\n", - " return {\n", - " **counts,\n", - " \"sufficient\": 100 * (samples >= threshold).sum() / N_POINTS,\n", - " \"accurate\": 100 * (error.relative_error <= MAX_RELATIVE_ERROR).sum() / N_POINTS,\n", - " \"satellite_days\": len(working) * duration / timedelta(days=1),\n", - " }\n", + " deployment = SCHEDULE.plan(d.layout, kind=d.field_of_regard)\n", + " cost = COST_MODEL.estimate(deployment, growth={\"development\": d.cost_growth})\n", + " record = {\"satellites\": len(members), \"planes\": count_planes(d.layout), **cost.metrics()}\n", + " cache = get_cache(d.points_seed, duration)\n", + " record.update(sample(cache(working)), satellite_days=len(working) * duration / timedelta(days=1))\n", + " if phased:\n", + " capability = evaluate_phases(deployment.phases(members), cache(members), sample)\n", + " record.update(summarize_phases(capability, requirements=[Requirement(\"sufficient\", \">=\", 50)]))\n", + " return record\n", "\n", " store = ResultStore(\n", " CACHE_DIRECTORY / \"results.sqlite\",\n", @@ -253,10 +264,10 @@ "id": "c9d8e1f0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:21:01.210039Z", - "iopub.status.busy": "2026-11-11T14:21:01.209797Z", - "iopub.status.idle": "2026-11-11T14:21:11.899228Z", - "shell.execute_reply": "2026-11-11T14:21:11.898438Z" + "iopub.execute_input": "2026-11-11T14:40:39.189180Z", + "iopub.status.busy": "2026-11-11T14:40:39.188994Z", + "iopub.status.idle": "2026-11-11T14:40:50.039779Z", + "shell.execute_reply": "2026-11-11T14:40:50.039062Z" } }, "outputs": [ @@ -414,10 +425,10 @@ "id": "d0e9f2a1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:21:11.900833Z", - "iopub.status.busy": "2026-11-11T14:21:11.900607Z", - "iopub.status.idle": "2026-11-11T14:21:12.104949Z", - "shell.execute_reply": "2026-11-11T14:21:12.103935Z" + "iopub.execute_input": "2026-11-11T14:40:50.041516Z", + "iopub.status.busy": "2026-11-11T14:40:50.041270Z", + "iopub.status.idle": "2026-11-11T14:40:50.241650Z", + "shell.execute_reply": "2026-11-11T14:40:50.240880Z" } }, "outputs": [ @@ -498,10 +509,10 @@ "id": "a2b3c4d5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:21:12.106575Z", - "iopub.status.busy": "2026-11-11T14:21:12.106321Z", - "iopub.status.idle": "2026-11-11T14:21:12.175920Z", - "shell.execute_reply": "2026-11-11T14:21:12.174966Z" + "iopub.execute_input": "2026-11-11T14:40:50.243231Z", + "iopub.status.busy": "2026-11-11T14:40:50.242983Z", + "iopub.status.idle": "2026-11-11T14:40:50.313673Z", + "shell.execute_reply": "2026-11-11T14:40:50.312923Z" } }, "outputs": [ @@ -698,10 +709,10 @@ "id": "b3c4d5e6", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:21:12.177660Z", - "iopub.status.busy": "2026-11-11T14:21:12.177404Z", - "iopub.status.idle": "2026-11-11T14:21:12.317148Z", - "shell.execute_reply": "2026-11-11T14:21:12.316316Z" + "iopub.execute_input": "2026-11-11T14:40:50.315307Z", + "iopub.status.busy": "2026-11-11T14:40:50.315131Z", + "iopub.status.idle": "2026-11-11T14:40:50.556804Z", + "shell.execute_reply": "2026-11-11T14:40:50.555987Z" } }, "outputs": [ @@ -751,10 +762,10 @@ "id": "d5e6f7a8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:21:12.318895Z", - "iopub.status.busy": "2026-11-11T14:21:12.318662Z", - "iopub.status.idle": "2026-11-11T14:21:12.499119Z", - "shell.execute_reply": "2026-11-11T14:21:12.498438Z" + "iopub.execute_input": "2026-11-11T14:40:50.558487Z", + "iopub.status.busy": "2026-11-11T14:40:50.558229Z", + "iopub.status.idle": "2026-11-11T14:40:50.649275Z", + "shell.execute_reply": "2026-11-11T14:40:50.648496Z" } }, "outputs": [ @@ -901,10 +912,10 @@ "id": "a8b9c0d1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:21:12.500851Z", - "iopub.status.busy": "2026-11-11T14:21:12.500597Z", - "iopub.status.idle": "2026-11-11T14:21:12.527749Z", - "shell.execute_reply": "2026-11-11T14:21:12.527019Z" + "iopub.execute_input": "2026-11-11T14:40:50.651031Z", + "iopub.status.busy": "2026-11-11T14:40:50.650783Z", + "iopub.status.idle": "2026-11-11T14:40:50.677257Z", + "shell.execute_reply": "2026-11-11T14:40:50.676513Z" } }, "outputs": [ @@ -1052,10 +1063,10 @@ "id": "a3b2c5d4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:21:12.529556Z", - "iopub.status.busy": "2026-11-11T14:21:12.529357Z", - "iopub.status.idle": "2026-11-11T14:21:14.108496Z", - "shell.execute_reply": "2026-11-11T14:21:14.107637Z" + "iopub.execute_input": "2026-11-11T14:40:50.678797Z", + "iopub.status.busy": "2026-11-11T14:40:50.678555Z", + "iopub.status.idle": "2026-11-11T14:40:52.213681Z", + "shell.execute_reply": "2026-11-11T14:40:52.212973Z" } }, "outputs": [ @@ -1304,10 +1315,10 @@ "id": "b5d3f7a9", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:21:14.110249Z", - "iopub.status.busy": "2026-11-11T14:21:14.109987Z", - "iopub.status.idle": "2026-11-11T14:21:41.491363Z", - "shell.execute_reply": "2026-11-11T14:21:41.490574Z" + "iopub.execute_input": "2026-11-11T14:40:52.215400Z", + "iopub.status.busy": "2026-11-11T14:40:52.215142Z", + "iopub.status.idle": "2026-11-11T14:41:20.328047Z", + "shell.execute_reply": "2026-11-11T14:41:20.327170Z" } }, "outputs": [ @@ -1457,10 +1468,10 @@ "id": "c6e4a8b0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:21:41.492994Z", - "iopub.status.busy": "2026-11-11T14:21:41.492802Z", - "iopub.status.idle": "2026-11-11T14:21:41.556683Z", - "shell.execute_reply": "2026-11-11T14:21:41.555878Z" + "iopub.execute_input": "2026-11-11T14:41:20.329902Z", + "iopub.status.busy": "2026-11-11T14:41:20.329648Z", + "iopub.status.idle": "2026-11-11T14:41:20.403075Z", + "shell.execute_reply": "2026-11-11T14:41:20.402124Z" } }, "outputs": [ @@ -2010,10 +2021,10 @@ "id": "f2a3b4c5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:21:41.558273Z", - "iopub.status.busy": "2026-11-11T14:21:41.558048Z", - "iopub.status.idle": "2026-11-11T14:21:42.470012Z", - "shell.execute_reply": "2026-11-11T14:21:42.469220Z" + "iopub.execute_input": "2026-11-11T14:41:20.405311Z", + "iopub.status.busy": "2026-11-11T14:41:20.405038Z", + "iopub.status.idle": "2026-11-11T14:41:21.427264Z", + "shell.execute_reply": "2026-11-11T14:41:21.426246Z" } }, "outputs": [ @@ -2515,10 +2526,10 @@ "id": "f9b7d1e3", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:21:42.471527Z", - "iopub.status.busy": "2026-11-11T14:21:42.471293Z", - "iopub.status.idle": "2026-11-11T14:21:43.834209Z", - "shell.execute_reply": "2026-11-11T14:21:43.833462Z" + "iopub.execute_input": "2026-11-11T14:41:21.429218Z", + "iopub.status.busy": "2026-11-11T14:41:21.428939Z", + "iopub.status.idle": "2026-11-11T14:41:22.945886Z", + "shell.execute_reply": "2026-11-11T14:41:22.945059Z" } }, "outputs": [ @@ -2748,10 +2759,10 @@ "id": "d1e2f3a4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:21:43.835835Z", - "iopub.status.busy": "2026-11-11T14:21:43.835590Z", - "iopub.status.idle": "2026-11-11T14:21:44.634525Z", - "shell.execute_reply": "2026-11-11T14:21:44.633716Z" + "iopub.execute_input": "2026-11-11T14:41:22.948393Z", + "iopub.status.busy": "2026-11-11T14:41:22.948166Z", + "iopub.status.idle": "2026-11-11T14:41:23.867042Z", + "shell.execute_reply": "2026-11-11T14:41:23.866131Z" } }, "outputs": [ @@ -2956,7 +2967,7 @@ "source": [ "## Trade Cost Against Sufficiency\n", "\n", - "The numbers of satellites and planes are proxies of cost. A `CostModel` estimates the life-cycle cost of each design from the costs of its satellites (the development of each type, and the production of its units on a learning curve), launches (here, a small launcher for every three satellites of a plane), and operations, given by the study (TAT-C does not include cost-estimating relationships). The costs here are illustrative, in millions of dollars. The evaluation adds the cost and its elements to each record, for the satellites of each design's imager (`kind`): a wider field of regard costs more to develop and build. A schedule (`CostSchedule`) dates the costs from rates, so that each design's schedule follows from its satellites and planes: development over three years, then the production of the satellites on one line at four a year, plane by plane, each plane launched when its satellites are ready (at most one launch every half year), and operations from each launch to the end of the mission (five years after the first launch). The dated costs give the present value of the cost (`cost present`, discounted at 3% a year) and the cost of the most expensive year (`cost peak annual`), for annual budgets.\n", + "The numbers of satellites and planes are proxies of cost. A `CostModel` estimates the life-cycle cost of each design from the costs of its satellites (the development of each type, and the production of its units on a learning curve), launches (here, a small launcher for every three satellites of a plane), and operations, given by the study (TAT-C does not include cost-estimating relationships). The costs here are illustrative, in millions of dollars. The evaluation adds the cost and its elements to each record, for the satellites of each design's imager (`kind`): a wider field of regard costs more to develop and build. The deployment of each design (`DeploymentSchedule.plan`) dates the costs, from rates, so that each design's schedule follows from its satellites and planes: development over three years, then the production of the satellites on one line at four a year, plane by plane, each plane launched when its satellites are ready (in launches of up to three satellites, at most one every half year), and operations from each launch to the end of the mission (five years after the first launch). The dated costs give the present value of the cost (`cost present`, discounted at 3% a year) and the cost of the most expensive year (`cost peak annual`), for annual budgets.\n", "\n", "The growth of the cost of development is uncertain (an `Uncertain` parameter, from 0.9 to 1.6 times the estimate, most likely 1), drawn for each replicate, so that statistics over the replicates give the cost at a confidence level: here, the 0.7 quantile (`cost p70`), as budgets are often set. A requirement keeps the designs whose cost at 70% confidence is within a budget, and the front trades this cost against the share of points sufficiently sampled. (Cost depends only on the design, so a constraint of the design space could exclude designs over a budget before they are evaluated, with the cost without growth.)" ] @@ -2967,10 +2978,10 @@ "id": "c2d3e4f5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:21:44.636162Z", - "iopub.status.busy": "2026-11-11T14:21:44.635918Z", - "iopub.status.idle": "2026-11-11T14:21:46.344648Z", - "shell.execute_reply": "2026-11-11T14:21:46.343920Z" + "iopub.execute_input": "2026-11-11T14:41:23.869193Z", + "iopub.status.busy": "2026-11-11T14:41:23.868963Z", + "iopub.status.idle": "2026-11-11T14:41:25.541556Z", + "shell.execute_reply": "2026-11-11T14:41:25.540782Z" } }, "outputs": [ @@ -3237,7 +3248,7 @@ "costed[\"description\"] = [describe(values.loc[key]) for key in costed.design]\n", "# the years from the start of development to the launch of every plane, from each design's schedule\n", "costed[\"deployed\"] = [\n", - " COST_MODEL.estimate(by_key[key].layout, kind=by_key[key].field_of_regard).deployed for key in costed.design\n", + " SCHEDULE.plan(by_key[key].layout, kind=by_key[key].field_of_regard).deployed for key in costed.design\n", "]\n", "efficient = costed[costed.pareto_probability >= 0.5]\n", "print(\n", @@ -3262,6 +3273,199 @@ "The growth of the cost of development affects every design alike in a replicate (common random numbers), so it shifts the costs at 70% confidence more for designs whose development costs more, here those of the wider imager. With five replicates of most designs, the 0.7 quantile of their costs is a coarse estimate: an evaluation that costs little more than the cost model (unlike the analysis of sampling) could draw more replicates of the cost alone." ] }, + { + "cell_type": "markdown", + "id": "e4f5a6b7", + "metadata": {}, + "source": [ + "## Account for Deployment\n", + "\n", + "The shares of points sampled so far are those of each design's full constellation, as if its satellites flew for the whole mission. They are launched over months to years, during which fewer satellites sample the points. The launches of each design's deployment divide its mission into phases, in each of which a set of its satellites flies (`Deployment.phases`); each phase is evaluated over the same representative day with the observations of its satellites (`evaluate_phases`, which filters the observations of the full constellation, from the cache), and the phases are combined over the mission (`summarize_phases`): the mean of each share weighted by the duration of the phases, over the five years from the first launch (`sufficient mean`), and the time from the start of development until half of the points are sampled sufficiently (`sufficient time`, infinite if never).\n", + "\n", + "The phased study evaluates the efficient designs of the first front (the most sufficient of each number of satellites and planes)." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "f5a6b7c8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-11T14:41:25.543200Z", + "iopub.status.busy": "2026-11-11T14:41:25.542944Z", + "iopub.status.idle": "2026-11-11T14:41:25.745945Z", + "shell.execute_reply": "2026-11-11T14:41:25.745240Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanesdeployedsufficientsufficient meanlostsufficient time
design
bc0fd0c644ee800 km, 60 deg FOR, SSO: 1 at 09:001.01.03.24.24.20.0inf
f7413b1f8466800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...2.01.03.513.813.80.0inf
33b006848799800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.03.828.625.82.8inf
d5d3fa915ca7800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...3.01.03.837.037.00.0inf
1af5f2707be3800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.04.566.461.45.04.5
400cf2b03fa8800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.04.598.087.011.04.5
\n", + "
" + ], + "text/plain": [ + " description satellites \\\n", + "design \n", + "bc0fd0c644ee 800 km, 60 deg FOR, SSO: 1 at 09:00 1.0 \n", + "f7413b1f8466 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 \n", + "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 \n", + "d5d3fa915ca7 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 \n", + "1af5f2707be3 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 \n", + "400cf2b03fa8 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 \n", + "\n", + " planes deployed sufficient sufficient mean lost \\\n", + "design \n", + "bc0fd0c644ee 1.0 3.2 4.2 4.2 0.0 \n", + "f7413b1f8466 1.0 3.5 13.8 13.8 0.0 \n", + "33b006848799 2.0 3.8 28.6 25.8 2.8 \n", + "d5d3fa915ca7 1.0 3.8 37.0 37.0 0.0 \n", + "1af5f2707be3 1.0 4.5 66.4 61.4 5.0 \n", + "400cf2b03fa8 2.0 4.5 98.0 87.0 11.0 \n", + "\n", + " sufficient time \n", + "design \n", + "bc0fd0c644ee inf \n", + "f7413b1f8466 inf \n", + "33b006848799 inf \n", + "d5d3fa915ca7 inf \n", + "1af5f2707be3 4.5 \n", + "400cf2b03fa8 4.5 " + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "PHASED = [\"sufficient\", \"sufficient mean\", \"sufficient time\"]\n", + "leaders = front.sort_values(\"sufficient\", ascending=False).drop_duplicates([\"satellites\", \"planes\"])\n", + "phased = make_study(phased=True).run([by_key[key] for key in leaders.design])\n", + "deployed = aggregate(phased, PHASED).set_index(\"design\")[PHASED]\n", + "leaders = leaders.set_index(\"design\")[[\"description\", \"satellites\", \"planes\"]].join(deployed)\n", + "leaders[\"deployed\"] = [SCHEDULE.plan(by_key[key].layout, kind=by_key[key].field_of_regard).deployed for key in leaders.index]\n", + "leaders[\"lost\"] = leaders[\"sufficient\"] - leaders[\"sufficient mean\"]\n", + "leaders.sort_values([\"satellites\", \"planes\"])[\n", + " [\"description\", \"satellites\", \"planes\", \"deployed\", \"sufficient\", \"sufficient mean\", \"lost\", \"sufficient time\"]\n", + "].round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "a6b7c8d9", + "metadata": {}, + "source": [ + "Deployment costs the designs of several planes or launches. Six satellites in two planes sample 98% of the points once deployed, but 87% on average over the mission, as the first plane flies alone for three quarters of a year while the second is produced, and they sample half of the points only 4.5 years after development starts, when the second plane is launched. Four satellites in one plane need two launches (of up to three satellites) half a year apart, and lose 5 points of their 66%; two satellites in two planes lose 3 points of their 29%. The designs launched at once lose nothing. Over a five-year mission, the loss is the share of the mission before full deployment times the shortfall of the partial constellation: a shorter mission, slower production, or fewer launches a year would weigh deployment more, and could reorder the front." + ] + }, { "cell_type": "markdown", "id": "c5d4e7f6", @@ -3276,14 +3480,14 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "id": "d6e5f8a7", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:21:46.346336Z", - "iopub.status.busy": "2026-11-11T14:21:46.346103Z", - "iopub.status.idle": "2026-11-11T14:21:48.775764Z", - "shell.execute_reply": "2026-11-11T14:21:48.775036Z" + "iopub.execute_input": "2026-11-11T14:41:25.747449Z", + "iopub.status.busy": "2026-11-11T14:41:25.747230Z", + "iopub.status.idle": "2026-11-11T14:41:28.420131Z", + "shell.execute_reply": "2026-11-11T14:41:28.419393Z" } }, "outputs": [ @@ -3382,7 +3586,7 @@ "3 24.8 " ] }, - "execution_count": 17, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -3439,14 +3643,14 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "id": "a9b8c1d0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:21:48.777426Z", - "iopub.status.busy": "2026-11-11T14:21:48.777179Z", - "iopub.status.idle": "2026-11-11T14:21:49.981232Z", - "shell.execute_reply": "2026-11-11T14:21:49.980627Z" + "iopub.execute_input": "2026-11-11T14:41:28.421864Z", + "iopub.status.busy": "2026-11-11T14:41:28.421666Z", + "iopub.status.idle": "2026-11-11T14:41:29.909474Z", + "shell.execute_reply": "2026-11-11T14:41:29.908607Z" } }, "outputs": [ @@ -3502,7 +3706,7 @@ "Latin hypercube sample 176.0 80.3" ] }, - "execution_count": 18, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -3553,14 +3757,14 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "id": "b0c9d2e1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:21:49.983152Z", - "iopub.status.busy": "2026-11-11T14:21:49.982934Z", - "iopub.status.idle": "2026-11-11T14:21:50.110916Z", - "shell.execute_reply": "2026-11-11T14:21:50.110192Z" + "iopub.execute_input": "2026-11-11T14:41:29.912401Z", + "iopub.status.busy": "2026-11-11T14:41:29.911914Z", + "iopub.status.idle": "2026-11-11T14:41:30.069650Z", + "shell.execute_reply": "2026-11-11T14:41:30.068286Z" } }, "outputs": [ @@ -3614,7 +3818,8 @@ "* The front of the means of the replicates is uncertain: `pareto_probability` finds the designs whose efficiency the replicates settle, and those that are equally good candidates, and `refine` adds replicates only to the latter, with a tolerance of differences that do not matter. `confirm` evaluates the selected designs with new replicates, which removes the optimism of selecting the best of many nearly equal designs.\n", "* Statistics other than means (such as a `Quantile` or the `Probability` of meeting a threshold) state how reliably a design performs, including with failures of satellites (`remove_failures`), and `Requirement`s on them are output constraints. `sensitivity` finds the design variables that drive each objective.\n", "* `screen` evaluates every design with a cheap study and the best with the full one, which finds the front at a fraction of the cost if the cheap study ranks designs as the full one does.\n", - "* A `CostModel` estimates the life-cycle cost of each design from the costs of its satellites, launches, and operations (given by the study), with uncertain growth whose quantiles give the cost at a confidence level, as an objective or a requirement in place of the numbers of satellites and planes.\n", + "* A `DeploymentSchedule` plans each design's deployment from rates of production and launch, which dates its costs and divides its mission into phases of the satellites that fly, evaluated with the observations of the full constellation for the mean capability over the mission and the time until a requirement is met.\n", + "* A `CostModel` estimates the life-cycle cost of each deployment from the costs of its satellites, launches, and operations (given by the study), with uncertain growth whose quantiles give the cost at a confidence level, as an objective or a requirement in place of the numbers of satellites and planes.\n", "* `optimize_optuna` and `optimize_pymoo` search spaces too large to enumerate, and find most of the front with a fraction of the designs.\n", "\n", "The sampling error here is that of a model of the field (an exponential correlation in time with a decorrelation time of 3 hours); with a simulation of the field (a nature run), `tatc.analysis.sample_field` and `compare_sampled_means` measure it directly. The costs are illustrative, and the numbers of satellites and planes, proxies of cost in the other sections. The uncertainties are those of the sample of points and the failures of satellites; others (such as the phase of the satellites or the period of the analysis) are further `Uncertain` parameters of the design space." diff --git a/src/tatc/tradespace/__init__.py b/src/tatc/tradespace/__init__.py index fff3401b..5ff28638 100644 --- a/src/tatc/tradespace/__init__.py +++ b/src/tatc/tradespace/__init__.py @@ -1,6 +1,7 @@ """ Trade space analysis: design spaces of (hierarchical) design variables and -uncertain parameters, building blocks of constellations (and their life-cycle cost), +uncertain parameters, building blocks of constellations (their deployment and life-cycle cost, +and capability over the phases of deployment), trade studies that evaluate their designs (with caches of analyses by satellite, in parallel), statistics of replicates and requirements on them, Pareto efficiency (with the uncertainty of replicates), @@ -17,7 +18,6 @@ from .cost import ( CostEstimate, CostModel, - CostSchedule, LaunchCost, OperationsCost, SatelliteCost, @@ -33,6 +33,16 @@ sso_planes_space, walker_space, ) +from .deployment import ( + Deployment, + DeploymentSchedule, + Launch, + Phase, + Production, + draw_failures, + evaluate_phases, + summarize_phases, +) from .criteria import ( Maximum, Mean, @@ -79,7 +89,8 @@ "Confirmation", "CostEstimate", "CostModel", - "CostSchedule", + "Deployment", + "DeploymentSchedule", "Derived", "Design", "DesignSpace", @@ -87,12 +98,15 @@ "Fixed", "Infeasible", "Integer", + "Launch", "LaunchCost", "Maximum", "Mean", "Minimum", "OperationsCost", + "Phase", "Probability", + "Production", "Quantile", "Real", "Refinement", @@ -115,6 +129,8 @@ "confirm", "count_planes", "count_satellites", + "draw_failures", + "evaluate_phases", "get_fingerprint", "get_satellite_key", "hours_to_time", @@ -134,5 +150,6 @@ "sensitivity", "sso_planes_space", "summarize", + "summarize_phases", "walker_space", ] diff --git a/src/tatc/tradespace/cost.py b/src/tatc/tradespace/cost.py index e3db6d24..f37844a2 100644 --- a/src/tatc/tradespace/cost.py +++ b/src/tatc/tradespace/cost.py @@ -1,8 +1,8 @@ """ Life-cycle cost of constellations for trade studies: the development, -production, launch, and operations of the satellites of their layouts (see -`walker_space`, `sso_planes_space`, and `planes_space`), with learning in -production, replenishment over the mission, and spares. +production, launch, and operations of the satellites of a deployment (see +`DeploymentSchedule`), with learning in production, replacements over the +mission, and spares, dated for their present value and annual costs. TAT-C does not include cost-estimating relationships, whose common forms are restricted or need calibration to an organization's experience: the costs of @@ -14,21 +14,18 @@ parameters, so that statistics of the cost over replicates (such as a 0.7 `Quantile`) are objectives or requirements. -An optional schedule (`CostSchedule`) dates the costs from rates, so that -each design's schedule follows from its satellites and planes: development -of each type of satellite, the production of its satellites on a line at a -production rate, launches at a cadence as satellites are ready, replacements -at the end of their design life, and operations from launch to the end of -the mission. The dated costs give the present value of the cost at a -discount rate, and the cost of each year (such as its peak, for annual -budgets). A schedule that is itself a decision (such as the launch cadence) -is a design variable, with the model built for each design:: +A deployment dates the costs: development of each type of satellite, +production of its satellites, launches, replacements, and operations from +launch to the end of the mission, so that each design's costs follow from +its satellites and planes. The dated costs give the present value of the +cost at a discount rate, and the cost of each year (such as its peak, for +annual budgets):: def evaluate(built): d, satellites = built - schedule = dataclasses.replace(SCHEDULE, launch_interval=d.launch_interval) - model = dataclasses.replace(MODEL, schedule=schedule) - return model.estimate(d.layout).metrics() + deployment = SCHEDULE.plan(d.layout, kind=d.payload) + cost = MODEL.estimate(deployment, growth={"development": d.growth}) + return cost.metrics() @author: Paul T. Grogan """ @@ -44,7 +41,7 @@ def evaluate(built): import pandas as pd from .constellations import PLANES, SSO_PLANES, WALKER, _kind, _layout, _layouts -from .values import Values +from .deployment import Deployment ELEMENTS = ("development", "production", "launch", "operations") """The elements of the cost of a constellation.""" @@ -89,23 +86,18 @@ class SatelliteCost: first_unit (float): The recurring cost of the first unit. learning_rate (float): The learning rate, in (0, 1]. mass (float | None): The mass (kg), for launches priced by mass. - development_years (float | None): The duration of its development, - with a schedule (see `CostSchedule`), if not the schedule's. """ development: float = 0.0 first_unit: float = 0.0 learning_rate: float = 1.0 mass: float | None = None - development_years: float | None = None def __post_init__(self): if not 0 < self.learning_rate <= 1: raise ValueError("learning_rate must be in (0, 1]") if self.development < 0 or self.first_unit < 0: raise ValueError("costs must not be negative") - if self.development_years is not None and self.development_years < 0: - raise ValueError("development_years must not be negative") def production(self, units: int) -> float: """ @@ -127,53 +119,21 @@ def production(self, units: int) -> float: @dataclass(frozen=True) class LaunchCost: """ - The cost of launching satellites: dedicated launches of each plane (as - many as it takes to carry its satellites, given a `capacity` in number - or mass), and prices per satellite and per kg (as of rideshares). Give - the fields of the launch service of a study and leave the others zero. + The cost of launches: of each launch of a deployment (dedicated + launches, see `DeploymentSchedule` for their capacity), and prices per + satellite and per kg (as of rideshares). Give the fields of the launch + service of a study and leave the others zero. Args: - per_launch (float): The cost of a dedicated launch. - capacity (int | None): The most satellites of a dedicated launch, if - limited. - mass_capacity (float | None): The most mass (kg) of a dedicated - launch, if limited. + per_launch (float): The cost of a launch. per_satellite (float): The cost of launching each satellite. per_kg (float): The cost of launching each kg of satellite. """ per_launch: float = 0.0 - capacity: int | None = None - mass_capacity: float | None = None per_satellite: float = 0.0 per_kg: float = 0.0 - def launches(self, satellites: int, mass: float | None) -> int: - """ - Gets the dedicated launches of a plane of satellites (0 without a - cost per launch). - - Args: - satellites (int): The number of satellites of the plane. - mass (float | None): The mass (kg) of each satellite. - - Returns: - int: the number of launches - """ - if self.per_launch == 0 or satellites <= 0: - return 0 - count = 1 - if self.capacity is not None: - count = max(count, math.ceil(satellites / self.capacity)) - if self.mass_capacity is not None: - if mass is None: - raise ValueError("a launch capacity in mass requires masses") - per_launch = math.floor(self.mass_capacity / mass) - if per_launch < 1: - raise ValueError("a satellite exceeds the mass capacity of a launch") - count = max(count, math.ceil(satellites / per_launch)) - return count - @dataclass(frozen=True) class OperationsCost: @@ -190,89 +150,6 @@ class OperationsCost: per_satellite_year: float = 0.0 -@dataclass(frozen=True) -class CostSchedule: - """ - A schedule of the costs of a constellation, from rates, and the discount - rate of their present value. - - Times are in years from the start of development, which begins `start` - years after the present (the date of present values). The schedule of a - design follows from its satellites and planes: - - * Each type of satellite is developed over `development_years` (or its - own, see `SatelliteCost`), its cost spread evenly. - * Its satellites are then produced on one line, in the order of the - planes, at `production_rate` satellites a year (or at once, if - `None`), each plane's paid for evenly while they are produced. - * Planes are launched in the order they are ready, at most one launch - every `launch_interval` years: a plane of several dedicated launches - (see `LaunchCost`) takes several, and its satellites are spread over - them. A launch is paid for when it flies. - * The mission lasts `years` (see `CostModel`) from the first launch. - Each satellite is replaced at the end of its design life (if before - the end of the mission), its replacement produced at the production - rate just before it is needed and launched then. - * Operations cost a fixed amount in each year of the mission, and each - satellite from its launch to the end of the mission. - - Costs spread over a period are dated at the middle of each of its - years. A cost at time `t` has a present value of `cost / (1 + - discount_rate) ** (start + t)`. - - Args: - discount_rate (float): The annual discount rate (such as 0.03). - development_years (float): The duration of development, before - production. - production_rate (float | None): The satellites of each type produced - a year, or `None` for production that takes no time. - launch_interval (float): The least time (years) between launches. - start (float): The years from the present to the start of - development. - """ - - discount_rate: float = 0.0 - development_years: float = 3.0 - production_rate: float | None = None - launch_interval: float = 0.0 - start: float = 0.0 - - def __post_init__(self): - if self.discount_rate <= -1: - raise ValueError("discount_rate must be greater than -1") - for name in ("development_years", "launch_interval"): - if getattr(self, name) < 0: - raise ValueError(f"{name} must not be negative") - if self.production_rate is not None and self.production_rate <= 0: - raise ValueError("production_rate must be positive") - - def producing(self, satellites: int) -> float: - """ - Gets the time to produce satellites on one line. - - Args: - satellites (int): The number of satellites. - - Returns: - float: the time (years) - """ - return ( - 0.0 if self.production_rate is None else satellites / self.production_rate - ) - - def discount(self, time: float) -> float: - """ - Gets the factor of the present value of a cost at a time. - - Args: - time (float): The time (years from the start of development). - - Returns: - float: the factor - """ - return float((1 + self.discount_rate) ** -(self.start + time)) - - def _spread(amount: float, begin: float, end: float) -> list[tuple[float, float]]: """ Spreads an amount evenly from `begin` to `end` (years), dated at the @@ -308,22 +185,12 @@ class CostEstimate: """dict: The units built of each type of satellite (including replacements and spares).""" launches: int = 0 - """int: The dedicated launches.""" + """int: The launches priced per launch.""" flows: list[tuple[float, str, float]] = field(default_factory=list) - """list: The dated costs, with a schedule (see `CostSchedule`): the time - (years from the start of development), element, and amount of each.""" - present: dict[str, float] | None = None - """dict | None: The present value of each element, with a schedule.""" - deployments: list[tuple[float, int]] = field(default_factory=list) - """list: The launches of the first satellites of the planes, with a - schedule: the time (years from the start of development) and number of - satellites of each.""" - - @property - def deployed(self) -> float | None: - """float | None: The time (years from the start of development) by - which every plane is deployed, with a schedule.""" - return max((time for time, _ in self.deployments), default=None) + """list: The dated costs: the time (years from the start of + development), element, and amount of each.""" + present: dict[str, float] = field(default_factory=dict) + """dict: The present value of each element.""" @property def total(self) -> float: @@ -331,23 +198,22 @@ def total(self) -> float: return self.development + self.production + self.launch + self.operations @property - def present_value(self) -> float | None: - """float | None: The present value of the total cost, with a - schedule.""" - return None if self.present is None else sum(self.present.values()) + def present_value(self) -> float: + """float: The present value of the total cost.""" + return float(sum(self.present.values())) def annual(self) -> pd.DataFrame: """ Gets the cost of each year (from the start of development), by - element and in total, with a schedule. + element and in total. Returns: pandas.DataFrame: a row per year, a column per element, and the `total` """ - if not self.flows: - raise ValueError("annual costs require a schedule (see CostSchedule)") frame = pd.DataFrame(self.flows, columns=["time", "element", "amount"]) + if len(frame) == 0: + return pd.DataFrame(columns=[*ELEMENTS, "total"]) frame["year"] = np.floor(frame["time"]).astype(int) table = frame.pivot_table( index="year", columns="element", values="amount", aggfunc="sum" @@ -361,25 +227,26 @@ def annual(self) -> pd.DataFrame: def metrics(self, prefix: str = "cost") -> dict[str, float]: """ Gets the cost as metrics of an evaluation (see `Study`): the total - (``) and each element (` development`, ` - production`, ` launch`, and ` operations`), and, with - a schedule, the present value of the total (` present`) and - the cost of its most expensive year (` peak annual`). + (``), each element (` development`, ` + production`, ` launch`, and ` operations`), the + present value of the total (` present`), and the cost of its + most expensive year (` peak annual`). Args: - prefix (str): The name of the total, and prefix of the elements. + prefix (str): The name of the total, and prefix of the others. Returns: dict[str, float]: the metrics """ - metrics = { + annual = self.annual() + return { prefix: self.total, **{f"{prefix} {element}": getattr(self, element) for element in ELEMENTS}, + f"{prefix} present": self.present_value, + f"{prefix} peak annual": ( + float(annual["total"].max()) if len(annual) > 0 else 0.0 + ), } - if self.present is not None: - metrics[f"{prefix} present"] = self.present_value - metrics[f"{prefix} peak annual"] = float(self.annual()["total"].max()) - return metrics Growth = float | Mapping[str, float] @@ -391,46 +258,47 @@ def metrics(self, prefix: str = "cost") -> dict[str, float]: class CostModel: """ A model of the life-cycle cost of constellations: the costs of their - types of satellites, launches, and operations over a mission of `years`. + types of satellites, launches, and operations, applied to their + deployments (see `DeploymentSchedule`), and the discount rate of their + present value. - Satellites are replaced at the end of their `design_life`: a mission of - 6 years with satellites of a design life of 3 years builds and launches - two generations of each satellite, whose units continue the learning - curve of the first. + A cost at time `t` (years from the start of development, which begins + `start` years after the present) has a present value of `cost / (1 + + discount_rate) ** (start + t)`. Args: satellites (SatelliteCost | Mapping[str, SatelliteCost]): The cost of the satellites, or of each type of satellite (by name). launch (LaunchCost): The cost of launches. operations (OperationsCost): The cost of operations. - years (float): The duration of the mission. - design_life (float | None): The design life of the satellites, or - `None` if they last the mission. - schedule (CostSchedule | None): The schedule of the costs (for their - present value and annual costs), if any. + discount_rate (float): The annual discount rate (such as 0.03). + start (float): The years from the present to the start of + development. """ satellites: SatelliteCost | Mapping[str, SatelliteCost] launch: LaunchCost = LaunchCost() operations: OperationsCost = OperationsCost() - years: float = 1.0 - design_life: float | None = None - schedule: CostSchedule | None = None + discount_rate: float = 0.0 + start: float = 0.0 def __post_init__(self): - if self.years <= 0: - raise ValueError("years must be positive") - if self.design_life is not None and self.design_life <= 0: - raise ValueError("design_life must be positive") + if self.discount_rate <= -1: + raise ValueError("discount_rate must be greater than -1") - @property - def generations(self) -> int: - """int: The generations of satellites built over the mission.""" - if self.design_life is None: - return 1 - return max(1, math.ceil(self.years / self.design_life - 1e-9)) + def discount(self, time: float) -> float: + """ + Gets the factor of the present value of a cost at a time. + + Args: + time (float): The time (years from the start of development). + + Returns: + float: the factor + """ + return float((1 + self.discount_rate) ** -(self.start + time)) - def _get_type(self, kind: str | None) -> SatelliteCost: + def _get_type(self, kind: Any) -> SatelliteCost: if isinstance(self.satellites, SatelliteCost): return self.satellites if kind is None: @@ -439,30 +307,14 @@ def _get_type(self, kind: str | None) -> SatelliteCost: raise ValueError(f"no cost of satellites of kind {kind!r}") return self.satellites[kind] - def estimate( - self, - layout: Any, - kind: str | None = None, - spares: int = 0, - growth: Growth = 1.0, - ) -> CostEstimate: + def estimate(self, deployment: Deployment, growth: Growth = 1.0) -> CostEstimate: """ - Estimates the life-cycle cost of a constellation: the layout (or - layouts) of its satellites (see `plane_sizes`), of one type (`kind`, - if the model has several), or a mapping of types to layouts (such as - the shells of a mixed constellation, each of its own payload). - - Each plane has `spares` more satellites (spares in orbit, built, - launched, and operated with it). Each type of satellite is developed - once; its units (of every generation) follow its learning curve; - each plane is launched (by dedicated launches, or per satellite or - kg) in each generation; and every satellite is operated for the - mission. - - With a schedule (see `CostSchedule`), the estimate dates its costs, - and gives their present value, annual costs, and deployments: - satellites launched after the first are operated, and may be - replaced, for less of the mission, which lowers their costs. + Estimates the life-cycle cost of a deployment, dating its costs: + the development of each type of satellite, spread over its + development; the production of its units along its learning curve, + spread over their production; each launch (and replacement), when it + flies; a fixed cost of operations over the mission; and each + satellite's operations from its launch to the end of the mission. Growth factors multiply the estimate, such as uncertain parameters of cost growth drawn for each replicate (for example, @@ -473,11 +325,8 @@ def estimate( (`NaN`). Args: - layout (Any): The layout (or layouts) of the satellites, or a - mapping of types of satellites to layouts. - kind (str | None): The type of the satellites of a layout, if the - model has several types. - spares (int): The spares in orbit in each plane. + deployment (Deployment): The deployment (see + `DeploymentSchedule.plan`). growth (float | Mapping[str, float]): A growth factor of the cost, or of each element (`"development"`, `"production"`, `"launch"`, or `"operations"`; others 1). @@ -485,53 +334,7 @@ def estimate( Returns: CostEstimate: the estimate """ - if spares < 0: - raise ValueError("spares must not be negative") - # a mapping of types to layouts (the values of a layout are a mapping too) - if isinstance(layout, Mapping) and not isinstance(layout, Values): - fleets = {name: plane_sizes(item) for name, item in layout.items()} - else: - fleets = {kind: plane_sizes(layout)} - if self.schedule is not None: - return self._estimate_scheduled(fleets, spares, _get_growth(growth)) - estimate = CostEstimate() - operated = 0 - for name, sizes in fleets.items(): - cost = self._get_type(name) - sizes = [size + spares for size in sizes if size > 0] - if not sizes: - continue - units = self.generations * sum(sizes) - estimate.units["satellites" if name is None else str(name)] = units - estimate.development += cost.development - estimate.production += cost.production(units) - launches = self.generations * sum( - self.launch.launches(size, cost.mass) for size in sizes - ) - estimate.launches += launches - if self.launch.per_kg > 0 and cost.mass is None: - raise ValueError("launches priced by mass require masses") - estimate.launch += launches * self.launch.per_launch + units * ( - self.launch.per_satellite + self.launch.per_kg * (cost.mass or 0.0) - ) - operated += sum(sizes) - estimate.operations = self.years * ( - self.operations.per_year + self.operations.per_satellite_year * operated - ) factors = _get_growth(growth) - for element in ELEMENTS: - setattr(estimate, element, getattr(estimate, element) * factors[element]) - return estimate - - def _estimate_scheduled( - self, fleets: dict, spares: int, factors: dict[str, float] - ) -> CostEstimate: - """ - Estimates the dated costs of the planes of each type of satellite - (see `estimate` and `CostSchedule`). - """ - # pylint: disable=too-many-locals - schedule = self.schedule estimate = CostEstimate() flows: list[tuple[float, str, float]] = [] @@ -541,90 +344,46 @@ def add(element: str, amounts: list[tuple[float, float]]) -> None: ) if self.launch.per_kg > 0 and any( - self._get_type(name).mass is None for name in fleets + self._get_type(kind).mass is None for kind in deployment.development ): raise ValueError("launches priced by mass require masses") - # development, then production of each type's planes on its line - planes = [] # (ready, name, cost, satellites) - batches: dict[Any, list[tuple[float, float, int]]] = {} - for name, sizes in fleets.items(): - cost = self._get_type(name) - sizes = [size + spares for size in sizes if size > 0] - if not sizes: - continue - developed = ( - schedule.development_years - if cost.development_years is None - else cost.development_years + for kind, developed in deployment.development.items(): + add( + "development", _spread(self._get_type(kind).development, 0.0, developed) ) - add("development", _spread(cost.development, 0.0, developed)) - line = developed - for size in sizes: - ready = line + schedule.producing(size) - batches.setdefault(name, []).append((line, ready, size)) - planes.append((ready, name, cost, size)) - line = ready - if not planes: - estimate.flows, estimate.present = [], dict.fromkeys(ELEMENTS, 0.0) - return estimate - # launches in the order planes are ready, at the launch cadence - launches = [] # (time, name, cost, satellites, dedicated) - cadence = -math.inf - for ready, name, cost, size in sorted(planes, key=lambda plane: plane[0]): - count = self.launch.launches(size, cost.mass) or 1 - first = max(ready, cadence) - for j in range(count): - carried = size // count + (1 if j < size % count else 0) - launches.append( - ( - first + j * schedule.launch_interval, - name, - cost, - carried, - self.launch.per_launch > 0, - ) - ) - cadence = first + count * schedule.launch_interval - estimate.deployments.append((first, size)) - originals = list(launches) - begin = min(time for time, *_ in launches) - end = begin + self.years - # replacements at the end of each design life, before the end - for time, name, cost, carried, dedicated in originals: - if self.design_life is None: - break - need = time + self.design_life - while need < end - 1e-9: - produced = need - schedule.producing(carried) - batches.setdefault(name, []).append((produced, need, carried)) - launches.append((need, name, cost, carried, dedicated)) - need += self.design_life - # production in order along each type's learning curve - for name, items in batches.items(): - cost = self._get_type(name) - built = 0 - for produced, ready, size in sorted(items, key=lambda item: item[0]): - amount = cost.production(built + size) - cost.production(built) - built += size - add("production", _spread(amount, produced, ready)) - estimate.units["satellites" if name is None else str(name)] = built - for time, name, cost, carried, dedicated in launches: - estimate.launches += int(dedicated) - price = (self.launch.per_launch if dedicated else 0.0) + carried * ( - self.launch.per_satellite + self.launch.per_kg * (cost.mass or 0.0) + built: dict[Any, int] = {} + for batch in deployment.production: + cost = self._get_type(batch.kind) + before = built.get(batch.kind, 0) + amount = cost.production(before + batch.satellites) - cost.production( + before ) - add("launch", [(time, price)]) - # operations of the mission, and of each satellite from its launch - add("operations", _spread(self.operations.per_year * self.years, begin, end)) - for time, _, _, carried, _ in originals: - add( - "operations", - _spread( - self.operations.per_satellite_year * carried * (end - time), - time, - end, - ), + built[batch.kind] = before + batch.satellites + add("production", _spread(amount, batch.begin, batch.end)) + estimate.units = { + "satellites" if kind is None else str(kind): units + for kind, units in built.items() + } + begin, end = deployment.begin, deployment.end + for launch in deployment.launches: + cost = self._get_type(launch.kind) + estimate.launches += int(self.launch.per_launch > 0) + price = self.launch.per_launch + launch.satellites * ( + self.launch.per_satellite + self.launch.per_kg * (cost.mass or 0.0) ) + add("launch", [(launch.time, price)]) + if launch.generation == 0: + add( + "operations", + _spread( + self.operations.per_satellite_year + * launch.satellites + * (end - launch.time), + launch.time, + end, + ), + ) + add("operations", _spread(self.operations.per_year * (end - begin), begin, end)) flows = [flow for flow in flows if flow[2] != 0] estimate.flows = sorted(flows, key=lambda flow: (flow[0], flow[1])) for element in ELEMENTS: @@ -636,7 +395,7 @@ def add(element: str, amounts: list[tuple[float, float]]) -> None: estimate.present = { element: float( sum( - amount * schedule.discount(time) + amount * self.discount(time) for time, kind, amount in flows if kind == element ) diff --git a/src/tatc/tradespace/deployment.py b/src/tatc/tradespace/deployment.py new file mode 100644 index 00000000..ef333f27 --- /dev/null +++ b/src/tatc/tradespace/deployment.py @@ -0,0 +1,575 @@ +""" +Deployment of constellations: when the satellites of a design are developed, +produced, launched, and replaced, which dates their costs (see `CostModel`) +and sets the satellites that observe in each phase of the mission, for +measures of capability over the mission rather than of the full +constellation alone. + +A `DeploymentSchedule` holds the rates and durations of a study (the +mission, the design life of satellites, the development and production of +each type of satellite, and the launch cadence and capacity), from which +each design's `Deployment` follows: a design of more satellites and planes +takes longer to produce and launch. Its launches divide the mission into +phases (`Deployment.phases`) of constant sets of operating satellites, each +evaluated over the study's representative period (`evaluate_phases`) and +combined over the mission (`summarize_phases`), such as the time-weighted +mean of a metric and the time until it first meets a requirement. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +import math +from collections.abc import Callable, Mapping, Sequence +from dataclasses import dataclass, field +from typing import Any + +import numpy as np +import pandas as pd + +from ..schemas import Satellite +from .constellations import PLANES, SSO_PLANES, WALKER, _kind, _layout, _layouts +from .criteria import _OPERATORS, Requirement +from .values import Values + +PerType = float | Mapping[Any, float] +"""A value for every type of satellite, or for each (by its name).""" + + +def _per_type(value: Any, kind: Any, name: str) -> Any: + """Gets the value of a type of satellite.""" + if isinstance(value, Mapping): + if kind not in value: + raise ValueError(f"no {name} of satellites of kind {kind!r}") + return value[kind] + return value + + +def _planes(layout: Any) -> list[tuple[int, Any]]: + """ + Gets the planes of a layout (or several): the number of satellites of + each, and its values (or `None` for the planes of a Walker layout). + """ + several = _layouts(layout) + if several is not None: + return [plane for item in several for plane in _planes(item)] + layout = _layout(layout) + kind = _kind(layout) + if kind == WALKER: + return [(int(layout.per_plane), None)] * int(layout.planes) + if kind in (SSO_PLANES, PLANES): + return [(int(plane.satellites), plane) for plane in layout.planes] + raise ValueError(f"unknown layout {kind!r}") + + +@dataclass(frozen=True) +class Launch: + """ + A launch of satellites of a plane (see `Deployment`). + """ + + time: float + """float: The time (years from the start of development).""" + plane: int + """int: The plane (its index, in the order of the layouts' planes).""" + kind: Any + """Any: The type of its satellites.""" + first: int + """int: The position in its plane of its first satellite.""" + satellites: int + """int: The number of satellites (including spares).""" + generation: int = 0 + """int: The generation (0 for the first, others replacements).""" + + +@dataclass(frozen=True) +class Production: + """ + The production of satellites of a type (see `Deployment`). + """ + + kind: Any + """Any: The type of the satellites.""" + begin: float + """float: The start of their production (years).""" + end: float + """float: The end of their production (years).""" + satellites: int + """int: The number of satellites.""" + + +@dataclass(frozen=True) +class Phase: + """ + A phase of a mission, in which a set of satellites operates (see + `Deployment.phases`). + """ + + start: float + """float: The start (years from the start of development).""" + end: float + """float: The end (years from the start of development).""" + satellites: tuple[str, ...] + """tuple[str, ...]: The names of the satellites that operate.""" + + @property + def duration(self) -> float: + """float: The duration (years).""" + return self.end - self.start + + +@dataclass +class Deployment: + """ + The deployment of a constellation: its development, production, + launches, and replacements (see `DeploymentSchedule.plan`). + """ + + schedule: DeploymentSchedule + """DeploymentSchedule: The schedule of the deployment.""" + planes: list[tuple[Any, int, int]] = field(default_factory=list) + """list: The planes, in the order of the layouts' planes: the type of + their satellites, the number of satellites of the layout, and of + spares.""" + development: dict[Any, float] = field(default_factory=dict) + """dict: The end of the development of each type of satellite (years).""" + production: list[Production] = field(default_factory=list) + """list[Production]: The production of the satellites, in order.""" + launches: list[Launch] = field(default_factory=list) + """list[Launch]: The launches (and replacements), in order.""" + + @property + def begin(self) -> float: + """float: The first launch, which begins the mission (years).""" + return min(launch.time for launch in self.launches) + + @property + def end(self) -> float: + """float: The end of the mission (years).""" + return self.begin + self.schedule.years + + @property + def deployed(self) -> float: + """float: The time by which every satellite of the first generation + is launched (years).""" + return max(launch.time for launch in self.launches if launch.generation == 0) + + @property + def units(self) -> dict[Any, int]: + """dict: The satellites produced of each type (including replacements + and spares).""" + units: dict[Any, int] = {} + for batch in self.production: + units[batch.kind] = units.get(batch.kind, 0) + batch.satellites + return units + + def phases( + self, + satellites: Sequence[Satellite | str], + failures: Mapping[str, float] | None = None, + ) -> list[Phase]: + """ + Gets the phases of the mission, from the first launch to its end, in + which constant sets of satellites operate: each satellite from its + launch, except, if it fails (at a time given by `failures`, see + `draw_failures`), from its failure to the launch of its replacement + (or the end of the mission). + + The satellites are those built for the layouts of the deployment + (see `build_constellation`), in the order of their planes (and of + several layouts, in the order given to `DeploymentSchedule.plan`), + without spares. The satellites of a plane of several launches + operate as each is launched, in order. + + Args: + satellites (Sequence[Satellite | str]): The satellites (or their + names), in the order of the planes. + failures (Mapping[str, float] | None): The time (years from the + start of development) at which satellites fail, by name. + + Returns: + list[Phase]: the phases, in order + """ + names = [s.name if isinstance(s, Satellite) else str(s) for s in satellites] + expected = sum(built for _, built, _ in self.planes) + if len(names) != expected: + raise ValueError( + f"expected {expected} satellites for the planes, not {len(names)}" + ) + offsets = np.cumsum([0] + [built for _, built, _ in self.planes]) + begin, end = self.begin, self.end + failures = failures or {} + intervals: dict[str, list[tuple[float, float]]] = {} + for launch in self.launches: + if launch.generation != 0: + continue + built = self.planes[launch.plane][1] + for position in range( + launch.first, min(launch.first + launch.satellites, built) + ): + name = names[offsets[launch.plane] + position] + start = launch.time + failure = failures.get(name) + if failure is None or failure >= end or failure < start: + intervals[name] = [(start, end)] + continue + replaced = [ + time for time in self._replacements(launch) if failure < time < end + ] + after = [(replaced[0], end)] if replaced else [] + intervals[name] = [(start, failure)] + after + events = {begin, end} + for spans in intervals.values(): + for start, stop in spans: + events.update((start, stop)) + times = sorted(time for time in events if begin <= time <= end) + phases: list[Phase] = [] + for start, stop in zip(times[:-1], times[1:]): + if stop - start <= 1e-12: + continue + middle = (start + stop) / 2 + active = tuple( + name + for name in names + if any(a <= middle < b for a, b in intervals.get(name, [])) + ) + if phases and phases[-1].satellites == active: + phases[-1] = Phase(phases[-1].start, stop, active) + else: + phases.append(Phase(start, stop, active)) + return phases + + def _replacements(self, launch: Launch) -> list[float]: + """Gets the times of the replacements of the satellites of a launch.""" + return sorted( + other.time + for other in self.launches + if other.generation > 0 + and other.plane == launch.plane + and other.first == launch.first + ) + + +@dataclass(frozen=True) +class DeploymentSchedule: + """ + A schedule of the deployment of constellations, from rates and + durations, so that each design's deployment follows from its satellites + and planes (see `plan`). Times are in years from the start of + development. + + * Each type of satellite is developed over `development_years` (one for + every type, or one for each). + * Its satellites are then produced on one line at `production_rate` + satellites a year (or at once, if `None`), plane by plane, in the + order of the layouts' planes (or of `order`). + * Each plane is launched when its satellites are ready, in as many + launches as its satellites need (given a `launch_capacity` in number + or mass, or one per plane), at most one every `launch_interval` years, + in the order the planes are ready. + * The mission lasts `years` from the first launch. Satellites are + replaced at the end of their `design_life` (if before the end of the + mission), each replacement produced at the production rate just + before it is needed and launched then. + + A schedule that is itself a decision (such as the launch cadence) is a + design variable, with the schedule made for each design (such as with + `dataclasses.replace`). + + Args: + years (float): The duration of the mission, from the first launch. + design_life (float | None): The design life of the satellites, or + `None` if they last the mission. + development_years (float | Mapping): The duration of development of + each type of satellite, before production. + production_rate (float | Mapping | None): The satellites of each type + produced a year, or `None` for production that takes no time. + launch_interval (float): The least time between launches. + launch_capacity (int | None): The most satellites of a launch, if + limited. + launch_mass_capacity (float | None): The most mass (kg) of a launch, + if limited (which requires the masses of the satellites). + order (Callable | None): A function of the index and values of a + plane (`None` for the planes of a Walker layout) that gives the + key by which its type's planes are produced and launched, if + not in the order of the layouts. + """ + + years: float = 1.0 + design_life: float | None = None + development_years: PerType = 0.0 + production_rate: PerType | None = None + launch_interval: float = 0.0 + launch_capacity: int | None = None + launch_mass_capacity: float | None = None + order: Callable[[int, Any], Any] | None = None + + def __post_init__(self): + if self.years <= 0: + raise ValueError("years must be positive") + if self.design_life is not None and self.design_life <= 0: + raise ValueError("design_life must be positive") + if self.launch_interval < 0: + raise ValueError("launch_interval must not be negative") + if self.launch_capacity is not None and self.launch_capacity < 1: + raise ValueError("launch_capacity must be at least 1") + rates = self.production_rate + values = rates.values() if isinstance(rates, Mapping) else [rates] + if any(rate is not None and rate <= 0 for rate in values): + raise ValueError("production_rate must be positive") + years = self.development_years + values = years.values() if isinstance(years, Mapping) else [years] + if any(value < 0 for value in values): + raise ValueError("development_years must not be negative") + + def launches_of(self, satellites: int, mass: float | None = None) -> int: + """ + Gets the launches of a plane of satellites. + + Args: + satellites (int): The number of satellites. + mass (float | None): The mass (kg) of each satellite. + + Returns: + int: the number of launches + """ + count = 1 + if self.launch_capacity is not None: + count = max(count, math.ceil(satellites / self.launch_capacity)) + if self.launch_mass_capacity is not None: + if mass is None: + raise ValueError("a launch capacity in mass requires masses") + per_launch = math.floor(self.launch_mass_capacity / mass) + if per_launch < 1: + raise ValueError("a satellite exceeds the mass capacity of a launch") + count = max(count, math.ceil(satellites / per_launch)) + return count + + def plan( + self, + layout: Any, + kind: Any = None, + spares: int = 0, + masses: PerType | None = None, + ) -> Deployment: + """ + Plans the deployment of a constellation: the layout (or layouts) of + its satellites, of one type (`kind`), or a mapping of types to + layouts (such as the shells of a mixed constellation). + + Args: + layout (Any): The layout (or layouts) of the satellites, or a + mapping of types of satellites to layouts. + kind (Any): The type of the satellites of a layout. + spares (int): The spares in orbit in each plane, produced and + launched with it. + masses (float | Mapping | None): The mass (kg) of the satellites + (of each type), for a launch capacity in mass. + + Returns: + Deployment: the deployment + """ + # pylint: disable=too-many-locals + if spares < 0: + raise ValueError("spares must not be negative") + # a mapping of types to layouts (the values of a layout are a mapping too) + if isinstance(layout, Mapping) and not isinstance(layout, Values): + fleets = dict(layout) + else: + fleets = {kind: layout} + deployment = Deployment(schedule=self) + planes = [] # (ready, index, kind, satellites) + for name, item in fleets.items(): + developed = float(_per_type(self.development_years, name, "development")) + rate = _per_type(self.production_rate, name, "production rate") + mass = None if masses is None else _per_type(masses, name, "mass") + deployment.development[name] = developed + listed = [] + for size, values in _planes(item): + index = len(deployment.planes) + deployment.planes.append((name, size, spares if size > 0 else 0)) + if size > 0: + listed.append((index, size + spares, values)) + if self.order is not None: + listed.sort(key=lambda plane: self.order(plane[0], plane[2])) + line = developed + for index, size, _ in listed: + ready = line + (0.0 if rate is None else size / rate) + deployment.production.append(Production(name, line, ready, size)) + planes.append((ready, index, name, size, mass)) + line = ready + if not planes: + raise ValueError("a deployment requires satellites") + cadence = -math.inf + for ready, index, name, size, mass in sorted(planes, key=lambda p: p[0]): + count = self.launches_of(size, mass) + first = max(ready, cadence) + position = 0 + for j in range(count): + carried = size // count + (1 if j < size % count else 0) + deployment.launches.append( + Launch( + first + j * self.launch_interval, index, name, position, carried + ) + ) + position += carried + cadence = first + count * self.launch_interval + end = deployment.end + if self.design_life is not None: + for launch in list(deployment.launches): + rate = _per_type(self.production_rate, launch.kind, "production rate") + need, generation = launch.time + self.design_life, 1 + while need < end - 1e-9: + produced = need - ( + 0.0 if rate is None else launch.satellites / rate + ) + deployment.production.append( + Production(launch.kind, produced, need, launch.satellites) + ) + deployment.launches.append( + Launch( + need, + launch.plane, + launch.kind, + launch.first, + launch.satellites, + generation, + ) + ) + need, generation = need + self.design_life, generation + 1 + deployment.production.sort(key=lambda batch: batch.begin) + deployment.launches.sort(key=lambda launch: (launch.time, launch.plane)) + return deployment + + +def draw_failures( + deployment: Deployment, + satellites: Sequence[Satellite | str], + annual_rate: float, + seed: int | None, +) -> dict[str, float]: + """ + Draws the times at which satellites fail (see `Deployment.phases`), each + after an exponentially distributed life from its launch (at a constant + `annual_rate` of failure), from an uncertain seed of a replicate (see + `Uncertain.seed`). The life of a satellite depends only on the seed and + its position, so that with common random numbers, the satellite at the + same position has the same life in the same replicate of every design. + + Args: + deployment (Deployment): The deployment. + satellites (Sequence[Satellite | str]): The satellites (or their + names), in the order of the planes (see `Deployment.phases`). + annual_rate (float): The rate of failure (per year). + seed (int | None): The seed of the replicate, or `None` for no + failures. + + Returns: + dict[str, float]: the time of failure of each satellite that fails + before the end of the mission + """ + if annual_rate < 0: + raise ValueError("annual_rate must not be negative") + if seed is None or annual_rate == 0: + return {} + launched = {} + for phase in deployment.phases(satellites): + for name in phase.satellites: + launched.setdefault(name, phase.start) + names = [s.name if isinstance(s, Satellite) else str(s) for s in satellites] + failures = {} + for k, name in enumerate(names): + life = np.random.default_rng([seed, k]).exponential(1 / annual_rate) + time = launched[name] + life + if time < deployment.end: + failures[name] = float(time) + return failures + + +def evaluate_phases( + phases: Sequence[Phase], + observations: pd.DataFrame, + metric: Callable[[pd.DataFrame], Mapping[str, float]], +) -> pd.DataFrame: + """ + Evaluates the phases of a mission: a metric of the observations of the + satellites that operate in each phase, over the study's representative + period (the observations of the full constellation, by satellite, such + as from a `SatelliteCache`, filtered to those of each phase). Phases of + the same satellites are evaluated once. + + Args: + phases (Sequence[Phase]): The phases (see `Deployment.phases`). + observations (pandas.DataFrame): The observations of every + satellite, with their names (`satellite`). + metric (Callable): A function of the observations of a phase (which + may be empty) that gives its metrics. + + Returns: + pandas.DataFrame: a row per phase: its `start`, `end`, `duration`, + number of `satellites`, and metrics + """ + rows, evaluated = [], {} + for phase in phases: + key = frozenset(phase.satellites) + if key not in evaluated: + if "satellite" in observations.columns: + subset = observations[observations["satellite"].isin(key)] + else: + subset = observations.iloc[0:0] + evaluated[key] = dict(metric(subset)) + rows.append( + { + "start": phase.start, + "end": phase.end, + "duration": phase.duration, + "satellites": len(phase.satellites), + **evaluated[key], + } + ) + return pd.DataFrame(rows) + + +def summarize_phases( + capability: pd.DataFrame, + metrics: Sequence[str] | None = None, + requirements: Sequence[Requirement] = (), +) -> dict[str, float]: + """ + Summarizes the capability of a mission over its phases (see + `evaluate_phases`): the mean of each metric weighted by the durations of + the phases (` mean`, over the mission, from its first launch), + and, for each requirement on a metric, the time (years from the start of + development) at which a phase first meets it (` time`, infinite + if none does). + + Args: + capability (pandas.DataFrame): The metrics of each phase. + metrics (Sequence[str] | None): The metrics, or `None` for every + column other than those of the phases. + requirements (Sequence[Requirement]): Requirements on metrics. + + Returns: + dict[str, float]: the summary, as metrics of an evaluation + """ + if metrics is None: + metrics = [ + column + for column in capability.columns + if column not in ("start", "end", "duration", "satellites") + ] + weights = capability["duration"].to_numpy(dtype=float) + summary = {} + for name in metrics: + values = capability[name].to_numpy(dtype=float) + summary[f"{name} mean"] = float(np.sum(values * weights) / np.sum(weights)) + for requirement in requirements: + met = _OPERATORS[requirement.operator]( + capability[requirement.name].to_numpy(dtype=float), requirement.value + ) + starts = capability["start"].to_numpy(dtype=float)[met] + summary[f"{requirement.name} time"] = ( + float(starts[0]) if len(starts) > 0 else math.inf + ) + return summary diff --git a/tests/tradespace/test_cost.py b/tests/tradespace/test_cost.py index 5e7c2e88..0594bd1f 100644 --- a/tests/tradespace/test_cost.py +++ b/tests/tradespace/test_cost.py @@ -11,7 +11,7 @@ from tatc.tradespace import ( Categorical, CostModel, - CostSchedule, + DeploymentSchedule, DesignSpace, Integer, LaunchCost, @@ -85,7 +85,7 @@ def test_layouts(self): class TestCostModel(unittest.TestCase): """ - Unit tests for life-cycle costs. + Unit tests for life-cycle costs of deployments. """ def setUp(self): @@ -93,17 +93,15 @@ def setUp(self): development=100, first_unit=10, learning_rate=0.9, mass=50 ) - def test_dedicated_launches(self): - """Planes are launched in as many launches as their capacity requires.""" + def test_elements(self): + """Costs of development, production, launches, and operations.""" model = CostModel( self.satellite, - launch=LaunchCost(per_launch=30, capacity=3), + launch=LaunchCost(per_launch=30), operations=OperationsCost(per_year=5, per_satellite_year=1), - years=6, - design_life=3, ) - self.assertEqual(model.generations, 2) - estimate = model.estimate(_walker(planes=3, per_plane=4)) + schedule = DeploymentSchedule(years=6, design_life=3, launch_capacity=3) + estimate = model.estimate(schedule.plan(_walker(planes=3, per_plane=4))) # two generations of 3 planes of 4 satellites, 2 launches each self.assertEqual(estimate.units, {"satellites": 24}) self.assertEqual(estimate.launches, 12) @@ -112,9 +110,10 @@ def test_dedicated_launches(self): self.assertEqual(estimate.launch, 12 * 30) self.assertEqual(estimate.operations, 6 * (5 + 12)) self.assertAlmostEqual( - estimate.total, - 100 + self.satellite.production(24) + 360 + 102, + estimate.total, 100 + self.satellite.production(24) + 360 + 102 ) + # without discounting, the present value is the total + self.assertAlmostEqual(estimate.present_value, estimate.total) metrics = estimate.metrics() self.assertEqual( list(metrics), @@ -124,6 +123,8 @@ def test_dedicated_launches(self): "cost production", "cost launch", "cost operations", + "cost present", + "cost peak annual", ], ) self.assertEqual(metrics["cost"], estimate.total) @@ -133,32 +134,23 @@ def test_rideshare(self): model = CostModel( self.satellite, launch=LaunchCost(per_satellite=2, per_kg=0.1) ) - estimate = model.estimate(_walker(planes=1, per_plane=4)) + estimate = model.estimate(DeploymentSchedule().plan(_walker(1, 4))) self.assertEqual(estimate.launches, 0) self.assertAlmostEqual(estimate.launch, 4 * (2 + 0.1 * 50)) with self.assertRaises(ValueError): - CostModel(SatelliteCost(), launch=LaunchCost(per_kg=1)).estimate(_walker()) - - def test_mass_capacity(self): - """A launch carries as many satellites as its mass capacity allows.""" - model = CostModel( - self.satellite, launch=LaunchCost(per_launch=30, mass_capacity=120) - ) - # 2 satellites of 50 kg per launch: 2 launches for each plane of 4 - self.assertEqual(model.estimate(_walker(planes=2, per_plane=4)).launches, 4) - with self.assertRaises(ValueError): - CostModel( - self.satellite, launch=LaunchCost(per_launch=30, mass_capacity=40) - ).estimate(_walker()) + CostModel(SatelliteCost(), launch=LaunchCost(per_kg=1)).estimate( + DeploymentSchedule().plan(_walker()) + ) def test_spares(self): """Spares in orbit are built, launched, and operated with each plane.""" model = CostModel( self.satellite, - launch=LaunchCost(per_launch=30, capacity=4), + launch=LaunchCost(per_launch=30), operations=OperationsCost(per_satellite_year=1), ) - estimate = model.estimate(_walker(planes=2, per_plane=4), spares=1) + schedule = DeploymentSchedule(launch_capacity=4) + estimate = model.estimate(schedule.plan(_walker(2, 4), spares=1)) self.assertEqual(estimate.units["satellites"], 10) self.assertEqual(estimate.launches, 4) self.assertEqual(estimate.operations, 10) @@ -167,36 +159,41 @@ def test_types(self): """Types of satellites are developed once each, with their own curves.""" small = SatelliteCost(development=10, first_unit=1) model = CostModel({"large": self.satellite, "small": small}) - walker, sso = ( - _walker(planes=1, per_plane=2), - _design( - layout=sso_planes_space(crossing=13.5, satellites=3, count=1) - ).layout, + sso = _design( + layout=sso_planes_space(crossing=13.5, satellites=3, count=1) + ).layout + mixed = model.estimate( + DeploymentSchedule().plan({"large": _walker(1, 2), "small": sso}) ) - mixed = model.estimate({"large": walker, "small": sso}) self.assertEqual(mixed.units, {"large": 2, "small": 3}) self.assertEqual(mixed.development, 110) self.assertAlmostEqual(mixed.production, self.satellite.production(2) + 3) - one = model.estimate(walker, kind="small") + one = model.estimate(DeploymentSchedule().plan(_walker(1, 2), kind="small")) self.assertEqual(one.development, 10) with self.assertRaises(ValueError): - model.estimate(walker) + model.estimate(DeploymentSchedule().plan(_walker(1, 2))) with self.assertRaises(ValueError): - model.estimate(walker, kind="medium") + model.estimate(DeploymentSchedule().plan(_walker(1, 2), kind="medium")) def test_growth(self): """Growth factors multiply the cost, or its elements.""" model = CostModel( - self.satellite, operations=OperationsCost(per_year=5), years=2 + self.satellite, operations=OperationsCost(per_year=5), discount_rate=0.05 ) - base = model.estimate(_walker()) - grown = model.estimate(_walker(), growth=1.5) + deployment = DeploymentSchedule(years=2, development_years=2).plan(_walker()) + base = model.estimate(deployment) + grown = model.estimate(deployment, growth=1.5) self.assertAlmostEqual(grown.total, 1.5 * base.total) - partial = model.estimate(_walker(), growth={"development": 2.0}) + partial = model.estimate(deployment, growth={"development": 2.0}) self.assertAlmostEqual(partial.development, 200) self.assertAlmostEqual(partial.operations, base.operations) + self.assertAlmostEqual( + partial.present["development"], 2 * base.present["development"] + ) + with self.assertRaises(ValueError): + model.estimate(deployment, growth={"insurance": 1.1}) with self.assertRaises(ValueError): - model.estimate(_walker(), growth={"insurance": 1.1}) + CostModel(self.satellite, discount_rate=-1) def test_trade_study(self): """Costs are constraints of design spaces and metrics of studies.""" @@ -207,6 +204,7 @@ def test_trade_study(self): }, launch=LaunchCost(per_launch=20), ) + schedule = DeploymentSchedule() budget = 200 space = DesignSpace( imager=Categorical(["narrow", "wide"]), @@ -218,16 +216,21 @@ def test_trade_study(self): ), growth=Uncertain(lambda rng: float(rng.triangular(0.9, 1.0, 1.5))), constraints=[ - lambda d: model.estimate(d.layout, kind=d.imager).total - budget + lambda d: model.estimate(schedule.plan(d.layout, kind=d.imager)).total + - budget ], ) designs = space.enumerate() - nominal = [model.estimate(d.layout, kind=d.imager).total for d in designs] + nominal = [ + model.estimate(schedule.plan(d.layout, kind=d.imager)).total + for d in designs + ] self.assertTrue(all(cost <= budget for cost in nominal)) self.assertLess(len(designs), 2 * 9) def evaluate(d): - cost = model.estimate(d.layout, kind=d.imager, growth=d.growth) + deployment = schedule.plan(d.layout, kind=d.imager) + cost = model.estimate(deployment, growth=d.growth) return {**cost.metrics(), "satellites": count_satellites(d.layout)} results = Study(space, lambda d: d, evaluate, replicates=20).run(designs) @@ -240,7 +243,7 @@ def evaluate(d): np.testing.assert_allclose(ratio, ratio.iloc[0]) # common random numbers -class TestCostSchedule(unittest.TestCase): +class TestDatedCosts(unittest.TestCase): """ Unit tests for dated costs and their present value. """ @@ -250,97 +253,43 @@ def setUp(self): "satellites": SatelliteCost( development=90, first_unit=10, learning_rate=0.9 ), - "launch": LaunchCost(per_launch=30, capacity=3), + "launch": LaunchCost(per_launch=30), "operations": OperationsCost(per_year=5, per_satellite_year=1), - "years": 6, - "design_life": 3, } self.layout = _walker(planes=3, per_plane=4) - def _estimate(self, layout=None, **schedule): - model = CostModel(**self.terms, schedule=CostSchedule(**schedule)) - return model.estimate(self.layout if layout is None else layout) - - def test_undiscounted(self): - """Without rates, intervals, or discounting, dated costs are the estimate's.""" - nominal = CostModel(**self.terms).estimate(self.layout) - dated = self._estimate() - for element in ("development", "production", "launch", "operations"): - self.assertAlmostEqual(getattr(dated, element), getattr(nominal, element)) - self.assertAlmostEqual(dated.present_value, nominal.total) - self.assertEqual(dated.units, nominal.units) - self.assertEqual(dated.launches, nominal.launches) - self.assertEqual(dated.deployments, [(3.0, 4)] * 3) - self.assertIsNone(nominal.present_value) - self.assertIsNone(nominal.deployed) - self.assertNotIn("cost present", nominal.metrics()) + def _estimate(self, discount_rate=0.1, start=0.0, **schedule): + terms = {"years": 6, "design_life": 3, "launch_capacity": 3, **schedule} + model = CostModel(**self.terms, discount_rate=discount_rate, start=start) + return model.estimate(DeploymentSchedule(**terms).plan(self.layout)) def test_present_value(self): """Costs are discounted from the present to their dates.""" - dated = self._estimate(discount_rate=0.1, development_years=3) + dated = self._estimate(development_years=3) # development of 90, evenly over 3 years, dated at mid-year expected = sum(30 / 1.1 ** (year + 0.5) for year in range(3)) self.assertAlmostEqual(dated.present["development"], expected) # launches of the first generation at year 3, the second at year 6 self.assertAlmostEqual(dated.present["launch"], 180 / 1.1**3 + 180 / 1.1**6) - later = self._estimate(discount_rate=0.1, development_years=3, start=2) + later = self._estimate(development_years=3, start=2) self.assertAlmostEqual(later.present_value, dated.present_value / 1.1**2) - metrics = dated.metrics() - self.assertAlmostEqual(metrics["cost present"], dated.present_value) - self.assertLess(metrics["cost present"], metrics["cost"]) + self.assertLess(dated.metrics()["cost present"], dated.total) - def test_production_rate(self): - """A production line deploys planes as their satellites are built.""" + def test_production(self): + """Production is paid while produced, along the learning curve.""" dated = self._estimate(development_years=2, production_rate=8) - # 4 satellites a plane at 8 a year: ready every half year - self.assertEqual([time for time, _ in dated.deployments], [2.5, 3.0, 3.5]) - self.assertAlmostEqual(dated.deployed, 3.5) production = [f for f in dated.flows if f[1] == "production"] self.assertAlmostEqual(production[0][0], 2.25) # middle of [2, 2.5) self.assertAlmostEqual(production[0][2], self.terms["satellites"].production(4)) - # more satellites take longer to deploy - larger = self._estimate( - _walker(planes=3, per_plane=6), development_years=2, production_rate=8 - ) - self.assertGreater(larger.deployed, dated.deployed) - def test_launch_cadence(self): - """Launches are at least an interval apart, a plane taking several.""" + def test_operations_from_launch(self): + """Satellites launched later are operated for less of the mission.""" dated = self._estimate(development_years=2, launch_interval=1) - launches = sorted(t for t, element, _ in dated.flows if element == "launch") - # 2 launches of each plane (a capacity of 3 satellites), a year apart, - # and the replacements 3 years later of those before the end of the - # mission (6 years after the first launch, at year 8) + launches = [t for t, element, _ in dated.flows if element == "launch"] self.assertEqual(launches, [2, 3, 4, 5, 5, 6, 6, 7, 7]) - self.assertEqual([time for time, _ in dated.deployments], [2, 4, 6]) - self.assertEqual(dated.launches, 6 + 3) - # satellites launched later are operated for less of the mission - nominal = CostModel(**self.terms).estimate(self.layout) - self.assertLess(dated.operations, nominal.operations) expected = 5 * 6 + sum(2 * (8 - t) for t in [2, 3, 4, 5, 6, 7]) self.assertAlmostEqual(dated.operations, expected) - def test_development_by_type(self): - """Types of satellites are developed over their own durations.""" - model = CostModel( - { - "new": SatelliteCost(development=50, first_unit=5, development_years=5), - "heritage": SatelliteCost(development=10, first_unit=5), - }, - schedule=CostSchedule(development_years=2), - ) - dated = model.estimate( - { - "new": _walker(planes=1, per_plane=2), - "heritage": _walker(planes=1, per_plane=2), - } - ) - self.assertEqual(sorted(dated.deployments), [(2.0, 2), (5.0, 2)]) - development = [f for f in dated.flows if f[1] == "development"] - self.assertEqual(max(time for time, *_ in development), 4.5) - with self.assertRaises(ValueError): - SatelliteCost(development_years=-1) - def test_annual(self): """Annual costs add to the total, and their peak is a metric.""" dated = self._estimate(development_years=2, launch_interval=1) @@ -350,22 +299,3 @@ def test_annual(self): self.assertAlmostEqual( dated.metrics()["cost peak annual"], annual["total"].max() ) - with self.assertRaises(ValueError): - CostModel(**self.terms).estimate(self.layout).annual() - - def test_growth_and_validation(self): - """Growth multiplies dated costs, and schedules are validated.""" - model = CostModel(**self.terms, schedule=CostSchedule(discount_rate=0.05)) - base = model.estimate(self.layout) - grown = model.estimate(self.layout, growth={"development": 2.0}) - self.assertAlmostEqual( - grown.present["development"], 2 * base.present["development"] - ) - self.assertAlmostEqual(grown.present["launch"], base.present["launch"]) - for invalid in ( - {"production_rate": 0}, - {"launch_interval": -1}, - {"discount_rate": -1}, - ): - with self.assertRaises(ValueError): - CostSchedule(**invalid) diff --git a/tests/tradespace/test_deployment.py b/tests/tradespace/test_deployment.py new file mode 100644 index 00000000..05b67151 --- /dev/null +++ b/tests/tradespace/test_deployment.py @@ -0,0 +1,203 @@ +""" +Unit tests for the deployment of constellations and capability over its +phases. + +@author Paul T. Grogan +""" + +import math +import unittest + +import numpy as np +import pandas as pd + +from tatc.tradespace import ( + DeploymentSchedule, + DesignSpace, + Real, + Requirement, + draw_failures, + evaluate_phases, + sso_planes_space, + summarize_phases, + walker_space, +) + + +def _walker(planes=3, per_plane=4): + (design,) = DesignSpace( + layout=walker_space( + inclination=55.0, planes=planes, per_plane=per_plane, relative_spacing=0 + ) + ).enumerate() + return design.layout + + +def _names(planes, per_plane): + """The names of the satellites of a Walker layout, in build order.""" + return [f"satellite {k + 1}" for k in range(planes * per_plane)] + + +class TestPlan(unittest.TestCase): + """ + Unit tests for planned deployments. + """ + + def test_production_rate(self): + """A production line deploys planes as their satellites are built.""" + deployment = DeploymentSchedule(development_years=2, production_rate=8).plan( + _walker(3, 4) + ) + # 4 satellites a plane at 8 a year: ready every half year + self.assertEqual([l.time for l in deployment.launches], [2.5, 3.0, 3.5]) + self.assertEqual(deployment.begin, 2.5) + self.assertEqual(deployment.deployed, 3.5) + larger = DeploymentSchedule(development_years=2, production_rate=8).plan( + _walker(3, 6) + ) + self.assertGreater(larger.deployed, deployment.deployed) + + def test_launch_cadence(self): + """Launches are at least an interval apart, a plane taking several.""" + schedule = DeploymentSchedule( + years=6, + design_life=3, + development_years=2, + launch_interval=1, + launch_capacity=3, + ) + deployment = schedule.plan(_walker(3, 4)) + first = [l for l in deployment.launches if l.generation == 0] + self.assertEqual([l.time for l in first], [2, 3, 4, 5, 6, 7]) + self.assertEqual( + [(l.plane, l.first, l.satellites) for l in first[:2]], + [(0, 0, 2), (0, 2, 2)], + ) + # replacements 3 years later, before the end of the mission at year 8 + replacements = [l.time for l in deployment.launches if l.generation > 0] + self.assertEqual(replacements, [5, 6, 7]) + self.assertEqual(deployment.end, 8) + self.assertEqual(deployment.units, {None: 12 + 6}) + + def test_types_and_order(self): + """Types are developed over their own durations, planes in an order.""" + schedule = DeploymentSchedule(development_years={"new": 5, "heritage": 2}) + sso = DesignSpace( + layout=sso_planes_space(crossing=Real(9, 12, step=3), satellites=1, count=2) + ) + layout = sso.enumerate()[0].layout + deployment = schedule.plan({"new": _walker(1, 2), "heritage": layout}) + self.assertEqual( + sorted((l.time, l.kind) for l in deployment.launches), + [(2.0, "heritage"), (2.0, "heritage"), (5.0, "new")], + ) + ordered = DeploymentSchedule( + production_rate=1, order=lambda index, plane: -plane.crossing + ).plan(layout) + crossings = [plane.crossing for plane in layout.planes] + latest = int(np.argmax(crossings)) + self.assertEqual(ordered.launches[0].plane, latest) + with self.assertRaises(ValueError): + DeploymentSchedule(development_years={"new": 5}).plan( + _walker(), kind="heritage" + ) + + def test_mass_capacity(self): + """A launch carries as many satellites as its mass capacity allows.""" + schedule = DeploymentSchedule(launch_mass_capacity=120) + deployment = schedule.plan(_walker(2, 4), masses=50) + self.assertEqual(len(deployment.launches), 4) + with self.assertRaises(ValueError): + schedule.plan(_walker(2, 4)) + with self.assertRaises(ValueError): + schedule.plan(_walker(2, 4), masses=200) + + def test_validation(self): + """Schedules are validated.""" + for invalid in ( + {"years": 0}, + {"design_life": 0}, + {"production_rate": 0}, + {"launch_interval": -1}, + {"launch_capacity": 0}, + {"development_years": -1}, + ): + with self.assertRaises(ValueError): + DeploymentSchedule(**invalid) + + +class TestPhases(unittest.TestCase): + """ + Unit tests for phases of a mission. + """ + + def setUp(self): + self.schedule = DeploymentSchedule( + years=4, design_life=2, development_years=1, production_rate=2 + ) + self.deployment = self.schedule.plan(_walker(2, 2)) + self.names = _names(2, 2) + + def test_deployment(self): + """Phases begin as planes are launched.""" + phases = self.deployment.phases(self.names) + self.assertEqual([(p.start, p.end) for p in phases], [(2, 3), (3, 6)]) + self.assertEqual(phases[0].satellites, tuple(self.names[:2])) + self.assertEqual(phases[1].satellites, tuple(self.names)) + with self.assertRaises(ValueError): + self.deployment.phases(self.names[:3]) + + def test_failures(self): + """A failed satellite is missing until its replacement is launched.""" + phases = self.deployment.phases(self.names, failures={self.names[0]: 2.5}) + # it fails at 2.5 and its replacement launches at 4 (a design life of 2) + self.assertEqual( + [(p.start, p.end, len(p.satellites)) for p in phases], + [(2, 2.5, 2), (2.5, 3, 1), (3, 4, 3), (4, 6, 4)], + ) + + def test_draw_failures(self): + """Failures are drawn from a rate, the same for the same position.""" + self.assertEqual(draw_failures(self.deployment, self.names, 0.5, None), {}) + failures = draw_failures(self.deployment, self.names, 0.5, seed=3) + again = draw_failures(self.deployment, self.names, 0.5, seed=3) + self.assertEqual(failures, again) + self.assertTrue(all(2 <= t < 6 for t in failures.values())) + many = [ + len(draw_failures(self.deployment, self.names, 0.5, seed=s)) + for s in range(200) + ] + # about 1 - exp(-0.5 * 3.5) of each satellite fails in the mission + self.assertAlmostEqual(np.mean(many) / 4, 1 - math.exp(-0.5 * 3.5), delta=0.06) + + def test_evaluate_and_summarize(self): + """Phases are evaluated with their satellites' observations, and summarized.""" + observations = pd.DataFrame({"satellite": self.names * 3, "target": range(12)}) + calls = [] + + def metric(obs): + calls.append(len(obs)) + return {"targets": 25.0 * obs["satellite"].nunique()} + + phases = self.deployment.phases(self.names, failures={self.names[0]: 2.5}) + capability = evaluate_phases(phases, observations, metric) + self.assertEqual(list(capability.targets), [50, 25, 75, 100]) + self.assertEqual(list(capability.satellites), [2, 1, 3, 4]) + summary = summarize_phases( + capability, + requirements=[ + Requirement("targets", ">=", 75), + Requirement("targets", ">=", 200), + ], + ) + expected = (50 * 0.5 + 25 * 0.5 + 75 * 1 + 100 * 2) / 4 + self.assertAlmostEqual(summary["targets mean"], expected) + self.assertEqual(summary["targets time"], math.inf) # the last requirement + first = summarize_phases( + capability, requirements=[Requirement("targets", ">=", 75)] + ) + self.assertEqual(first["targets time"], 3) + # phases of the same satellites are evaluated once + repeated = evaluate_phases(phases + phases, observations, metric) + self.assertEqual(len(repeated), 8) + self.assertEqual(len(calls), 4 + 4) From 10ae93b247ce29adf8e63a127dabfb1bd94d2069 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Wed, 11 Nov 2026 08:49:04 -0700 Subject: [PATCH 15/52] simulate missions with failures of satellites and launches, and policies that restore them --- CHANGELOG.md | 3 +- docs/api_reference/tradespace.rst | 33 +- docs/examples/SearchTradeSpace.ipynb | 572 +++++++++++++++++-------- src/tatc/tradespace/__init__.py | 23 +- src/tatc/tradespace/cost.py | 58 +-- src/tatc/tradespace/deployment.py | 337 ++++----------- src/tatc/tradespace/failures.py | 342 +++++++++++++++ src/tatc/tradespace/mission.py | 614 +++++++++++++++++++++++++++ tests/tradespace/test_deployment.py | 34 +- tests/tradespace/test_failures.py | 332 +++++++++++++++ 10 files changed, 1868 insertions(+), 480 deletions(-) create mode 100644 src/tatc/tradespace/failures.py create mode 100644 src/tatc/tradespace/mission.py create mode 100644 tests/tradespace/test_failures.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 6e8b45a2..3f02a828 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -20,7 +20,8 @@ Added: - Building blocks of constellations: fragments of design spaces of Walker constellations (`tradespace.walker_space`) and planes of sun-synchronous orbits (`sso_planes_space`, whose planes have different crossing times), `build_constellation`, which builds the satellites of either with instruments or entries of the instrument catalog (with their validated attitudes, and several entries on one satellite), and `count_satellites` and `count_planes`. The phase and node of the lead satellite of a Walker constellation (`phase_fraction` and `node_fraction`, design variables or uncertain parameters) are fractions of the intervals over which they give distinct constellations (`360 / per_plane` degrees of phase, and `360 / planes` degrees of node for a delta configuration or 360 for a star), so that a search does not evaluate the same constellation at several phases or nodes. Planes of inclined orbits (`planes_space`), each with its own inclination and node (uncertain by default, as of satellites launched as secondary payloads). The satellites of the planes of `sso_planes_space` and `planes_space` are evenly spaced, or follow each other in a train at an `interval` (minutes), on the same ground track or in the same plane (`repeat_ground_track`). The phase of each plane (`phase_fraction`, which replaces `phase` of `sso_planes_space`) is a fraction of the interval over which it gives distinct planes (`360 / satellites` degrees for evenly spaced satellites, 360 for a train), from which each fragment derives the plane's `true_anomaly`, as for the lead satellite of a Walker constellation. `build_constellation`, `count_satellites`, and `count_planes` take several layouts (a list, or a `Repeat` of a `Choice` of layouts), such as the shells of a mixed constellation. - Function `tradespace.screen` (and class `Screening`), which screens designs with studies of increasing fidelity, keeping whole fronts of the best designs of each stage for the next. - Searches of design spaces with optional optimizers: `tradespace.optimize_optuna` suggests designs with Optuna trials (`DesignSpace.suggest`, define-by-run over the hierarchical space), and `optimize_pymoo` and `make_pymoo_problem` search the unit hypercube that encodes a design space (`DesignSpace.unit_paths`, `encode`, and `decode`) with pymoo. Each design is evaluated once, and the designs proposed together are evaluated together, in parallel if the study is. Constraints of a design space may return the amount of their violation (`Infeasible.violation`), which Optuna's trials record (`set_constraint`) for its constraint-aware samplers, and which is the constraint value of pymoo problems. Optional dependencies `tradespace` (joblib, Optuna, and pymoo). - - Deployment of constellations (`tradespace.DeploymentSchedule`): from the rates and durations of a study (the mission and design life, the development of each type of satellite, its production on a line at a production rate, and launches at a cadence and capacity, in number or mass, optionally in an order of planes), each design's deployment (`DeploymentSchedule.plan`, a `Deployment` of its `Production`, `Launch`es, and replacements), so that a design of more satellites and planes takes longer to deploy. Its launches divide the mission into phases of constant sets of operating satellites (`Deployment.phases`, optionally with failures until their replacement, `draw_failures`), evaluated over the study's representative period from the observations of the full constellation (`evaluate_phases`) and combined over the mission (`summarize_phases`: the time-weighted mean of each metric and the time until it first meets a requirement). + - Deployment of constellations (`tradespace.DeploymentSchedule`): from the rates and durations of a study (the mission and design life, the development of each type of satellite, its production on a line at a production rate, and launches at a cadence and capacity, in number or mass, optionally in an order of planes), each design's deployment (`DeploymentSchedule.plan`, a `Deployment` of its `Production`, `Launch`es, and replacements), so that a design of more satellites and planes takes longer to deploy. Its launches divide the mission into phases of constant sets of operating satellites (`Deployment.phases`), evaluated over the study's representative period from the observations of the full constellation (`evaluate_phases`) and combined over the mission (`summarize_phases`: the time-weighted mean of each metric and the time until it first meets a requirement). + - Simulated missions with failures (`Deployment.simulate`, a `MissionHistory` for each replicate, drawn from its seed with common random numbers between designs): lives of satellites whose failure rates vary over the lifecycle (`tradespace.Exponential`, `Weibull`, `Bathtub` of competing causes, and `Piecewise` rates by age, `Lifetime`), failures of launches (`FailureModel`), and a policy that degrades or restores failed satellites (`RestorationPolicy`) by spares in orbit (taking a failed satellite's place after drifting), spares on the ground (launched at the next launch slot), or satellites produced when needed (after procurement, on the production line), optionally replenishing spares and batching restorations in launches. A history gives the phases in which satellites operate (`MissionHistory.phases`), measures of the mission (`MissionHistory.metrics`: failures, restorations, spares used, time to restore, and availability), and, priced by a `CostModel`, the cost of what it produces and launches. - Life-cycle costs of deployments for trade studies (`tradespace.CostModel`): the development of each type of satellite, the production of its units on a learning curve (`SatelliteCost`), launches (per launch, or prices per satellite and kg, `LaunchCost`), operations (`OperationsCost`), replacements, and spares in orbit, dated by the deployment for their present value at a discount rate (`CostEstimate.present_value`, metric `cost present`) and annual costs (`CostEstimate.annual`, metric `cost peak annual`), with growth factors for cost risk (such as uncertain parameters, whose quantiles over replicates give the cost at a confidence level). TAT-C does not include cost-estimating relationships: the costs are given by the study. Fingerprints describe dataclasses (such as cost models) by their fields. - Function `tradespace.confirm` (and class `Confirmation`), which evaluates selected designs (such as a front) with new replicates that played no part in their selection, removing the optimism of the selection (the winner's curse, `Confirmation.optimism`). `ResultStore` keys evaluations by the fingerprint of a study (`Study.fingerprint`, see `get_fingerprint`: its seed, use of common random numbers, design space, and build and evaluation functions, and the version of TAT-C), warning if it holds evaluations of other definitions, which are not reused; `SatelliteCache` keys results on disk by the fingerprint of its function. `refine` treats designs with fewer than `min_replicates` (5) as uncertain whatever their probability, adds the replicates left to `max_replicates` in a last partial step, and warns if designs remain uncertain without a tolerance. `sensitivity` gives adjusted shares (epsilon squared) by default, without the share that the levels of a variable explain by chance (`adjusted=False` for correlation ratios). - Searches with Optuna accept categorical options that depend on earlier decisions (a parameter for each set of options), use TPE with a constant liar in batches by default (which spreads the trials of a batch), and stop after `max_designs` designs evaluated (trials that suggest designs evaluated before are told their objectives without evaluating them again). A design infeasible in some of its replicates violates its feasibility by their share (`Evaluations.infeasibility`), and the first design evaluated in a search is evaluated alone, to check that evaluations give one record each. `Study` records errors of evaluations as infeasible, without storing them, with `errors="record"`. Enumeration walks the items of unordered repetitions in one order only (the same designs, in the same order, four times faster for three sun-synchronous planes), and `DesignSpace.size` counts designs without keeping them. Pareto fronts are found by a vectorized sweep in lexicographic order that compares designs only with the efficient designs before them, and fronts with tolerances by comparing designs only with the efficient designs without tolerances (which dominate every design that any design dominates within the tolerances), in blocks of bounded memory: 20,000 designs in 0.05 s (0.11 s with tolerances) rather than 17 s, and the bootstraps of `pareto_probability` (and so `refine`) about 20 times faster. diff --git a/docs/api_reference/tradespace.rst b/docs/api_reference/tradespace.rst index c3ed1e9a..11aa0048 100644 --- a/docs/api_reference/tradespace.rst +++ b/docs/api_reference/tradespace.rst @@ -79,12 +79,41 @@ Deployment :members: plan, launches_of .. autoclass:: tatc.tradespace.Deployment - :members: phases, begin, end, deployed, units + :members: simulate, phases, begin, end, deployed, units .. autoclass:: tatc.tradespace.Launch .. autoclass:: tatc.tradespace.Production +Failures and Missions +--------------------- + +.. automodule:: tatc.tradespace.failures + :no-members: + +.. autoclass:: tatc.tradespace.FailureModel + :members: life_of + +.. autoclass:: tatc.tradespace.Lifetime + :members: survival, hazard, cumulative_hazard, sample + +.. autoclass:: tatc.tradespace.Exponential + +.. autoclass:: tatc.tradespace.Weibull + +.. autoclass:: tatc.tradespace.Bathtub + +.. autoclass:: tatc.tradespace.Piecewise + +.. autoclass:: tatc.tradespace.RestorationPolicy + :members: ground_spares_of + +.. automodule:: tatc.tradespace.mission + :no-members: + +.. autoclass:: tatc.tradespace.MissionHistory + :members: phases, metrics, in_orbit + .. autoclass:: tatc.tradespace.Phase :members: duration @@ -92,8 +121,6 @@ Deployment .. autofunction:: tatc.tradespace.summarize_phases -.. autofunction:: tatc.tradespace.draw_failures - Costs ----- diff --git a/docs/examples/SearchTradeSpace.ipynb b/docs/examples/SearchTradeSpace.ipynb index f45ce3ff..7e6aa58c 100644 --- a/docs/examples/SearchTradeSpace.ipynb +++ b/docs/examples/SearchTradeSpace.ipynb @@ -28,10 +28,10 @@ "id": "c3d2e5f4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:40:37.247741Z", - "iopub.status.busy": "2026-11-11T14:40:37.247465Z", - "iopub.status.idle": "2026-11-11T14:40:37.981230Z", - "shell.execute_reply": "2026-11-11T14:40:37.980406Z" + "iopub.execute_input": "2026-11-11T15:45:26.875139Z", + "iopub.status.busy": "2026-11-11T15:45:26.874923Z", + "iopub.status.idle": "2026-11-11T15:45:27.598015Z", + "shell.execute_reply": "2026-11-11T15:45:27.597171Z" } }, "outputs": [], @@ -79,10 +79,10 @@ "id": "e5f4a7b6", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:40:37.983212Z", - "iopub.status.busy": "2026-11-11T14:40:37.982872Z", - "iopub.status.idle": "2026-11-11T14:40:39.177541Z", - "shell.execute_reply": "2026-11-11T14:40:39.176735Z" + "iopub.execute_input": "2026-11-11T15:45:27.599909Z", + "iopub.status.busy": "2026-11-11T15:45:27.599607Z", + "iopub.status.idle": "2026-11-11T15:45:28.761055Z", + "shell.execute_reply": "2026-11-11T15:45:28.760302Z" } }, "outputs": [ @@ -134,7 +134,7 @@ "\n", "The evaluation computes both objectives: the share of points with at least four samples, and the share whose sampling error (`tatc.analysis.estimate_sampling_error`, for an exponential correlation in time with a decorrelation time of 3 hours) is at most half the field's standard deviation. A `ResultStore` keeps the records of the evaluations in a file, so that running the notebook again (or resuming it after an interruption) takes them from the file rather than evaluating them again.\n", "\n", - "`make_study` makes studies of other durations, numbers of replicates, and probabilities that satellites fail, as for screening and robustness (below). Each evaluation also plans the deployment of the design (`DeploymentSchedule`) and estimates its life-cycle cost (`CostModel`, both used below), and reports the cost of its computation (`satellite_days`, the satellites times the days analyzed), which measures the computation independently of the cache." + "`make_study` makes studies of other durations and numbers of replicates, of the phases of deployment, and with failures, as for screening, deployment, and robustness (below). Each evaluation also plans the deployment of the design (`DeploymentSchedule`) and estimates its life-cycle cost (`CostModel`, both used below), and reports the cost of its computation (`satellite_days`, the satellites times the days analyzed), which measures the computation independently of the cache." ] }, { @@ -143,10 +143,10 @@ "id": "a7b6c9d8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:40:39.179365Z", - "iopub.status.busy": "2026-11-11T14:40:39.178987Z", - "iopub.status.idle": "2026-11-11T14:40:39.187656Z", - "shell.execute_reply": "2026-11-11T14:40:39.186867Z" + "iopub.execute_input": "2026-11-11T15:45:28.762913Z", + "iopub.status.busy": "2026-11-11T15:45:28.762565Z", + "iopub.status.idle": "2026-11-11T15:45:28.770788Z", + "shell.execute_reply": "2026-11-11T15:45:28.770226Z" } }, "outputs": [], @@ -167,7 +167,6 @@ " build_constellation,\n", " count_planes,\n", " evaluate_phases,\n", - " remove_failures,\n", " summarize_phases,\n", ")\n", "\n", @@ -202,10 +201,10 @@ " return caches[seed, duration]\n", "\n", "\n", - "def make_study(duration=DURATION, replicates=N_REPLICATES, failure_probability=0.0, phased=False):\n", - " \"\"\"A study of the shares (%) of points sampled sufficiently and accurately over a duration, by the satellites\n", - " of each design that do not fail, and (if phased) their means over the phases of the mission as the satellites are\n", - " deployed, and the time until half of the points are sampled sufficiently.\"\"\"\n", + "def make_study(duration=DURATION, replicates=N_REPLICATES, failures=None, policy=None, spares=0, phased=False):\n", + " \"\"\"A study of the shares (%) of points sampled sufficiently and accurately over a duration by the satellites of\n", + " each design, and (if phased) their means over the phases of the mission as the satellites are deployed (and fail\n", + " and are restored, with failures and a policy), and the time until half of the points are sampled sufficiently.\"\"\"\n", " threshold = SAMPLES_PER_DAY * duration / timedelta(days=1)\n", "\n", " def sample(observations):\n", @@ -221,25 +220,28 @@ "\n", " def build(d):\n", " imager = Instrument(name=\"imager\", field_of_regard=d.field_of_regard)\n", - " members = build_constellation(d.layout, imager, epoch=START, altitude=d.altitude)\n", - " return d, members, remove_failures(members, failure_probability, d.failure_seed)\n", + " return d, build_constellation(d.layout, imager, epoch=START, altitude=d.altitude)\n", "\n", " def evaluate(built):\n", - " d, members, working = built\n", - " deployment = SCHEDULE.plan(d.layout, kind=d.field_of_regard)\n", - " cost = COST_MODEL.estimate(deployment, growth={\"development\": d.cost_growth})\n", + " d, members = built\n", + " deployment = SCHEDULE.plan(d.layout, kind=d.field_of_regard, spares=spares)\n", + " # the mission of the replicate: without failures, or with failures drawn from its seed\n", + " history = deployment.simulate(failures, policy, d.failure_seed if failures else None)\n", + " cost = COST_MODEL.estimate(history, growth={\"development\": d.cost_growth})\n", " record = {\"satellites\": len(members), \"planes\": count_planes(d.layout), **cost.metrics()}\n", " cache = get_cache(d.points_seed, duration)\n", - " record.update(sample(cache(working)), satellite_days=len(working) * duration / timedelta(days=1))\n", + " record.update(sample(cache(members)), satellite_days=len(members) * duration / timedelta(days=1))\n", " if phased:\n", - " capability = evaluate_phases(deployment.phases(members), cache(members), sample)\n", + " capability = evaluate_phases(history.phases(members), cache(members), sample)\n", " record.update(summarize_phases(capability, requirements=[Requirement(\"sufficient\", \">=\", 50)]))\n", + " if failures:\n", + " record.update(history.metrics())\n", " return record\n", "\n", " store = ResultStore(\n", " CACHE_DIRECTORY / \"results.sqlite\",\n", - " namespace=f\"{N_POINTS} points, start {START.isoformat()}, duration {duration}, failures \"\n", - " + f\"{failure_probability}, accuracy {MAX_RELATIVE_ERROR} at {DECORRELATION_TIME}\",\n", + " namespace=f\"{N_POINTS} points, start {START.isoformat()}, duration {duration}, \"\n", + " + f\"accuracy {MAX_RELATIVE_ERROR} at {DECORRELATION_TIME}\",\n", " )\n", " return Study(space, build, evaluate, replicates=replicates, n_jobs=-1, store=store)\n", "\n", @@ -264,10 +266,10 @@ "id": "c9d8e1f0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:40:39.189180Z", - "iopub.status.busy": "2026-11-11T14:40:39.188994Z", - "iopub.status.idle": "2026-11-11T14:40:50.039779Z", - "shell.execute_reply": "2026-11-11T14:40:50.039062Z" + "iopub.execute_input": "2026-11-11T15:45:28.772217Z", + "iopub.status.busy": "2026-11-11T15:45:28.771983Z", + "iopub.status.idle": "2026-11-11T15:45:29.046177Z", + "shell.execute_reply": "2026-11-11T15:45:29.045346Z" } }, "outputs": [ @@ -425,10 +427,10 @@ "id": "d0e9f2a1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:40:50.041516Z", - "iopub.status.busy": "2026-11-11T14:40:50.041270Z", - "iopub.status.idle": "2026-11-11T14:40:50.241650Z", - "shell.execute_reply": "2026-11-11T14:40:50.240880Z" + "iopub.execute_input": "2026-11-11T15:45:29.047885Z", + "iopub.status.busy": "2026-11-11T15:45:29.047622Z", + "iopub.status.idle": "2026-11-11T15:45:29.248945Z", + "shell.execute_reply": "2026-11-11T15:45:29.248202Z" } }, "outputs": [ @@ -509,10 +511,10 @@ "id": "a2b3c4d5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:40:50.243231Z", - "iopub.status.busy": "2026-11-11T14:40:50.242983Z", - "iopub.status.idle": "2026-11-11T14:40:50.313673Z", - "shell.execute_reply": "2026-11-11T14:40:50.312923Z" + "iopub.execute_input": "2026-11-11T15:45:29.250595Z", + "iopub.status.busy": "2026-11-11T15:45:29.250419Z", + "iopub.status.idle": "2026-11-11T15:45:29.319573Z", + "shell.execute_reply": "2026-11-11T15:45:29.318806Z" } }, "outputs": [ @@ -709,10 +711,10 @@ "id": "b3c4d5e6", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:40:50.315307Z", - "iopub.status.busy": "2026-11-11T14:40:50.315131Z", - "iopub.status.idle": "2026-11-11T14:40:50.556804Z", - "shell.execute_reply": "2026-11-11T14:40:50.555987Z" + "iopub.execute_input": "2026-11-11T15:45:29.321366Z", + "iopub.status.busy": "2026-11-11T15:45:29.321119Z", + "iopub.status.idle": "2026-11-11T15:45:29.552614Z", + "shell.execute_reply": "2026-11-11T15:45:29.551859Z" } }, "outputs": [ @@ -762,10 +764,10 @@ "id": "d5e6f7a8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:40:50.558487Z", - "iopub.status.busy": "2026-11-11T14:40:50.558229Z", - "iopub.status.idle": "2026-11-11T14:40:50.649275Z", - "shell.execute_reply": "2026-11-11T14:40:50.648496Z" + "iopub.execute_input": "2026-11-11T15:45:29.554347Z", + "iopub.status.busy": "2026-11-11T15:45:29.554080Z", + "iopub.status.idle": "2026-11-11T15:45:29.637602Z", + "shell.execute_reply": "2026-11-11T15:45:29.636844Z" } }, "outputs": [ @@ -869,7 +871,7 @@ "rows = []\n", "for row in (first, second):\n", " d = by_key[row.design].realize(0)\n", - " _, members, _ = make_study().build(d)\n", + " _, members = make_study().build(d)\n", " observations = get_cache(d.points_seed, DURATION)(members)\n", " points = generate_points_random(N_POINTS, seed=d.points_seed)\n", " revisits = compute_revisit_statistics(observations, START, START + DURATION, targets=points)\n", @@ -912,10 +914,10 @@ "id": "a8b9c0d1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:40:50.651031Z", - "iopub.status.busy": "2026-11-11T14:40:50.650783Z", - "iopub.status.idle": "2026-11-11T14:40:50.677257Z", - "shell.execute_reply": "2026-11-11T14:40:50.676513Z" + "iopub.execute_input": "2026-11-11T15:45:29.639395Z", + "iopub.status.busy": "2026-11-11T15:45:29.639129Z", + "iopub.status.idle": "2026-11-11T15:45:29.665668Z", + "shell.execute_reply": "2026-11-11T15:45:29.664910Z" } }, "outputs": [ @@ -1063,10 +1065,10 @@ "id": "a3b2c5d4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:40:50.678797Z", - "iopub.status.busy": "2026-11-11T14:40:50.678555Z", - "iopub.status.idle": "2026-11-11T14:40:52.213681Z", - "shell.execute_reply": "2026-11-11T14:40:52.212973Z" + "iopub.execute_input": "2026-11-11T15:45:29.667334Z", + "iopub.status.busy": "2026-11-11T15:45:29.667145Z", + "iopub.status.idle": "2026-11-11T15:45:31.164514Z", + "shell.execute_reply": "2026-11-11T15:45:31.163828Z" } }, "outputs": [ @@ -1315,10 +1317,10 @@ "id": "b5d3f7a9", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:40:52.215400Z", - "iopub.status.busy": "2026-11-11T14:40:52.215142Z", - "iopub.status.idle": "2026-11-11T14:41:20.328047Z", - "shell.execute_reply": "2026-11-11T14:41:20.327170Z" + "iopub.execute_input": "2026-11-11T15:45:31.166169Z", + "iopub.status.busy": "2026-11-11T15:45:31.165922Z", + "iopub.status.idle": "2026-11-11T15:46:03.844811Z", + "shell.execute_reply": "2026-11-11T15:46:03.844100Z" } }, "outputs": [ @@ -1468,10 +1470,10 @@ "id": "c6e4a8b0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:41:20.329902Z", - "iopub.status.busy": "2026-11-11T14:41:20.329648Z", - "iopub.status.idle": "2026-11-11T14:41:20.403075Z", - "shell.execute_reply": "2026-11-11T14:41:20.402124Z" + "iopub.execute_input": "2026-11-11T15:46:03.846457Z", + "iopub.status.busy": "2026-11-11T15:46:03.846196Z", + "iopub.status.idle": "2026-11-11T15:46:03.907520Z", + "shell.execute_reply": "2026-11-11T15:46:03.906799Z" } }, "outputs": [ @@ -2021,10 +2023,10 @@ "id": "f2a3b4c5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:41:20.405311Z", - "iopub.status.busy": "2026-11-11T14:41:20.405038Z", - "iopub.status.idle": "2026-11-11T14:41:21.427264Z", - "shell.execute_reply": "2026-11-11T14:41:21.426246Z" + "iopub.execute_input": "2026-11-11T15:46:03.909174Z", + "iopub.status.busy": "2026-11-11T15:46:03.908919Z", + "iopub.status.idle": "2026-11-11T15:46:04.821166Z", + "shell.execute_reply": "2026-11-11T15:46:04.820423Z" } }, "outputs": [ @@ -2526,10 +2528,10 @@ "id": "f9b7d1e3", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:41:21.429218Z", - "iopub.status.busy": "2026-11-11T14:41:21.428939Z", - "iopub.status.idle": "2026-11-11T14:41:22.945886Z", - "shell.execute_reply": "2026-11-11T14:41:22.945059Z" + "iopub.execute_input": "2026-11-11T15:46:04.822703Z", + "iopub.status.busy": "2026-11-11T15:46:04.822534Z", + "iopub.status.idle": "2026-11-11T15:46:06.153716Z", + "shell.execute_reply": "2026-11-11T15:46:06.152966Z" } }, "outputs": [ @@ -2748,9 +2750,16 @@ "id": "c0d1e2f3", "metadata": {}, "source": [ - "## Assess Robustness to Failures\n", + "## Plan for Failures\n", "\n", - "A design that needs every satellite to work is fragile. A study in which each satellite fails with a probability of 10% (`remove_failures`, drawn in each replicate from an uncertain seed, so that the satellite at the same position fails in every design) evaluates the efficient designs (by the share of points accurately sampled) in 20 replicates. The table compares their shares with and without failures, on average and in the worst 10% of the replicates (`Quantile`)." + "A design that needs every satellite to work is fragile, and what failures cost depends on how the mission responds to them. A `FailureModel` gives the life of the satellites from their launch, here a bathtub curve of infant mortality, random failures, and wear-out (`Bathtub` of `Weibull` and `Exponential` lives, illustrative), and the probability that a launch fails. Each replicate simulates the mission of a design with failures drawn from its seed (`Deployment.simulate`, with common random numbers: the satellite at the same position of the same plane fails at the same age in every design), and a `RestorationPolicy` responds to them:\n", + "\n", + "* **degrade**: fly the satellites that remain;\n", + "* **produce**: restore each failed satellite by producing a new one (after half a year of procurement, on the production line) and launching it;\n", + "* **spare in orbit**: a spare in each plane, launched with it, takes a failed satellite's place within months (others are produced), and is produced again;\n", + "* **spare on ground**: a spare, produced after the first satellites and stored, is launched at the next slot (others are produced), and is produced again.\n", + "\n", + "Each history gives both the cost of what is produced and launched (the restorations and spares, and the launches that fail) and the phases in which its satellites operate, evaluated as in the previous section: the share of points accurately sampled on average over the mission, and in the worst 10% of the replicates, and the cost at 70% confidence, for the efficient designs by accuracy, in 20 replicates of each policy." ] }, { @@ -2759,13 +2768,20 @@ "id": "d1e2f3a4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:41:22.948393Z", - "iopub.status.busy": "2026-11-11T14:41:22.948166Z", - "iopub.status.idle": "2026-11-11T14:41:23.867042Z", - "shell.execute_reply": "2026-11-11T14:41:23.866131Z" + "iopub.execute_input": "2026-11-11T15:46:06.155498Z", + "iopub.status.busy": "2026-11-11T15:46:06.155305Z", + "iopub.status.idle": "2026-11-11T15:46:10.706851Z", + "shell.execute_reply": "2026-11-11T15:46:10.705993Z" } }, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "37% of the satellites fail in 5 years\n" + ] + }, { "data": { "text/html": [ @@ -2779,19 +2795,40 @@ " vertical-align: top;\n", " }\n", "\n", - " .dataframe thead th {\n", + " .dataframe thead tr th {\n", + " text-align: left;\n", + " }\n", + "\n", + " .dataframe thead tr:last-of-type th {\n", " text-align: right;\n", " }\n", "\n", "\n", " \n", - " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", @@ -2800,6 +2837,15 @@ " \n", " \n", " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", @@ -2807,132 +2853,274 @@ " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", + " \n", " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", + " \n", " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", "
descriptionaccurateaccurate p10accurate with failuresaccurate p10 with failuresfull constellationaccurateaccurate p10cost p70
policydegradeproducespare in orbitspare on grounddegradeproducespare in orbitspare on grounddegradeproducespare in orbitspare on ground
design
de5bf5d3c148800 km, 60 deg FOR, SSO: 1 at 06:003.91.03.63.53.73.83.80.10.91.01.0121.0129.5147.7148.8
7274d007018f800 km, 60 deg FOR, SSO: 2 at 09:009.65.98.63.87.58.89.09.21.04.24.45.5138.1165.1181.3185.3
b85daf65c3a4800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...16.79.914.013.915.62.610.710.311.014.35.9155.8202.0225.3220.4
104e33a3c842800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac...28.624.824.411.016.422.523.724.15.816.317.317.4180.4226.5252.6252.4
33b006848799800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...31.725.021.625.726.81.827.10.314.120.620.3147.4162.3195.6189.1
ceabaa8327b8800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:0054.849.048.028.235.645.047.447.812.235.540.840.9163.6195.4231.4212.0
92ff9cd17e00800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...57.852.652.631.934.843.245.745.818.133.438.838.8171.1209.1256.1229.3
25d7b27dab28800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:0082.277.773.050.854.468.968.371.726.659.563.563.9180.1215.6254.2236.1
716cb479efda700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...97.295.089.966.379.075.780.943.771.370.073.2218.1276.0326.9301.8
679ca275c8fc5529c21520be800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...98.096.097.796.081.083.877.683.878.981.973.782.0262.3351.3406.9367.5
5529c21520be679ca275c8fc800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...98.096.097.896.080.983.777.483.877.381.673.381.9262.3351.3406.9367.5
de505bc89299800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...98.096.097.495.980.783.877.583.878.281.973.482.1262.3351.3406.9367.5
\n", "" ], "text/plain": [ - " description accurate \\\n", - "design \n", - "de5bf5d3c148 800 km, 60 deg FOR, SSO: 1 at 06:00 3.9 \n", - "7274d007018f 800 km, 60 deg FOR, SSO: 2 at 09:00 9.6 \n", - "b85daf65c3a4 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... 16.7 \n", - "104e33a3c842 800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac... 28.6 \n", - "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 31.7 \n", - "ceabaa8327b8 800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00 54.8 \n", - "92ff9cd17e00 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 57.8 \n", - "25d7b27dab28 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00 82.2 \n", - "716cb479efda 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... 97.2 \n", - "679ca275c8fc 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 98.0 \n", - "5529c21520be 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 98.0 \n", - "de505bc89299 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 98.0 \n", + " description \\\n", + "policy \n", + "design \n", + "de5bf5d3c148 800 km, 60 deg FOR, SSO: 1 at 06:00 \n", + "7274d007018f 800 km, 60 deg FOR, SSO: 2 at 09:00 \n", + "b85daf65c3a4 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... \n", + "104e33a3c842 800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac... \n", + "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", + "ceabaa8327b8 800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00 \n", + "92ff9cd17e00 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... \n", + "25d7b27dab28 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00 \n", + "716cb479efda 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", + "5529c21520be 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", + "679ca275c8fc 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", + "de505bc89299 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", + "\n", + " full constellation accurate \\\n", + "policy degrade produce spare in orbit \n", + "design \n", + "de5bf5d3c148 3.9 3.5 3.7 3.8 \n", + "7274d007018f 9.6 7.5 8.8 9.0 \n", + "b85daf65c3a4 16.7 9.9 14.0 13.9 \n", + "104e33a3c842 28.6 16.4 22.5 23.7 \n", + "33b006848799 31.7 21.6 25.7 26.8 \n", + "ceabaa8327b8 54.8 35.6 45.0 47.4 \n", + "92ff9cd17e00 57.8 34.8 43.2 45.7 \n", + "25d7b27dab28 82.2 54.4 68.9 68.3 \n", + "716cb479efda 97.2 66.3 79.0 75.7 \n", + "5529c21520be 98.0 81.0 83.8 77.6 \n", + "679ca275c8fc 98.0 80.9 83.7 77.4 \n", + "de505bc89299 98.0 80.7 83.8 77.5 \n", + "\n", + " accurate p10 \\\n", + "policy spare on ground degrade produce spare in orbit \n", + "design \n", + "de5bf5d3c148 3.8 0.1 0.9 1.0 \n", + "7274d007018f 9.2 1.0 4.2 4.4 \n", + "b85daf65c3a4 15.6 2.6 10.7 10.3 \n", + "104e33a3c842 24.1 5.8 16.3 17.3 \n", + "33b006848799 27.1 0.3 14.1 20.6 \n", + "ceabaa8327b8 47.8 12.2 35.5 40.8 \n", + "92ff9cd17e00 45.8 18.1 33.4 38.8 \n", + "25d7b27dab28 71.7 26.6 59.5 63.5 \n", + "716cb479efda 80.9 43.7 71.3 70.0 \n", + "5529c21520be 83.8 78.9 81.9 73.7 \n", + "679ca275c8fc 83.8 77.3 81.6 73.3 \n", + "de505bc89299 83.8 78.2 81.9 73.4 \n", "\n", - " accurate p10 accurate with failures accurate p10 with failures \n", - "design \n", - "de5bf5d3c148 1.0 3.6 0.9 \n", - "7274d007018f 5.9 8.6 3.8 \n", - "b85daf65c3a4 11.0 14.3 5.9 \n", - "104e33a3c842 24.8 24.4 11.0 \n", - "33b006848799 25.0 26.8 1.8 \n", - "ceabaa8327b8 49.0 48.0 28.2 \n", - "92ff9cd17e00 52.6 52.6 31.9 \n", - "25d7b27dab28 77.7 73.0 50.8 \n", - "716cb479efda 95.0 89.9 79.0 \n", - "679ca275c8fc 96.0 97.7 96.0 \n", - "5529c21520be 96.0 97.8 96.0 \n", - "de505bc89299 96.0 97.4 95.9 " + " cost p70 \n", + "policy spare on ground degrade produce spare in orbit spare on ground \n", + "design \n", + "de5bf5d3c148 1.0 121.0 129.5 147.7 148.8 \n", + "7274d007018f 5.5 138.1 165.1 181.3 185.3 \n", + "b85daf65c3a4 11.0 155.8 202.0 225.3 220.4 \n", + "104e33a3c842 17.4 180.4 226.5 252.6 252.4 \n", + "33b006848799 20.3 147.4 162.3 195.6 189.1 \n", + "ceabaa8327b8 40.9 163.6 195.4 231.4 212.0 \n", + "92ff9cd17e00 38.8 171.1 209.1 256.1 229.3 \n", + "25d7b27dab28 63.9 180.1 215.6 254.2 236.1 \n", + "716cb479efda 73.2 218.1 276.0 326.9 301.8 \n", + "5529c21520be 82.0 262.3 351.3 406.9 367.5 \n", + "679ca275c8fc 81.9 262.3 351.3 406.9 367.5 \n", + "de505bc89299 82.1 262.3 351.3 406.9 367.5 " ] }, "execution_count": 15, @@ -2941,15 +3129,42 @@ } ], "source": [ + "from tatc.tradespace import Bathtub, Exponential, FailureModel, RestorationPolicy, Weibull\n", + "\n", + "# illustrative lives: about 9% fail in their first year, 3% a year at random, and wear-out after about 8 years\n", + "FAILURES = FailureModel(\n", + " life=Bathtub(infant=Weibull(shape=0.5, scale=100), random=Exponential(0.03), wear_out=Weibull(shape=4, scale=9)),\n", + " launch=0.05,\n", + ")\n", + "POLICIES = { # the policy and the spares in orbit of each plane\n", + " \"degrade\": (RestorationPolicy(restore=False), 0),\n", + " \"produce\": (RestorationPolicy(procurement_years=0.5), 0),\n", + " \"spare in orbit\": (RestorationPolicy(procurement_years=0.5, replenish=True), 1),\n", + " \"spare on ground\": (RestorationPolicy(procurement_years=0.5, ground_spares=1, replenish=True), 0),\n", + "}\n", + "print(f\"{1 - FAILURES.life.survival(5):.0%} of the satellites fail in 5 years\")\n", + "\n", "robust_designs = [by_key[key] for key in accuracy.design[accuracy.pareto]]\n", - "failing = make_study(replicates=20, failure_probability=0.1).run(robust_designs)\n", + "ROBUST = {\n", + " \"accurate\": \"accurate mean\",\n", + " \"accurate p10\": Quantile(\"accurate mean\", 0.1),\n", + " \"availability\": \"availability\",\n", + " \"cost p70\": Quantile(\"cost\", 0.7),\n", + "}\n", + "outcomes = []\n", + "for name, (policy, spares) in POLICIES.items():\n", + " study = make_study(replicates=20, failures=FAILURES, policy=policy, spares=spares, phased=True)\n", + " outcome = aggregate(study.run(robust_designs), ROBUST).set_index(\"design\")[list(ROBUST)]\n", + " outcomes.append(outcome.assign(policy=name))\n", + "outcomes = pd.concat(outcomes)\n", "nominal = make_study(replicates=20).run(robust_designs)\n", - "STATS = {\"accurate\": \"accurate\", \"accurate p10\": Quantile(\"accurate\", 0.1)}\n", - "robustness = aggregate(nominal, STATS).set_index(\"design\")[list(STATS)].join(\n", - " aggregate(failing, STATS).set_index(\"design\")[list(STATS)].add_suffix(\" with failures\")\n", - ")\n", - "robustness.insert(0, \"description\", [describe(values.loc[key]) for key in robustness.index])\n", - "robustness.sort_values(\"accurate\").round(1)" + "full = aggregate(nominal, [\"accurate\"]).set_index(\"design\")\n", + "table = outcomes.pivot(columns=\"policy\", values=[\"accurate\", \"accurate p10\", \"cost p70\"])[\n", + " [(metric, policy) for metric in (\"accurate\", \"accurate p10\", \"cost p70\") for policy in POLICIES]\n", + "]\n", + "table.insert(0, (\"full constellation\", \"\"), full[\"accurate\"])\n", + "table.insert(0, (\"description\", \"\"), [describe(values.loc[key]) for key in table.index])\n", + "table.sort_values((\"full constellation\", \"\")).round(1)" ] }, { @@ -2957,7 +3172,14 @@ "id": "e2f3a4b5", "metadata": {}, "source": [ - "Designs that are equally accurate without failures differ with them. Nine satellites in three planes hardly change (98% accurate, and at least 96% in the worst 10% of the replicates), as the failure of a satellite leaves others in its plane. Six satellites in three planes lose 7 points on average, and four in two sun-synchronous planes 9 points, with as little as 51% in the worst 10% of the replicates. Two satellites in two planes lose 5 points on average, but nearly everything in the worst replicates, in which one of the two fails. The worst case, as a quantile over replicates with failures, is a criterion for the robustness of a design that its mean hides." + "The shares accurately sampled over the mission fall short of those of the full constellation under every policy, by the phases of deployment and the failures of launches as well as of satellites (37% of which fail within five years). The response to failures matters most for the designs of several satellites in several planes, and in their worst replicates:\n", + "\n", + "* **Degrading** is cheapest, but loses 8 to 15 points of the mean against producing replacements for the designs of three to six satellites in two or three planes, and more in their worst 10% of replicates (44% against 71% for six satellites in three Walker planes; 0.3% against 14% for two satellites in two planes, which can lose both). Nine satellites in three planes lose only 3 points: a failure leaves eight.\n", + "* **Producing replacements** restores most of it, at 7 to 34% more cost at 70% confidence than degrading.\n", + "* **Spares** cost 22 to 55% more than degrading, and pay off in the worst replicates of the small designs of several planes: two satellites in two planes keep 20% in their worst replicates with a spare, against 14% by producing replacements. A spare on the ground costs less than a spare in each plane for the designs of several planes, and restores as well.\n", + "* **A spare in orbit can hurt**: for six or nine satellites in three planes, the spares delay the deployment (each plane's spare takes longer to produce, and a fourth satellite in a plane takes a second launch of up to three), so that they sample less on average (76% against 79% for six satellites, 78% against 84% for nine) at the highest cost.\n", + "\n", + "The policies and spares are decisions of a design: as design variables, with the policy made for each design, they put the trade of cost against robustness on the front, with statistics of the worst replicates (`Quantile`) or of meeting a requirement (`Probability`) as objectives." ] }, { @@ -2978,10 +3200,10 @@ "id": "c2d3e4f5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:41:23.869193Z", - "iopub.status.busy": "2026-11-11T14:41:23.868963Z", - "iopub.status.idle": "2026-11-11T14:41:25.541556Z", - "shell.execute_reply": "2026-11-11T14:41:25.540782Z" + "iopub.execute_input": "2026-11-11T15:46:10.708404Z", + "iopub.status.busy": "2026-11-11T15:46:10.708173Z", + "iopub.status.idle": "2026-11-11T15:46:12.371561Z", + "shell.execute_reply": "2026-11-11T15:46:12.370913Z" } }, "outputs": [ @@ -3291,10 +3513,10 @@ "id": "f5a6b7c8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:41:25.543200Z", - "iopub.status.busy": "2026-11-11T14:41:25.542944Z", - "iopub.status.idle": "2026-11-11T14:41:25.745945Z", - "shell.execute_reply": "2026-11-11T14:41:25.745240Z" + "iopub.execute_input": "2026-11-11T15:46:12.373184Z", + "iopub.status.busy": "2026-11-11T15:46:12.372961Z", + "iopub.status.idle": "2026-11-11T15:46:12.558914Z", + "shell.execute_reply": "2026-11-11T15:46:12.558209Z" } }, "outputs": [ @@ -3484,10 +3706,10 @@ "id": "d6e5f8a7", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:41:25.747449Z", - "iopub.status.busy": "2026-11-11T14:41:25.747230Z", - "iopub.status.idle": "2026-11-11T14:41:28.420131Z", - "shell.execute_reply": "2026-11-11T14:41:28.419393Z" + "iopub.execute_input": "2026-11-11T15:46:12.560452Z", + "iopub.status.busy": "2026-11-11T15:46:12.560216Z", + "iopub.status.idle": "2026-11-11T15:46:14.959735Z", + "shell.execute_reply": "2026-11-11T15:46:14.958907Z" } }, "outputs": [ @@ -3647,10 +3869,10 @@ "id": "a9b8c1d0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:41:28.421864Z", - "iopub.status.busy": "2026-11-11T14:41:28.421666Z", - "iopub.status.idle": "2026-11-11T14:41:29.909474Z", - "shell.execute_reply": "2026-11-11T14:41:29.908607Z" + "iopub.execute_input": "2026-11-11T15:46:14.961343Z", + "iopub.status.busy": "2026-11-11T15:46:14.961107Z", + "iopub.status.idle": "2026-11-11T15:46:15.923190Z", + "shell.execute_reply": "2026-11-11T15:46:15.922471Z" } }, "outputs": [ @@ -3761,10 +3983,10 @@ "id": "b0c9d2e1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T14:41:29.912401Z", - "iopub.status.busy": "2026-11-11T14:41:29.911914Z", - "iopub.status.idle": "2026-11-11T14:41:30.069650Z", - "shell.execute_reply": "2026-11-11T14:41:30.068286Z" + "iopub.execute_input": "2026-11-11T15:46:15.924775Z", + "iopub.status.busy": "2026-11-11T15:46:15.924549Z", + "iopub.status.idle": "2026-11-11T15:46:16.047642Z", + "shell.execute_reply": "2026-11-11T15:46:16.046881Z" } }, "outputs": [ @@ -3816,7 +4038,7 @@ "* A `Study` evaluates designs in replicates, in parallel, with a `SatelliteCache` that analyzes each distinct satellite once and a `ResultStore` that keeps its evaluations (by the fingerprint of the study, so that a changed study evaluates its designs again). Every design of a space of about a thousand designs can be evaluated in minutes.\n", "* Statistical sufficiency is measured by the sampling error of the statistic that observations estimate (`tatc.analysis.estimate_sampling_error`), which counts of samples overstate when samples cluster in time, as they do in a single plane; revisit statistics and local time coverage explain it.\n", "* The front of the means of the replicates is uncertain: `pareto_probability` finds the designs whose efficiency the replicates settle, and those that are equally good candidates, and `refine` adds replicates only to the latter, with a tolerance of differences that do not matter. `confirm` evaluates the selected designs with new replicates, which removes the optimism of selecting the best of many nearly equal designs.\n", - "* Statistics other than means (such as a `Quantile` or the `Probability` of meeting a threshold) state how reliably a design performs, including with failures of satellites (`remove_failures`), and `Requirement`s on them are output constraints. `sensitivity` finds the design variables that drive each objective.\n", + "* Statistics other than means (such as a `Quantile` or the `Probability` of meeting a threshold) state how reliably a design performs, and `Requirement`s on them are output constraints. Simulated missions (`Deployment.simulate`) draw the failures of satellites and launches from lives whose failure rates vary over the lifecycle (`FailureModel`), and restore them or not (`RestorationPolicy`, by spares in orbit or on the ground, or by producing new ones), for both the cost and the capability of each policy. `sensitivity` finds the design variables that drive each objective.\n", "* `screen` evaluates every design with a cheap study and the best with the full one, which finds the front at a fraction of the cost if the cheap study ranks designs as the full one does.\n", "* A `DeploymentSchedule` plans each design's deployment from rates of production and launch, which dates its costs and divides its mission into phases of the satellites that fly, evaluated with the observations of the full constellation for the mean capability over the mission and the time until a requirement is met.\n", "* A `CostModel` estimates the life-cycle cost of each deployment from the costs of its satellites, launches, and operations (given by the study), with uncertain growth whose quantiles give the cost at a confidence level, as an objective or a requirement in place of the numbers of satellites and planes.\n", diff --git a/src/tatc/tradespace/__init__.py b/src/tatc/tradespace/__init__.py index 5ff28638..817be307 100644 --- a/src/tatc/tradespace/__init__.py +++ b/src/tatc/tradespace/__init__.py @@ -37,11 +37,17 @@ Deployment, DeploymentSchedule, Launch, - Phase, Production, - draw_failures, - evaluate_phases, - summarize_phases, +) +from .mission import MissionHistory, Phase, evaluate_phases, summarize_phases +from .failures import ( + Bathtub, + Exponential, + FailureModel, + Lifetime, + Piecewise, + RestorationPolicy, + Weibull, ) from .criteria import ( Maximum, @@ -83,6 +89,7 @@ from .values import ChoiceValues, RepeatValues, Scope, Values __all__ = [ + "Bathtub", "Categorical", "Choice", "ChoiceValues", @@ -95,16 +102,21 @@ "Design", "DesignSpace", "Evaluations", + "Exponential", + "FailureModel", "Fixed", "Infeasible", "Integer", "Launch", "LaunchCost", + "Lifetime", "Maximum", "Mean", "Minimum", + "MissionHistory", "OperationsCost", "Phase", + "Piecewise", "Probability", "Production", "Quantile", @@ -113,6 +125,7 @@ "Repeat", "RepeatValues", "Requirement", + "RestorationPolicy", "ResultStore", "SatelliteCache", "SatelliteCost", @@ -124,12 +137,12 @@ "Uncertain", "Values", "Variable", + "Weibull", "aggregate", "build_constellation", "confirm", "count_planes", "count_satellites", - "draw_failures", "evaluate_phases", "get_fingerprint", "get_satellite_key", diff --git a/src/tatc/tradespace/cost.py b/src/tatc/tradespace/cost.py index f37844a2..9118ab5b 100644 --- a/src/tatc/tradespace/cost.py +++ b/src/tatc/tradespace/cost.py @@ -42,6 +42,7 @@ def evaluate(built): from .constellations import PLANES, SSO_PLANES, WALKER, _kind, _layout, _layouts from .deployment import Deployment +from .mission import MissionHistory ELEMENTS = ("development", "production", "launch", "operations") """The elements of the cost of a constellation.""" @@ -307,14 +308,20 @@ def _get_type(self, kind: Any) -> SatelliteCost: raise ValueError(f"no cost of satellites of kind {kind!r}") return self.satellites[kind] - def estimate(self, deployment: Deployment, growth: Growth = 1.0) -> CostEstimate: + def estimate( + self, deployment: Deployment | MissionHistory, growth: Growth = 1.0 + ) -> CostEstimate: """ - Estimates the life-cycle cost of a deployment, dating its costs: - the development of each type of satellite, spread over its - development; the production of its units along its learning curve, - spread over their production; each launch (and replacement), when it - flies; a fixed cost of operations over the mission; and each - satellite's operations from its launch to the end of the mission. + Estimates the life-cycle cost of a deployment (as planned, without + failures) or of a simulated mission (see `Deployment.simulate`), with + the satellites and launches its failures and restorations take, + dating its costs: the development of each type of satellite, spread + over its development; the production of its units (including spares, + replacements, and restorations) along its learning curve, spread over + their production; each launch (including those that fail), when it + flies; a fixed cost of operations over the mission; and the + operations of each satellite while it is in orbit (operating, or a + spare waiting). Growth factors multiply the estimate, such as uncertain parameters of cost growth drawn for each replicate (for example, @@ -325,8 +332,8 @@ def estimate(self, deployment: Deployment, growth: Growth = 1.0) -> CostEstimate (`NaN`). Args: - deployment (Deployment): The deployment (see - `DeploymentSchedule.plan`). + deployment (Deployment | MissionHistory): The deployment (see + `DeploymentSchedule.plan`), or a simulated mission. growth (float | Mapping[str, float]): A growth factor of the cost, or of each element (`"development"`, `"production"`, `"launch"`, or `"operations"`; others 1). @@ -335,6 +342,9 @@ def estimate(self, deployment: Deployment, growth: Growth = 1.0) -> CostEstimate CostEstimate: the estimate """ factors = _get_growth(growth) + history = ( + deployment.simulate() if isinstance(deployment, Deployment) else deployment + ) estimate = CostEstimate() flows: list[tuple[float, str, float]] = [] @@ -344,15 +354,15 @@ def add(element: str, amounts: list[tuple[float, float]]) -> None: ) if self.launch.per_kg > 0 and any( - self._get_type(kind).mass is None for kind in deployment.development + self._get_type(kind).mass is None for kind in history.development ): raise ValueError("launches priced by mass require masses") - for kind, developed in deployment.development.items(): + for kind, developed in history.development.items(): add( "development", _spread(self._get_type(kind).development, 0.0, developed) ) built: dict[Any, int] = {} - for batch in deployment.production: + for batch in history.production: cost = self._get_type(batch.kind) before = built.get(batch.kind, 0) amount = cost.production(before + batch.satellites) - cost.production( @@ -364,25 +374,23 @@ def add(element: str, amounts: list[tuple[float, float]]) -> None: "satellites" if kind is None else str(kind): units for kind, units in built.items() } - begin, end = deployment.begin, deployment.end - for launch in deployment.launches: + begin, end = history.begin, history.end + for launch in history.launches: cost = self._get_type(launch.kind) estimate.launches += int(self.launch.per_launch > 0) price = self.launch.per_launch + launch.satellites * ( self.launch.per_satellite + self.launch.per_kg * (cost.mass or 0.0) ) add("launch", [(launch.time, price)]) - if launch.generation == 0: - add( - "operations", - _spread( - self.operations.per_satellite_year - * launch.satellites - * (end - launch.time), - launch.time, - end, - ), - ) + for start, stop, count in history.in_orbit(): + add( + "operations", + _spread( + self.operations.per_satellite_year * count * (stop - start), + start, + stop, + ), + ) add("operations", _spread(self.operations.per_year * (end - begin), begin, end)) flows = [flow for flow in flows if flow[2] != 0] estimate.flows = sorted(flows, key=lambda flow: (flow[0], flow[1])) diff --git a/src/tatc/tradespace/deployment.py b/src/tatc/tradespace/deployment.py index ef333f27..bb56fefa 100644 --- a/src/tatc/tradespace/deployment.py +++ b/src/tatc/tradespace/deployment.py @@ -9,8 +9,13 @@ mission, the design life of satellites, the development and production of each type of satellite, and the launch cadence and capacity), from which each design's `Deployment` follows: a design of more satellites and planes -takes longer to produce and launch. Its launches divide the mission into -phases (`Deployment.phases`) of constant sets of operating satellites, each +takes longer to produce and launch. A deployment simulates a mission +(`Deployment.simulate`) with the failures of its satellites and launches +(see `FailureModel`) and a policy that restores them or not (see +`RestorationPolicy`), drawn for each replicate: the `MissionHistory` of +what is produced and launched, which a `CostModel` prices, and of the +satellites that operate. Their changes divide the mission into phases +(`MissionHistory.phases`) of constant sets of operating satellites, each evaluated over the study's representative period (`evaluate_phases`) and combined over the mission (`summarize_phases`), such as the time-weighted mean of a metric and the time until it first meets a requirement. @@ -23,16 +28,16 @@ import math from collections.abc import Callable, Mapping, Sequence from dataclasses import dataclass, field -from typing import Any - -import numpy as np -import pandas as pd +from typing import TYPE_CHECKING, Any from ..schemas import Satellite from .constellations import PLANES, SSO_PLANES, WALKER, _kind, _layout, _layouts -from .criteria import _OPERATORS, Requirement +from .failures import FailureModel, RestorationPolicy from .values import Values +if TYPE_CHECKING: + from .mission import MissionHistory, Phase + PerType = float | Mapping[Any, float] """A value for every type of satellite, or for each (by its name).""" @@ -66,7 +71,8 @@ def _planes(layout: Any) -> list[tuple[int, Any]]: @dataclass(frozen=True) class Launch: """ - A launch of satellites of a plane (see `Deployment`). + A launch of satellites of a plane (see `Deployment` and + `MissionHistory`). """ time: float @@ -76,17 +82,25 @@ class Launch: kind: Any """Any: The type of its satellites.""" first: int - """int: The position in its plane of its first satellite.""" + """int: The position in its plane of its first satellite (-1 for the + launches of restorations and spares).""" satellites: int """int: The number of satellites (including spares).""" generation: int = 0 - """int: The generation (0 for the first, others replacements).""" + """int: The generation (0 for the first, others planned replacements).""" + purpose: str = "deployment" + """str: `"deployment"`, `"replacement"` (planned, at the end of a + design life), `"restoration"` (of failed satellites), or `"spare"` (a + spare in orbit replenished).""" + failed: bool = False + """bool: Whether the launch failed, losing its satellites.""" @dataclass(frozen=True) class Production: """ - The production of satellites of a type (see `Deployment`). + The production of satellites of a type (see `Deployment` and + `MissionHistory`). """ kind: Any @@ -97,33 +111,16 @@ class Production: """float: The end of their production (years).""" satellites: int """int: The number of satellites.""" - - -@dataclass(frozen=True) -class Phase: - """ - A phase of a mission, in which a set of satellites operates (see - `Deployment.phases`). - """ - - start: float - """float: The start (years from the start of development).""" - end: float - """float: The end (years from the start of development).""" - satellites: tuple[str, ...] - """tuple[str, ...]: The names of the satellites that operate.""" - - @property - def duration(self) -> float: - """float: The duration (years).""" - return self.end - self.start + purpose: str = "deployment" + """str: `"deployment"`, `"replacement"`, `"restoration"`, or `"spare"`.""" @dataclass class Deployment: """ - The deployment of a constellation: its development, production, - launches, and replacements (see `DeploymentSchedule.plan`). + The planned deployment of a constellation: its development, production, + launches, and planned replacements (see `DeploymentSchedule.plan`), + without failures. """ schedule: DeploymentSchedule @@ -137,7 +134,9 @@ class Deployment: production: list[Production] = field(default_factory=list) """list[Production]: The production of the satellites, in order.""" launches: list[Launch] = field(default_factory=list) - """list[Launch]: The launches (and replacements), in order.""" + """list[Launch]: The launches (and planned replacements), in order.""" + masses: dict[Any, float | None] = field(default_factory=dict) + """dict: The mass (kg) of each type of satellite, if given.""" @property def begin(self) -> float: @@ -153,7 +152,9 @@ def end(self) -> float: def deployed(self) -> float: """float: The time by which every satellite of the first generation is launched (years).""" - return max(launch.time for launch in self.launches if launch.generation == 0) + return max( + launch.time for launch in self.launches if launch.purpose == "deployment" + ) @property def units(self) -> dict[Any, int]: @@ -164,91 +165,57 @@ def units(self) -> dict[Any, int]: units[batch.kind] = units.get(batch.kind, 0) + batch.satellites return units - def phases( + def simulate( self, - satellites: Sequence[Satellite | str], - failures: Mapping[str, float] | None = None, - ) -> list[Phase]: + failures: FailureModel | None = None, + policy: RestorationPolicy | None = None, + seed: int | None = None, + ) -> MissionHistory: """ - Gets the phases of the mission, from the first launch to its end, in - which constant sets of satellites operate: each satellite from its - launch, except, if it fails (at a time given by `failures`, see - `draw_failures`), from its failure to the launch of its replacement - (or the end of the mission). - - The satellites are those built for the layouts of the deployment - (see `build_constellation`), in the order of their planes (and of - several layouts, in the order given to `DeploymentSchedule.plan`), - without spares. The satellites of a plane of several launches - operate as each is launched, in order. + Simulates the mission: the deployment, with the failures of its + satellites and launches (drawn from a seed of a replicate, such as an + uncertain parameter, see `Uncertain.seed`) and the restoration of + failed satellites by a policy. Without a seed, nothing fails (but a + policy's spares on the ground are still produced). + + A satellite's life is drawn when it is launched (or takes the place + of a failed one), from a random number generator seeded by the seed + and its plane, position, and generation, and the success of a launch + from one seeded by its plane and order: with common random numbers, + the satellite at the same position of the same plane fails at the + same age in the same replicate of every design. Spares in orbit do + not age or fail until they take a failed satellite's place. + + Args: + failures (FailureModel | None): The failures, or `None` for none. + policy (RestorationPolicy | None): The policy for failed + satellites, or `None` to restore them by producing new ones. + seed (int | None): The seed of the replicate, or `None` for no + failures. + + Returns: + MissionHistory: the history of the mission + """ + # pylint: disable=import-outside-toplevel + from .mission import _Simulation + + return _Simulation( + self, failures or FailureModel(), policy or RestorationPolicy(), seed + ).run() + + def phases(self, satellites: Sequence[Satellite | str]) -> list[Phase]: + """ + Gets the phases of the mission without failures (see + `MissionHistory.phases`). Args: satellites (Sequence[Satellite | str]): The satellites (or their names), in the order of the planes. - failures (Mapping[str, float] | None): The time (years from the - start of development) at which satellites fail, by name. Returns: list[Phase]: the phases, in order """ - names = [s.name if isinstance(s, Satellite) else str(s) for s in satellites] - expected = sum(built for _, built, _ in self.planes) - if len(names) != expected: - raise ValueError( - f"expected {expected} satellites for the planes, not {len(names)}" - ) - offsets = np.cumsum([0] + [built for _, built, _ in self.planes]) - begin, end = self.begin, self.end - failures = failures or {} - intervals: dict[str, list[tuple[float, float]]] = {} - for launch in self.launches: - if launch.generation != 0: - continue - built = self.planes[launch.plane][1] - for position in range( - launch.first, min(launch.first + launch.satellites, built) - ): - name = names[offsets[launch.plane] + position] - start = launch.time - failure = failures.get(name) - if failure is None or failure >= end or failure < start: - intervals[name] = [(start, end)] - continue - replaced = [ - time for time in self._replacements(launch) if failure < time < end - ] - after = [(replaced[0], end)] if replaced else [] - intervals[name] = [(start, failure)] + after - events = {begin, end} - for spans in intervals.values(): - for start, stop in spans: - events.update((start, stop)) - times = sorted(time for time in events if begin <= time <= end) - phases: list[Phase] = [] - for start, stop in zip(times[:-1], times[1:]): - if stop - start <= 1e-12: - continue - middle = (start + stop) / 2 - active = tuple( - name - for name in names - if any(a <= middle < b for a, b in intervals.get(name, [])) - ) - if phases and phases[-1].satellites == active: - phases[-1] = Phase(phases[-1].start, stop, active) - else: - phases.append(Phase(start, stop, active)) - return phases - - def _replacements(self, launch: Launch) -> list[float]: - """Gets the times of the replacements of the satellites of a launch.""" - return sorted( - other.time - for other in self.launches - if other.generation > 0 - and other.plane == launch.plane - and other.first == launch.first - ) + return self.simulate().phases(satellites) @dataclass(frozen=True) @@ -280,7 +247,8 @@ class DeploymentSchedule: Args: years (float): The duration of the mission, from the first launch. design_life (float | None): The design life of the satellites, or - `None` if they last the mission. + `None` if they last the mission (or fail, see + `Deployment.simulate`). development_years (float | Mapping): The duration of development of each type of satellite, before production. production_rate (float | Mapping | None): The satellites of each type @@ -363,7 +331,8 @@ def plan( mapping of types of satellites to layouts. kind (Any): The type of the satellites of a layout. spares (int): The spares in orbit in each plane, produced and - launched with it. + launched with it, which wait in orbit to take the place of + failed satellites (see `RestorationPolicy`). masses (float | Mapping | None): The mass (kg) of the satellites (of each type), for a launch capacity in mass. @@ -379,12 +348,13 @@ def plan( else: fleets = {kind: layout} deployment = Deployment(schedule=self) - planes = [] # (ready, index, kind, satellites) + planes = [] # (ready, index, kind, satellites, mass) for name, item in fleets.items(): developed = float(_per_type(self.development_years, name, "development")) rate = _per_type(self.production_rate, name, "production rate") mass = None if masses is None else _per_type(masses, name, "mass") deployment.development[name] = developed + deployment.masses[name] = mass listed = [] for size, values in _planes(item): index = len(deployment.planes) @@ -425,7 +395,13 @@ def plan( 0.0 if rate is None else launch.satellites / rate ) deployment.production.append( - Production(launch.kind, produced, need, launch.satellites) + Production( + launch.kind, + produced, + need, + launch.satellites, + "replacement", + ) ) deployment.launches.append( Launch( @@ -435,141 +411,10 @@ def plan( launch.first, launch.satellites, generation, + "replacement", ) ) need, generation = need + self.design_life, generation + 1 deployment.production.sort(key=lambda batch: batch.begin) deployment.launches.sort(key=lambda launch: (launch.time, launch.plane)) return deployment - - -def draw_failures( - deployment: Deployment, - satellites: Sequence[Satellite | str], - annual_rate: float, - seed: int | None, -) -> dict[str, float]: - """ - Draws the times at which satellites fail (see `Deployment.phases`), each - after an exponentially distributed life from its launch (at a constant - `annual_rate` of failure), from an uncertain seed of a replicate (see - `Uncertain.seed`). The life of a satellite depends only on the seed and - its position, so that with common random numbers, the satellite at the - same position has the same life in the same replicate of every design. - - Args: - deployment (Deployment): The deployment. - satellites (Sequence[Satellite | str]): The satellites (or their - names), in the order of the planes (see `Deployment.phases`). - annual_rate (float): The rate of failure (per year). - seed (int | None): The seed of the replicate, or `None` for no - failures. - - Returns: - dict[str, float]: the time of failure of each satellite that fails - before the end of the mission - """ - if annual_rate < 0: - raise ValueError("annual_rate must not be negative") - if seed is None or annual_rate == 0: - return {} - launched = {} - for phase in deployment.phases(satellites): - for name in phase.satellites: - launched.setdefault(name, phase.start) - names = [s.name if isinstance(s, Satellite) else str(s) for s in satellites] - failures = {} - for k, name in enumerate(names): - life = np.random.default_rng([seed, k]).exponential(1 / annual_rate) - time = launched[name] + life - if time < deployment.end: - failures[name] = float(time) - return failures - - -def evaluate_phases( - phases: Sequence[Phase], - observations: pd.DataFrame, - metric: Callable[[pd.DataFrame], Mapping[str, float]], -) -> pd.DataFrame: - """ - Evaluates the phases of a mission: a metric of the observations of the - satellites that operate in each phase, over the study's representative - period (the observations of the full constellation, by satellite, such - as from a `SatelliteCache`, filtered to those of each phase). Phases of - the same satellites are evaluated once. - - Args: - phases (Sequence[Phase]): The phases (see `Deployment.phases`). - observations (pandas.DataFrame): The observations of every - satellite, with their names (`satellite`). - metric (Callable): A function of the observations of a phase (which - may be empty) that gives its metrics. - - Returns: - pandas.DataFrame: a row per phase: its `start`, `end`, `duration`, - number of `satellites`, and metrics - """ - rows, evaluated = [], {} - for phase in phases: - key = frozenset(phase.satellites) - if key not in evaluated: - if "satellite" in observations.columns: - subset = observations[observations["satellite"].isin(key)] - else: - subset = observations.iloc[0:0] - evaluated[key] = dict(metric(subset)) - rows.append( - { - "start": phase.start, - "end": phase.end, - "duration": phase.duration, - "satellites": len(phase.satellites), - **evaluated[key], - } - ) - return pd.DataFrame(rows) - - -def summarize_phases( - capability: pd.DataFrame, - metrics: Sequence[str] | None = None, - requirements: Sequence[Requirement] = (), -) -> dict[str, float]: - """ - Summarizes the capability of a mission over its phases (see - `evaluate_phases`): the mean of each metric weighted by the durations of - the phases (` mean`, over the mission, from its first launch), - and, for each requirement on a metric, the time (years from the start of - development) at which a phase first meets it (` time`, infinite - if none does). - - Args: - capability (pandas.DataFrame): The metrics of each phase. - metrics (Sequence[str] | None): The metrics, or `None` for every - column other than those of the phases. - requirements (Sequence[Requirement]): Requirements on metrics. - - Returns: - dict[str, float]: the summary, as metrics of an evaluation - """ - if metrics is None: - metrics = [ - column - for column in capability.columns - if column not in ("start", "end", "duration", "satellites") - ] - weights = capability["duration"].to_numpy(dtype=float) - summary = {} - for name in metrics: - values = capability[name].to_numpy(dtype=float) - summary[f"{name} mean"] = float(np.sum(values * weights) / np.sum(weights)) - for requirement in requirements: - met = _OPERATORS[requirement.operator]( - capability[requirement.name].to_numpy(dtype=float), requirement.value - ) - starts = capability["start"].to_numpy(dtype=float)[met] - summary[f"{requirement.name} time"] = ( - float(starts[0]) if len(starts) > 0 else math.inf - ) - return summary diff --git a/src/tatc/tradespace/failures.py b/src/tatc/tradespace/failures.py new file mode 100644 index 00000000..b5b2696c --- /dev/null +++ b/src/tatc/tradespace/failures.py @@ -0,0 +1,342 @@ +""" +Failures of satellites and launches, and the policies that restore (or do +not restore) the satellites that fail, for simulations of missions (see +`Deployment.simulate`). + +The life of a satellite (from its launch) follows a distribution whose +failure rate may vary over its lifecycle: constant (`Exponential`), +decreasing in infancy or increasing with wear (`Weibull`), both (`Bathtub`, +the earliest of competing causes), or given by intervals of age +(`Piecewise`). A `FailureModel` gives the life of each type of satellite and +the probability that a launch fails, and a `RestorationPolicy` whether and +how failed satellites are restored: by spares in orbit, by spares on the +ground, or by satellites built when needed. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +import math +from collections.abc import Mapping, Sequence +from dataclasses import dataclass +from typing import Any + +import numpy as np + + +class Lifetime: + """ + Base class of distributions of the life (years) of a satellite from its + launch. + """ + + def cumulative_hazard(self, age: np.ndarray) -> np.ndarray: + """ + Gets the cumulative hazard at ages (the negative logarithm of the + survival). + + Args: + age (numpy.ndarray): The ages (years). + + Returns: + numpy.ndarray: the cumulative hazard + """ + raise NotImplementedError + + def hazard(self, age: np.ndarray) -> np.ndarray: + """ + Gets the hazard (failure rate, per year) at ages. + + Args: + age (numpy.ndarray): The ages (years). + + Returns: + numpy.ndarray: the hazard + """ + raise NotImplementedError + + def survival(self, age: np.ndarray) -> np.ndarray: + """ + Gets the probability of surviving to ages. + + Args: + age (numpy.ndarray): The ages (years). + + Returns: + numpy.ndarray: the survival + """ + return np.exp(-self.cumulative_hazard(np.asarray(age, dtype=float))) + + def sample(self, rng: np.random.Generator) -> float: + """ + Draws a life (years, infinite if the satellite never fails). + + Args: + rng (numpy.random.Generator): The random number generator. + + Returns: + float: the life + """ + raise NotImplementedError + + +@dataclass(frozen=True) +class Exponential(Lifetime): + """ + A life of constant failure rate (random failures). + + Args: + rate (float): The failure rate (per year). + """ + + rate: float + + def __post_init__(self): + if self.rate < 0: + raise ValueError("rate must not be negative") + + def cumulative_hazard(self, age): + return self.rate * np.asarray(age, dtype=float) + + def hazard(self, age): + return np.full_like(np.asarray(age, dtype=float), self.rate) + + def sample(self, rng): + return math.inf if self.rate == 0 else float(rng.exponential(1 / self.rate)) + + +@dataclass(frozen=True) +class Weibull(Lifetime): + """ + A life of a Weibull distribution: a failure rate that decreases with age + (infant mortality) if its shape is less than 1, is constant if 1, and + increases (wear-out) if greater. + + Args: + shape (float): The shape. + scale (float): The scale (years), the age at which 63% have failed. + """ + + shape: float + scale: float + + def __post_init__(self): + if self.shape <= 0 or self.scale <= 0: + raise ValueError("shape and scale must be positive") + + def cumulative_hazard(self, age): + return (np.asarray(age, dtype=float) / self.scale) ** self.shape + + def hazard(self, age): + age = np.asarray(age, dtype=float) + with np.errstate(divide="ignore"): + return (self.shape / self.scale) * (age / self.scale) ** (self.shape - 1) + + def sample(self, rng): + return float(self.scale * rng.weibull(self.shape)) + + +@dataclass(frozen=True) +class Bathtub(Lifetime): + """ + A life of competing causes of failure (the earliest of their lives), such + as the bathtub curve of infant mortality, random failures, and wear-out: + its hazard is the sum of theirs. + + Args: + infant (Lifetime | None): Failures early in life. + random (Lifetime | None): Failures at random. + wear_out (Lifetime | None): Failures late in life. + """ + + infant: Lifetime | None = None + random: Lifetime | None = None + wear_out: Lifetime | None = None + + @property + def causes(self) -> list[Lifetime]: + """list[Lifetime]: The causes of failure.""" + return [c for c in (self.infant, self.random, self.wear_out) if c is not None] + + def cumulative_hazard(self, age): + age = np.asarray(age, dtype=float) + return sum((c.cumulative_hazard(age) for c in self.causes), np.zeros_like(age)) + + def hazard(self, age): + age = np.asarray(age, dtype=float) + return sum((c.hazard(age) for c in self.causes), np.zeros_like(age)) + + def sample(self, rng): + return min((c.sample(rng) for c in self.causes), default=math.inf) + + +@dataclass(frozen=True) +class Piecewise(Lifetime): + """ + A life of failure rates given by intervals of age: `rates[i]` from + `breaks[i]` to `breaks[i + 1]` (the last beyond the last break), as from + reliability data. + + Args: + breaks (Sequence[float]): The ages (years) at which the intervals + begin, from 0, increasing. + rates (Sequence[float]): The failure rate (per year) of each. + """ + + breaks: Sequence[float] + rates: Sequence[float] + + def __post_init__(self): + breaks, rates = list(self.breaks), list(self.rates) + if len(breaks) == 0 or breaks[0] != 0: + raise ValueError("breaks must begin at 0") + if len(breaks) != len(rates): + raise ValueError("a rate is required for each interval") + if any(b <= a for a, b in zip(breaks[:-1], breaks[1:])): + raise ValueError("breaks must increase") + if any(rate < 0 for rate in rates): + raise ValueError("rates must not be negative") + object.__setattr__(self, "breaks", tuple(float(b) for b in breaks)) + object.__setattr__(self, "rates", tuple(float(r) for r in rates)) + + def _ends(self) -> np.ndarray: + return np.append(np.asarray(self.breaks[1:]), math.inf) + + def cumulative_hazard(self, age): + age = np.asarray(age, dtype=float) + starts, ends = np.asarray(self.breaks), self._ends() + within = np.clip(age[..., None] - starts, 0, ends - starts) + return np.sum(within * np.asarray(self.rates), axis=-1) + + def hazard(self, age): + age = np.asarray(age, dtype=float) + index = np.searchsorted(np.asarray(self.breaks), age, side="right") - 1 + return np.asarray(self.rates)[np.clip(index, 0, len(self.rates) - 1)] + + def sample(self, rng): + # the age at which the cumulative hazard reaches a unit exponential draw + target = float(rng.exponential(1.0)) + cumulative = 0.0 + for start, end, rate in zip(self.breaks, self._ends(), self.rates): + span = end - start + if rate > 0 and cumulative + rate * span >= target: + return start + (target - cumulative) / rate + cumulative += rate * span if math.isfinite(span) else 0.0 + return math.inf + + +@dataclass(frozen=True) +class FailureModel: + """ + The failures of a mission: the life of the satellites (of every type, or + of each, by name; `None` if they do not fail) and the probability that + a launch fails, losing its satellites. + + Args: + life (Lifetime | Mapping[Any, Lifetime] | None): The life of the + satellites. + launch (float): The probability that a launch fails. + """ + + life: Lifetime | Mapping[Any, Lifetime | None] | None = None + launch: float = 0.0 + + def __post_init__(self): + if not 0 <= self.launch <= 1: + raise ValueError("launch must be a probability") + + def life_of(self, kind: Any) -> Lifetime | None: + """ + Gets the life of a type of satellite. + + Args: + kind (Any): The type. + + Returns: + Lifetime | None: the life, or `None` if it does not fail + """ + if isinstance(self.life, Mapping): + if kind not in self.life: + raise ValueError(f"no life of satellites of kind {kind!r}") + return self.life[kind] + return self.life + + +@dataclass(frozen=True) +class RestorationPolicy: + """ + A policy for satellites that fail: to fly the others (`restore=False`, + degrading the constellation until the satellites are replaced at the end + of their design life, if they are), or to restore them, from the fastest + source available when the failure is known (`detection_years` after it): + + * a spare in orbit in the failed satellite's plane (see the `spares` of + `DeploymentSchedule.plan`), which takes its place after + `drift_years`; + * a spare on the ground (`ground_spares` of each type, produced after + the first satellites and stored), launched at the next launch slot; + * a satellite produced when needed, `procurement_years` after it is + ordered (for long-lead items) and on its type's production line (after + the work before it), then launched at the next launch slot. + + A restoration of a plane joins a launch already booked for the plane, if + it has room (see the launch capacity of `DeploymentSchedule`); otherwise + it books one at the next launch slot after waiting `batch_years` for + others. With `replenish`, a spare that is used is produced again (and, + in orbit, launched to its plane), procured and produced as a satellite + produced when needed, which shares the production line with + restorations. + + Args: + restore (bool): `True` to restore failed satellites. + detection_years (float): The time to know of a failure. + drift_years (float): The time for a spare in orbit to take the place + of a failed satellite. + procurement_years (float): The time from ordering a satellite to the + start of its production. + ground_spares (int | Mapping[Any, int]): The spares on the ground of + each type of satellite. + replenish (bool): `True` to replace the spares that are used. + batch_years (float): The time that restorations of a plane wait to + share a launch. + """ + + restore: bool = True + detection_years: float = 0.1 + drift_years: float = 0.25 + procurement_years: float = 0.0 + ground_spares: int | Mapping[Any, int] = 0 + replenish: bool = False + batch_years: float = 0.0 + + def __post_init__(self): + for name in ( + "detection_years", + "drift_years", + "procurement_years", + "batch_years", + ): + if getattr(self, name) < 0: + raise ValueError(f"{name} must not be negative") + values = ( + self.ground_spares.values() + if isinstance(self.ground_spares, Mapping) + else [self.ground_spares] + ) + if any(value < 0 for value in values): + raise ValueError("ground_spares must not be negative") + + def ground_spares_of(self, kind: Any) -> int: + """ + Gets the spares on the ground of a type of satellite. + + Args: + kind (Any): The type. + + Returns: + int: the number of spares + """ + if isinstance(self.ground_spares, Mapping): + return int(self.ground_spares.get(kind, 0)) + return int(self.ground_spares) diff --git a/src/tatc/tradespace/mission.py b/src/tatc/tradespace/mission.py new file mode 100644 index 00000000..40995dde --- /dev/null +++ b/src/tatc/tradespace/mission.py @@ -0,0 +1,614 @@ +""" +Simulated missions: the history of a deployment with failures and +restorations (see `Deployment.simulate`), the phases of a mission in which +constant sets of satellites operate, and their evaluation over the study's +representative period and combination over the mission. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +import heapq +import itertools +import math +from collections.abc import Callable, Mapping, Sequence +from dataclasses import dataclass, field, replace +from typing import Any + +import numpy as np +import pandas as pd + +from ..schemas import Satellite +from .criteria import _OPERATORS, Requirement +from .deployment import Deployment, DeploymentSchedule, Launch, Production, _per_type +from .failures import FailureModel, RestorationPolicy + + +@dataclass(frozen=True) +class Phase: + """ + A phase of a mission, in which a set of satellites operates (see + `MissionHistory.phases`). + """ + + start: float + """float: The start (years from the start of development).""" + end: float + """float: The end (years from the start of development).""" + satellites: tuple[str, ...] + """tuple[str, ...]: The names of the satellites that operate.""" + + @property + def duration(self) -> float: + """float: The duration (years).""" + return self.end - self.start + + +def _names(satellites: Sequence[Satellite | str]) -> list[str]: + return [s.name if isinstance(s, Satellite) else str(s) for s in satellites] + + +@dataclass +class MissionHistory: + """ + The history of a simulated mission (see `Deployment.simulate`): what is + produced and launched (as a deployment, which a `CostModel` prices), when + satellites fail and are restored, and when each operates. + """ + + deployment: Deployment + """Deployment: The planned deployment.""" + production: list[Production] = field(default_factory=list) + """list[Production]: The production of satellites, in order.""" + launches: list[Launch] = field(default_factory=list) + """list[Launch]: The launches, in order.""" + operating: dict[tuple[int, int], list[tuple[float, float]]] = field( + default_factory=dict + ) + """dict: The intervals in which the satellite at each position of each + plane (by plane and position) operates.""" + parked: list[tuple[float, float, int]] = field(default_factory=list) + """list: The intervals in which spares wait in orbit, and their number.""" + failures: list[tuple[float, int, int, str]] = field(default_factory=list) + """list: The failures: their time, plane, position, and cause (`"life"` + or `"launch"`).""" + restorations: list[tuple[int, int, float, float, str]] = field(default_factory=list) + """list: The restorations: their plane, position, the time of the failure + and of the restoration, and the source (`"orbit"`, `"ground"`, or + `"production"`).""" + + @property + def schedule(self) -> DeploymentSchedule: + """DeploymentSchedule: The schedule of the deployment.""" + return self.deployment.schedule + + @property + def planes(self) -> list[tuple[Any, int, int]]: + """list: The planes of the deployment.""" + return self.deployment.planes + + @property + def development(self) -> dict[Any, float]: + """dict: The end of the development of each type of satellite.""" + return self.deployment.development + + @property + def masses(self) -> dict[Any, float | None]: + """dict: The mass of each type of satellite, if given.""" + return self.deployment.masses + + @property + def begin(self) -> float: + """float: The beginning of the mission (its planned first launch).""" + return self.deployment.begin + + @property + def end(self) -> float: + """float: The end of the mission.""" + return self.deployment.end + + def in_orbit(self) -> list[tuple[float, float, int]]: + """ + Gets the intervals in which satellites are in orbit (operating, or + spares waiting), for the cost of their operations. + + Returns: + list: the intervals, and the number of satellites in each + """ + spans = [ + (start, stop, 1) + for intervals in self.operating.values() + for start, stop in intervals + ] + return spans + list(self.parked) + + def phases(self, satellites: Sequence[Satellite | str]) -> list[Phase]: + """ + Gets the phases of the mission, from its beginning to its end, in + which constant sets of satellites operate. + + The satellites are those built for the layouts of the deployment + (see `build_constellation`), in the order of their planes (and of + several layouts, in the order given to `DeploymentSchedule.plan`), + without spares: the satellite at each position of each plane is the + one (and its replacements) that operates there. + + Args: + satellites (Sequence[Satellite | str]): The satellites (or their + names), in the order of the planes. + + Returns: + list[Phase]: the phases, in order + """ + names = _names(satellites) + expected = sum(built for _, built, _ in self.planes) + if len(names) != expected: + raise ValueError( + f"expected {expected} satellites for the planes, not {len(names)}" + ) + offsets = np.cumsum([0] + [built for _, built, _ in self.planes]) + intervals = { + names[offsets[plane] + position]: spans + for (plane, position), spans in self.operating.items() + } + begin, end = self.begin, self.end + events = {begin, end} + for spans in intervals.values(): + for start, stop in spans: + events.update((start, stop)) + times = sorted(time for time in events if begin <= time <= end) + phases: list[Phase] = [] + for start, stop in zip(times[:-1], times[1:]): + if stop - start <= 1e-12: + continue + middle = (start + stop) / 2 + active = tuple( + name + for name in names + if any(a <= middle < b for a, b in intervals.get(name, [])) + ) + if phases and phases[-1].satellites == active: + phases[-1] = Phase(phases[-1].start, stop, active) + else: + phases.append(Phase(start, stop, active)) + return phases + + def metrics(self) -> dict[str, float]: + """ + Gets measures of the mission as metrics of an evaluation: the + failures of satellites (`failures`, including those lost in + launches), the launches that failed (`launch failures`), the + restorations (`restorations`), the spares used (`spares used`), the + mean time from failure to restoration (`restoration years`, `NaN` + without restorations), and the availability of the satellites + (`availability`: their years of operation, as a share of those of + the planned deployment). + + Returns: + dict[str, float]: the metrics + """ + planned = self.deployment.simulate() + operated = sum(b - a for spans in self.operating.values() for a, b in spans) + possible = sum(b - a for spans in planned.operating.values() for a, b in spans) + delays = [restored - failed for *_, failed, restored, _ in self.restorations] + return { + "failures": float(len(self.failures)), + "launch failures": float(sum(launch.failed for launch in self.launches)), + "restorations": float(len(self.restorations)), + "spares used": float( + sum(source != "production" for *_, source in self.restorations) + ), + "restoration years": float(np.mean(delays)) if delays else math.nan, + "availability": operated / possible if possible > 0 else math.nan, + } + + +@dataclass +class _Booking: + """A launch of restorations or spares, open to more until it flies.""" + + time: float + plane: int + kind: Any + items: list = field(default_factory=list) + order: int = 0 + + +class _Simulation: + """ + A discrete-event simulation of a mission (see `Deployment.simulate`). + """ + + # pylint: disable=too-many-instance-attributes + + def __init__( + self, + deployment: Deployment, + failures: FailureModel, + policy: RestorationPolicy, + seed: int | None, + ): + self.deployment, self.failures, self.policy = deployment, failures, policy + self.seed = seed + self.schedule = deployment.schedule + self.end = deployment.end + self.history = MissionHistory( + deployment, production=list(deployment.production) + ) + self.events: list = [] + self.counter = itertools.count() + # the state of each position: its generation, when it began to + # operate (or None), when it failed, and whether it awaits restoration + self.slots = { + (plane, position): { + "generation": -1, + "up": None, + "down": None, + "pending": False, + } + for plane, (_, built, _) in enumerate(deployment.planes) + for position in range(built) + } + self.spares = dict.fromkeys(range(len(deployment.planes)), 0) + self.spares_since: dict[int, float] = {} + self.ground: dict[Any, int] = {} + self.line = { + kind: max( + ( + b.end + for b in deployment.production + if b.kind == kind and b.purpose == "deployment" + ), + default=developed, + ) + for kind, developed in deployment.development.items() + } + self.booked = sorted(launch.time for launch in deployment.launches) + self.open: dict[int, list[_Booking]] = {} + self.launches_of_plane: dict[int, int] = {} + + # --- randomness + + def _rng(self, *key: int) -> np.random.Generator: + return np.random.default_rng([self.seed, *key]) + + def _life(self, plane: int, position: int, generation: int) -> float: + if self.seed is None: + return math.inf + life = self.failures.life_of(self.deployment.planes[plane][0]) + if life is None: + return math.inf + return life.sample(self._rng(0, plane, position, generation)) + + def _launch_fails(self, *key: int) -> bool: + if self.seed is None or self.failures.launch == 0: + return False + return bool(self._rng(1, *key).random() < self.failures.launch) + + # --- events + + def _push(self, time: float, kind: str, *payload: Any) -> None: + heapq.heappush(self.events, (time, next(self.counter), kind, payload)) + + def run(self) -> MissionHistory: + """Runs the simulation, returning the history of the mission.""" + # pylint: disable=too-many-branches + for kind in self.deployment.development: + count = self.policy.ground_spares_of(kind) + if count > 0: + begin = self.line[kind] + ready = begin + self._producing(kind, count) + self.history.production.append( + Production(kind, begin, ready, count, "spare") + ) + self.line[kind] = ready + self.ground.setdefault(kind, 0) + self._push(ready, "stock", kind, count) + for launch in self.deployment.launches: + self._push(launch.time, "planned", launch) + steps = 0 + while self.events: + time, _, kind, payload = heapq.heappop(self.events) + if time >= self.end: + break + steps += 1 + if steps > 1_000_000: + raise RuntimeError("the simulation does not progress") + getattr(self, f"_on_{kind}")(time, *payload) + for (plane, position), slot in self.slots.items(): + if slot["up"] is not None: + self._close(plane, position, self.end) + for plane, since in self.spares_since.items(): + if self.spares[plane] > 0: + self.history.parked.append((since, self.end, self.spares[plane])) + self.history.production.sort(key=lambda batch: batch.begin) + self.history.launches.sort(key=lambda launch: (launch.time, launch.plane)) + return self.history + + def _on_stock(self, time: float, kind: Any, count: int) -> None: + del time + self.ground[kind] = self.ground.get(kind, 0) + count + + def _on_planned(self, time: float, launch: Launch) -> None: + failed = self._launch_fails(0, launch.plane, launch.first, launch.generation) + self.history.launches.append(replace(launch, failed=failed)) + built = self.deployment.planes[launch.plane][1] + positions = range(launch.first, launch.first + launch.satellites) + for position in positions: + if position >= built: + continue + slot = self.slots[launch.plane, position] + if launch.purpose == "deployment": + if failed: + self._fail(time, launch.plane, position, "launch") + else: + self._up(time, launch.plane, position) + elif not failed: + # a planned replacement takes the place of the satellite + if slot["up"] is not None: + self._close(launch.plane, position, time) + self._up(time, launch.plane, position) + spares = sum(position >= built for position in positions) + if spares and not failed: + level = self.deployment.planes[launch.plane][2] + if launch.purpose == "deployment": + self._park(time, launch.plane, spares) + else: + self._park( + time, + launch.plane, + max(0, min(spares, level - self.spares[launch.plane])), + ) + + def _on_fail(self, time: float, plane: int, position: int, generation: int) -> None: + slot = self.slots[plane, position] + if slot["generation"] != generation or slot["up"] is None: + return # a satellite replaced before it failed + self._close(plane, position, time) + self._fail(time, plane, position, "life") + + def _fail(self, time: float, plane: int, position: int, cause: str) -> None: + slot = self.slots[plane, position] + slot["down"] = time + self.history.failures.append((time, plane, position, cause)) + if self.policy.restore and not slot["pending"]: + slot["pending"] = True + self._push(time + self.policy.detection_years, "request", plane, position) + + def _on_request(self, time: float, plane: int, position: int) -> None: + slot = self.slots[plane, position] + if slot["up"] is not None: # restored by a planned replacement + slot["pending"] = False + return + kind = self.deployment.planes[plane][0] + if self.spares[plane] > 0: + self._park(time, plane, -1) + self._push( + time + self.policy.drift_years, "activate", plane, position, "orbit" + ) + if self.policy.replenish: + ready = self._produce(time, kind, 1, "spare") + self._book(plane, kind, ready, ("spare",)) + elif self.ground.get(kind, 0) > 0: + self.ground[kind] -= 1 + self._book(plane, kind, time, ("slot", position, "ground")) + if self.policy.replenish: + ready = self._produce(time, kind, 1, "spare") + self._push(ready, "stock", kind, 1) + else: + ready = self._produce(time, kind, 1, "restoration") + self._book(plane, kind, ready, ("slot", position, "production")) + + def _on_activate(self, time: float, plane: int, position: int, source: str) -> None: + slot = self.slots[plane, position] + if slot["up"] is not None: + self._park(time, plane, 1) # not needed: back to waiting + return + self._restore(time, plane, position, source) + + def _on_booking(self, time: float, booking: _Booking) -> None: + self.open[booking.plane].remove(booking) + failed = self._launch_fails(1, booking.plane, booking.order) + spare = all(item[0] == "spare" for item in booking.items) + self.history.launches.append( + Launch( + time, + booking.plane, + booking.kind, + -1, + len(booking.items), + purpose="spare" if spare else "restoration", + failed=failed, + ) + ) + for item in booking.items: + if item[0] == "spare": + if not failed: + self._park(time, booking.plane, 1) + continue + _, position, source = item + slot = self.slots[booking.plane, position] + if failed: + slot["pending"] = False + self.history.failures.append((time, booking.plane, position, "launch")) + if self.policy.restore: + slot["pending"] = True + self._push( + time + max(self.policy.detection_years, 1e-6), + "request", + booking.plane, + position, + ) + elif slot["up"] is not None: + self._park(time, booking.plane, 1) # not needed: a spare in orbit + else: + self._restore(time, booking.plane, position, source) + + # --- actions + + def _up(self, time: float, plane: int, position: int) -> None: + slot = self.slots[plane, position] + slot["generation"] += 1 + slot["up"], slot["pending"] = time, False + life = self._life(plane, position, slot["generation"]) + if time + life < self.end: + self._push(time + life, "fail", plane, position, slot["generation"]) + + def _close(self, plane: int, position: int, time: float) -> None: + slot = self.slots[plane, position] + if time > slot["up"]: + self.history.operating.setdefault((plane, position), []).append( + (slot["up"], time) + ) + slot["up"] = None + + def _restore(self, time: float, plane: int, position: int, source: str) -> None: + slot = self.slots[plane, position] + self.history.restorations.append((plane, position, slot["down"], time, source)) + self._up(time, plane, position) + + def _park(self, time: float, plane: int, change: int) -> None: + if change == 0: + return + if self.spares[plane] > 0: + since = self.spares_since[plane] + if time > since: + self.history.parked.append((since, time, self.spares[plane])) + self.spares[plane] += change + self.spares_since[plane] = time + + def _producing(self, kind: Any, count: int) -> float: + rate = _per_type(self.schedule.production_rate, kind, "production rate") + return 0.0 if rate is None else count / rate + + def _produce(self, time: float, kind: Any, count: int, purpose: str) -> float: + begin = max(self.line[kind], time + self.policy.procurement_years) + ready = begin + self._producing(kind, count) + self.line[kind] = ready + self.history.production.append(Production(kind, begin, ready, count, purpose)) + return ready + + def _slot(self, ready: float) -> float: + """The earliest launch at or after a time, at the launch cadence.""" + interval = self.schedule.launch_interval + time = ready + if interval > 0: + for booked in self.booked: + if booked - interval < time < booked + interval: + time = booked + interval + return time + + def _capacity(self, kind: Any) -> float: + capacity = math.inf + if self.schedule.launch_capacity is not None: + capacity = self.schedule.launch_capacity + if self.schedule.launch_mass_capacity is not None: + mass = self.deployment.masses.get(kind) + if mass is not None: + capacity = min( + capacity, math.floor(self.schedule.launch_mass_capacity / mass) + ) + return capacity + + def _book(self, plane: int, kind: Any, ready: float, item: tuple) -> None: + """Books an item on a launch of a plane: an open one, or a new one.""" + for booking in self.open.get(plane, []): + if booking.time >= ready and len(booking.items) < self._capacity(kind): + booking.items.append(item) + return + time = self._slot(ready + self.policy.batch_years) + order = self.launches_of_plane.get(plane, 0) + self.launches_of_plane[plane] = order + 1 + booking = _Booking(time, plane, kind, [item], order) + self.open.setdefault(plane, []).append(booking) + self.booked = sorted(self.booked + [time]) + self._push(time, "booking", booking) + + +def evaluate_phases( + phases: Sequence[Phase], + observations: pd.DataFrame, + metric: Callable[[pd.DataFrame], Mapping[str, float]], +) -> pd.DataFrame: + """ + Evaluates the phases of a mission: a metric of the observations of the + satellites that operate in each phase, over the study's representative + period (the observations of the full constellation, by satellite, such + as from a `SatelliteCache`, filtered to those of each phase). Phases of + the same satellites are evaluated once. + + Args: + phases (Sequence[Phase]): The phases (see `MissionHistory.phases`). + observations (pandas.DataFrame): The observations of every + satellite, with their names (`satellite`). + metric (Callable): A function of the observations of a phase (which + may be empty) that gives its metrics. + + Returns: + pandas.DataFrame: a row per phase: its `start`, `end`, `duration`, + number of `satellites`, and metrics + """ + rows, evaluated = [], {} + for phase in phases: + key = frozenset(phase.satellites) + if key not in evaluated: + if "satellite" in observations.columns: + subset = observations[observations["satellite"].isin(key)] + else: + subset = observations.iloc[0:0] + evaluated[key] = dict(metric(subset)) + rows.append( + { + "start": phase.start, + "end": phase.end, + "duration": phase.duration, + "satellites": len(phase.satellites), + **evaluated[key], + } + ) + return pd.DataFrame(rows) + + +def summarize_phases( + capability: pd.DataFrame, + metrics: Sequence[str] | None = None, + requirements: Sequence[Requirement] = (), +) -> dict[str, float]: + """ + Summarizes the capability of a mission over its phases (see + `evaluate_phases`): the mean of each metric weighted by the durations of + the phases (` mean`, over the mission, from its first launch), + and, for each requirement on a metric, the time (years from the start of + development) at which a phase first meets it (` time`, infinite + if none does). + + Args: + capability (pandas.DataFrame): The metrics of each phase. + metrics (Sequence[str] | None): The metrics, or `None` for every + column other than those of the phases. + requirements (Sequence[Requirement]): Requirements on metrics. + + Returns: + dict[str, float]: the summary, as metrics of an evaluation + """ + if metrics is None: + metrics = [ + column + for column in capability.columns + if column not in ("start", "end", "duration", "satellites") + ] + weights = capability["duration"].to_numpy(dtype=float) + summary = {} + for name in metrics: + values = capability[name].to_numpy(dtype=float) + summary[f"{name} mean"] = float(np.sum(values * weights) / np.sum(weights)) + for requirement in requirements: + met = _OPERATORS[requirement.operator]( + capability[requirement.name].to_numpy(dtype=float), requirement.value + ) + starts = capability["start"].to_numpy(dtype=float)[met] + summary[f"{requirement.name} time"] = ( + float(starts[0]) if len(starts) > 0 else math.inf + ) + return summary diff --git a/tests/tradespace/test_deployment.py b/tests/tradespace/test_deployment.py index 05b67151..e2f35b34 100644 --- a/tests/tradespace/test_deployment.py +++ b/tests/tradespace/test_deployment.py @@ -14,9 +14,9 @@ from tatc.tradespace import ( DeploymentSchedule, DesignSpace, + Phase, Real, Requirement, - draw_failures, evaluate_phases, sso_planes_space, summarize_phases, @@ -147,29 +147,6 @@ def test_deployment(self): with self.assertRaises(ValueError): self.deployment.phases(self.names[:3]) - def test_failures(self): - """A failed satellite is missing until its replacement is launched.""" - phases = self.deployment.phases(self.names, failures={self.names[0]: 2.5}) - # it fails at 2.5 and its replacement launches at 4 (a design life of 2) - self.assertEqual( - [(p.start, p.end, len(p.satellites)) for p in phases], - [(2, 2.5, 2), (2.5, 3, 1), (3, 4, 3), (4, 6, 4)], - ) - - def test_draw_failures(self): - """Failures are drawn from a rate, the same for the same position.""" - self.assertEqual(draw_failures(self.deployment, self.names, 0.5, None), {}) - failures = draw_failures(self.deployment, self.names, 0.5, seed=3) - again = draw_failures(self.deployment, self.names, 0.5, seed=3) - self.assertEqual(failures, again) - self.assertTrue(all(2 <= t < 6 for t in failures.values())) - many = [ - len(draw_failures(self.deployment, self.names, 0.5, seed=s)) - for s in range(200) - ] - # about 1 - exp(-0.5 * 3.5) of each satellite fails in the mission - self.assertAlmostEqual(np.mean(many) / 4, 1 - math.exp(-0.5 * 3.5), delta=0.06) - def test_evaluate_and_summarize(self): """Phases are evaluated with their satellites' observations, and summarized.""" observations = pd.DataFrame({"satellite": self.names * 3, "target": range(12)}) @@ -179,7 +156,14 @@ def metric(obs): calls.append(len(obs)) return {"targets": 25.0 * obs["satellite"].nunique()} - phases = self.deployment.phases(self.names, failures={self.names[0]: 2.5}) + # the first satellite fails at 2.5 and is replaced at 4 + names = tuple(self.names) + phases = [ + Phase(2, 2.5, names[:2]), + Phase(2.5, 3, names[1:2]), + Phase(3, 4, names[1:]), + Phase(4, 6, names), + ] capability = evaluate_phases(phases, observations, metric) self.assertEqual(list(capability.targets), [50, 25, 75, 100]) self.assertEqual(list(capability.satellites), [2, 1, 3, 4]) diff --git a/tests/tradespace/test_failures.py b/tests/tradespace/test_failures.py new file mode 100644 index 00000000..2ddb9549 --- /dev/null +++ b/tests/tradespace/test_failures.py @@ -0,0 +1,332 @@ +""" +Unit tests for failures of satellites and launches, their restoration, and +simulations of missions. + +@author Paul T. Grogan +""" + +import math +import unittest +from dataclasses import dataclass + +import numpy as np + +from tatc.tradespace import ( + Bathtub, + CostModel, + DeploymentSchedule, + DesignSpace, + Exponential, + FailureModel, + LaunchCost, + Lifetime, + OperationsCost, + Piecewise, + RestorationPolicy, + SatelliteCost, + Weibull, + walker_space, +) + + +def _walker(planes=1, per_plane=2): + (design,) = DesignSpace( + layout=walker_space( + inclination=55.0, planes=planes, per_plane=per_plane, relative_spacing=0 + ) + ).enumerate() + return design.layout + + +def _names(count): + return [f"satellite {k + 1}" for k in range(count)] + + +@dataclass(frozen=True) +class _Fixed(Lifetime): + """A life of a fixed duration (the first satellite only, if `first`).""" + + years: float + + def cumulative_hazard(self, age): + return np.where(np.asarray(age) >= self.years, np.inf, 0.0) + + def hazard(self, age): + return np.zeros_like(np.asarray(age, dtype=float)) + + def sample(self, rng): + return self.years + + +def _empirical(life, ages, n=40_000, seed=1): + rng = np.random.default_rng(seed) + lives = np.array([life.sample(rng) for _ in range(n)]) + return np.array([(lives > age).mean() for age in ages]) + + +class TestLifetimes(unittest.TestCase): + """ + Unit tests for distributions of life. + """ + + ages = np.array([0.5, 2.0, 5.0, 9.0]) + + def test_exponential(self): + """A constant failure rate.""" + life = Exponential(0.2) + np.testing.assert_allclose(life.survival(self.ages), np.exp(-0.2 * self.ages)) + np.testing.assert_allclose(life.hazard(self.ages), 0.2) + np.testing.assert_allclose( + _empirical(life, self.ages), life.survival(self.ages), atol=0.01 + ) + self.assertEqual(Exponential(0).sample(np.random.default_rng(0)), math.inf) + with self.assertRaises(ValueError): + Exponential(-1) + + def test_weibull(self): + """Decreasing and increasing failure rates.""" + infant, wear = Weibull(0.5, 20), Weibull(4, 6) + for life in (infant, wear): + np.testing.assert_allclose( + _empirical(life, self.ages), life.survival(self.ages), atol=0.01 + ) + self.assertGreater(infant.hazard(0.5), infant.hazard(5)) + self.assertLess(wear.hazard(0.5), wear.hazard(5)) + with self.assertRaises(ValueError): + Weibull(0, 1) + + def test_bathtub(self): + """Competing causes: hazards add, the earliest fails.""" + parts = (Weibull(0.5, 30), Exponential(0.05), Weibull(5, 7)) + life = Bathtub(*parts) + np.testing.assert_allclose( + life.hazard(self.ages), sum(p.hazard(self.ages) for p in parts) + ) + np.testing.assert_allclose( + life.survival(self.ages), + np.prod([p.survival(self.ages) for p in parts], axis=0), + ) + np.testing.assert_allclose( + _empirical(life, self.ages), life.survival(self.ages), atol=0.01 + ) + # high early, low in the middle, high late + hazard = life.hazard(np.array([0.05, 3.0, 9.0])) + self.assertTrue(hazard[0] > hazard[1] < hazard[2]) + self.assertEqual(Bathtub().sample(np.random.default_rng(0)), math.inf) + + def test_piecewise(self): + """Failure rates by intervals of age.""" + life = Piecewise([0, 1, 4], [0.3, 0.05, 0.2]) + np.testing.assert_allclose(life.hazard(np.array([0.5, 2, 6])), [0.3, 0.05, 0.2]) + expected = np.exp( + -np.array([0.15, 0.3 + 0.05, 0.3 + 0.15 + 0.2, 0.3 + 0.15 + 1.0]) + ) + np.testing.assert_allclose(life.survival(self.ages), expected) + np.testing.assert_allclose( + _empirical(life, self.ages), life.survival(self.ages), atol=0.01 + ) + never = Piecewise([0, 1], [0.5, 0.0]) + self.assertGreater( + np.mean( + [never.sample(np.random.default_rng(s)) == math.inf for s in range(400)] + ), + 0.5, + ) + for breaks, rates in ( + ([1, 2], [0.1, 0.1]), + ([0, 2], [0.1]), + ([0, 2, 1], [1, 1, 1]), + ): + with self.assertRaises(ValueError): + Piecewise(breaks, rates) + + def test_models(self): + """Lives of each type of satellite, and failures of launches.""" + model = FailureModel(life={"a": Exponential(0.1), "b": None}, launch=0.05) + self.assertEqual(model.life_of("a"), Exponential(0.1)) + self.assertIsNone(model.life_of("b")) + with self.assertRaises(ValueError): + model.life_of("c") + with self.assertRaises(ValueError): + FailureModel(launch=1.5) + + +class TestSimulation(unittest.TestCase): + """ + Unit tests for simulated missions. + """ + + def setUp(self): + # one plane of 2 satellites, launched at year 1, for a mission of 4 years + self.schedule = DeploymentSchedule( + years=4, development_years=1, production_rate=4, launch_interval=0.5 + ) + self.layout = _walker(1, 2) + self.names = _names(2) + # every satellite fails 1.5 years after it begins to operate + self.failures = FailureModel(life=_Fixed(1.5)) + + def _simulate(self, policy, spares=0, failures=None, seed=0): + deployment = self.schedule.plan(self.layout, spares=spares) + return deployment.simulate(failures or self.failures, policy, seed) + + def test_without_failures(self): + """Without failures, the history is the deployment's.""" + deployment = self.schedule.plan(self.layout) + history = deployment.simulate() + self.assertEqual(history.failures, []) + self.assertEqual( + history.operating, {(0, 0): [(1.5, 5.5)], (0, 1): [(1.5, 5.5)]} + ) + model = CostModel( + SatelliteCost(development=10, first_unit=5), + launch=LaunchCost(per_launch=3), + operations=OperationsCost(per_satellite_year=1), + ) + self.assertAlmostEqual( + model.estimate(deployment).total, model.estimate(history).total + ) + # a failure model without a seed draws no failures + self.assertEqual(deployment.simulate(self.failures, seed=None).failures, []) + self.assertEqual(history.metrics()["availability"], 1.0) + + def test_degrade(self): + """Without restoration, failed satellites stay failed.""" + history = self._simulate(RestorationPolicy(restore=False)) + # both fail at 3.0 (1.5 years after their launch at 1.5) + self.assertEqual(history.operating[0, 0], [(1.5, 3.0)]) + self.assertEqual(len(history.failures), 2) + self.assertEqual(history.restorations, []) + self.assertAlmostEqual(history.metrics()["availability"], 1.5 / 4) + phases = history.phases(self.names) + self.assertEqual( + [(p.start, p.end, len(p.satellites)) for p in phases], + [(1.5, 3.0, 2), (3.0, 5.5, 0)], + ) + + def test_restore_by_production(self): + """A failed satellite is produced, then launched at the next slot.""" + policy = RestorationPolicy(detection_years=0.1, procurement_years=0.2) + history = self._simulate(policy) + # failed at 3.0, ordered at 3.1, produced from 3.3 to 3.55 (the + # second after it, to 3.8), each launched when ready (slots 0.5 apart) + restored = sorted( + (p, failed, round(when, 6), source) + for p, failed, when, source in [ + (pos, f, r, s) for _, pos, f, r, s in history.restorations[:2] + ] + ) + self.assertEqual([r[2] for r in restored], [3.55, 4.05]) + self.assertTrue(all(r[3] == "production" for r in restored)) + purposes = [b.purpose for b in history.production] + self.assertIn("restoration", purposes) + self.assertEqual( + sorted(l.purpose for l in history.launches).count("restoration"), + sum(1 for l in history.launches if l.purpose == "restoration"), + ) + + def test_restore_from_orbit(self): + """A spare in orbit takes a failed satellite's place after drifting.""" + policy = RestorationPolicy(detection_years=0.1, drift_years=0.2) + history = self._simulate(policy, spares=1) + first = sorted(history.restorations, key=lambda r: r[3])[0] + self.assertEqual(first[4], "orbit") + self.assertAlmostEqual(first[3] - first[2], 0.3) + # the other satellite, failing at the same time, waits for production + sources = [r[4] for r in history.restorations] + self.assertIn("production", sources) + self.assertGreater(history.metrics()["spares used"], 0) + + def test_restore_from_ground(self): + """A spare on the ground is launched at the next slot.""" + policy = RestorationPolicy(detection_years=0.1, ground_spares=2) + history = self._simulate(policy) + sources = [r[4] for r in history.restorations[:2]] + self.assertEqual(sources, ["ground", "ground"]) + delays = sorted(round(r[3] - r[2], 6) for r in history.restorations[:2]) + # both known at 3.1, and launched together then + self.assertEqual(delays, [0.1, 0.1]) + restorations = [l for l in history.launches if l.purpose == "restoration"] + self.assertEqual(restorations[0].satellites, 2) + spares = [b for b in history.production if b.purpose == "spare"] + self.assertEqual(sum(b.satellites for b in spares), 2) + + def test_batching(self): + """Restorations of a plane waiting within a window share a launch.""" + alone = self._simulate(RestorationPolicy(ground_spares=2)) + shared = self._simulate(RestorationPolicy(ground_spares=2, batch_years=0.2)) + count = lambda h: sum(l.purpose == "restoration" for l in h.launches) + self.assertGreater(count(alone), count(shared)) + + def test_launch_failures(self): + """A failed launch loses its satellites.""" + always = FailureModel(launch=1.0) + degraded = self._simulate(RestorationPolicy(restore=False), failures=always) + self.assertEqual(degraded.operating, {}) + self.assertTrue(all(launch.failed for launch in degraded.launches)) + self.assertEqual(degraded.metrics()["availability"], 0) + restored = self._simulate(RestorationPolicy(), failures=always) + # restorations are attempted (and fail) until the end of the mission + self.assertGreater(len(restored.launches), len(degraded.launches)) + self.assertEqual(restored.operating, {}) + + def test_planned_replacement(self): + """A planned replacement restores a degraded satellite.""" + schedule = DeploymentSchedule(years=4, design_life=2, development_years=1) + history = schedule.plan(self.layout).simulate( + self.failures, RestorationPolicy(restore=False), seed=0 + ) + # launched at 1, failed at 2.5, replaced at 3, failed at 4.5 + self.assertEqual(history.operating[0, 0], [(1, 2.5), (3, 4.5)]) + + def test_common_random_numbers(self): + """The satellite at the same position fails at the same age.""" + failures = FailureModel(life=Exponential(0.3), launch=0.1) + first = self._simulate( + RestorationPolicy(restore=False), failures=failures, seed=4 + ) + other = self._simulate(RestorationPolicy(), failures=failures, seed=4) + self.assertEqual(first.failures[0], other.failures[0]) + different = self._simulate(RestorationPolicy(), failures=failures, seed=5) + self.assertNotEqual(first.failures, different.failures) + + def test_costs_of_policies(self): + """Restorations and spares cost more than degrading.""" + model = CostModel( + SatelliteCost(development=10, first_unit=5), + launch=LaunchCost(per_launch=3), + operations=OperationsCost(per_satellite_year=1), + ) + failures = FailureModel(life=Exponential(0.3)) + totals = {} + for name, policy, spares in ( + ("degrade", RestorationPolicy(restore=False), 0), + ("produce", RestorationPolicy(), 0), + ("orbit", RestorationPolicy(replenish=True), 1), + ): + costs, availability = [], [] + for seed in range(100): + history = self._simulate( + policy, spares=spares, failures=failures, seed=seed + ) + costs.append(model.estimate(history).total) + availability.append(history.metrics()["availability"]) + totals[name] = (np.mean(costs), np.mean(availability)) + self.assertLess(totals["degrade"][0], totals["produce"][0]) + self.assertLess(totals["degrade"][1], totals["produce"][1]) + self.assertLess(totals["produce"][0], totals["orbit"][0]) + + def test_policy_validation(self): + """Policies are validated.""" + for invalid in ( + {"detection_years": -1}, + {"drift_years": -1}, + {"procurement_years": -1}, + {"batch_years": -1}, + {"ground_spares": -1}, + ): + with self.assertRaises(ValueError): + RestorationPolicy(**invalid) + self.assertEqual( + RestorationPolicy(ground_spares={"a": 2}).ground_spares_of("b"), 0 + ) From 76f58acc769efdbc626677fa4f50789e3e1088c1 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Wed, 11 Nov 2026 09:13:28 -0700 Subject: [PATCH 16/52] expose restoration policies as design variables with policy_space and configure --- CHANGELOG.md | 2 +- docs/api_reference/tradespace.rst | 4 + docs/examples/SearchTradeSpace.ipynb | 641 ++++++++++++++++++++------- src/tatc/tradespace/__init__.py | 5 +- src/tatc/tradespace/failures.py | 77 +++- src/tatc/tradespace/values.py | 30 ++ tests/tradespace/test_failures.py | 103 +++++ 7 files changed, 696 insertions(+), 166 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3f02a828..e1c1d58b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -21,7 +21,7 @@ Added: - Function `tradespace.screen` (and class `Screening`), which screens designs with studies of increasing fidelity, keeping whole fronts of the best designs of each stage for the next. - Searches of design spaces with optional optimizers: `tradespace.optimize_optuna` suggests designs with Optuna trials (`DesignSpace.suggest`, define-by-run over the hierarchical space), and `optimize_pymoo` and `make_pymoo_problem` search the unit hypercube that encodes a design space (`DesignSpace.unit_paths`, `encode`, and `decode`) with pymoo. Each design is evaluated once, and the designs proposed together are evaluated together, in parallel if the study is. Constraints of a design space may return the amount of their violation (`Infeasible.violation`), which Optuna's trials record (`set_constraint`) for its constraint-aware samplers, and which is the constraint value of pymoo problems. Optional dependencies `tradespace` (joblib, Optuna, and pymoo). - Deployment of constellations (`tradespace.DeploymentSchedule`): from the rates and durations of a study (the mission and design life, the development of each type of satellite, its production on a line at a production rate, and launches at a cadence and capacity, in number or mass, optionally in an order of planes), each design's deployment (`DeploymentSchedule.plan`, a `Deployment` of its `Production`, `Launch`es, and replacements), so that a design of more satellites and planes takes longer to deploy. Its launches divide the mission into phases of constant sets of operating satellites (`Deployment.phases`), evaluated over the study's representative period from the observations of the full constellation (`evaluate_phases`) and combined over the mission (`summarize_phases`: the time-weighted mean of each metric and the time until it first meets a requirement). - - Simulated missions with failures (`Deployment.simulate`, a `MissionHistory` for each replicate, drawn from its seed with common random numbers between designs): lives of satellites whose failure rates vary over the lifecycle (`tradespace.Exponential`, `Weibull`, `Bathtub` of competing causes, and `Piecewise` rates by age, `Lifetime`), failures of launches (`FailureModel`), and a policy that degrades or restores failed satellites (`RestorationPolicy`) by spares in orbit (taking a failed satellite's place after drifting), spares on the ground (launched at the next launch slot), or satellites produced when needed (after procurement, on the production line), optionally replenishing spares and batching restorations in launches. A history gives the phases in which satellites operate (`MissionHistory.phases`), measures of the mission (`MissionHistory.metrics`: failures, restorations, spares used, time to restore, and availability), and, priced by a `CostModel`, the cost of what it produces and launches. + - Simulated missions with failures (`Deployment.simulate`, a `MissionHistory` for each replicate, drawn from its seed with common random numbers between designs): lives of satellites whose failure rates vary over the lifecycle (`tradespace.Exponential`, `Weibull`, `Bathtub` of competing causes, and `Piecewise` rates by age, `Lifetime`), failures of launches (`FailureModel`), and a policy that degrades or restores failed satellites (`RestorationPolicy`) by spares in orbit (taking a failed satellite's place after drifting), spares on the ground (launched at the next launch slot), or satellites produced when needed (after procurement, on the production line), optionally replenishing spares and batching restorations in launches. A history gives the phases in which satellites operate (`MissionHistory.phases`), measures of the mission (`MissionHistory.metrics`: failures, restorations, spares used, time to restore, and availability), and, priced by a `CostModel`, the cost of what it produces and launches. Policies are decisions of designs with a fragment of a design space (`policy_space`: whether to restore, spares in orbit and on the ground, and other fields of the policy, without spares that would never be used), and `configure` makes a policy (or a deployment schedule, or another dataclass) from the values of a design. - Life-cycle costs of deployments for trade studies (`tradespace.CostModel`): the development of each type of satellite, the production of its units on a learning curve (`SatelliteCost`), launches (per launch, or prices per satellite and kg, `LaunchCost`), operations (`OperationsCost`), replacements, and spares in orbit, dated by the deployment for their present value at a discount rate (`CostEstimate.present_value`, metric `cost present`) and annual costs (`CostEstimate.annual`, metric `cost peak annual`), with growth factors for cost risk (such as uncertain parameters, whose quantiles over replicates give the cost at a confidence level). TAT-C does not include cost-estimating relationships: the costs are given by the study. Fingerprints describe dataclasses (such as cost models) by their fields. - Function `tradespace.confirm` (and class `Confirmation`), which evaluates selected designs (such as a front) with new replicates that played no part in their selection, removing the optimism of the selection (the winner's curse, `Confirmation.optimism`). `ResultStore` keys evaluations by the fingerprint of a study (`Study.fingerprint`, see `get_fingerprint`: its seed, use of common random numbers, design space, and build and evaluation functions, and the version of TAT-C), warning if it holds evaluations of other definitions, which are not reused; `SatelliteCache` keys results on disk by the fingerprint of its function. `refine` treats designs with fewer than `min_replicates` (5) as uncertain whatever their probability, adds the replicates left to `max_replicates` in a last partial step, and warns if designs remain uncertain without a tolerance. `sensitivity` gives adjusted shares (epsilon squared) by default, without the share that the levels of a variable explain by chance (`adjusted=False` for correlation ratios). - Searches with Optuna accept categorical options that depend on earlier decisions (a parameter for each set of options), use TPE with a constant liar in batches by default (which spreads the trials of a batch), and stop after `max_designs` designs evaluated (trials that suggest designs evaluated before are told their objectives without evaluating them again). A design infeasible in some of its replicates violates its feasibility by their share (`Evaluations.infeasibility`), and the first design evaluated in a search is evaluated alone, to check that evaluations give one record each. `Study` records errors of evaluations as infeasible, without storing them, with `errors="record"`. Enumeration walks the items of unordered repetitions in one order only (the same designs, in the same order, four times faster for three sun-synchronous planes), and `DesignSpace.size` counts designs without keeping them. Pareto fronts are found by a vectorized sweep in lexicographic order that compares designs only with the efficient designs before them, and fronts with tolerances by comparing designs only with the efficient designs without tolerances (which dominate every design that any design dominates within the tolerances), in blocks of bounded memory: 20,000 designs in 0.05 s (0.11 s with tolerances) rather than 17 s, and the bootstraps of `pareto_probability` (and so `refine`) about 20 times faster. diff --git a/docs/api_reference/tradespace.rst b/docs/api_reference/tradespace.rst index 11aa0048..13b62f6a 100644 --- a/docs/api_reference/tradespace.rst +++ b/docs/api_reference/tradespace.rst @@ -47,6 +47,8 @@ Designs .. autoclass:: tatc.tradespace.Scope +.. autofunction:: tatc.tradespace.configure + Constellations -------------- @@ -108,6 +110,8 @@ Failures and Missions .. autoclass:: tatc.tradespace.RestorationPolicy :members: ground_spares_of +.. autofunction:: tatc.tradespace.policy_space + .. automodule:: tatc.tradespace.mission :no-members: diff --git a/docs/examples/SearchTradeSpace.ipynb b/docs/examples/SearchTradeSpace.ipynb index 7e6aa58c..722f9614 100644 --- a/docs/examples/SearchTradeSpace.ipynb +++ b/docs/examples/SearchTradeSpace.ipynb @@ -28,10 +28,10 @@ "id": "c3d2e5f4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:45:26.875139Z", - "iopub.status.busy": "2026-11-11T15:45:26.874923Z", - "iopub.status.idle": "2026-11-11T15:45:27.598015Z", - "shell.execute_reply": "2026-11-11T15:45:27.597171Z" + "iopub.execute_input": "2026-11-11T15:53:11.393375Z", + "iopub.status.busy": "2026-11-11T15:53:11.393137Z", + "iopub.status.idle": "2026-11-11T15:53:12.109607Z", + "shell.execute_reply": "2026-11-11T15:53:12.108717Z" } }, "outputs": [], @@ -79,10 +79,10 @@ "id": "e5f4a7b6", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:45:27.599909Z", - "iopub.status.busy": "2026-11-11T15:45:27.599607Z", - "iopub.status.idle": "2026-11-11T15:45:28.761055Z", - "shell.execute_reply": "2026-11-11T15:45:28.760302Z" + "iopub.execute_input": "2026-11-11T15:53:12.111462Z", + "iopub.status.busy": "2026-11-11T15:53:12.111141Z", + "iopub.status.idle": "2026-11-11T15:53:13.272309Z", + "shell.execute_reply": "2026-11-11T15:53:13.271593Z" } }, "outputs": [ @@ -143,10 +143,10 @@ "id": "a7b6c9d8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:45:28.762913Z", - "iopub.status.busy": "2026-11-11T15:45:28.762565Z", - "iopub.status.idle": "2026-11-11T15:45:28.770788Z", - "shell.execute_reply": "2026-11-11T15:45:28.770226Z" + "iopub.execute_input": "2026-11-11T15:53:13.274135Z", + "iopub.status.busy": "2026-11-11T15:53:13.273771Z", + "iopub.status.idle": "2026-11-11T15:53:13.283438Z", + "shell.execute_reply": "2026-11-11T15:53:13.282593Z" } }, "outputs": [], @@ -160,11 +160,13 @@ " LaunchCost,\n", " OperationsCost,\n", " Requirement,\n", + " RestorationPolicy,\n", " ResultStore,\n", " SatelliteCache,\n", " SatelliteCost,\n", " Study,\n", " build_constellation,\n", + " configure,\n", " count_planes,\n", " evaluate_phases,\n", " summarize_phases,\n", @@ -201,10 +203,13 @@ " return caches[seed, duration]\n", "\n", "\n", - "def make_study(duration=DURATION, replicates=N_REPLICATES, failures=None, policy=None, spares=0, phased=False):\n", + "def make_study(\n", + " duration=DURATION, replicates=N_REPLICATES, failures=None, policy=None, spares=0, phased=False, design_space=None\n", + "):\n", " \"\"\"A study of the shares (%) of points sampled sufficiently and accurately over a duration by the satellites of\n", " each design, and (if phased) their means over the phases of the mission as the satellites are deployed (and fail\n", - " and are restored, with failures and a policy), and the time until half of the points are sampled sufficiently.\"\"\"\n", + " and are restored, with failures and a policy, or the policy of each design of a design space with one), and the\n", + " time until half of the points are sampled sufficiently.\"\"\"\n", " threshold = SAMPLES_PER_DAY * duration / timedelta(days=1)\n", "\n", " def sample(observations):\n", @@ -224,9 +229,13 @@ "\n", " def evaluate(built):\n", " d, members = built\n", - " deployment = SCHEDULE.plan(d.layout, kind=d.field_of_regard, spares=spares)\n", + " # the policy of the design (see policy_space), or the study's\n", + " decided = d.values.get(\"policy\")\n", + " restoration = policy if decided is None else configure(policy or RestorationPolicy(), decided)\n", + " orbit_spares = spares if decided is None else decided.orbit_spares\n", + " deployment = SCHEDULE.plan(d.layout, kind=d.field_of_regard, spares=orbit_spares)\n", " # the mission of the replicate: without failures, or with failures drawn from its seed\n", - " history = deployment.simulate(failures, policy, d.failure_seed if failures else None)\n", + " history = deployment.simulate(failures, restoration, d.failure_seed if failures else None)\n", " cost = COST_MODEL.estimate(history, growth={\"development\": d.cost_growth})\n", " record = {\"satellites\": len(members), \"planes\": count_planes(d.layout), **cost.metrics()}\n", " cache = get_cache(d.points_seed, duration)\n", @@ -243,7 +252,7 @@ " namespace=f\"{N_POINTS} points, start {START.isoformat()}, duration {duration}, \"\n", " + f\"accuracy {MAX_RELATIVE_ERROR} at {DECORRELATION_TIME}\",\n", " )\n", - " return Study(space, build, evaluate, replicates=replicates, n_jobs=-1, store=store)\n", + " return Study(design_space or space, build, evaluate, replicates=replicates, n_jobs=-1, store=store)\n", "\n", "\n", "OBJECTIVES = {\"satellites\": \"min\", \"planes\": \"min\", \"sufficient\": \"max\"}\n", @@ -266,10 +275,10 @@ "id": "c9d8e1f0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:45:28.772217Z", - "iopub.status.busy": "2026-11-11T15:45:28.771983Z", - "iopub.status.idle": "2026-11-11T15:45:29.046177Z", - "shell.execute_reply": "2026-11-11T15:45:29.045346Z" + "iopub.execute_input": "2026-11-11T15:53:13.285080Z", + "iopub.status.busy": "2026-11-11T15:53:13.284900Z", + "iopub.status.idle": "2026-11-11T15:53:24.094780Z", + "shell.execute_reply": "2026-11-11T15:53:24.094024Z" } }, "outputs": [ @@ -427,10 +436,10 @@ "id": "d0e9f2a1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:45:29.047885Z", - "iopub.status.busy": "2026-11-11T15:45:29.047622Z", - "iopub.status.idle": "2026-11-11T15:45:29.248945Z", - "shell.execute_reply": "2026-11-11T15:45:29.248202Z" + "iopub.execute_input": "2026-11-11T15:53:24.096487Z", + "iopub.status.busy": "2026-11-11T15:53:24.096248Z", + "iopub.status.idle": "2026-11-11T15:53:24.298526Z", + "shell.execute_reply": "2026-11-11T15:53:24.297697Z" } }, "outputs": [ @@ -511,10 +520,10 @@ "id": "a2b3c4d5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:45:29.250595Z", - "iopub.status.busy": "2026-11-11T15:45:29.250419Z", - "iopub.status.idle": "2026-11-11T15:45:29.319573Z", - "shell.execute_reply": "2026-11-11T15:45:29.318806Z" + "iopub.execute_input": "2026-11-11T15:53:24.300293Z", + "iopub.status.busy": "2026-11-11T15:53:24.300025Z", + "iopub.status.idle": "2026-11-11T15:53:24.370838Z", + "shell.execute_reply": "2026-11-11T15:53:24.370139Z" } }, "outputs": [ @@ -711,10 +720,10 @@ "id": "b3c4d5e6", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:45:29.321366Z", - "iopub.status.busy": "2026-11-11T15:45:29.321119Z", - "iopub.status.idle": "2026-11-11T15:45:29.552614Z", - "shell.execute_reply": "2026-11-11T15:45:29.551859Z" + "iopub.execute_input": "2026-11-11T15:53:24.372489Z", + "iopub.status.busy": "2026-11-11T15:53:24.372255Z", + "iopub.status.idle": "2026-11-11T15:53:24.597282Z", + "shell.execute_reply": "2026-11-11T15:53:24.596624Z" } }, "outputs": [ @@ -764,10 +773,10 @@ "id": "d5e6f7a8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:45:29.554347Z", - "iopub.status.busy": "2026-11-11T15:45:29.554080Z", - "iopub.status.idle": "2026-11-11T15:45:29.637602Z", - "shell.execute_reply": "2026-11-11T15:45:29.636844Z" + "iopub.execute_input": "2026-11-11T15:53:24.599270Z", + "iopub.status.busy": "2026-11-11T15:53:24.598999Z", + "iopub.status.idle": "2026-11-11T15:53:24.685193Z", + "shell.execute_reply": "2026-11-11T15:53:24.684422Z" } }, "outputs": [ @@ -914,10 +923,10 @@ "id": "a8b9c0d1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:45:29.639395Z", - "iopub.status.busy": "2026-11-11T15:45:29.639129Z", - "iopub.status.idle": "2026-11-11T15:45:29.665668Z", - "shell.execute_reply": "2026-11-11T15:45:29.664910Z" + "iopub.execute_input": "2026-11-11T15:53:24.686964Z", + "iopub.status.busy": "2026-11-11T15:53:24.686716Z", + "iopub.status.idle": "2026-11-11T15:53:24.714958Z", + "shell.execute_reply": "2026-11-11T15:53:24.714111Z" } }, "outputs": [ @@ -1065,10 +1074,10 @@ "id": "a3b2c5d4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:45:29.667334Z", - "iopub.status.busy": "2026-11-11T15:45:29.667145Z", - "iopub.status.idle": "2026-11-11T15:45:31.164514Z", - "shell.execute_reply": "2026-11-11T15:45:31.163828Z" + "iopub.execute_input": "2026-11-11T15:53:24.716682Z", + "iopub.status.busy": "2026-11-11T15:53:24.716423Z", + "iopub.status.idle": "2026-11-11T15:53:26.215264Z", + "shell.execute_reply": "2026-11-11T15:53:26.214544Z" } }, "outputs": [ @@ -1317,10 +1326,10 @@ "id": "b5d3f7a9", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:45:31.166169Z", - "iopub.status.busy": "2026-11-11T15:45:31.165922Z", - "iopub.status.idle": "2026-11-11T15:46:03.844811Z", - "shell.execute_reply": "2026-11-11T15:46:03.844100Z" + "iopub.execute_input": "2026-11-11T15:53:26.216881Z", + "iopub.status.busy": "2026-11-11T15:53:26.216696Z", + "iopub.status.idle": "2026-11-11T15:53:52.822355Z", + "shell.execute_reply": "2026-11-11T15:53:52.821697Z" } }, "outputs": [ @@ -1470,10 +1479,10 @@ "id": "c6e4a8b0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:46:03.846457Z", - "iopub.status.busy": "2026-11-11T15:46:03.846196Z", - "iopub.status.idle": "2026-11-11T15:46:03.907520Z", - "shell.execute_reply": "2026-11-11T15:46:03.906799Z" + "iopub.execute_input": "2026-11-11T15:53:52.824233Z", + "iopub.status.busy": "2026-11-11T15:53:52.823957Z", + "iopub.status.idle": "2026-11-11T15:53:52.884778Z", + "shell.execute_reply": "2026-11-11T15:53:52.884062Z" } }, "outputs": [ @@ -2023,10 +2032,10 @@ "id": "f2a3b4c5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:46:03.909174Z", - "iopub.status.busy": "2026-11-11T15:46:03.908919Z", - "iopub.status.idle": "2026-11-11T15:46:04.821166Z", - "shell.execute_reply": "2026-11-11T15:46:04.820423Z" + "iopub.execute_input": "2026-11-11T15:53:52.886323Z", + "iopub.status.busy": "2026-11-11T15:53:52.886093Z", + "iopub.status.idle": "2026-11-11T15:53:53.753577Z", + "shell.execute_reply": "2026-11-11T15:53:53.752812Z" } }, "outputs": [ @@ -2528,10 +2537,10 @@ "id": "f9b7d1e3", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:46:04.822703Z", - "iopub.status.busy": "2026-11-11T15:46:04.822534Z", - "iopub.status.idle": "2026-11-11T15:46:06.153716Z", - "shell.execute_reply": "2026-11-11T15:46:06.152966Z" + "iopub.execute_input": "2026-11-11T15:53:53.755267Z", + "iopub.status.busy": "2026-11-11T15:53:53.755026Z", + "iopub.status.idle": "2026-11-11T15:53:55.066717Z", + "shell.execute_reply": "2026-11-11T15:53:55.065901Z" } }, "outputs": [ @@ -2759,7 +2768,7 @@ "* **spare in orbit**: a spare in each plane, launched with it, takes a failed satellite's place within months (others are produced), and is produced again;\n", "* **spare on ground**: a spare, produced after the first satellites and stored, is launched at the next slot (others are produced), and is produced again.\n", "\n", - "Each history gives both the cost of what is produced and launched (the restorations and spares, and the launches that fail) and the phases in which its satellites operate, evaluated as in the previous section: the share of points accurately sampled on average over the mission, and in the worst 10% of the replicates, and the cost at 70% confidence, for the efficient designs by accuracy, in 20 replicates of each policy." + "The policy is a decision of each design: a fragment of the design space (`policy_space`) decides whether to restore failed satellites, and the spares in orbit (in each plane) and on the ground (here, none or one of each, and none without restoration, which would never use them), and configures the policy of each design (`configure`, from a base policy of half a year of procurement and spares that are produced again). The efficient designs by accuracy, each with each of the five policies, form a design space of both, in which each history gives both the cost of what is produced and launched (the restorations and spares, and the launches that fail) and the phases in which its satellites operate, evaluated as in the previous section: the share of points accurately sampled on average over the mission, and in the worst 10% of 20 replicates, and the cost at 70% confidence." ] }, { @@ -2768,10 +2777,10 @@ "id": "d1e2f3a4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:46:06.155498Z", - "iopub.status.busy": "2026-11-11T15:46:06.155305Z", - "iopub.status.idle": "2026-11-11T15:46:10.706851Z", - "shell.execute_reply": "2026-11-11T15:46:10.705993Z" + "iopub.execute_input": "2026-11-11T15:53:55.068297Z", + "iopub.status.busy": "2026-11-11T15:53:55.068062Z", + "iopub.status.idle": "2026-11-11T15:54:00.308458Z", + "shell.execute_reply": "2026-11-11T15:54:00.307779Z" } }, "outputs": [ @@ -2809,9 +2818,9 @@ " \n", " description\n", " full constellation\n", - " accurate\n", - " accurate p10\n", - " cost p70\n", + " accurate\n", + " accurate p10\n", + " cost p70\n", " \n", " \n", " policy\n", @@ -2821,17 +2830,23 @@ " produce\n", " spare in orbit\n", " spare on ground\n", + " spares in orbit and on ground\n", " degrade\n", " produce\n", " spare in orbit\n", " spare on ground\n", + " spares in orbit and on ground\n", " degrade\n", " produce\n", " spare in orbit\n", " spare on ground\n", + " spares in orbit and on ground\n", " \n", " \n", - " design\n", + " base\n", + " \n", + " \n", + " \n", " \n", " \n", " \n", @@ -2857,14 +2872,17 @@ " 3.7\n", " 3.8\n", " 3.8\n", + " 3.8\n", " 0.1\n", " 0.9\n", " 1.0\n", " 1.0\n", + " 1.0\n", " 121.0\n", " 129.5\n", " 147.7\n", " 148.8\n", + " 162.7\n", " \n", " \n", " 7274d007018f\n", @@ -2874,14 +2892,17 @@ " 8.8\n", " 9.0\n", " 9.2\n", + " 9.1\n", " 1.0\n", " 4.2\n", " 4.4\n", " 5.5\n", + " 5.5\n", " 138.1\n", " 165.1\n", " 181.3\n", " 185.3\n", + " 195.0\n", " \n", " \n", " b85daf65c3a4\n", @@ -2891,14 +2912,17 @@ " 14.0\n", " 13.9\n", " 15.6\n", + " 14.2\n", " 2.6\n", " 10.7\n", " 10.3\n", " 11.0\n", + " 10.3\n", " 155.8\n", " 202.0\n", " 225.3\n", " 220.4\n", + " 233.1\n", " \n", " \n", " 104e33a3c842\n", @@ -2908,14 +2932,17 @@ " 22.5\n", " 23.7\n", " 24.1\n", + " 24.6\n", " 5.8\n", " 16.3\n", " 17.3\n", " 17.4\n", + " 18.6\n", " 180.4\n", " 226.5\n", " 252.6\n", " 252.4\n", + " 263.3\n", " \n", " \n", " 33b006848799\n", @@ -2925,14 +2952,17 @@ " 25.7\n", " 26.8\n", " 27.1\n", + " 27.0\n", " 0.3\n", " 14.1\n", " 20.6\n", " 20.3\n", + " 20.6\n", " 147.4\n", " 162.3\n", " 195.6\n", " 189.1\n", + " 209.3\n", " \n", " \n", " ceabaa8327b8\n", @@ -2942,14 +2972,17 @@ " 45.0\n", " 47.4\n", " 47.8\n", + " 47.5\n", " 12.2\n", " 35.5\n", " 40.8\n", " 40.9\n", + " 40.8\n", " 163.6\n", " 195.4\n", " 231.4\n", " 212.0\n", + " 244.7\n", " \n", " \n", " 92ff9cd17e00\n", @@ -2959,14 +2992,17 @@ " 43.2\n", " 45.7\n", " 45.8\n", + " 46.1\n", " 18.1\n", " 33.4\n", " 38.8\n", " 38.8\n", + " 38.8\n", " 171.1\n", " 209.1\n", " 256.1\n", " 229.3\n", + " 269.1\n", " \n", " \n", " 25d7b27dab28\n", @@ -2976,14 +3012,17 @@ " 68.9\n", " 68.3\n", " 71.7\n", + " 68.3\n", " 26.6\n", " 59.5\n", " 63.5\n", " 63.9\n", + " 63.5\n", " 180.1\n", " 215.6\n", " 254.2\n", " 236.1\n", + " 266.9\n", " \n", " \n", " 716cb479efda\n", @@ -2993,14 +3032,17 @@ " 79.0\n", " 75.7\n", " 80.9\n", + " 76.1\n", " 43.7\n", " 71.3\n", " 70.0\n", " 73.2\n", + " 72.1\n", " 218.1\n", " 276.0\n", " 326.9\n", " 301.8\n", + " 339.0\n", " \n", " \n", " 5529c21520be\n", @@ -3010,14 +3052,17 @@ " 83.8\n", " 77.6\n", " 83.8\n", + " 77.6\n", " 78.9\n", " 81.9\n", " 73.7\n", " 82.0\n", + " 73.9\n", " 262.3\n", " 351.3\n", " 406.9\n", " 367.5\n", + " 418.2\n", " \n", " \n", " 679ca275c8fc\n", @@ -3027,14 +3072,17 @@ " 83.7\n", " 77.4\n", " 83.8\n", + " 77.5\n", " 77.3\n", " 81.6\n", " 73.3\n", " 81.9\n", + " 73.6\n", " 262.3\n", " 351.3\n", " 406.9\n", " 367.5\n", + " 418.2\n", " \n", " \n", " de505bc89299\n", @@ -3044,14 +3092,17 @@ " 83.8\n", " 77.5\n", " 83.8\n", + " 77.5\n", " 78.2\n", " 81.9\n", " 73.4\n", " 82.1\n", + " 73.6\n", " 262.3\n", " 351.3\n", " 406.9\n", " 367.5\n", + " 418.2\n", " \n", " \n", "\n", @@ -3060,7 +3111,7 @@ "text/plain": [ " description \\\n", "policy \n", - "design \n", + "base \n", "de5bf5d3c148 800 km, 60 deg FOR, SSO: 1 at 06:00 \n", "7274d007018f 800 km, 60 deg FOR, SSO: 2 at 09:00 \n", "b85daf65c3a4 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... \n", @@ -3076,7 +3127,7 @@ "\n", " full constellation accurate \\\n", "policy degrade produce spare in orbit \n", - "design \n", + "base \n", "de5bf5d3c148 3.9 3.5 3.7 3.8 \n", "7274d007018f 9.6 7.5 8.8 9.0 \n", "b85daf65c3a4 16.7 9.9 14.0 13.9 \n", @@ -3090,37 +3141,69 @@ "679ca275c8fc 98.0 80.9 83.7 77.4 \n", "de505bc89299 98.0 80.7 83.8 77.5 \n", "\n", - " accurate p10 \\\n", - "policy spare on ground degrade produce spare in orbit \n", - "design \n", - "de5bf5d3c148 3.8 0.1 0.9 1.0 \n", - "7274d007018f 9.2 1.0 4.2 4.4 \n", - "b85daf65c3a4 15.6 2.6 10.7 10.3 \n", - "104e33a3c842 24.1 5.8 16.3 17.3 \n", - "33b006848799 27.1 0.3 14.1 20.6 \n", - "ceabaa8327b8 47.8 12.2 35.5 40.8 \n", - "92ff9cd17e00 45.8 18.1 33.4 38.8 \n", - "25d7b27dab28 71.7 26.6 59.5 63.5 \n", - "716cb479efda 80.9 43.7 71.3 70.0 \n", - "5529c21520be 83.8 78.9 81.9 73.7 \n", - "679ca275c8fc 83.8 77.3 81.6 73.3 \n", - "de505bc89299 83.8 78.2 81.9 73.4 \n", + " accurate p10 \\\n", + "policy spare on ground spares in orbit and on ground degrade \n", + "base \n", + "de5bf5d3c148 3.8 3.8 0.1 \n", + "7274d007018f 9.2 9.1 1.0 \n", + "b85daf65c3a4 15.6 14.2 2.6 \n", + "104e33a3c842 24.1 24.6 5.8 \n", + "33b006848799 27.1 27.0 0.3 \n", + "ceabaa8327b8 47.8 47.5 12.2 \n", + "92ff9cd17e00 45.8 46.1 18.1 \n", + "25d7b27dab28 71.7 68.3 26.6 \n", + "716cb479efda 80.9 76.1 43.7 \n", + "5529c21520be 83.8 77.6 78.9 \n", + "679ca275c8fc 83.8 77.5 77.3 \n", + "de505bc89299 83.8 77.5 78.2 \n", "\n", - " cost p70 \n", - "policy spare on ground degrade produce spare in orbit spare on ground \n", - "design \n", - "de5bf5d3c148 1.0 121.0 129.5 147.7 148.8 \n", - "7274d007018f 5.5 138.1 165.1 181.3 185.3 \n", - "b85daf65c3a4 11.0 155.8 202.0 225.3 220.4 \n", - "104e33a3c842 17.4 180.4 226.5 252.6 252.4 \n", - "33b006848799 20.3 147.4 162.3 195.6 189.1 \n", - "ceabaa8327b8 40.9 163.6 195.4 231.4 212.0 \n", - "92ff9cd17e00 38.8 171.1 209.1 256.1 229.3 \n", - "25d7b27dab28 63.9 180.1 215.6 254.2 236.1 \n", - "716cb479efda 73.2 218.1 276.0 326.9 301.8 \n", - "5529c21520be 82.0 262.3 351.3 406.9 367.5 \n", - "679ca275c8fc 81.9 262.3 351.3 406.9 367.5 \n", - "de505bc89299 82.1 262.3 351.3 406.9 367.5 " + " \\\n", + "policy produce spare in orbit spare on ground \n", + "base \n", + "de5bf5d3c148 0.9 1.0 1.0 \n", + "7274d007018f 4.2 4.4 5.5 \n", + "b85daf65c3a4 10.7 10.3 11.0 \n", + "104e33a3c842 16.3 17.3 17.4 \n", + "33b006848799 14.1 20.6 20.3 \n", + "ceabaa8327b8 35.5 40.8 40.9 \n", + "92ff9cd17e00 33.4 38.8 38.8 \n", + "25d7b27dab28 59.5 63.5 63.9 \n", + "716cb479efda 71.3 70.0 73.2 \n", + "5529c21520be 81.9 73.7 82.0 \n", + "679ca275c8fc 81.6 73.3 81.9 \n", + "de505bc89299 81.9 73.4 82.1 \n", + "\n", + " cost p70 \\\n", + "policy spares in orbit and on ground degrade produce spare in orbit \n", + "base \n", + "de5bf5d3c148 1.0 121.0 129.5 147.7 \n", + "7274d007018f 5.5 138.1 165.1 181.3 \n", + "b85daf65c3a4 10.3 155.8 202.0 225.3 \n", + "104e33a3c842 18.6 180.4 226.5 252.6 \n", + "33b006848799 20.6 147.4 162.3 195.6 \n", + "ceabaa8327b8 40.8 163.6 195.4 231.4 \n", + "92ff9cd17e00 38.8 171.1 209.1 256.1 \n", + "25d7b27dab28 63.5 180.1 215.6 254.2 \n", + "716cb479efda 72.1 218.1 276.0 326.9 \n", + "5529c21520be 73.9 262.3 351.3 406.9 \n", + "679ca275c8fc 73.6 262.3 351.3 406.9 \n", + "de505bc89299 73.6 262.3 351.3 406.9 \n", + "\n", + " \n", + "policy spare on ground spares in orbit and on ground \n", + "base \n", + "de5bf5d3c148 148.8 162.7 \n", + "7274d007018f 185.3 195.0 \n", + "b85daf65c3a4 220.4 233.1 \n", + "104e33a3c842 252.4 263.3 \n", + "33b006848799 189.1 209.3 \n", + "ceabaa8327b8 212.0 244.7 \n", + "92ff9cd17e00 229.3 269.1 \n", + "25d7b27dab28 236.1 266.9 \n", + "716cb479efda 301.8 339.0 \n", + "5529c21520be 367.5 418.2 \n", + "679ca275c8fc 367.5 418.2 \n", + "de505bc89299 367.5 418.2 " ] }, "execution_count": 15, @@ -3129,40 +3212,55 @@ } ], "source": [ - "from tatc.tradespace import Bathtub, Exponential, FailureModel, RestorationPolicy, Weibull\n", + "from tatc.tradespace import Bathtub, Exponential, FailureModel, Integer, Weibull, policy_space\n", "\n", "# illustrative lives: about 9% fail in their first year, 3% a year at random, and wear-out after about 8 years\n", "FAILURES = FailureModel(\n", " life=Bathtub(infant=Weibull(shape=0.5, scale=100), random=Exponential(0.03), wear_out=Weibull(shape=4, scale=9)),\n", " launch=0.05,\n", ")\n", - "POLICIES = { # the policy and the spares in orbit of each plane\n", - " \"degrade\": (RestorationPolicy(restore=False), 0),\n", - " \"produce\": (RestorationPolicy(procurement_years=0.5), 0),\n", - " \"spare in orbit\": (RestorationPolicy(procurement_years=0.5, replenish=True), 1),\n", - " \"spare on ground\": (RestorationPolicy(procurement_years=0.5, ground_spares=1, replenish=True), 0),\n", - "}\n", "print(f\"{1 - FAILURES.life.survival(5):.0%} of the satellites fail in 5 years\")\n", + "BASE_POLICY = RestorationPolicy(procurement_years=0.5, replenish=True)\n", + "POLICY = policy_space(orbit_spares=Integer(0, 1), ground_spares=Integer(0, 1), replenish=True)\n", "\n", - "robust_designs = [by_key[key] for key in accuracy.design[accuracy.pareto]]\n", - "ROBUST = {\n", - " \"accurate\": \"accurate mean\",\n", - " \"accurate p10\": Quantile(\"accurate mean\", 0.1),\n", - " \"availability\": \"availability\",\n", - " \"cost p70\": Quantile(\"cost\", 0.7),\n", - "}\n", - "outcomes = []\n", - "for name, (policy, spares) in POLICIES.items():\n", - " study = make_study(replicates=20, failures=FAILURES, policy=policy, spares=spares, phased=True)\n", - " outcome = aggregate(study.run(robust_designs), ROBUST).set_index(\"design\")[list(ROBUST)]\n", - " outcomes.append(outcome.assign(policy=name))\n", - "outcomes = pd.concat(outcomes)\n", - "nominal = make_study(replicates=20).run(robust_designs)\n", - "full = aggregate(nominal, [\"accurate\"]).set_index(\"design\")\n", - "table = outcomes.pivot(columns=\"policy\", values=[\"accurate\", \"accurate p10\", \"cost p70\"])[\n", - " [(metric, policy) for metric in (\"accurate\", \"accurate p10\", \"cost p70\") for policy in POLICIES]\n", - "]\n", - "table.insert(0, (\"full constellation\", \"\"), full[\"accurate\"])\n", + "# the design space with a policy, and the efficient designs by accuracy with each policy\n", + "policy_trade = DesignSpace(**space.children, policy=POLICY, constraints=space.constraints)\n", + "with_policies, base_of = [], {}\n", + "for key in accuracy.design[accuracy.pareto]:\n", + " for policy in POLICY.enumerate():\n", + " design = policy_trade.design({**by_key[key].decisions, \"policy\": policy.decisions})\n", + " with_policies.append(design)\n", + " base_of[design.key] = key\n", + "\n", + "\n", + "def describe_policy(row):\n", + " \"\"\"A short description of a policy.\"\"\"\n", + " if not row[\"policy.restore\"]:\n", + " return \"degrade\"\n", + " orbit, ground = row[\"policy.orbit_spares\"] > 0, row[\"policy.ground_spares\"] > 0\n", + " return {\n", + " (False, False): \"produce\",\n", + " (True, False): \"spare in orbit\",\n", + " (False, True): \"spare on ground\",\n", + " (True, True): \"spares in orbit and on ground\",\n", + " }[orbit, ground]\n", + "\n", + "\n", + "study = make_study(replicates=20, failures=FAILURES, policy=BASE_POLICY, phased=True, design_space=policy_trade)\n", + "trades = study.run(with_policies)\n", + "ROBUST = {\"accurate\": \"accurate mean\", \"accurate p10\": Quantile(\"accurate mean\", 0.1), \"cost p70\": Quantile(\"cost\", 0.7)}\n", + "traded = aggregate(trades, ROBUST).set_index(\"design\")[list(ROBUST)]\n", + "first = trades.drop_duplicates(\"design\").set_index(\"design\")\n", + "traded[\"policy\"] = [describe_policy(first.loc[key]) for key in traded.index]\n", + "traded[\"base\"] = [base_of[key] for key in traded.index]\n", + "\n", + "# the shares of the full constellations, without deployment or failures, for comparison\n", + "nominal = make_study(replicates=20).run([by_key[key] for key in accuracy.design[accuracy.pareto]])\n", + "full = aggregate(nominal, [\"accurate\"]).set_index(\"design\")[\"accurate\"]\n", + "ORDER = [\"degrade\", \"produce\", \"spare in orbit\", \"spare on ground\", \"spares in orbit and on ground\"]\n", + "table = traded.pivot(index=\"base\", columns=\"policy\", values=[\"accurate\", \"accurate p10\", \"cost p70\"])\n", + "table = table[[(metric, policy) for metric in (\"accurate\", \"accurate p10\", \"cost p70\") for policy in ORDER]]\n", + "table.insert(0, (\"full constellation\", \"\"), full.reindex(table.index))\n", "table.insert(0, (\"description\", \"\"), [describe(values.loc[key]) for key in table.index])\n", "table.sort_values((\"full constellation\", \"\")).round(1)" ] @@ -3177,9 +3275,230 @@ "* **Degrading** is cheapest, but loses 8 to 15 points of the mean against producing replacements for the designs of three to six satellites in two or three planes, and more in their worst 10% of replicates (44% against 71% for six satellites in three Walker planes; 0.3% against 14% for two satellites in two planes, which can lose both). Nine satellites in three planes lose only 3 points: a failure leaves eight.\n", "* **Producing replacements** restores most of it, at 7 to 34% more cost at 70% confidence than degrading.\n", "* **Spares** cost 22 to 55% more than degrading, and pay off in the worst replicates of the small designs of several planes: two satellites in two planes keep 20% in their worst replicates with a spare, against 14% by producing replacements. A spare on the ground costs less than a spare in each plane for the designs of several planes, and restores as well.\n", - "* **A spare in orbit can hurt**: for six or nine satellites in three planes, the spares delay the deployment (each plane's spare takes longer to produce, and a fourth satellite in a plane takes a second launch of up to three), so that they sample less on average (76% against 79% for six satellites, 78% against 84% for nine) at the highest cost.\n", - "\n", - "The policies and spares are decisions of a design: as design variables, with the policy made for each design, they put the trade of cost against robustness on the front, with statistics of the worst replicates (`Quantile`) or of meeting a requirement (`Probability`) as objectives." + "* **A spare in orbit can hurt**: for six or nine satellites in three planes, the spares delay the deployment (each plane's spare takes longer to produce, and a fourth satellite in a plane takes a second launch of up to three), so that they sample less on average (76% against 79% for six satellites, 78% against 84% for nine) at the highest cost. Spares in orbit and on the ground together cost the most, and sample no more than a spare on the ground alone." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "b8c9d0e1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-11T15:54:00.310149Z", + "iopub.status.busy": "2026-11-11T15:54:00.309927Z", + "iopub.status.idle": "2026-11-11T15:54:00.317921Z", + "shell.execute_reply": "2026-11-11T15:54:00.317217Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionpolicyaccurateaccurate p10cost p70
design
56ce6ae8edc1800 km, 60 deg FOR, SSO: 1 at 06:00degrade3.50.1121.0
098de5b3e423800 km, 60 deg FOR, SSO: 1 at 06:00produce3.70.9129.5
21919a7c8e69800 km, 60 deg FOR, SSO: 2 at 09:00degrade7.51.0138.1
638697713902800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...degrade9.92.6155.8
ad99c42082ab800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...produce25.714.1162.3
99b1dc715f39800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...degrade34.818.1171.1
a5094a34ed10800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00degrade54.426.6180.1
2f843d5c75f6800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00produce45.035.5195.4
1b5495ba11a7800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00spare on ground47.840.9212.0
13c5120fa410800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00produce68.959.5215.6
fb6667b89846800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00spare on ground71.763.9236.1
de2b7982bdac800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...degrade81.078.9262.3
6fa2ff2ab331800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...produce83.881.9351.3
b5772457c7b2800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...spare on ground83.882.1367.5
\n", + "
" + ], + "text/plain": [ + " description \\\n", + "design \n", + "56ce6ae8edc1 800 km, 60 deg FOR, SSO: 1 at 06:00 \n", + "098de5b3e423 800 km, 60 deg FOR, SSO: 1 at 06:00 \n", + "21919a7c8e69 800 km, 60 deg FOR, SSO: 2 at 09:00 \n", + "638697713902 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... \n", + "ad99c42082ab 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", + "99b1dc715f39 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... \n", + "a5094a34ed10 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00 \n", + "2f843d5c75f6 800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00 \n", + "1b5495ba11a7 800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00 \n", + "13c5120fa410 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00 \n", + "fb6667b89846 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00 \n", + "de2b7982bdac 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", + "6fa2ff2ab331 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", + "b5772457c7b2 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", + "\n", + " policy accurate accurate p10 cost p70 \n", + "design \n", + "56ce6ae8edc1 degrade 3.5 0.1 121.0 \n", + "098de5b3e423 produce 3.7 0.9 129.5 \n", + "21919a7c8e69 degrade 7.5 1.0 138.1 \n", + "638697713902 degrade 9.9 2.6 155.8 \n", + "ad99c42082ab produce 25.7 14.1 162.3 \n", + "99b1dc715f39 degrade 34.8 18.1 171.1 \n", + "a5094a34ed10 degrade 54.4 26.6 180.1 \n", + "2f843d5c75f6 produce 45.0 35.5 195.4 \n", + "1b5495ba11a7 spare on ground 47.8 40.9 212.0 \n", + "13c5120fa410 produce 68.9 59.5 215.6 \n", + "fb6667b89846 spare on ground 71.7 63.9 236.1 \n", + "de2b7982bdac degrade 81.0 78.9 262.3 \n", + "6fa2ff2ab331 produce 83.8 81.9 351.3 \n", + "b5772457c7b2 spare on ground 83.8 82.1 367.5 " + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# the efficient designs and policies, by their cost and their accuracy in the worst 10% of the replicates\n", + "efficient = traded[pareto_front(traded, {\"cost p70\": \"min\", \"accurate p10\": \"max\"})]\n", + "efficient.assign(description=[describe(values.loc[key]) for key in efficient.base]).sort_values(\"cost p70\")[\n", + " [\"description\", \"policy\", \"accurate\", \"accurate p10\", \"cost p70\"]\n", + "].round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "c9d0e1f2", + "metadata": {}, + "source": [ + "The front of cost at 70% confidence against the share accurately sampled in the worst 10% of the replicates chooses designs and policies together. Its cheapest designs degrade (one or a few satellites); restoring is efficient from two satellites in two planes, whose replacements lift their worst replicates from 0.3% to 14% for 15 million more. A spare on the ground is efficient for three or four satellites in two sun-synchronous planes (41% and 64% in their worst replicates, for 17 and 21 million more than producing replacements). Nine satellites in three planes degrade gracefully: degrading keeps 79% in their worst replicates for 262 million, and restoring adds 3 points for 89 million more. A spare in orbit is not efficient for any design here, as it delays the deployment. The policy that a design deserves depends on the design, which is why the policy is a decision of the design rather than of the study." ] }, { @@ -3196,14 +3515,14 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "id": "c2d3e4f5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:46:10.708404Z", - "iopub.status.busy": "2026-11-11T15:46:10.708173Z", - "iopub.status.idle": "2026-11-11T15:46:12.371561Z", - "shell.execute_reply": "2026-11-11T15:46:12.370913Z" + "iopub.execute_input": "2026-11-11T15:54:00.319318Z", + "iopub.status.busy": "2026-11-11T15:54:00.319096Z", + "iopub.status.idle": "2026-11-11T15:54:01.936446Z", + "shell.execute_reply": "2026-11-11T15:54:01.935756Z" } }, "outputs": [ @@ -3445,7 +3764,7 @@ "961 0.6 " ] }, - "execution_count": 16, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -3509,14 +3828,14 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "id": "f5a6b7c8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:46:12.373184Z", - "iopub.status.busy": "2026-11-11T15:46:12.372961Z", - "iopub.status.idle": "2026-11-11T15:46:12.558914Z", - "shell.execute_reply": "2026-11-11T15:46:12.558209Z" + "iopub.execute_input": "2026-11-11T15:54:01.938067Z", + "iopub.status.busy": "2026-11-11T15:54:01.937839Z", + "iopub.status.idle": "2026-11-11T15:54:02.129173Z", + "shell.execute_reply": "2026-11-11T15:54:02.128434Z" } }, "outputs": [ @@ -3662,7 +3981,7 @@ "400cf2b03fa8 4.5 " ] }, - "execution_count": 17, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -3702,14 +4021,14 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "id": "d6e5f8a7", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:46:12.560452Z", - "iopub.status.busy": "2026-11-11T15:46:12.560216Z", - "iopub.status.idle": "2026-11-11T15:46:14.959735Z", - "shell.execute_reply": "2026-11-11T15:46:14.958907Z" + "iopub.execute_input": "2026-11-11T15:54:02.130737Z", + "iopub.status.busy": "2026-11-11T15:54:02.130532Z", + "iopub.status.idle": "2026-11-11T15:54:04.505496Z", + "shell.execute_reply": "2026-11-11T15:54:04.504744Z" } }, "outputs": [ @@ -3808,7 +4127,7 @@ "3 24.8 " ] }, - "execution_count": 18, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -3865,14 +4184,14 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "id": "a9b8c1d0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:46:14.961343Z", - "iopub.status.busy": "2026-11-11T15:46:14.961107Z", - "iopub.status.idle": "2026-11-11T15:46:15.923190Z", - "shell.execute_reply": "2026-11-11T15:46:15.922471Z" + "iopub.execute_input": "2026-11-11T15:54:04.507077Z", + "iopub.status.busy": "2026-11-11T15:54:04.506835Z", + "iopub.status.idle": "2026-11-11T15:54:05.526109Z", + "shell.execute_reply": "2026-11-11T15:54:05.525303Z" } }, "outputs": [ @@ -3928,7 +4247,7 @@ "Latin hypercube sample 176.0 80.3" ] }, - "execution_count": 19, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -3979,14 +4298,14 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "id": "b0c9d2e1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:46:15.924775Z", - "iopub.status.busy": "2026-11-11T15:46:15.924549Z", - "iopub.status.idle": "2026-11-11T15:46:16.047642Z", - "shell.execute_reply": "2026-11-11T15:46:16.046881Z" + "iopub.execute_input": "2026-11-11T15:54:05.528240Z", + "iopub.status.busy": "2026-11-11T15:54:05.527780Z", + "iopub.status.idle": "2026-11-11T15:54:05.656547Z", + "shell.execute_reply": "2026-11-11T15:54:05.655821Z" } }, "outputs": [ @@ -4038,7 +4357,7 @@ "* A `Study` evaluates designs in replicates, in parallel, with a `SatelliteCache` that analyzes each distinct satellite once and a `ResultStore` that keeps its evaluations (by the fingerprint of the study, so that a changed study evaluates its designs again). Every design of a space of about a thousand designs can be evaluated in minutes.\n", "* Statistical sufficiency is measured by the sampling error of the statistic that observations estimate (`tatc.analysis.estimate_sampling_error`), which counts of samples overstate when samples cluster in time, as they do in a single plane; revisit statistics and local time coverage explain it.\n", "* The front of the means of the replicates is uncertain: `pareto_probability` finds the designs whose efficiency the replicates settle, and those that are equally good candidates, and `refine` adds replicates only to the latter, with a tolerance of differences that do not matter. `confirm` evaluates the selected designs with new replicates, which removes the optimism of selecting the best of many nearly equal designs.\n", - "* Statistics other than means (such as a `Quantile` or the `Probability` of meeting a threshold) state how reliably a design performs, and `Requirement`s on them are output constraints. Simulated missions (`Deployment.simulate`) draw the failures of satellites and launches from lives whose failure rates vary over the lifecycle (`FailureModel`), and restore them or not (`RestorationPolicy`, by spares in orbit or on the ground, or by producing new ones), for both the cost and the capability of each policy. `sensitivity` finds the design variables that drive each objective.\n", + "* Statistics other than means (such as a `Quantile` or the `Probability` of meeting a threshold) state how reliably a design performs, and `Requirement`s on them are output constraints. Simulated missions (`Deployment.simulate`) draw the failures of satellites and launches from lives whose failure rates vary over the lifecycle (`FailureModel`), and restore them or not (`RestorationPolicy`, by spares in orbit or on the ground, or by producing new ones), for both the cost and the capability of each policy; the policy is a decision of each design (`policy_space`, configured by `configure`), on the front with the design. `sensitivity` finds the design variables that drive each objective.\n", "* `screen` evaluates every design with a cheap study and the best with the full one, which finds the front at a fraction of the cost if the cheap study ranks designs as the full one does.\n", "* A `DeploymentSchedule` plans each design's deployment from rates of production and launch, which dates its costs and divides its mission into phases of the satellites that fly, evaluated with the observations of the full constellation for the mean capability over the mission and the time until a requirement is met.\n", "* A `CostModel` estimates the life-cycle cost of each deployment from the costs of its satellites, launches, and operations (given by the study), with uncertain growth whose quantiles give the cost at a confidence level, as an objective or a requirement in place of the numbers of satellites and planes.\n", diff --git a/src/tatc/tradespace/__init__.py b/src/tatc/tradespace/__init__.py index 817be307..d8a81083 100644 --- a/src/tatc/tradespace/__init__.py +++ b/src/tatc/tradespace/__init__.py @@ -48,6 +48,7 @@ Piecewise, RestorationPolicy, Weibull, + policy_space, ) from .criteria import ( Maximum, @@ -86,7 +87,7 @@ from .space import Design, DesignSpace from .store import ResultStore from .study import Study, summarize -from .values import ChoiceValues, RepeatValues, Scope, Values +from .values import ChoiceValues, RepeatValues, Scope, Values, configure __all__ = [ "Bathtub", @@ -140,6 +141,7 @@ "Weibull", "aggregate", "build_constellation", + "configure", "confirm", "count_planes", "count_satellites", @@ -157,6 +159,7 @@ "pareto_ranks", "plane_sizes", "planes_space", + "policy_space", "refine", "remove_failures", "screen", diff --git a/src/tatc/tradespace/failures.py b/src/tatc/tradespace/failures.py index b5b2696c..b14c3764 100644 --- a/src/tatc/tradespace/failures.py +++ b/src/tatc/tradespace/failures.py @@ -10,7 +10,9 @@ (`Piecewise`). A `FailureModel` gives the life of each type of satellite and the probability that a launch fails, and a `RestorationPolicy` whether and how failed satellites are restored: by spares in orbit, by spares on the -ground, or by satellites built when needed. +ground, or by satellites built when needed. A policy is a decision of a +design with a fragment of a design space (`policy_space`), whose values +configure it (see `configure`). @author: Paul T. Grogan """ @@ -18,12 +20,16 @@ from __future__ import annotations import math -from collections.abc import Mapping, Sequence -from dataclasses import dataclass +from collections.abc import Callable, Mapping, Sequence +from dataclasses import dataclass, fields from typing import Any import numpy as np +from .nodes import Categorical +from .space import DesignSpace +from .values import Scope + class Lifetime: """ @@ -340,3 +346,68 @@ def ground_spares_of(self, kind: Any) -> int: if isinstance(self.ground_spares, Mapping): return int(self.ground_spares.get(kind, 0)) return int(self.ground_spares) + + +def _spares_restore(d: Scope) -> bool: + """Whether spares are only kept by a policy that restores failures.""" + return bool(d.restore) or (d.orbit_spares == 0 and d.ground_spares == 0) + + +def policy_space( + *, + restore: Any = None, + orbit_spares: Any = 0, + ground_spares: Any = 0, + replenish: Any = False, + require_restoration: bool = True, + constraints: Sequence[Callable[[Scope], Any]] = (), + **others: Any, +) -> DesignSpace: + """ + Gets a fragment of a design space of policies for failed satellites (see + `RestorationPolicy`), for trades of their cost against their + robustness: whether to `restore` failed satellites (by default a + variable, `False` or `True`), the spares in orbit in each plane + (`orbit_spares`, which a deployment plans, see the `spares` of + `DeploymentSchedule.plan`), the spares on the ground (`ground_spares`), + whether to `replenish` used spares, and other fields of the policy (such + as `drift_years`). Each is a node of a design space (such as a design + variable) or a value. + + A design's policy is configured from the values of the fragment, and its + deployment planned with their spares in orbit:: + + policy = configure(BASE_POLICY, d.policy) + deployment = SCHEDULE.plan(d.layout, spares=d.policy.orbit_spares) + history = deployment.simulate(FAILURES, policy, d.failure_seed) + + Spares without restoration would never be used, so a constraint excludes + them (unless `require_restoration` is `False`). + + Args: + restore (Any): Whether to restore failed satellites, by default a + variable. + orbit_spares (Any): The spares in orbit in each plane. + ground_spares (Any): The spares on the ground. + replenish (Any): Whether to replenish used spares. + require_restoration (bool): `True` to exclude spares without + restoration. + constraints (Sequence[Callable]): Other constraints of the fragment. + **others (Any): Other fields of `RestorationPolicy`. + + Returns: + DesignSpace: the fragment + """ + names = {field.name for field in fields(RestorationPolicy)} + unknown = set(others) - names + if unknown: + raise ValueError(f"no fields of RestorationPolicy named {sorted(unknown)}") + children = { + "restore": Categorical([False, True]) if restore is None else restore, + "orbit_spares": orbit_spares, + "ground_spares": ground_spares, + "replenish": replenish, + **others, + } + rules = ([_spares_restore] if require_restoration else []) + list(constraints) + return DesignSpace(constraints=rules, **children) diff --git a/src/tatc/tradespace/values.py b/src/tatc/tradespace/values.py index 0aaa2679..3fa7826a 100644 --- a/src/tatc/tradespace/values.py +++ b/src/tatc/tradespace/values.py @@ -7,6 +7,7 @@ from __future__ import annotations +import dataclasses from collections.abc import Iterator, Mapping from typing import Any @@ -163,3 +164,32 @@ def __getattr__(self, name: str) -> Any: def __getitem__(self, name: str) -> Any: return getattr(self, name) + + +def configure(base: Any, values: Any = None, **overrides: Any) -> Any: + """ + Configures a dataclass (such as a `RestorationPolicy` or a + `DeploymentSchedule`) from the values of a design: the fields of `base` + that the values name (such as those of `policy_space`, or design + variables named after fields) are replaced by them, as are those given + as keyword arguments. Values that name no field are ignored. + + Args: + base (Any): The dataclass instance, whose other fields are kept. + values (Any): The values of a design (a `Values` or `ChoiceValues` + view, or a mapping), or `None`. + **overrides (Any): Other values of fields. + + Returns: + Any: a copy of `base` with the values of its fields + """ + if not dataclasses.is_dataclass(base) or isinstance(base, type): + raise TypeError("configure requires a dataclass instance") + if isinstance(values, ChoiceValues): + values = values.value + names = {field.name for field in dataclasses.fields(base)} + changes = {name: values[name] for name in (values or {}) if name in names} + unknown = set(overrides) - names + if unknown: + raise ValueError(f"no fields named {sorted(unknown)}") + return dataclasses.replace(base, **changes, **overrides) diff --git a/tests/tradespace/test_failures.py b/tests/tradespace/test_failures.py index 2ddb9549..b3159c89 100644 --- a/tests/tradespace/test_failures.py +++ b/tests/tradespace/test_failures.py @@ -18,13 +18,20 @@ DesignSpace, Exponential, FailureModel, + Integer, LaunchCost, Lifetime, OperationsCost, Piecewise, RestorationPolicy, SatelliteCost, + Study, + Uncertain, Weibull, + aggregate, + configure, + pareto_front, + policy_space, walker_space, ) @@ -330,3 +337,99 @@ def test_policy_validation(self): self.assertEqual( RestorationPolicy(ground_spares={"a": 2}).ground_spares_of("b"), 0 ) + + +class TestPolicySpace(unittest.TestCase): + """ + Unit tests for policies as decisions of designs. + """ + + def test_fragment(self): + """Policies are enumerated, without spares that are never used.""" + space = policy_space(orbit_spares=Integer(0, 1), ground_spares=Integer(0, 1)) + flats = [d.flat() for d in space.enumerate()] + self.assertEqual(len(flats), 5) + self.assertNotIn( + {"restore": False, "orbit_spares": 1, "ground_spares": 0}, flats + ) + loose = policy_space( + orbit_spares=Integer(0, 1), + ground_spares=Integer(0, 1), + require_restoration=False, + ) + self.assertEqual(len(loose.enumerate()), 8) + with self.assertRaises(ValueError): + policy_space(drift=0.1) + + def test_configure(self): + """Values of a design configure a policy or a schedule.""" + space = DesignSpace( + policy=policy_space( + restore=True, ground_spares=Integer(1, 2), drift_years=0.5 + ), + launch_interval=Integer(0, 1), + ) + design = space.enumerate()[-1] + base = RestorationPolicy(procurement_years=0.3) + policy = configure(base, design.policy) + self.assertEqual( + (policy.restore, policy.ground_spares, policy.drift_years), (True, 2, 0.5) + ) + self.assertEqual(policy.procurement_years, 0.3) + schedule = configure(DeploymentSchedule(years=5), design.values, years=6) + self.assertEqual((schedule.launch_interval, schedule.years), (1, 6)) + with self.assertRaises(ValueError): + configure(base, design.policy, unknown=1) + with self.assertRaises(TypeError): + configure(RestorationPolicy, design.policy) + + def test_trade_of_policies(self): + """Policies trade cost against availability on a front.""" + schedule = DeploymentSchedule( + years=5, development_years=1, production_rate=4, launch_capacity=3 + ) + failures = FailureModel(life=Exponential(0.3), launch=0.05) + model = CostModel( + SatelliteCost(development=10, first_unit=5), + launch=LaunchCost(per_launch=3), + operations=OperationsCost(per_satellite_year=1), + ) + space = DesignSpace( + layout=walker_space( + inclination=55.0, planes=Integer(1, 2), per_plane=2, relative_spacing=0 + ), + policy=policy_space( + orbit_spares=Integer(0, 1), ground_spares=Integer(0, 1) + ), + failure_seed=Uncertain.seed(), + ) + + def evaluate(d): + deployment = schedule.plan(d.layout, spares=d.policy.orbit_spares) + history = deployment.simulate( + failures, configure(RestorationPolicy(), d.policy), d.failure_seed + ) + return { + "cost": model.estimate(history).total, + "availability": history.metrics()["availability"], + } + + designs = space.enumerate() + self.assertEqual(len(designs), 2 * 5) + results = Study(space, lambda d: d, evaluate, replicates=30).run(designs) + summary = aggregate(results, ["cost", "availability"]) + front = summary[pareto_front(summary, {"cost": "min", "availability": "max"})] + policies = { + ( + row["policy.restore"], + row["policy.orbit_spares"], + row["policy.ground_spares"], + ) + for _, row in results.drop_duplicates("design") + .set_index("design") + .loc[front.design] + .iterrows() + } + # degrading is the cheapest, and a policy that restores is the most available + self.assertIn((False, 0, 0), policies) + self.assertGreater(len(policies), 1) From 06b061078c4aaf8fc117c04d426f2fc48daf5131 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Wed, 11 Nov 2026 09:31:59 -0700 Subject: [PATCH 17/52] evaluate many histories of missions per replicate with a cache of phase metrics --- CHANGELOG.md | 2 +- docs/api_reference/tradespace.rst | 9 +- docs/examples/SearchTradeSpace.ipynb | 885 +++++++++++++++------------ src/tatc/tradespace/__init__.py | 13 +- src/tatc/tradespace/deployment.py | 57 +- src/tatc/tradespace/mission.py | 239 +++++++- tests/tradespace/test_failures.py | 137 +++++ 7 files changed, 906 insertions(+), 436 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index e1c1d58b..6ec73073 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -21,7 +21,7 @@ Added: - Function `tradespace.screen` (and class `Screening`), which screens designs with studies of increasing fidelity, keeping whole fronts of the best designs of each stage for the next. - Searches of design spaces with optional optimizers: `tradespace.optimize_optuna` suggests designs with Optuna trials (`DesignSpace.suggest`, define-by-run over the hierarchical space), and `optimize_pymoo` and `make_pymoo_problem` search the unit hypercube that encodes a design space (`DesignSpace.unit_paths`, `encode`, and `decode`) with pymoo. Each design is evaluated once, and the designs proposed together are evaluated together, in parallel if the study is. Constraints of a design space may return the amount of their violation (`Infeasible.violation`), which Optuna's trials record (`set_constraint`) for its constraint-aware samplers, and which is the constraint value of pymoo problems. Optional dependencies `tradespace` (joblib, Optuna, and pymoo). - Deployment of constellations (`tradespace.DeploymentSchedule`): from the rates and durations of a study (the mission and design life, the development of each type of satellite, its production on a line at a production rate, and launches at a cadence and capacity, in number or mass, optionally in an order of planes), each design's deployment (`DeploymentSchedule.plan`, a `Deployment` of its `Production`, `Launch`es, and replacements), so that a design of more satellites and planes takes longer to deploy. Its launches divide the mission into phases of constant sets of operating satellites (`Deployment.phases`), evaluated over the study's representative period from the observations of the full constellation (`evaluate_phases`) and combined over the mission (`summarize_phases`: the time-weighted mean of each metric and the time until it first meets a requirement). - - Simulated missions with failures (`Deployment.simulate`, a `MissionHistory` for each replicate, drawn from its seed with common random numbers between designs): lives of satellites whose failure rates vary over the lifecycle (`tradespace.Exponential`, `Weibull`, `Bathtub` of competing causes, and `Piecewise` rates by age, `Lifetime`), failures of launches (`FailureModel`), and a policy that degrades or restores failed satellites (`RestorationPolicy`) by spares in orbit (taking a failed satellite's place after drifting), spares on the ground (launched at the next launch slot), or satellites produced when needed (after procurement, on the production line), optionally replenishing spares and batching restorations in launches. A history gives the phases in which satellites operate (`MissionHistory.phases`), measures of the mission (`MissionHistory.metrics`: failures, restorations, spares used, time to restore, and availability), and, priced by a `CostModel`, the cost of what it produces and launches. Policies are decisions of designs with a fragment of a design space (`policy_space`: whether to restore, spares in orbit and on the ground, and other fields of the policy, without spares that would never be used), and `configure` makes a policy (or a deployment schedule, or another dataclass) from the values of a design. + - Simulated missions with failures (`Deployment.simulate`, a `MissionHistory` for each replicate, drawn from its seed with common random numbers between designs): lives of satellites whose failure rates vary over the lifecycle (`tradespace.Exponential`, `Weibull`, `Bathtub` of competing causes, and `Piecewise` rates by age, `Lifetime`), failures of launches (`FailureModel`), and a policy that degrades or restores failed satellites (`RestorationPolicy`) by spares in orbit (taking a failed satellite's place after drifting), spares on the ground (launched at the next launch slot), or satellites produced when needed (after procurement, on the production line), optionally replenishing spares and batching restorations in launches. A history gives the phases in which satellites operate (`MissionHistory.phases`), measures of the mission (`MissionHistory.metrics`: failures, restorations, spares used, time to restore, and availability), and, priced by a `CostModel`, the cost of what it produces and launches. Policies are decisions of designs with a fragment of a design space (`policy_space`: whether to restore, spares in orbit and on the ground, and other fields of the policy, without spares that would never be used), and `configure` makes a policy (or a deployment schedule, or another dataclass) from the values of a design. Many histories of a replicate's mission (`Deployment.simulate_many`) share its sample of targets: `evaluate_missions` evaluates them (with their measures and costs) with a cache that evaluates each set of operating satellites once (`PhaseCache`, keyed by the content of the satellites and shared by the histories, policies, and designs of a replicate), and `summarize_missions` gives their means, quantiles (the risk of the mission), and probabilities of meeting requirements, as one record of the replicate. - Life-cycle costs of deployments for trade studies (`tradespace.CostModel`): the development of each type of satellite, the production of its units on a learning curve (`SatelliteCost`), launches (per launch, or prices per satellite and kg, `LaunchCost`), operations (`OperationsCost`), replacements, and spares in orbit, dated by the deployment for their present value at a discount rate (`CostEstimate.present_value`, metric `cost present`) and annual costs (`CostEstimate.annual`, metric `cost peak annual`), with growth factors for cost risk (such as uncertain parameters, whose quantiles over replicates give the cost at a confidence level). TAT-C does not include cost-estimating relationships: the costs are given by the study. Fingerprints describe dataclasses (such as cost models) by their fields. - Function `tradespace.confirm` (and class `Confirmation`), which evaluates selected designs (such as a front) with new replicates that played no part in their selection, removing the optimism of the selection (the winner's curse, `Confirmation.optimism`). `ResultStore` keys evaluations by the fingerprint of a study (`Study.fingerprint`, see `get_fingerprint`: its seed, use of common random numbers, design space, and build and evaluation functions, and the version of TAT-C), warning if it holds evaluations of other definitions, which are not reused; `SatelliteCache` keys results on disk by the fingerprint of its function. `refine` treats designs with fewer than `min_replicates` (5) as uncertain whatever their probability, adds the replicates left to `max_replicates` in a last partial step, and warns if designs remain uncertain without a tolerance. `sensitivity` gives adjusted shares (epsilon squared) by default, without the share that the levels of a variable explain by chance (`adjusted=False` for correlation ratios). - Searches with Optuna accept categorical options that depend on earlier decisions (a parameter for each set of options), use TPE with a constant liar in batches by default (which spreads the trials of a batch), and stop after `max_designs` designs evaluated (trials that suggest designs evaluated before are told their objectives without evaluating them again). A design infeasible in some of its replicates violates its feasibility by their share (`Evaluations.infeasibility`), and the first design evaluated in a search is evaluated alone, to check that evaluations give one record each. `Study` records errors of evaluations as infeasible, without storing them, with `errors="record"`. Enumeration walks the items of unordered repetitions in one order only (the same designs, in the same order, four times faster for three sun-synchronous planes), and `DesignSpace.size` counts designs without keeping them. Pareto fronts are found by a vectorized sweep in lexicographic order that compares designs only with the efficient designs before them, and fronts with tolerances by comparing designs only with the efficient designs without tolerances (which dominate every design that any design dominates within the tolerances), in blocks of bounded memory: 20,000 designs in 0.05 s (0.11 s with tolerances) rather than 17 s, and the bootstraps of `pareto_probability` (and so `refine`) about 20 times faster. diff --git a/docs/api_reference/tradespace.rst b/docs/api_reference/tradespace.rst index 13b62f6a..2bfaf9ec 100644 --- a/docs/api_reference/tradespace.rst +++ b/docs/api_reference/tradespace.rst @@ -81,7 +81,7 @@ Deployment :members: plan, launches_of .. autoclass:: tatc.tradespace.Deployment - :members: simulate, phases, begin, end, deployed, units + :members: simulate, simulate_many, planned, phases, begin, end, deployed, units .. autoclass:: tatc.tradespace.Launch @@ -125,6 +125,13 @@ Failures and Missions .. autofunction:: tatc.tradespace.summarize_phases +.. autoclass:: tatc.tradespace.PhaseCache + :members: evaluate, clear + +.. autofunction:: tatc.tradespace.evaluate_missions + +.. autofunction:: tatc.tradespace.summarize_missions + Costs ----- diff --git a/docs/examples/SearchTradeSpace.ipynb b/docs/examples/SearchTradeSpace.ipynb index 722f9614..c90ffcba 100644 --- a/docs/examples/SearchTradeSpace.ipynb +++ b/docs/examples/SearchTradeSpace.ipynb @@ -28,10 +28,10 @@ "id": "c3d2e5f4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:53:11.393375Z", - "iopub.status.busy": "2026-11-11T15:53:11.393137Z", - "iopub.status.idle": "2026-11-11T15:53:12.109607Z", - "shell.execute_reply": "2026-11-11T15:53:12.108717Z" + "iopub.execute_input": "2026-11-11T16:24:11.112102Z", + "iopub.status.busy": "2026-11-11T16:24:11.111858Z", + "iopub.status.idle": "2026-11-11T16:24:11.842166Z", + "shell.execute_reply": "2026-11-11T16:24:11.841458Z" } }, "outputs": [], @@ -79,10 +79,10 @@ "id": "e5f4a7b6", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:53:12.111462Z", - "iopub.status.busy": "2026-11-11T15:53:12.111141Z", - "iopub.status.idle": "2026-11-11T15:53:13.272309Z", - "shell.execute_reply": "2026-11-11T15:53:13.271593Z" + "iopub.execute_input": "2026-11-11T16:24:11.844260Z", + "iopub.status.busy": "2026-11-11T16:24:11.843990Z", + "iopub.status.idle": "2026-11-11T16:24:13.012686Z", + "shell.execute_reply": "2026-11-11T16:24:13.011904Z" } }, "outputs": [ @@ -143,10 +143,10 @@ "id": "a7b6c9d8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:53:13.274135Z", - "iopub.status.busy": "2026-11-11T15:53:13.273771Z", - "iopub.status.idle": "2026-11-11T15:53:13.283438Z", - "shell.execute_reply": "2026-11-11T15:53:13.282593Z" + "iopub.execute_input": "2026-11-11T16:24:13.014527Z", + "iopub.status.busy": "2026-11-11T16:24:13.014184Z", + "iopub.status.idle": "2026-11-11T16:24:13.023994Z", + "shell.execute_reply": "2026-11-11T16:24:13.023258Z" } }, "outputs": [], @@ -159,6 +159,7 @@ " DeploymentSchedule,\n", " LaunchCost,\n", " OperationsCost,\n", + " PhaseCache,\n", " Requirement,\n", " RestorationPolicy,\n", " ResultStore,\n", @@ -168,7 +169,9 @@ " build_constellation,\n", " configure,\n", " count_planes,\n", + " evaluate_missions,\n", " evaluate_phases,\n", + " summarize_missions,\n", " summarize_phases,\n", ")\n", "\n", @@ -204,12 +207,20 @@ "\n", "\n", "def make_study(\n", - " duration=DURATION, replicates=N_REPLICATES, failures=None, policy=None, spares=0, phased=False, design_space=None\n", + " duration=DURATION,\n", + " replicates=N_REPLICATES,\n", + " failures=None,\n", + " policy=None,\n", + " spares=0,\n", + " histories=1,\n", + " phased=False,\n", + " design_space=None,\n", "):\n", " \"\"\"A study of the shares (%) of points sampled sufficiently and accurately over a duration by the satellites of\n", - " each design, and (if phased) their means over the phases of the mission as the satellites are deployed (and fail\n", - " and are restored, with failures and a policy, or the policy of each design of a design space with one), and the\n", - " time until half of the points are sampled sufficiently.\"\"\"\n", + " each design, and (if phased) their means over the phases of the mission as the satellites are deployed and the\n", + " time until half of the points are sampled sufficiently, or (with failures) their means over the phases of\n", + " histories of the mission in which satellites fail and are restored (by a policy, or the policy of each design of\n", + " a design space with one), and their worst 10% of the histories, and the cost at 70% confidence.\"\"\"\n", " threshold = SAMPLES_PER_DAY * duration / timedelta(days=1)\n", "\n", " def sample(observations):\n", @@ -223,6 +234,10 @@ " \"accurate\": 100 * (error.relative_error <= MAX_RELATIVE_ERROR).sum() / N_POINTS,\n", " }\n", "\n", + " # the shares of the sets of satellites that operate in phases, shared by the histories, policies, and designs of a\n", + " # replicate (in a worker's chunk of evaluations)\n", + " phase_cache = PhaseCache(sample)\n", + "\n", " def build(d):\n", " imager = Instrument(name=\"imager\", field_of_regard=d.field_of_regard)\n", " return d, build_constellation(d.layout, imager, epoch=START, altitude=d.altitude)\n", @@ -234,17 +249,29 @@ " restoration = policy if decided is None else configure(policy or RestorationPolicy(), decided)\n", " orbit_spares = spares if decided is None else decided.orbit_spares\n", " deployment = SCHEDULE.plan(d.layout, kind=d.field_of_regard, spares=orbit_spares)\n", - " # the mission of the replicate: without failures, or with failures drawn from its seed\n", - " history = deployment.simulate(failures, restoration, d.failure_seed if failures else None)\n", - " cost = COST_MODEL.estimate(history, growth={\"development\": d.cost_growth})\n", - " record = {\"satellites\": len(members), \"planes\": count_planes(d.layout), **cost.metrics()}\n", + " growth = {\"development\": d.cost_growth}\n", + " record = {\n", + " \"satellites\": len(members),\n", + " \"planes\": count_planes(d.layout),\n", + " **COST_MODEL.estimate(deployment, growth).metrics(),\n", + " }\n", " cache = get_cache(d.points_seed, duration)\n", " record.update(sample(cache(members)), satellite_days=len(members) * duration / timedelta(days=1))\n", - " if phased:\n", - " capability = evaluate_phases(history.phases(members), cache(members), sample)\n", - " record.update(summarize_phases(capability, requirements=[Requirement(\"sufficient\", \">=\", 50)]))\n", " if failures:\n", - " record.update(history.metrics())\n", + " # histories of the mission in the replicate, with failures drawn from its seed, on its points\n", + " missions = evaluate_missions(\n", + " deployment.simulate_many(failures, restoration, d.failure_seed, histories),\n", + " members,\n", + " cache(members),\n", + " phase_cache,\n", + " context=(d.points_seed, duration),\n", + " cost_model=COST_MODEL,\n", + " growth=growth,\n", + " )\n", + " record.update(summarize_missions(missions, quantiles={\"accurate mean\": 0.1, \"cost\": 0.7}))\n", + " elif phased:\n", + " capability = evaluate_phases(deployment.phases(members), cache(members), sample)\n", + " record.update(summarize_phases(capability, requirements=[Requirement(\"sufficient\", \">=\", 50)]))\n", " return record\n", "\n", " store = ResultStore(\n", @@ -275,10 +302,10 @@ "id": "c9d8e1f0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:53:13.285080Z", - "iopub.status.busy": "2026-11-11T15:53:13.284900Z", - "iopub.status.idle": "2026-11-11T15:53:24.094780Z", - "shell.execute_reply": "2026-11-11T15:53:24.094024Z" + "iopub.execute_input": "2026-11-11T16:24:13.025616Z", + "iopub.status.busy": "2026-11-11T16:24:13.025388Z", + "iopub.status.idle": "2026-11-11T16:24:23.734510Z", + "shell.execute_reply": "2026-11-11T16:24:23.733836Z" } }, "outputs": [ @@ -436,10 +463,10 @@ "id": "d0e9f2a1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:53:24.096487Z", - "iopub.status.busy": "2026-11-11T15:53:24.096248Z", - "iopub.status.idle": "2026-11-11T15:53:24.298526Z", - "shell.execute_reply": "2026-11-11T15:53:24.297697Z" + "iopub.execute_input": "2026-11-11T16:24:23.736172Z", + "iopub.status.busy": "2026-11-11T16:24:23.735928Z", + "iopub.status.idle": "2026-11-11T16:24:23.940201Z", + "shell.execute_reply": "2026-11-11T16:24:23.939421Z" } }, "outputs": [ @@ -520,10 +547,10 @@ "id": "a2b3c4d5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:53:24.300293Z", - "iopub.status.busy": "2026-11-11T15:53:24.300025Z", - "iopub.status.idle": "2026-11-11T15:53:24.370838Z", - "shell.execute_reply": "2026-11-11T15:53:24.370139Z" + "iopub.execute_input": "2026-11-11T16:24:23.941898Z", + "iopub.status.busy": "2026-11-11T16:24:23.941702Z", + "iopub.status.idle": "2026-11-11T16:24:24.013001Z", + "shell.execute_reply": "2026-11-11T16:24:24.012215Z" } }, "outputs": [ @@ -720,10 +747,10 @@ "id": "b3c4d5e6", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:53:24.372489Z", - "iopub.status.busy": "2026-11-11T15:53:24.372255Z", - "iopub.status.idle": "2026-11-11T15:53:24.597282Z", - "shell.execute_reply": "2026-11-11T15:53:24.596624Z" + "iopub.execute_input": "2026-11-11T16:24:24.015389Z", + "iopub.status.busy": "2026-11-11T16:24:24.015093Z", + "iopub.status.idle": "2026-11-11T16:24:24.253642Z", + "shell.execute_reply": "2026-11-11T16:24:24.252785Z" } }, "outputs": [ @@ -773,10 +800,10 @@ "id": "d5e6f7a8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:53:24.599270Z", - "iopub.status.busy": "2026-11-11T15:53:24.598999Z", - "iopub.status.idle": "2026-11-11T15:53:24.685193Z", - "shell.execute_reply": "2026-11-11T15:53:24.684422Z" + "iopub.execute_input": "2026-11-11T16:24:24.255350Z", + "iopub.status.busy": "2026-11-11T16:24:24.255105Z", + "iopub.status.idle": "2026-11-11T16:24:24.342477Z", + "shell.execute_reply": "2026-11-11T16:24:24.341683Z" } }, "outputs": [ @@ -923,10 +950,10 @@ "id": "a8b9c0d1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:53:24.686964Z", - "iopub.status.busy": "2026-11-11T15:53:24.686716Z", - "iopub.status.idle": "2026-11-11T15:53:24.714958Z", - "shell.execute_reply": "2026-11-11T15:53:24.714111Z" + "iopub.execute_input": "2026-11-11T16:24:24.344173Z", + "iopub.status.busy": "2026-11-11T16:24:24.343933Z", + "iopub.status.idle": "2026-11-11T16:24:24.370388Z", + "shell.execute_reply": "2026-11-11T16:24:24.369688Z" } }, "outputs": [ @@ -1074,10 +1101,10 @@ "id": "a3b2c5d4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:53:24.716682Z", - "iopub.status.busy": "2026-11-11T15:53:24.716423Z", - "iopub.status.idle": "2026-11-11T15:53:26.215264Z", - "shell.execute_reply": "2026-11-11T15:53:26.214544Z" + "iopub.execute_input": "2026-11-11T16:24:24.372211Z", + "iopub.status.busy": "2026-11-11T16:24:24.371971Z", + "iopub.status.idle": "2026-11-11T16:24:25.911165Z", + "shell.execute_reply": "2026-11-11T16:24:25.910335Z" } }, "outputs": [ @@ -1326,10 +1353,10 @@ "id": "b5d3f7a9", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:53:26.216881Z", - "iopub.status.busy": "2026-11-11T15:53:26.216696Z", - "iopub.status.idle": "2026-11-11T15:53:52.822355Z", - "shell.execute_reply": "2026-11-11T15:53:52.821697Z" + "iopub.execute_input": "2026-11-11T16:24:25.913006Z", + "iopub.status.busy": "2026-11-11T16:24:25.912746Z", + "iopub.status.idle": "2026-11-11T16:24:52.827886Z", + "shell.execute_reply": "2026-11-11T16:24:52.827165Z" } }, "outputs": [ @@ -1479,10 +1506,10 @@ "id": "c6e4a8b0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:53:52.824233Z", - "iopub.status.busy": "2026-11-11T15:53:52.823957Z", - "iopub.status.idle": "2026-11-11T15:53:52.884778Z", - "shell.execute_reply": "2026-11-11T15:53:52.884062Z" + "iopub.execute_input": "2026-11-11T16:24:52.829551Z", + "iopub.status.busy": "2026-11-11T16:24:52.829312Z", + "iopub.status.idle": "2026-11-11T16:24:52.889724Z", + "shell.execute_reply": "2026-11-11T16:24:52.889031Z" } }, "outputs": [ @@ -2032,10 +2059,10 @@ "id": "f2a3b4c5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:53:52.886323Z", - "iopub.status.busy": "2026-11-11T15:53:52.886093Z", - "iopub.status.idle": "2026-11-11T15:53:53.753577Z", - "shell.execute_reply": "2026-11-11T15:53:53.752812Z" + "iopub.execute_input": "2026-11-11T16:24:52.891225Z", + "iopub.status.busy": "2026-11-11T16:24:52.891006Z", + "iopub.status.idle": "2026-11-11T16:24:53.765102Z", + "shell.execute_reply": "2026-11-11T16:24:53.764291Z" } }, "outputs": [ @@ -2537,10 +2564,10 @@ "id": "f9b7d1e3", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:53:53.755267Z", - "iopub.status.busy": "2026-11-11T15:53:53.755026Z", - "iopub.status.idle": "2026-11-11T15:53:55.066717Z", - "shell.execute_reply": "2026-11-11T15:53:55.065901Z" + "iopub.execute_input": "2026-11-11T16:24:53.766667Z", + "iopub.status.busy": "2026-11-11T16:24:53.766495Z", + "iopub.status.idle": "2026-11-11T16:24:55.082829Z", + "shell.execute_reply": "2026-11-11T16:24:55.082045Z" } }, "outputs": [ @@ -2768,7 +2795,9 @@ "* **spare in orbit**: a spare in each plane, launched with it, takes a failed satellite's place within months (others are produced), and is produced again;\n", "* **spare on ground**: a spare, produced after the first satellites and stored, is launched at the next slot (others are produced), and is produced again.\n", "\n", - "The policy is a decision of each design: a fragment of the design space (`policy_space`) decides whether to restore failed satellites, and the spares in orbit (in each plane) and on the ground (here, none or one of each, and none without restoration, which would never use them), and configures the policy of each design (`configure`, from a base policy of half a year of procurement and spares that are produced again). The efficient designs by accuracy, each with each of the five policies, form a design space of both, in which each history gives both the cost of what is produced and launched (the restorations and spares, and the launches that fail) and the phases in which its satellites operate, evaluated as in the previous section: the share of points accurately sampled on average over the mission, and in the worst 10% of 20 replicates, and the cost at 70% confidence." + "The policy is a decision of each design: a fragment of the design space (`policy_space`) decides whether to restore failed satellites, and the spares in orbit (in each plane) and on the ground (here, none or one of each, and none without restoration, which would never use them), and configures the policy of each design (`configure`, from a base policy of half a year of procurement and spares that are produced again). The efficient designs by accuracy, each with each of the five policies, form a design space of both, in which each history gives both the cost of what is produced and launched (the restorations and spares, and the launches that fail) and the phases in which its satellites operate, evaluated as in the previous section: the share of points accurately sampled on average over the mission, and in the worst 10% of the histories, and the cost at 70% confidence.\n", + "\n", + "The failures are cheap to simulate, but each phase's share is expensive to evaluate, and most phases repeat the same sets of operating satellites. Each replicate (a sample of points, the expensive part) therefore simulates 20 histories of the failures of its mission (`Deployment.simulate_many`), evaluates them together (`evaluate_missions`) with a cache that evaluates each set of satellites once (`PhaseCache`, shared by the histories, policies, and designs of a replicate), and summarizes them (`summarize_missions`): their mean share, and their worst 10% (the risk of the mission), and their cost at 70% confidence. Five replicates of 20 histories measure the risk of each mission with 100 histories, at a fraction of the cost of 100 replicates." ] }, { @@ -2777,10 +2806,10 @@ "id": "d1e2f3a4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:53:55.068297Z", - "iopub.status.busy": "2026-11-11T15:53:55.068062Z", - "iopub.status.idle": "2026-11-11T15:54:00.308458Z", - "shell.execute_reply": "2026-11-11T15:54:00.307779Z" + "iopub.execute_input": "2026-11-11T16:24:55.084424Z", + "iopub.status.busy": "2026-11-11T16:24:55.084198Z", + "iopub.status.idle": "2026-11-11T16:24:58.861991Z", + "shell.execute_reply": "2026-11-11T16:24:58.861312Z" } }, "outputs": [ @@ -2791,6 +2820,13 @@ "37% of the satellites fail in 5 years\n" ] }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "60 designs x 5 replicates x 20 histories in 3 s\n" + ] + }, { "data": { "text/html": [ @@ -2868,241 +2904,241 @@ " de5bf5d3c148\n", " 800 km, 60 deg FOR, SSO: 1 at 06:00\n", " 3.9\n", + " 3.4\n", + " 4.3\n", + " 4.5\n", + " 4.6\n", + " 4.6\n", + " 0.6\n", " 3.5\n", - " 3.7\n", - " 3.8\n", - " 3.8\n", - " 3.8\n", - " 0.1\n", - " 0.9\n", - " 1.0\n", - " 1.0\n", - " 1.0\n", - " 121.0\n", - " 129.5\n", - " 147.7\n", - " 148.8\n", - " 162.7\n", + " 4.2\n", + " 4.2\n", + " 4.2\n", + " 110.2\n", + " 126.3\n", + " 144.3\n", + " 143.0\n", + " 159.0\n", " \n", " \n", " 7274d007018f\n", " 800 km, 60 deg FOR, SSO: 2 at 09:00\n", " 9.6\n", - " 7.5\n", - " 8.8\n", - " 9.0\n", - " 9.2\n", - " 9.1\n", - " 1.0\n", - " 4.2\n", - " 4.4\n", - " 5.5\n", - " 5.5\n", - " 138.1\n", - " 165.1\n", - " 181.3\n", - " 185.3\n", - " 195.0\n", + " 8.1\n", + " 10.3\n", + " 10.8\n", + " 10.9\n", + " 10.8\n", + " 2.8\n", + " 8.7\n", + " 9.9\n", + " 9.7\n", + " 9.9\n", + " 128.8\n", + " 152.5\n", + " 168.6\n", + " 169.2\n", + " 182.7\n", " \n", " \n", " b85daf65c3a4\n", " 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...\n", " 16.7\n", - " 9.9\n", - " 14.0\n", - " 13.9\n", + " 11.9\n", + " 16.4\n", + " 16.4\n", + " 18.0\n", + " 16.6\n", + " 3.5\n", + " 13.6\n", + " 14.3\n", " 15.6\n", - " 14.2\n", - " 2.6\n", - " 10.7\n", - " 10.3\n", - " 11.0\n", - " 10.3\n", - " 155.8\n", - " 202.0\n", - " 225.3\n", - " 220.4\n", - " 233.1\n", + " 14.7\n", + " 145.8\n", + " 187.4\n", + " 212.3\n", + " 206.0\n", + " 225.6\n", " \n", " \n", " 104e33a3c842\n", " 800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac...\n", " 28.6\n", - " 16.4\n", - " 22.5\n", - " 23.7\n", - " 24.1\n", - " 24.6\n", - " 5.8\n", - " 16.3\n", - " 17.3\n", - " 17.4\n", - " 18.6\n", - " 180.4\n", - " 226.5\n", - " 252.6\n", - " 252.4\n", - " 263.3\n", + " 15.3\n", + " 21.4\n", + " 23.5\n", + " 23.3\n", + " 23.8\n", + " 7.2\n", + " 18.7\n", + " 20.5\n", + " 20.6\n", + " 21.3\n", + " 169.7\n", + " 221.9\n", + " 241.7\n", + " 246.0\n", + " 252.5\n", " \n", " \n", " 33b006848799\n", " 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...\n", " 31.7\n", - " 21.6\n", - " 25.7\n", - " 26.8\n", - " 27.1\n", - " 27.0\n", - " 0.3\n", - " 14.1\n", - " 20.6\n", - " 20.3\n", - " 20.6\n", - " 147.4\n", - " 162.3\n", - " 195.6\n", - " 189.1\n", - " 209.3\n", + " 15.9\n", + " 24.9\n", + " 27.7\n", + " 28.2\n", + " 27.9\n", + " 1.9\n", + " 18.7\n", + " 23.9\n", + " 24.7\n", + " 24.4\n", + " 136.2\n", + " 169.1\n", + " 203.5\n", + " 187.4\n", + " 216.1\n", " \n", " \n", " ceabaa8327b8\n", " 800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00\n", " 54.8\n", - " 35.6\n", - " 45.0\n", - " 47.4\n", - " 47.8\n", - " 47.5\n", - " 12.2\n", + " 30.0\n", + " 44.8\n", + " 49.1\n", + " 49.4\n", + " 49.2\n", + " 8.7\n", " 35.5\n", - " 40.8\n", - " 40.9\n", - " 40.8\n", - " 163.6\n", - " 195.4\n", - " 231.4\n", - " 212.0\n", - " 244.7\n", + " 44.4\n", + " 43.5\n", + " 44.3\n", + " 153.3\n", + " 197.1\n", + " 227.9\n", + " 213.3\n", + " 240.6\n", " \n", " \n", " 92ff9cd17e00\n", " 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...\n", " 57.8\n", - " 34.8\n", - " 43.2\n", - " 45.7\n", + " 30.3\n", + " 42.8\n", + " 46.4\n", " 45.8\n", - " 46.1\n", - " 18.1\n", - " 33.4\n", - " 38.8\n", - " 38.8\n", - " 38.8\n", - " 171.1\n", - " 209.1\n", - " 256.1\n", - " 229.3\n", - " 269.1\n", + " 46.7\n", + " 11.9\n", + " 36.1\n", + " 41.9\n", + " 40.9\n", + " 43.3\n", + " 160.7\n", + " 206.4\n", + " 252.0\n", + " 225.2\n", + " 263.8\n", " \n", " \n", " 25d7b27dab28\n", " 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00\n", " 82.2\n", - " 54.4\n", - " 68.9\n", - " 68.3\n", - " 71.7\n", - " 68.3\n", - " 26.6\n", - " 59.5\n", - " 63.5\n", - " 63.9\n", - " 63.5\n", - " 180.1\n", - " 215.6\n", - " 254.2\n", - " 236.1\n", - " 266.9\n", + " 50.8\n", + " 67.0\n", + " 67.7\n", + " 71.0\n", + " 68.0\n", + " 21.9\n", + " 57.8\n", + " 61.2\n", + " 64.3\n", + " 62.3\n", + " 169.9\n", + " 220.8\n", + " 249.5\n", + " 236.4\n", + " 261.4\n", " \n", " \n", " 716cb479efda\n", " 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...\n", " 97.2\n", - " 66.3\n", - " 79.0\n", - " 75.7\n", - " 80.9\n", - " 76.1\n", - " 43.7\n", - " 71.3\n", - " 70.0\n", + " 64.8\n", + " 77.7\n", + " 74.6\n", + " 79.5\n", + " 74.8\n", + " 42.5\n", + " 71.2\n", + " 68.5\n", " 73.2\n", - " 72.1\n", - " 218.1\n", - " 276.0\n", - " 326.9\n", - " 301.8\n", - " 339.0\n", + " 68.1\n", + " 209.1\n", + " 276.2\n", + " 315.4\n", + " 294.8\n", + " 328.9\n", " \n", " \n", " 5529c21520be\n", " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " 98.0\n", - " 81.0\n", - " 83.8\n", + " 81.1\n", + " 83.9\n", " 77.6\n", - " 83.8\n", + " 83.9\n", " 77.6\n", - " 78.9\n", - " 81.9\n", - " 73.7\n", - " 82.0\n", - " 73.9\n", - " 262.3\n", - " 351.3\n", - " 406.9\n", - " 367.5\n", - " 418.2\n", + " 74.1\n", + " 79.0\n", + " 72.8\n", + " 79.0\n", + " 72.8\n", + " 253.0\n", + " 338.0\n", + " 390.5\n", + " 357.4\n", + " 398.7\n", " \n", " \n", " 679ca275c8fc\n", " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " 98.0\n", - " 80.9\n", - " 83.7\n", - " 77.4\n", - " 83.8\n", - " 77.5\n", - " 77.3\n", - " 81.6\n", - " 73.3\n", - " 81.9\n", - " 73.6\n", - " 262.3\n", - " 351.3\n", - " 406.9\n", - " 367.5\n", - " 418.2\n", + " 81.0\n", + " 83.9\n", + " 77.6\n", + " 83.9\n", + " 77.6\n", + " 73.1\n", + " 78.7\n", + " 72.8\n", + " 78.7\n", + " 72.8\n", + " 253.0\n", + " 338.0\n", + " 390.5\n", + " 357.4\n", + " 398.7\n", " \n", " \n", " de505bc89299\n", " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " 98.0\n", - " 80.7\n", - " 83.8\n", + " 81.1\n", + " 83.9\n", " 77.5\n", - " 83.8\n", + " 83.9\n", " 77.5\n", - " 78.2\n", - " 81.9\n", - " 73.4\n", - " 82.1\n", - " 73.6\n", - " 262.3\n", - " 351.3\n", - " 406.9\n", - " 367.5\n", - " 418.2\n", + " 73.9\n", + " 78.7\n", + " 72.7\n", + " 78.7\n", + " 72.7\n", + " 253.0\n", + " 338.0\n", + " 390.5\n", + " 357.4\n", + " 398.7\n", " \n", " \n", "\n", @@ -3128,82 +3164,82 @@ " full constellation accurate \\\n", "policy degrade produce spare in orbit \n", "base \n", - "de5bf5d3c148 3.9 3.5 3.7 3.8 \n", - "7274d007018f 9.6 7.5 8.8 9.0 \n", - "b85daf65c3a4 16.7 9.9 14.0 13.9 \n", - "104e33a3c842 28.6 16.4 22.5 23.7 \n", - "33b006848799 31.7 21.6 25.7 26.8 \n", - "ceabaa8327b8 54.8 35.6 45.0 47.4 \n", - "92ff9cd17e00 57.8 34.8 43.2 45.7 \n", - "25d7b27dab28 82.2 54.4 68.9 68.3 \n", - "716cb479efda 97.2 66.3 79.0 75.7 \n", - "5529c21520be 98.0 81.0 83.8 77.6 \n", - "679ca275c8fc 98.0 80.9 83.7 77.4 \n", - "de505bc89299 98.0 80.7 83.8 77.5 \n", + "de5bf5d3c148 3.9 3.4 4.3 4.5 \n", + "7274d007018f 9.6 8.1 10.3 10.8 \n", + "b85daf65c3a4 16.7 11.9 16.4 16.4 \n", + "104e33a3c842 28.6 15.3 21.4 23.5 \n", + "33b006848799 31.7 15.9 24.9 27.7 \n", + "ceabaa8327b8 54.8 30.0 44.8 49.1 \n", + "92ff9cd17e00 57.8 30.3 42.8 46.4 \n", + "25d7b27dab28 82.2 50.8 67.0 67.7 \n", + "716cb479efda 97.2 64.8 77.7 74.6 \n", + "5529c21520be 98.0 81.1 83.9 77.6 \n", + "679ca275c8fc 98.0 81.0 83.9 77.6 \n", + "de505bc89299 98.0 81.1 83.9 77.5 \n", "\n", " accurate p10 \\\n", "policy spare on ground spares in orbit and on ground degrade \n", "base \n", - "de5bf5d3c148 3.8 3.8 0.1 \n", - "7274d007018f 9.2 9.1 1.0 \n", - "b85daf65c3a4 15.6 14.2 2.6 \n", - "104e33a3c842 24.1 24.6 5.8 \n", - "33b006848799 27.1 27.0 0.3 \n", - "ceabaa8327b8 47.8 47.5 12.2 \n", - "92ff9cd17e00 45.8 46.1 18.1 \n", - "25d7b27dab28 71.7 68.3 26.6 \n", - "716cb479efda 80.9 76.1 43.7 \n", - "5529c21520be 83.8 77.6 78.9 \n", - "679ca275c8fc 83.8 77.5 77.3 \n", - "de505bc89299 83.8 77.5 78.2 \n", + "de5bf5d3c148 4.6 4.6 0.6 \n", + "7274d007018f 10.9 10.8 2.8 \n", + "b85daf65c3a4 18.0 16.6 3.5 \n", + "104e33a3c842 23.3 23.8 7.2 \n", + "33b006848799 28.2 27.9 1.9 \n", + "ceabaa8327b8 49.4 49.2 8.7 \n", + "92ff9cd17e00 45.8 46.7 11.9 \n", + "25d7b27dab28 71.0 68.0 21.9 \n", + "716cb479efda 79.5 74.8 42.5 \n", + "5529c21520be 83.9 77.6 74.1 \n", + "679ca275c8fc 83.9 77.6 73.1 \n", + "de505bc89299 83.9 77.5 73.9 \n", "\n", " \\\n", "policy produce spare in orbit spare on ground \n", "base \n", - "de5bf5d3c148 0.9 1.0 1.0 \n", - "7274d007018f 4.2 4.4 5.5 \n", - "b85daf65c3a4 10.7 10.3 11.0 \n", - "104e33a3c842 16.3 17.3 17.4 \n", - "33b006848799 14.1 20.6 20.3 \n", - "ceabaa8327b8 35.5 40.8 40.9 \n", - "92ff9cd17e00 33.4 38.8 38.8 \n", - "25d7b27dab28 59.5 63.5 63.9 \n", - "716cb479efda 71.3 70.0 73.2 \n", - "5529c21520be 81.9 73.7 82.0 \n", - "679ca275c8fc 81.6 73.3 81.9 \n", - "de505bc89299 81.9 73.4 82.1 \n", + "de5bf5d3c148 3.5 4.2 4.2 \n", + "7274d007018f 8.7 9.9 9.7 \n", + "b85daf65c3a4 13.6 14.3 15.6 \n", + "104e33a3c842 18.7 20.5 20.6 \n", + "33b006848799 18.7 23.9 24.7 \n", + "ceabaa8327b8 35.5 44.4 43.5 \n", + "92ff9cd17e00 36.1 41.9 40.9 \n", + "25d7b27dab28 57.8 61.2 64.3 \n", + "716cb479efda 71.2 68.5 73.2 \n", + "5529c21520be 79.0 72.8 79.0 \n", + "679ca275c8fc 78.7 72.8 78.7 \n", + "de505bc89299 78.7 72.7 78.7 \n", "\n", " cost p70 \\\n", "policy spares in orbit and on ground degrade produce spare in orbit \n", "base \n", - "de5bf5d3c148 1.0 121.0 129.5 147.7 \n", - "7274d007018f 5.5 138.1 165.1 181.3 \n", - "b85daf65c3a4 10.3 155.8 202.0 225.3 \n", - "104e33a3c842 18.6 180.4 226.5 252.6 \n", - "33b006848799 20.6 147.4 162.3 195.6 \n", - "ceabaa8327b8 40.8 163.6 195.4 231.4 \n", - "92ff9cd17e00 38.8 171.1 209.1 256.1 \n", - "25d7b27dab28 63.5 180.1 215.6 254.2 \n", - "716cb479efda 72.1 218.1 276.0 326.9 \n", - "5529c21520be 73.9 262.3 351.3 406.9 \n", - "679ca275c8fc 73.6 262.3 351.3 406.9 \n", - "de505bc89299 73.6 262.3 351.3 406.9 \n", + "de5bf5d3c148 4.2 110.2 126.3 144.3 \n", + "7274d007018f 9.9 128.8 152.5 168.6 \n", + "b85daf65c3a4 14.7 145.8 187.4 212.3 \n", + "104e33a3c842 21.3 169.7 221.9 241.7 \n", + "33b006848799 24.4 136.2 169.1 203.5 \n", + "ceabaa8327b8 44.3 153.3 197.1 227.9 \n", + "92ff9cd17e00 43.3 160.7 206.4 252.0 \n", + "25d7b27dab28 62.3 169.9 220.8 249.5 \n", + "716cb479efda 68.1 209.1 276.2 315.4 \n", + "5529c21520be 72.8 253.0 338.0 390.5 \n", + "679ca275c8fc 72.8 253.0 338.0 390.5 \n", + "de505bc89299 72.7 253.0 338.0 390.5 \n", "\n", " \n", "policy spare on ground spares in orbit and on ground \n", "base \n", - "de5bf5d3c148 148.8 162.7 \n", - "7274d007018f 185.3 195.0 \n", - "b85daf65c3a4 220.4 233.1 \n", - "104e33a3c842 252.4 263.3 \n", - "33b006848799 189.1 209.3 \n", - "ceabaa8327b8 212.0 244.7 \n", - "92ff9cd17e00 229.3 269.1 \n", - "25d7b27dab28 236.1 266.9 \n", - "716cb479efda 301.8 339.0 \n", - "5529c21520be 367.5 418.2 \n", - "679ca275c8fc 367.5 418.2 \n", - "de505bc89299 367.5 418.2 " + "de5bf5d3c148 143.0 159.0 \n", + "7274d007018f 169.2 182.7 \n", + "b85daf65c3a4 206.0 225.6 \n", + "104e33a3c842 246.0 252.5 \n", + "33b006848799 187.4 216.1 \n", + "ceabaa8327b8 213.3 240.6 \n", + "92ff9cd17e00 225.2 263.8 \n", + "25d7b27dab28 236.4 261.4 \n", + "716cb479efda 294.8 328.9 \n", + "5529c21520be 357.4 398.7 \n", + "679ca275c8fc 357.4 398.7 \n", + "de505bc89299 357.4 398.7 " ] }, "execution_count": 15, @@ -3212,6 +3248,8 @@ } ], "source": [ + "import time\n", + "\n", "from tatc.tradespace import Bathtub, Exponential, FailureModel, Integer, Weibull, policy_space\n", "\n", "# illustrative lives: about 9% fail in their first year, 3% a year at random, and wear-out after about 8 years\n", @@ -3246,9 +3284,12 @@ " }[orbit, ground]\n", "\n", "\n", - "study = make_study(replicates=20, failures=FAILURES, policy=BASE_POLICY, phased=True, design_space=policy_trade)\n", + "study = make_study(replicates=5, failures=FAILURES, policy=BASE_POLICY, histories=20, design_space=policy_trade)\n", + "began = time.perf_counter()\n", "trades = study.run(with_policies)\n", - "ROBUST = {\"accurate\": \"accurate mean\", \"accurate p10\": Quantile(\"accurate mean\", 0.1), \"cost p70\": Quantile(\"cost\", 0.7)}\n", + "print(f\"{len(with_policies)} designs x 5 replicates x 20 histories in {time.perf_counter() - began:.0f} s\")\n", + "# the means over the replicates of the histories' mean share, worst 10%, and cost at 70% confidence\n", + "ROBUST = {\"accurate\": \"accurate mean\", \"accurate p10\": \"accurate mean p10\", \"cost p70\": \"cost p70\"}\n", "traded = aggregate(trades, ROBUST).set_index(\"design\")[list(ROBUST)]\n", "first = trades.drop_duplicates(\"design\").set_index(\"design\")\n", "traded[\"policy\"] = [describe_policy(first.loc[key]) for key in traded.index]\n", @@ -3270,12 +3311,12 @@ "id": "e2f3a4b5", "metadata": {}, "source": [ - "The shares accurately sampled over the mission fall short of those of the full constellation under every policy, by the phases of deployment and the failures of launches as well as of satellites (37% of which fail within five years). The response to failures matters most for the designs of several satellites in several planes, and in their worst replicates:\n", + "The 6,000 histories (100 of each of the 60 designs and policies) take a few seconds here, against about as long for 1,200 histories of one per replicate without the cache. The shares accurately sampled over the mission fall short of those of the full constellation under every policy, by the phases of deployment and the failures of launches as well as of satellites (37% of which fail within five years). The response to failures matters most for the designs of several satellites in several planes, and in their worst histories:\n", "\n", - "* **Degrading** is cheapest, but loses 8 to 15 points of the mean against producing replacements for the designs of three to six satellites in two or three planes, and more in their worst 10% of replicates (44% against 71% for six satellites in three Walker planes; 0.3% against 14% for two satellites in two planes, which can lose both). Nine satellites in three planes lose only 3 points: a failure leaves eight.\n", - "* **Producing replacements** restores most of it, at 7 to 34% more cost at 70% confidence than degrading.\n", - "* **Spares** cost 22 to 55% more than degrading, and pay off in the worst replicates of the small designs of several planes: two satellites in two planes keep 20% in their worst replicates with a spare, against 14% by producing replacements. A spare on the ground costs less than a spare in each plane for the designs of several planes, and restores as well.\n", - "* **A spare in orbit can hurt**: for six or nine satellites in three planes, the spares delay the deployment (each plane's spare takes longer to produce, and a fourth satellite in a plane takes a second launch of up to three), so that they sample less on average (76% against 79% for six satellites, 78% against 84% for nine) at the highest cost. Spares in orbit and on the ground together cost the most, and sample no more than a spare on the ground alone." + "* **Degrading** is cheapest, but loses 13 to 16 points of the mean against producing replacements for the designs of three to six satellites in two or three planes, and more in their worst 10% of histories (43% against 71% for six satellites in three Walker planes; 2% against 19% for two satellites in two planes, which can lose both). Nine satellites in three planes lose only 3 points: a failure leaves eight.\n", + "* **Producing replacements** restores most of it, at 15 to 34% more cost at 70% confidence than degrading.\n", + "* **Spares** cost 30 to 57% more than degrading, and pay off in the worst histories of the small designs of several planes: two satellites in two planes keep 24 to 25% in their worst histories with a spare, against 19% by producing replacements. A spare on the ground costs less than a spare in each plane for the designs of several planes, and restores about as well.\n", + "* **A spare in orbit can hurt**: for six or nine satellites in three planes, the spares delay the deployment (each plane's spare takes longer to produce, and a fourth satellite in a plane takes a second launch of up to three), so that they sample less on average (75% against 78% for six satellites, 78% against 84% for nine) at a higher cost. Spares in orbit and on the ground together cost the most, and sample about as much as a spare on the ground alone, or less." ] }, { @@ -3284,10 +3325,10 @@ "id": "b8c9d0e1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:54:00.310149Z", - "iopub.status.busy": "2026-11-11T15:54:00.309927Z", - "iopub.status.idle": "2026-11-11T15:54:00.317921Z", - "shell.execute_reply": "2026-11-11T15:54:00.317217Z" + "iopub.execute_input": "2026-11-11T16:24:58.864067Z", + "iopub.status.busy": "2026-11-11T16:24:58.863784Z", + "iopub.status.idle": "2026-11-11T16:24:58.872763Z", + "shell.execute_reply": "2026-11-11T16:24:58.872043Z" } }, "outputs": [ @@ -3332,113 +3373,137 @@ " 56ce6ae8edc1\n", " 800 km, 60 deg FOR, SSO: 1 at 06:00\n", " degrade\n", - " 3.5\n", - " 0.1\n", - " 121.0\n", + " 3.4\n", + " 0.6\n", + " 110.2\n", " \n", " \n", " 098de5b3e423\n", " 800 km, 60 deg FOR, SSO: 1 at 06:00\n", " produce\n", - " 3.7\n", - " 0.9\n", - " 129.5\n", + " 4.3\n", + " 3.5\n", + " 126.3\n", + " \n", + " \n", + " 8961b8a2b01b\n", + " 800 km, 60 deg FOR, SSO: 1 at 06:00\n", + " spare on ground\n", + " 4.6\n", + " 4.2\n", + " 143.0\n", " \n", " \n", - " 21919a7c8e69\n", + " dcfeee8eff41\n", " 800 km, 60 deg FOR, SSO: 2 at 09:00\n", - " degrade\n", - " 7.5\n", - " 1.0\n", - " 138.1\n", + " produce\n", + " 10.3\n", + " 8.7\n", + " 152.5\n", " \n", " \n", - " 638697713902\n", - " 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...\n", + " 99b1dc715f39\n", + " 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...\n", " degrade\n", - " 9.9\n", - " 2.6\n", - " 155.8\n", + " 30.3\n", + " 11.9\n", + " 160.7\n", " \n", " \n", " ad99c42082ab\n", " 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...\n", " produce\n", - " 25.7\n", - " 14.1\n", - " 162.3\n", - " \n", - " \n", - " 99b1dc715f39\n", - " 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...\n", - " degrade\n", - " 34.8\n", - " 18.1\n", - " 171.1\n", + " 24.9\n", + " 18.7\n", + " 169.1\n", " \n", " \n", " a5094a34ed10\n", " 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00\n", " degrade\n", - " 54.4\n", - " 26.6\n", - " 180.1\n", + " 50.8\n", + " 21.9\n", + " 169.9\n", + " \n", + " \n", + " cc2e14e787ff\n", + " 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...\n", + " spare on ground\n", + " 28.2\n", + " 24.7\n", + " 187.4\n", " \n", " \n", " 2f843d5c75f6\n", " 800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00\n", " produce\n", - " 45.0\n", + " 44.8\n", " 35.5\n", - " 195.4\n", + " 197.1\n", + " \n", + " \n", + " 13421e38f465\n", + " 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...\n", + " produce\n", + " 42.8\n", + " 36.1\n", + " 206.4\n", + " \n", + " \n", + " 3a902b976460\n", + " 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...\n", + " degrade\n", + " 64.8\n", + " 42.5\n", + " 209.1\n", " \n", " \n", " 1b5495ba11a7\n", " 800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00\n", " spare on ground\n", - " 47.8\n", - " 40.9\n", - " 212.0\n", + " 49.4\n", + " 43.5\n", + " 213.3\n", " \n", " \n", " 13c5120fa410\n", " 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00\n", " produce\n", - " 68.9\n", - " 59.5\n", - " 215.6\n", + " 67.0\n", + " 57.8\n", + " 220.8\n", " \n", " \n", " fb6667b89846\n", " 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00\n", " spare on ground\n", - " 71.7\n", - " 63.9\n", - " 236.1\n", + " 71.0\n", + " 64.3\n", + " 236.4\n", " \n", " \n", " de2b7982bdac\n", " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " degrade\n", - " 81.0\n", - " 78.9\n", - " 262.3\n", + " 81.1\n", + " 74.1\n", + " 253.0\n", " \n", " \n", - " 6fa2ff2ab331\n", + " db5c6ac01a32\n", " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " produce\n", - " 83.8\n", - " 81.9\n", - " 351.3\n", + " 83.9\n", + " 79.0\n", + " 338.0\n", " \n", " \n", - " b5772457c7b2\n", + " 6f15b1416c43\n", " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " spare on ground\n", - " 83.8\n", - " 82.1\n", - " 367.5\n", + " 83.9\n", + " 79.0\n", + " 357.4\n", " \n", " \n", "\n", @@ -3449,35 +3514,41 @@ "design \n", "56ce6ae8edc1 800 km, 60 deg FOR, SSO: 1 at 06:00 \n", "098de5b3e423 800 km, 60 deg FOR, SSO: 1 at 06:00 \n", - "21919a7c8e69 800 km, 60 deg FOR, SSO: 2 at 09:00 \n", - "638697713902 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... \n", - "ad99c42082ab 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", + "8961b8a2b01b 800 km, 60 deg FOR, SSO: 1 at 06:00 \n", + "dcfeee8eff41 800 km, 60 deg FOR, SSO: 2 at 09:00 \n", "99b1dc715f39 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... \n", + "ad99c42082ab 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", "a5094a34ed10 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00 \n", + "cc2e14e787ff 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", "2f843d5c75f6 800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00 \n", + "13421e38f465 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... \n", + "3a902b976460 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", "1b5495ba11a7 800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00 \n", "13c5120fa410 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00 \n", "fb6667b89846 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00 \n", "de2b7982bdac 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", - "6fa2ff2ab331 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", - "b5772457c7b2 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", + "db5c6ac01a32 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", + "6f15b1416c43 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", "\n", " policy accurate accurate p10 cost p70 \n", "design \n", - "56ce6ae8edc1 degrade 3.5 0.1 121.0 \n", - "098de5b3e423 produce 3.7 0.9 129.5 \n", - "21919a7c8e69 degrade 7.5 1.0 138.1 \n", - "638697713902 degrade 9.9 2.6 155.8 \n", - "ad99c42082ab produce 25.7 14.1 162.3 \n", - "99b1dc715f39 degrade 34.8 18.1 171.1 \n", - "a5094a34ed10 degrade 54.4 26.6 180.1 \n", - "2f843d5c75f6 produce 45.0 35.5 195.4 \n", - "1b5495ba11a7 spare on ground 47.8 40.9 212.0 \n", - "13c5120fa410 produce 68.9 59.5 215.6 \n", - "fb6667b89846 spare on ground 71.7 63.9 236.1 \n", - "de2b7982bdac degrade 81.0 78.9 262.3 \n", - "6fa2ff2ab331 produce 83.8 81.9 351.3 \n", - "b5772457c7b2 spare on ground 83.8 82.1 367.5 " + "56ce6ae8edc1 degrade 3.4 0.6 110.2 \n", + "098de5b3e423 produce 4.3 3.5 126.3 \n", + "8961b8a2b01b spare on ground 4.6 4.2 143.0 \n", + "dcfeee8eff41 produce 10.3 8.7 152.5 \n", + "99b1dc715f39 degrade 30.3 11.9 160.7 \n", + "ad99c42082ab produce 24.9 18.7 169.1 \n", + "a5094a34ed10 degrade 50.8 21.9 169.9 \n", + "cc2e14e787ff spare on ground 28.2 24.7 187.4 \n", + "2f843d5c75f6 produce 44.8 35.5 197.1 \n", + "13421e38f465 produce 42.8 36.1 206.4 \n", + "3a902b976460 degrade 64.8 42.5 209.1 \n", + "1b5495ba11a7 spare on ground 49.4 43.5 213.3 \n", + "13c5120fa410 produce 67.0 57.8 220.8 \n", + "fb6667b89846 spare on ground 71.0 64.3 236.4 \n", + "de2b7982bdac degrade 81.1 74.1 253.0 \n", + "db5c6ac01a32 produce 83.9 79.0 338.0 \n", + "6f15b1416c43 spare on ground 83.9 79.0 357.4 " ] }, "execution_count": 16, @@ -3498,7 +3569,7 @@ "id": "c9d0e1f2", "metadata": {}, "source": [ - "The front of cost at 70% confidence against the share accurately sampled in the worst 10% of the replicates chooses designs and policies together. Its cheapest designs degrade (one or a few satellites); restoring is efficient from two satellites in two planes, whose replacements lift their worst replicates from 0.3% to 14% for 15 million more. A spare on the ground is efficient for three or four satellites in two sun-synchronous planes (41% and 64% in their worst replicates, for 17 and 21 million more than producing replacements). Nine satellites in three planes degrade gracefully: degrading keeps 79% in their worst replicates for 262 million, and restoring adds 3 points for 89 million more. A spare in orbit is not efficient for any design here, as it delays the deployment. The policy that a design deserves depends on the design, which is why the policy is a decision of the design rather than of the study." + "The front of cost at 70% confidence against the share accurately sampled in the worst 10% of the histories chooses designs and policies together. Along it, degrading is the cheapest policy of a design and restoring buys robustness: four satellites in two sun-synchronous planes keep 22% of the points accurately sampled in their worst histories if they degrade (170 million), 58% if they produce replacements (221 million), and 64% with a spare on the ground (236 million); nine satellites in three planes keep 74%, 79%, and 79% for 253, 338, and 357 million, as a failure leaves eight. A spare on the ground is efficient for designs of one to nine satellites, but a spare in orbit is not efficient for any design here, as it delays the deployment. The policy that a design deserves depends on the design, which is why the policy is a decision of the design rather than of the study." ] }, { @@ -3519,10 +3590,10 @@ "id": "c2d3e4f5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:54:00.319318Z", - "iopub.status.busy": "2026-11-11T15:54:00.319096Z", - "iopub.status.idle": "2026-11-11T15:54:01.936446Z", - "shell.execute_reply": "2026-11-11T15:54:01.935756Z" + "iopub.execute_input": "2026-11-11T16:24:58.874341Z", + "iopub.status.busy": "2026-11-11T16:24:58.874109Z", + "iopub.status.idle": "2026-11-11T16:25:00.514221Z", + "shell.execute_reply": "2026-11-11T16:25:00.513422Z" } }, "outputs": [ @@ -3832,10 +3903,10 @@ "id": "f5a6b7c8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:54:01.938067Z", - "iopub.status.busy": "2026-11-11T15:54:01.937839Z", - "iopub.status.idle": "2026-11-11T15:54:02.129173Z", - "shell.execute_reply": "2026-11-11T15:54:02.128434Z" + "iopub.execute_input": "2026-11-11T16:25:00.515972Z", + "iopub.status.busy": "2026-11-11T16:25:00.515729Z", + "iopub.status.idle": "2026-11-11T16:25:00.716288Z", + "shell.execute_reply": "2026-11-11T16:25:00.715464Z" } }, "outputs": [ @@ -4025,10 +4096,10 @@ "id": "d6e5f8a7", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:54:02.130737Z", - "iopub.status.busy": "2026-11-11T15:54:02.130532Z", - "iopub.status.idle": "2026-11-11T15:54:04.505496Z", - "shell.execute_reply": "2026-11-11T15:54:04.504744Z" + "iopub.execute_input": "2026-11-11T16:25:00.717945Z", + "iopub.status.busy": "2026-11-11T16:25:00.717717Z", + "iopub.status.idle": "2026-11-11T16:25:03.115122Z", + "shell.execute_reply": "2026-11-11T16:25:03.114367Z" } }, "outputs": [ @@ -4188,10 +4259,10 @@ "id": "a9b8c1d0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:54:04.507077Z", - "iopub.status.busy": "2026-11-11T15:54:04.506835Z", - "iopub.status.idle": "2026-11-11T15:54:05.526109Z", - "shell.execute_reply": "2026-11-11T15:54:05.525303Z" + "iopub.execute_input": "2026-11-11T16:25:03.116826Z", + "iopub.status.busy": "2026-11-11T16:25:03.116576Z", + "iopub.status.idle": "2026-11-11T16:25:04.177322Z", + "shell.execute_reply": "2026-11-11T16:25:04.176587Z" } }, "outputs": [ @@ -4302,10 +4373,10 @@ "id": "b0c9d2e1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T15:54:05.528240Z", - "iopub.status.busy": "2026-11-11T15:54:05.527780Z", - "iopub.status.idle": "2026-11-11T15:54:05.656547Z", - "shell.execute_reply": "2026-11-11T15:54:05.655821Z" + "iopub.execute_input": "2026-11-11T16:25:04.178880Z", + "iopub.status.busy": "2026-11-11T16:25:04.178651Z", + "iopub.status.idle": "2026-11-11T16:25:04.306680Z", + "shell.execute_reply": "2026-11-11T16:25:04.305975Z" } }, "outputs": [ diff --git a/src/tatc/tradespace/__init__.py b/src/tatc/tradespace/__init__.py index d8a81083..f2456bbe 100644 --- a/src/tatc/tradespace/__init__.py +++ b/src/tatc/tradespace/__init__.py @@ -39,7 +39,15 @@ Launch, Production, ) -from .mission import MissionHistory, Phase, evaluate_phases, summarize_phases +from .mission import ( + MissionHistory, + Phase, + PhaseCache, + evaluate_missions, + evaluate_phases, + summarize_missions, + summarize_phases, +) from .failures import ( Bathtub, Exponential, @@ -117,6 +125,7 @@ "MissionHistory", "OperationsCost", "Phase", + "PhaseCache", "Piecewise", "Probability", "Production", @@ -145,6 +154,7 @@ "confirm", "count_planes", "count_satellites", + "evaluate_missions", "evaluate_phases", "get_fingerprint", "get_satellite_key", @@ -166,6 +176,7 @@ "sensitivity", "sso_planes_space", "summarize", + "summarize_missions", "summarize_phases", "walker_space", ] diff --git a/src/tatc/tradespace/deployment.py b/src/tatc/tradespace/deployment.py index bb56fefa..7fc5504a 100644 --- a/src/tatc/tradespace/deployment.py +++ b/src/tatc/tradespace/deployment.py @@ -137,6 +137,7 @@ class Deployment: """list[Launch]: The launches (and planned replacements), in order.""" masses: dict[Any, float | None] = field(default_factory=dict) """dict: The mass (kg) of each type of satellite, if given.""" + _planned: MissionHistory | None = field(default=None, repr=False, compare=False) @property def begin(self) -> float: @@ -169,7 +170,7 @@ def simulate( self, failures: FailureModel | None = None, policy: RestorationPolicy | None = None, - seed: int | None = None, + seed: int | Sequence[int] | None = None, ) -> MissionHistory: """ Simulates the mission: the deployment, with the failures of its @@ -190,8 +191,9 @@ def simulate( failures (FailureModel | None): The failures, or `None` for none. policy (RestorationPolicy | None): The policy for failed satellites, or `None` to restore them by producing new ones. - seed (int | None): The seed of the replicate, or `None` for no - failures. + seed (int | Sequence[int] | None): The seed of the replicate (or + a sequence of integers, such as the seed and the index of a + history, see `simulate_many`), or `None` for no failures. Returns: MissionHistory: the history of the mission @@ -203,6 +205,53 @@ def simulate( self, failures or FailureModel(), policy or RestorationPolicy(), seed ).run() + def planned(self) -> MissionHistory: + """ + Gets the history of the mission without failures (see `simulate`), + simulated once. + + Returns: + MissionHistory: the history + """ + if self._planned is None: + self._planned = self.simulate() + return self._planned + + def simulate_many( + self, + failures: FailureModel, + policy: RestorationPolicy | None, + seed: int | None, + histories: int, + ) -> list[MissionHistory]: + """ + Simulates several histories of the mission in a replicate (see + `simulate`), history `k` drawn from the seed and `k`, so that, with + common random numbers, the same history of the same replicate draws + the same failures in every design. Without a seed, the one history + without failures. + + Many histories of the failures of a replicate, whose sample of + targets (the expensive part of an evaluation) they share, measure the + risk of a mission at little cost (see `evaluate_missions` and + `PhaseCache`). + + Args: + failures (FailureModel): The failures. + policy (RestorationPolicy | None): The policy for failed + satellites. + seed (int | None): The seed of the replicate. + histories (int): The number of histories. + + Returns: + list[MissionHistory]: the histories + """ + if histories < 1: + raise ValueError("histories must be at least 1") + if seed is None: + return [self.simulate(failures, policy, None)] + return [self.simulate(failures, policy, (seed, k)) for k in range(histories)] + def phases(self, satellites: Sequence[Satellite | str]) -> list[Phase]: """ Gets the phases of the mission without failures (see @@ -215,7 +264,7 @@ def phases(self, satellites: Sequence[Satellite | str]) -> list[Phase]: Returns: list[Phase]: the phases, in order """ - return self.simulate().phases(satellites) + return self.planned().phases(satellites) @dataclass(frozen=True) diff --git a/src/tatc/tradespace/mission.py b/src/tatc/tradespace/mission.py index 40995dde..3379684b 100644 --- a/src/tatc/tradespace/mission.py +++ b/src/tatc/tradespace/mission.py @@ -20,6 +20,7 @@ import pandas as pd from ..schemas import Satellite +from .cache import get_satellite_key from .criteria import _OPERATORS, Requirement from .deployment import Deployment, DeploymentSchedule, Launch, Production, _per_type from .failures import FailureModel, RestorationPolicy @@ -188,7 +189,7 @@ def metrics(self) -> dict[str, float]: Returns: dict[str, float]: the metrics """ - planned = self.deployment.simulate() + planned = self.deployment.planned() operated = sum(b - a for spans in self.operating.values() for a, b in spans) possible = sum(b - a for spans in planned.operating.values() for a, b in spans) delays = [restored - failed for *_, failed, restored, _ in self.restorations] @@ -227,7 +228,7 @@ def __init__( deployment: Deployment, failures: FailureModel, policy: RestorationPolicy, - seed: int | None, + seed: int | Sequence[int] | None, ): self.deployment, self.failures, self.policy = deployment, failures, policy self.seed = seed @@ -271,7 +272,8 @@ def __init__( # --- randomness def _rng(self, *key: int) -> np.random.Generator: - return np.random.default_rng([self.seed, *key]) + seed = list(self.seed) if isinstance(self.seed, Sequence) else [self.seed] + return np.random.default_rng([*seed, *key]) def _life(self, plane: int, position: int, generation: int) -> float: if self.seed is None: @@ -549,25 +551,7 @@ def evaluate_phases( pandas.DataFrame: a row per phase: its `start`, `end`, `duration`, number of `satellites`, and metrics """ - rows, evaluated = [], {} - for phase in phases: - key = frozenset(phase.satellites) - if key not in evaluated: - if "satellite" in observations.columns: - subset = observations[observations["satellite"].isin(key)] - else: - subset = observations.iloc[0:0] - evaluated[key] = dict(metric(subset)) - rows.append( - { - "start": phase.start, - "end": phase.end, - "duration": phase.duration, - "satellites": len(phase.satellites), - **evaluated[key], - } - ) - return pd.DataFrame(rows) + return _evaluate_phases(phases, observations, lambda subset, _: metric(subset())) def summarize_phases( @@ -612,3 +596,214 @@ def summarize_phases( float(starts[0]) if len(starts) > 0 else math.inf ) return summary + + +def _evaluate_phases( + phases: Sequence[Phase], + observations: pd.DataFrame, + metric: Callable[[Callable[[], pd.DataFrame], frozenset], Mapping[str, float]], +) -> pd.DataFrame: + """ + Evaluates phases with a metric of a function that gets their + observations (only if needed) and the names of their satellites (see + `evaluate_phases`), each set of satellites once. + """ + rows, evaluated = [], {} + for phase in phases: + names = frozenset(phase.satellites) + if names not in evaluated: + + def subset(names: frozenset = names) -> pd.DataFrame: + if "satellite" in observations.columns: + return observations[observations["satellite"].isin(names)] + return observations.iloc[0:0] + + evaluated[names] = dict(metric(subset, names)) + rows.append( + { + "start": phase.start, + "end": phase.end, + "duration": phase.duration, + "satellites": len(phase.satellites), + **evaluated[names], + } + ) + return pd.DataFrame(rows) + + +class PhaseCache: + """ + A cache of a metric of the phases of missions (see `evaluate_phases`), + keyed by a context that identifies the observations (such as the seed of + a replicate's sample of targets and the analysis period) and by the + content of the satellites that operate (see `get_satellite_key`), so that + the phases of missions with the same satellites (of other histories, + policies, or designs, in the same replicate) are evaluated once. + + The metric must depend only on the observations, not on the names of the + satellites. Copies sent to the parallel workers of a study start with an + empty memory, which the evaluations of a chunk share (consecutive + evaluations of the same replicate, see `Study`). + + Args: + metric (Callable): A function of the observations of a phase (which + may be empty) that gives its metrics. + """ + + def __init__(self, metric: Callable[[pd.DataFrame], Mapping[str, float]]): + self.metric = metric + self.hits = 0 + """int: The phases taken from the cache.""" + self.misses = 0 + """int: The phases evaluated.""" + self._memory: dict = {} + + def __getstate__(self) -> dict: + state = self.__dict__.copy() + state["_memory"] = {} + return state + + def evaluate( + self, + phases: Sequence[Phase], + observations: pd.DataFrame, + satellites: Sequence[Satellite] | Mapping[str, str], + context: Any, + ) -> pd.DataFrame: + """ + Evaluates the phases of a mission (see `evaluate_phases`), taking + the metrics of the satellites of a phase from the cache if they are + in it. + + Args: + phases (Sequence[Phase]): The phases. + observations (pandas.DataFrame): The observations of every + satellite, with their names (`satellite`). + satellites (Sequence[Satellite] | Mapping[str, str]): The + satellites, which key the cache by their content (or the keys + of their names, see `get_satellite_key`). + context (Any): A hashable identifier of the observations (such + as the seed of their targets and their period). + + Returns: + pandas.DataFrame: a row per phase: its `start`, `end`, + `duration`, number of `satellites`, and metrics + """ + keys = ( + satellites + if isinstance(satellites, Mapping) + else {s.name: get_satellite_key(s) for s in satellites} + ) + + def cached(subset: Callable[[], pd.DataFrame], names: frozenset) -> dict: + key = (context, frozenset(keys[name] for name in names)) + if key in self._memory: + self.hits += 1 + else: + self.misses += 1 + self._memory[key] = dict(self.metric(subset())) + return self._memory[key] + + return _evaluate_phases(phases, observations, cached) + + def clear(self) -> None: + """ + Clears the cache and its statistics. + """ + self._memory.clear() + self.hits = self.misses = 0 + + def __repr__(self) -> str: + return ( + f"PhaseCache({len(self._memory)} results, " + + f"{self.hits} hits, {self.misses} misses)" + ) + + +def evaluate_missions( + histories: Sequence[MissionHistory], + satellites: Sequence[Satellite], + observations: pd.DataFrame, + metric: Callable[[pd.DataFrame], Mapping[str, float]] | PhaseCache, + context: Any = None, + cost_model: Any = None, + growth: Any = 1.0, +) -> pd.DataFrame: + """ + Evaluates histories of a mission (such as those of a replicate, see + `Deployment.simulate_many`): for each, the mean of each metric over the + phases of the mission (` mean`, see `summarize_phases`), its + measures (see `MissionHistory.metrics`), and its cost (see + `CostEstimate.metrics`, with a cost model). The histories share the + observations of the replicate, so that a `PhaseCache` (as the metric) + evaluates each set of operating satellites once. + + Args: + histories (Sequence[MissionHistory]): The histories. + satellites (Sequence[Satellite]): The satellites (see + `MissionHistory.phases`). + observations (pandas.DataFrame): The observations of every + satellite, with their names (`satellite`). + metric (Callable | PhaseCache): A function of the observations of a + phase that gives its metrics, or a cache of one. + context (Any): A hashable identifier of the observations, for a + cache. + cost_model (CostModel | None): A model of the cost of each history. + growth (float | Mapping[str, float]): The growth of the cost. + + Returns: + pandas.DataFrame: a row per history + """ + rows = [] + keys = {s.name: get_satellite_key(s) for s in satellites} + for history in histories: + phases = history.phases(satellites) + if isinstance(metric, PhaseCache): + capability = metric.evaluate(phases, observations, keys, context) + else: + capability = evaluate_phases(phases, observations, metric) + row = {**summarize_phases(capability), **history.metrics()} + if cost_model is not None: + row.update(cost_model.estimate(history, growth).metrics()) + rows.append(row) + return pd.DataFrame(rows) + + +def summarize_missions( + missions: pd.DataFrame, + quantiles: Mapping[str, float | Sequence[float]] | None = None, + requirements: Sequence[Requirement] = (), +) -> dict[str, float]: + """ + Summarizes histories of a mission (see `evaluate_missions`) as the + metrics of an evaluation: the mean of each column over the histories + (by the same name), quantiles of columns over the histories (` + p`, such as `"accurate mean p10"` for the 0.1 quantile, the + risk of the mission), and the share of the histories that meet each + requirement on a column (`P( )`). + + The quantiles and probabilities are over the histories of a replicate, + whose statistics over the replicates (such as their mean, see + `aggregate`) combine the risk of the mission with the uncertainty of the + replicates' other parameters (such as their targets). + + Args: + missions (pandas.DataFrame): A row per history. + quantiles (Mapping | None): The quantiles of columns, by column. + requirements (Sequence[Requirement]): Requirements on columns. + + Returns: + dict[str, float]: the summary + """ + numeric = missions.select_dtypes("number") + summary = {column: float(numeric[column].mean()) for column in numeric.columns} + for column, values in (quantiles or {}).items(): + for q in [values] if isinstance(values, (int, float)) else values: + summary[f"{column} p{100 * q:g}"] = float(numeric[column].quantile(q)) + for requirement in requirements: + met = _OPERATORS[requirement.operator]( + missions[requirement.name].to_numpy(dtype=float), requirement.value + ) + statement = f"{requirement.name} {requirement.operator} {requirement.value:g}" + summary[f"P({statement})"] = float(np.mean(met)) + return summary diff --git a/tests/tradespace/test_failures.py b/tests/tradespace/test_failures.py index b3159c89..3cb1438c 100644 --- a/tests/tradespace/test_failures.py +++ b/tests/tradespace/test_failures.py @@ -10,6 +10,7 @@ from dataclasses import dataclass import numpy as np +import pandas as pd from tatc.tradespace import ( Bathtub, @@ -22,16 +23,22 @@ LaunchCost, Lifetime, OperationsCost, + PhaseCache, Piecewise, + Requirement, RestorationPolicy, SatelliteCost, Study, Uncertain, Weibull, aggregate, + build_constellation, configure, + evaluate_missions, + evaluate_phases, pareto_front, policy_space, + summarize_missions, walker_space, ) @@ -433,3 +440,133 @@ def evaluate(d): # degrading is the cheapest, and a policy that restores is the most available self.assertIn((False, 0, 0), policies) self.assertGreater(len(policies), 1) + + +class TestManyMissions(unittest.TestCase): + """ + Unit tests for many histories of missions in a replicate, and their + evaluation with a cache. + """ + + def setUp(self): + from datetime import ( + datetime, + timezone, + ) # pylint: disable=import-outside-toplevel + + from tatc.schemas import Instrument # pylint: disable=import-outside-toplevel + + self.schedule = DeploymentSchedule( + years=5, development_years=1, production_rate=4, launch_capacity=3 + ) + self.layout = _walker(2, 2) + self.satellites = build_constellation( + self.layout, + Instrument(name="imager", field_of_regard=60), + epoch=datetime(2026, 1, 1, tzinfo=timezone.utc), + altitude=700e3, + ) + names = [s.name for s in self.satellites] + self.observations = pd.DataFrame({"satellite": names * 5, "target": range(20)}) + self.failures = FailureModel(life=Exponential(0.3), launch=0.05) + self.calls = [] + + def _metric(self, observations): + self.calls.append(len(observations)) + return {"share": 25.0 * observations["satellite"].nunique()} + + def test_simulate_many(self): + """Histories of a replicate differ, and are the same in every design.""" + deployment = self.schedule.plan(self.layout) + histories = deployment.simulate_many(self.failures, RestorationPolicy(), 7, 10) + self.assertEqual(len(histories), 10) + self.assertGreater(len({tuple(h.failures) for h in histories}), 1) + again = deployment.simulate(self.failures, RestorationPolicy(), (7, 3)) + self.assertEqual(again.failures, histories[3].failures) + degraded = deployment.simulate_many( + self.failures, RestorationPolicy(restore=False), 7, 10 + ) + self.assertEqual(degraded[3].failures[0], histories[3].failures[0]) + self.assertEqual( + len(deployment.simulate_many(self.failures, None, None, 10)), 1 + ) + self.assertIs(deployment.planned(), deployment.planned()) + with self.assertRaises(ValueError): + deployment.simulate_many(self.failures, None, 7, 0) + + def test_phase_cache(self): + """A cache evaluates each set of satellites once, as without it.""" + deployment = self.schedule.plan(self.layout) + histories = deployment.simulate_many(self.failures, RestorationPolicy(), 7, 20) + cache = PhaseCache(self._metric) + for history in histories: + phases = history.phases(self.satellites) + cached = cache.evaluate(phases, self.observations, self.satellites, "r0") + direct = evaluate_phases(phases, self.observations, self._metric) + pd.testing.assert_frame_equal(cached, direct) + self.assertGreater(cache.hits, cache.misses) + # satellites of the same content (other names) share results + renamed = [ + s.model_copy(update={"name": f"other {k}"}) + for k, s in enumerate(self.satellites) + ] + observations = self.observations.replace( + {s.name: r.name for s, r in zip(self.satellites, renamed)} + ) + misses = cache.misses + cache.evaluate(histories[0].phases(renamed), observations, renamed, "r0") + self.assertEqual(cache.misses, misses) + # other observations (another context) are evaluated again + cache.evaluate( + histories[0].phases(self.satellites), + self.observations, + self.satellites, + "r1", + ) + self.assertGreater(cache.misses, misses) + cache.clear() + self.assertEqual((cache.hits, cache.misses), (0, 0)) + + def test_evaluate_and_summarize(self): + """Histories are evaluated, priced, and summarized as one record.""" + deployment = self.schedule.plan(self.layout) + histories = deployment.simulate_many(self.failures, RestorationPolicy(), 7, 30) + model = CostModel( + SatelliteCost(development=10, first_unit=5), launch=LaunchCost(per_launch=3) + ) + missions = evaluate_missions( + histories, + self.satellites, + self.observations, + PhaseCache(self._metric), + context="r0", + cost_model=model, + ) + self.assertEqual(len(missions), 30) + for column in ( + "share mean", + "availability", + "failures", + "cost", + "cost present", + ): + self.assertIn(column, missions.columns) + summary = summarize_missions( + missions, + quantiles={"share mean": [0.1, 0.5], "cost": 0.7}, + requirements=[Requirement("share mean", ">=", 60)], + ) + self.assertAlmostEqual(summary["share mean"], missions["share mean"].mean()) + self.assertAlmostEqual( + summary["share mean p10"], missions["share mean"].quantile(0.1) + ) + self.assertIn("share mean p50", summary) + self.assertIn("cost p70", summary) + self.assertAlmostEqual( + summary["P(share mean >= 60)"], (missions["share mean"] >= 60).mean() + ) + # without a cache, the same evaluations + direct = evaluate_missions( + histories, self.satellites, self.observations, self._metric + ) + np.testing.assert_allclose(direct["share mean"], missions["share mean"]) From a6f038a27bcd847efca463209b7963942e6a74ba Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Wed, 11 Nov 2026 09:49:57 -0700 Subject: [PATCH 18/52] vectorize sampling error estimates over targets --- CHANGELOG.md | 2 +- src/tatc/analysis/sufficiency.py | 111 ++++++++++++++++++++++--------- 2 files changed, 82 insertions(+), 31 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6ec73073..ab22f004 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,7 +10,7 @@ Added: - Field `type` of a catalog configuration's `attitude` (`attitude`, `glint`, or `target`), which builds an `Attitude`, `GlintAttitude`, or `TargetAttitude`, as for OCO-2's glint mode. - Field `blind_intervals` of `Attitude`: intervals of argument of latitude in which a space system's instruments do not observe, for example while the body or a mechanism moves. Observations in them are not valid, so point observations, ground tracks (`valid_obs`, and the swaths of `compute_ground_track`), orbit tracks, and ground pixels omit them, and the periods and swaths of region observations end at them. Method `is_observing` of attitudes, schedules, and instruments. - Field `type` (`instrument`, `pointed`, or `conical`) of `Instrument`, `PointedInstrument`, and `ConicalInstrument`, which identifies the instrument class in serialized data. Data without a `type` loads as the class its fields imply. - - Analysis methods of the statistical sufficiency of observations (module `analysis.sufficiency`): `estimate_sampling_error`, the error of estimating the mean of a field over a period from each target's samples, for a field with a standard deviation and an exponential correlation in time (exact, see `sampling_error_variance`), with the effective number of independent samples; `sample_field`, which samples a field (an xarray `DataArray`, such as a nature run) at the time and place of each observation, and `compare_sampled_means`, which measures the sampling error against it; `compute_revisit_statistics`, the quantiles of revisits and the longest gap of each target (including the edges of the period); and `compute_local_time_coverage`, the distribution of samples in local time of day. The decorrelation time of `estimate_sampling_error` may differ between targets. The validation notebook `ValidateSamplingErrorIMERG` compares its predictions with the errors of monthly means of IMERG precipitation sampled by four constellation designs. + - Analysis methods of the statistical sufficiency of observations (module `analysis.sufficiency`): `estimate_sampling_error`, the error of estimating the mean of a field over a period from each target's samples, for a field with a standard deviation and an exponential correlation in time (exact, see `sampling_error_variance`), with the effective number of independent samples; `sample_field`, which samples a field (an xarray `DataArray`, such as a nature run) at the time and place of each observation, and `compare_sampled_means`, which measures the sampling error against it; `compute_revisit_statistics`, the quantiles of revisits and the longest gap of each target (including the edges of the period); and `compute_local_time_coverage`, the distribution of samples in local time of day. The decorrelation time of `estimate_sampling_error` may differ between targets. The validation notebook `ValidateSamplingErrorIMERG` compares its predictions with the errors of monthly means of IMERG precipitation sampled by four constellation designs. `estimate_sampling_error` computes the error terms of every target at once (the sum of the correlations between pairs of samples by a recursion over their times), with the same results 3 to 6 times faster. - Module `tradespace` (prototype) for trade studies. A `DesignSpace` declares design variables (`Real`, `Integer`, `Categorical`), fixed and `Derived` values, and `Uncertain` parameters (drawn per replicate, not searched), grouped hierarchically with `Choice` (one of several branches) and `Repeat` (a variable number of items, such as orbit planes, optionally unordered). Bounds, derived values, and constraints are callables of the values decided before them. `DesignSpace.enumerate` gives every feasible design (a full factorial design, including variables that exist only in some designs), and `sample` a Latin hypercube or random sample. A `Design` has a `key` from its decisions and `flat` values by path, and `realize` draws a replicate's uncertain parameters, with common random numbers between designs by default. `Study` builds and evaluates designs in replicates into a data frame, recording designs that fail validation as infeasible, in worker processes with `n_jobs` (or on an `executor`); `summarize` gives the mean, standard deviation, and standard error of metrics over replicates. - Class `tradespace.SatelliteCache`, which caches an analysis of single satellites by their content (orbit, instruments, and attitude, not their name, see `get_satellite_key`), in memory or on disk, so that designs that share satellites compute their results once. - Functions `tradespace.pareto_front`, `pareto_ranks` (both with optional tolerances of objectives, within which designs near the front are efficient), and `hypervolume` (exact) of designs with several objectives to minimize or maximize, and `pareto_probability`, the probability that each design is efficient given the uncertainty of its replicates (a bootstrap that resamples the same replicates for every design). diff --git a/src/tatc/analysis/sufficiency.py b/src/tatc/analysis/sufficiency.py index 6e489352..bcd93b21 100644 --- a/src/tatc/analysis/sufficiency.py +++ b/src/tatc/analysis/sufficiency.py @@ -55,12 +55,10 @@ def _get_targets( or those observed. """ if targets is None: - first = observations.drop_duplicates("target_hash") - return gpd.GeoDataFrame( - {"target_hash": first["target_hash"].to_numpy()}, - geometry=first.geometry.to_numpy(), - crs="EPSG:4326", - ) + first = ~observations["target_hash"].duplicated().to_numpy() + result = observations.loc[first, ["target_hash", "geometry"]] + result = result.reset_index(drop=True) + return result if result.crs is not None else result.set_crs("EPSG:4326") geometry = targets if isinstance(targets, gpd.GeoSeries) else targets.geometry return gpd.GeoDataFrame( {"target_hash": _hash_geometries(geometry)}, @@ -134,6 +132,60 @@ def _error_terms( return float(pairs), float(max(pairs - 2 * cross + within, 0.0)) +def _error_terms_by_group( + seconds: np.ndarray, + codes: np.ndarray, + groups: int, + length: float, + scales: np.ndarray, +) -> tuple[np.ndarray, np.ndarray, np.ndarray]: + """ + Computes the error terms (see `_error_terms`) of the samples of each + group (such as a target) at once: the samples' times (seconds), the code + of the group of each (0 to `groups` - 1), and the decorrelation time of + each group. Gives the number of samples of each group, the mean + correlation between pairs of its samples, and the variance of its + sampling error (`NaN` without samples). + + The sum of the correlations between pairs of samples follows, for the + samples of a group in order of time, from the recursion `S_j = exp(-(t_j + - t_(j-1)) / scale) * (S_(j-1) + 1)` (the sum of the correlations of + sample `j` with those before it), stepped for every group at once. + """ + if length <= 0 or np.any(scales <= 0): + raise ValueError("the length and decorrelation time must be positive") + order = np.lexsort((seconds, codes)) + t, c = seconds[order], codes[order] + counts = np.bincount(c, minlength=groups) + first = np.concatenate([[0], np.cumsum(counts)[:-1]]) + position = np.arange(len(t)) - first[c] + width = int(counts.max()) if len(counts) > 0 and len(t) > 0 else 0 + table = np.zeros((groups, max(width, 1))) + table[c, position] = t + recent = np.zeros(groups) # S of the latest sample of each group + total = np.zeros(groups) # sum of S over the samples of each group + for k in range(1, width): + active = counts > k + gap = table[active, k] - table[active, k - 1] + recent[active] = np.exp(-gap / scales[active]) * (recent[active] + 1) + total[active] += recent[active] + with np.errstate(divide="ignore", invalid="ignore"): + pairs = (counts + 2 * total) / counts.astype(float) ** 2 + cross = np.bincount( + c, weights=_exponential_integral(t, length, scales[c]), minlength=groups + ) / (counts * length) + within = ( + 2 + * (scales * length - scales**2 * (1 - np.exp(-length / scales))) + / length**2 + ) + variance = np.maximum(pairs - 2 * cross + within, 0.0) + empty = counts == 0 + pairs[empty] = np.nan + variance[empty] = np.nan + return counts, pairs, variance + + def estimate_sampling_error( observations: gpd.GeoDataFrame, start: datetime, @@ -184,40 +236,39 @@ def estimate_sampling_error( geopandas.GeoDataFrame: a row per target """ length = (end - start).total_seconds() + result = _get_targets(observations, targets) + seconds = _get_seconds(observations[time_column], start) + codes, keys = pd.factorize(observations["target_hash"].to_numpy()) + # the decorrelation time of each observed target if isinstance(decorrelation_time, (Mapping, pd.Series)): scales = { key: pd.Timedelta(value).total_seconds() for key, value in dict(decorrelation_time).items() } + per_group = np.array([scales[key] for key in keys], dtype=float) else: - scales = None - scale = decorrelation_time.total_seconds() - result = _get_targets(observations, targets) - seconds = pd.Series( - _get_seconds(observations[time_column], start), index=observations.index + per_group = np.full(len(keys), decorrelation_time.total_seconds()) + counts, pairs, variance = _error_terms_by_group( + seconds, codes, len(keys), length, per_group ) - groups = seconds.groupby(observations["target_hash"].to_numpy()) - terms = { - key: _error_terms( - group.to_numpy(), length, scale if scales is None else scales[key] - ) - for key, group in groups - } - variance = {key: value[1] for key, value in terms.items()} - correlation = {key: value[0] for key, value in terms.items()} - counts = groups.size() - result["samples"] = result["target_hash"].map(counts).fillna(0).astype(int) - relative_variance = result["target_hash"].map(variance).astype(float) + # the group of each target (-1 for targets without samples) + index = pd.Index(keys).get_indexer(result["target_hash"].to_numpy()) + found = index >= 0 + picked = np.where(found, index, 0) + samples = np.where(found, counts[picked], 0).astype(int) + relative_error = np.sqrt(np.where(found, variance[picked], np.nan)) + with np.errstate(divide="ignore"): + effective = np.where(found, 1 / pairs[picked], 0.0) if isinstance(standard_deviation, (Mapping, pd.Series)): - sigma = result["target_hash"].map(standard_deviation).astype(float) + sigma = result["target_hash"].map(standard_deviation).to_numpy(dtype=float) else: sigma = float(standard_deviation) - result["relative_error"] = np.sqrt(relative_variance) - result["sampling_error"] = result["relative_error"] * sigma - result["effective_samples"] = ( - 1 / result["target_hash"].map(correlation).astype(float) - ).fillna(0.0) - return result + return result.assign( + samples=samples, + relative_error=relative_error, + sampling_error=relative_error * sigma, + effective_samples=effective, + ) def compute_revisit_statistics( From f86738a4149e2066f52bb596d5ec811c33b727c6 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Wed, 11 Nov 2026 09:54:39 -0700 Subject: [PATCH 19/52] vectorize revisit statistics over targets --- CHANGELOG.md | 2 +- src/tatc/analysis/sufficiency.py | 87 ++++++++++++++++++++------------ 2 files changed, 56 insertions(+), 33 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index ab22f004..1d74cdf6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,7 +10,7 @@ Added: - Field `type` of a catalog configuration's `attitude` (`attitude`, `glint`, or `target`), which builds an `Attitude`, `GlintAttitude`, or `TargetAttitude`, as for OCO-2's glint mode. - Field `blind_intervals` of `Attitude`: intervals of argument of latitude in which a space system's instruments do not observe, for example while the body or a mechanism moves. Observations in them are not valid, so point observations, ground tracks (`valid_obs`, and the swaths of `compute_ground_track`), orbit tracks, and ground pixels omit them, and the periods and swaths of region observations end at them. Method `is_observing` of attitudes, schedules, and instruments. - Field `type` (`instrument`, `pointed`, or `conical`) of `Instrument`, `PointedInstrument`, and `ConicalInstrument`, which identifies the instrument class in serialized data. Data without a `type` loads as the class its fields imply. - - Analysis methods of the statistical sufficiency of observations (module `analysis.sufficiency`): `estimate_sampling_error`, the error of estimating the mean of a field over a period from each target's samples, for a field with a standard deviation and an exponential correlation in time (exact, see `sampling_error_variance`), with the effective number of independent samples; `sample_field`, which samples a field (an xarray `DataArray`, such as a nature run) at the time and place of each observation, and `compare_sampled_means`, which measures the sampling error against it; `compute_revisit_statistics`, the quantiles of revisits and the longest gap of each target (including the edges of the period); and `compute_local_time_coverage`, the distribution of samples in local time of day. The decorrelation time of `estimate_sampling_error` may differ between targets. The validation notebook `ValidateSamplingErrorIMERG` compares its predictions with the errors of monthly means of IMERG precipitation sampled by four constellation designs. `estimate_sampling_error` computes the error terms of every target at once (the sum of the correlations between pairs of samples by a recursion over their times), with the same results 3 to 6 times faster. + - Analysis methods of the statistical sufficiency of observations (module `analysis.sufficiency`): `estimate_sampling_error`, the error of estimating the mean of a field over a period from each target's samples, for a field with a standard deviation and an exponential correlation in time (exact, see `sampling_error_variance`), with the effective number of independent samples; `sample_field`, which samples a field (an xarray `DataArray`, such as a nature run) at the time and place of each observation, and `compare_sampled_means`, which measures the sampling error against it; `compute_revisit_statistics`, the quantiles of revisits and the longest gap of each target (including the edges of the period); and `compute_local_time_coverage`, the distribution of samples in local time of day. The decorrelation time of `estimate_sampling_error` may differ between targets. The validation notebook `ValidateSamplingErrorIMERG` compares its predictions with the errors of monthly means of IMERG precipitation sampled by four constellation designs. `estimate_sampling_error` and `compute_revisit_statistics` compute the statistics of every target at once (the sum of the correlations between pairs of samples by a recursion over their times, and the gaps and their quantiles from the samples in order), with the same results 3 to 12 times faster. - Module `tradespace` (prototype) for trade studies. A `DesignSpace` declares design variables (`Real`, `Integer`, `Categorical`), fixed and `Derived` values, and `Uncertain` parameters (drawn per replicate, not searched), grouped hierarchically with `Choice` (one of several branches) and `Repeat` (a variable number of items, such as orbit planes, optionally unordered). Bounds, derived values, and constraints are callables of the values decided before them. `DesignSpace.enumerate` gives every feasible design (a full factorial design, including variables that exist only in some designs), and `sample` a Latin hypercube or random sample. A `Design` has a `key` from its decisions and `flat` values by path, and `realize` draws a replicate's uncertain parameters, with common random numbers between designs by default. `Study` builds and evaluates designs in replicates into a data frame, recording designs that fail validation as infeasible, in worker processes with `n_jobs` (or on an `executor`); `summarize` gives the mean, standard deviation, and standard error of metrics over replicates. - Class `tradespace.SatelliteCache`, which caches an analysis of single satellites by their content (orbit, instruments, and attitude, not their name, see `get_satellite_key`), in memory or on disk, so that designs that share satellites compute their results once. - Functions `tradespace.pareto_front`, `pareto_ranks` (both with optional tolerances of objectives, within which designs near the front are efficient), and `hypervolume` (exact) of designs with several objectives to minimize or maximize, and `pareto_probability`, the probability that each design is efficient given the uncertainty of its replicates (a bootstrap that resamples the same replicates for every design). diff --git a/src/tatc/analysis/sufficiency.py b/src/tatc/analysis/sufficiency.py index bcd93b21..8759de75 100644 --- a/src/tatc/analysis/sufficiency.py +++ b/src/tatc/analysis/sufficiency.py @@ -305,38 +305,61 @@ def compute_revisit_statistics( """ length = (end - start).total_seconds() result = _get_targets(observations, targets) - seconds = pd.Series( - _get_seconds(observations[time_column], start), index=observations.index - ) - rows = {} - for key, group in seconds.groupby(observations["target_hash"].to_numpy()): - t = np.sort(group.to_numpy()) - gaps = np.diff(t) - edges = np.diff(np.concatenate([[0.0], t, [length]])) - row = { - "samples": len(t), - "revisit": gaps.mean() if len(gaps) else np.nan, - "max_gap": edges.max(), - } - for q in quantiles: - row[f"revisit p{round(100 * q)}"] = ( - np.quantile(gaps, q) if len(gaps) else np.nan - ) - rows[key] = row - table = pd.DataFrame.from_dict(rows, orient="index") - columns = ["samples", "revisit"] + [f"revisit p{round(100 * q)}" for q in quantiles] - for column in columns + ["max_gap"]: - values = ( - result["target_hash"].map(table[column]) - if column in table - else pd.Series(np.nan, index=result.index) - ) - result[column] = values - result["samples"] = result["samples"].fillna(0).astype(int) - result["max_gap"] = result["max_gap"].fillna(length) - for column in columns[1:] + ["max_gap"]: - result[column] = pd.to_timedelta(result[column], unit="s") - return result + seconds = _get_seconds(observations[time_column], start) + codes, keys = pd.factorize(observations["target_hash"].to_numpy()) + groups = len(keys) + # the samples of each target in order of time, and the gaps between them + order = np.lexsort((seconds, codes)) + t, c = seconds[order], codes[order] + counts = np.bincount(c, minlength=groups) + ends = np.cumsum(counts) + same = c[1:] == c[:-1] + gaps, gap_codes = (t[1:] - t[:-1])[same], c[1:][same] + gap_counts = np.bincount(gap_codes, minlength=groups) + with np.errstate(invalid="ignore", divide="ignore"): + revisit = np.bincount(gap_codes, weights=gaps, minlength=groups) / gap_counts + # the longest time without a sample, from the start to the end of the period + longest = np.full(groups, -np.inf) + if len(t) > 0: + longest = np.maximum(t[ends - counts], length - t[ends - 1]) + np.maximum.at(longest, gap_codes, gaps) + # quantiles of the gaps of each target (by linear interpolation, as numpy) + gap_order = np.lexsort((gaps, gap_codes)) + ordered = gaps[gap_order] + gap_starts = np.cumsum(gap_counts) - gap_counts + has_gaps = gap_counts > 0 + revisits = {} + for q in quantiles: + position = q * np.maximum(gap_counts - 1, 0) + below = np.floor(position).astype(int) + above = np.minimum(below + 1, np.maximum(gap_counts - 1, 0)) + low = np.where(has_gaps, gap_starts + below, 0) + high = np.where(has_gaps, gap_starts + above, 0) + if len(ordered) > 0: + value = ordered[low] + (ordered[high] - ordered[low]) * (position - below) + else: + value = np.zeros(groups) + revisits[f"revisit p{round(100 * q)}"] = np.where(has_gaps, value, np.nan) + # the statistics of every target (without samples: none, and the whole period) + index = pd.Index(keys).get_indexer(result["target_hash"].to_numpy()) + found = index >= 0 + picked = np.where(found, index, 0) + + def per_target(values: np.ndarray, missing: float) -> np.ndarray: + if groups == 0: + return np.full(len(index), missing) + return np.where(found, values[picked], missing) + + columns = { + "samples": per_target(counts, 0).astype(int), + "revisit": pd.to_timedelta(per_target(revisit, np.nan), unit="s"), + **{ + name: pd.to_timedelta(per_target(values, np.nan), unit="s") + for name, values in revisits.items() + }, + "max_gap": pd.to_timedelta(per_target(longest, length), unit="s"), + } + return result.assign(**columns) def compute_local_time_coverage( From aaa876e4e90491137fcd58e0a0bd9038fdf91d33 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Wed, 11 Nov 2026 10:12:09 -0700 Subject: [PATCH 20/52] stratify failure histories and estimate mission means with control variates --- CHANGELOG.md | 2 +- docs/api_reference/tradespace.rst | 4 +- docs/examples/SearchTradeSpace.ipynb | 816 ++++++++++++++------------- src/tatc/tradespace/deployment.py | 45 +- src/tatc/tradespace/failures.py | 49 +- src/tatc/tradespace/mission.py | 151 ++++- tests/tradespace/test_failures.py | 124 +++- 7 files changed, 780 insertions(+), 411 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 1d74cdf6..e772d735 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -21,7 +21,7 @@ Added: - Function `tradespace.screen` (and class `Screening`), which screens designs with studies of increasing fidelity, keeping whole fronts of the best designs of each stage for the next. - Searches of design spaces with optional optimizers: `tradespace.optimize_optuna` suggests designs with Optuna trials (`DesignSpace.suggest`, define-by-run over the hierarchical space), and `optimize_pymoo` and `make_pymoo_problem` search the unit hypercube that encodes a design space (`DesignSpace.unit_paths`, `encode`, and `decode`) with pymoo. Each design is evaluated once, and the designs proposed together are evaluated together, in parallel if the study is. Constraints of a design space may return the amount of their violation (`Infeasible.violation`), which Optuna's trials record (`set_constraint`) for its constraint-aware samplers, and which is the constraint value of pymoo problems. Optional dependencies `tradespace` (joblib, Optuna, and pymoo). - Deployment of constellations (`tradespace.DeploymentSchedule`): from the rates and durations of a study (the mission and design life, the development of each type of satellite, its production on a line at a production rate, and launches at a cadence and capacity, in number or mass, optionally in an order of planes), each design's deployment (`DeploymentSchedule.plan`, a `Deployment` of its `Production`, `Launch`es, and replacements), so that a design of more satellites and planes takes longer to deploy. Its launches divide the mission into phases of constant sets of operating satellites (`Deployment.phases`), evaluated over the study's representative period from the observations of the full constellation (`evaluate_phases`) and combined over the mission (`summarize_phases`: the time-weighted mean of each metric and the time until it first meets a requirement). - - Simulated missions with failures (`Deployment.simulate`, a `MissionHistory` for each replicate, drawn from its seed with common random numbers between designs): lives of satellites whose failure rates vary over the lifecycle (`tradespace.Exponential`, `Weibull`, `Bathtub` of competing causes, and `Piecewise` rates by age, `Lifetime`), failures of launches (`FailureModel`), and a policy that degrades or restores failed satellites (`RestorationPolicy`) by spares in orbit (taking a failed satellite's place after drifting), spares on the ground (launched at the next launch slot), or satellites produced when needed (after procurement, on the production line), optionally replenishing spares and batching restorations in launches. A history gives the phases in which satellites operate (`MissionHistory.phases`), measures of the mission (`MissionHistory.metrics`: failures, restorations, spares used, time to restore, and availability), and, priced by a `CostModel`, the cost of what it produces and launches. Policies are decisions of designs with a fragment of a design space (`policy_space`: whether to restore, spares in orbit and on the ground, and other fields of the policy, without spares that would never be used), and `configure` makes a policy (or a deployment schedule, or another dataclass) from the values of a design. Many histories of a replicate's mission (`Deployment.simulate_many`) share its sample of targets: `evaluate_missions` evaluates them (with their measures and costs) with a cache that evaluates each set of operating satellites once (`PhaseCache`, keyed by the content of the satellites and shared by the histories, policies, and designs of a replicate), and `summarize_missions` gives their means, quantiles (the risk of the mission), and probabilities of meeting requirements, as one record of the replicate. + - Simulated missions with failures (`Deployment.simulate`, a `MissionHistory` for each replicate, drawn from its seed with common random numbers between designs): lives of satellites whose failure rates vary over the lifecycle (`tradespace.Exponential`, `Weibull`, `Bathtub` of competing causes, and `Piecewise` rates by age, `Lifetime`), failures of launches (`FailureModel`), and a policy that degrades or restores failed satellites (`RestorationPolicy`) by spares in orbit (taking a failed satellite's place after drifting), spares on the ground (launched at the next launch slot), or satellites produced when needed (after procurement, on the production line), optionally replenishing spares and batching restorations in launches. A history gives the phases in which satellites operate (`MissionHistory.phases`), measures of the mission (`MissionHistory.metrics`: failures, restorations, spares used, time to restore, and availability), and, priced by a `CostModel`, the cost of what it produces and launches. Policies are decisions of designs with a fragment of a design space (`policy_space`: whether to restore, spares in orbit and on the ground, and other fields of the policy, without spares that would never be used), and `configure` makes a policy (or a deployment schedule, or another dataclass) from the values of a design. Many histories of a replicate's mission (`Deployment.simulate_many`) share its sample of targets: `evaluate_missions` evaluates them (with their measures and costs) with a cache that evaluates each set of operating satellites once (`PhaseCache`, keyed by the content of the satellites and shared by the histories, policies, and designs of a replicate), and `summarize_missions` gives their means, quantiles (the risk of the mission), and probabilities of meeting requirements, as one record of the replicate. The histories of a replicate are stratified by default (a Latin hypercube over the histories of each satellite's life and each launch, drawn from uniform numbers by `Lifetime.from_uniform`), which estimates the means of missions 3 to 15 times more precisely than independent histories, and means may be estimated with control variates (`summarize_missions(controls=...)`, such as the availability of the mission, whose expected value simulations alone estimate, `Deployment.expected_metrics`). - Life-cycle costs of deployments for trade studies (`tradespace.CostModel`): the development of each type of satellite, the production of its units on a learning curve (`SatelliteCost`), launches (per launch, or prices per satellite and kg, `LaunchCost`), operations (`OperationsCost`), replacements, and spares in orbit, dated by the deployment for their present value at a discount rate (`CostEstimate.present_value`, metric `cost present`) and annual costs (`CostEstimate.annual`, metric `cost peak annual`), with growth factors for cost risk (such as uncertain parameters, whose quantiles over replicates give the cost at a confidence level). TAT-C does not include cost-estimating relationships: the costs are given by the study. Fingerprints describe dataclasses (such as cost models) by their fields. - Function `tradespace.confirm` (and class `Confirmation`), which evaluates selected designs (such as a front) with new replicates that played no part in their selection, removing the optimism of the selection (the winner's curse, `Confirmation.optimism`). `ResultStore` keys evaluations by the fingerprint of a study (`Study.fingerprint`, see `get_fingerprint`: its seed, use of common random numbers, design space, and build and evaluation functions, and the version of TAT-C), warning if it holds evaluations of other definitions, which are not reused; `SatelliteCache` keys results on disk by the fingerprint of its function. `refine` treats designs with fewer than `min_replicates` (5) as uncertain whatever their probability, adds the replicates left to `max_replicates` in a last partial step, and warns if designs remain uncertain without a tolerance. `sensitivity` gives adjusted shares (epsilon squared) by default, without the share that the levels of a variable explain by chance (`adjusted=False` for correlation ratios). - Searches with Optuna accept categorical options that depend on earlier decisions (a parameter for each set of options), use TPE with a constant liar in batches by default (which spreads the trials of a batch), and stop after `max_designs` designs evaluated (trials that suggest designs evaluated before are told their objectives without evaluating them again). A design infeasible in some of its replicates violates its feasibility by their share (`Evaluations.infeasibility`), and the first design evaluated in a search is evaluated alone, to check that evaluations give one record each. `Study` records errors of evaluations as infeasible, without storing them, with `errors="record"`. Enumeration walks the items of unordered repetitions in one order only (the same designs, in the same order, four times faster for three sun-synchronous planes), and `DesignSpace.size` counts designs without keeping them. Pareto fronts are found by a vectorized sweep in lexicographic order that compares designs only with the efficient designs before them, and fronts with tolerances by comparing designs only with the efficient designs without tolerances (which dominate every design that any design dominates within the tolerances), in blocks of bounded memory: 20,000 designs in 0.05 s (0.11 s with tolerances) rather than 17 s, and the bootstraps of `pareto_probability` (and so `refine`) about 20 times faster. diff --git a/docs/api_reference/tradespace.rst b/docs/api_reference/tradespace.rst index 2bfaf9ec..bc6063a6 100644 --- a/docs/api_reference/tradespace.rst +++ b/docs/api_reference/tradespace.rst @@ -81,7 +81,7 @@ Deployment :members: plan, launches_of .. autoclass:: tatc.tradespace.Deployment - :members: simulate, simulate_many, planned, phases, begin, end, deployed, units + :members: simulate, simulate_many, expected_metrics, planned, phases, begin, end, deployed, units .. autoclass:: tatc.tradespace.Launch @@ -97,7 +97,7 @@ Failures and Missions :members: life_of .. autoclass:: tatc.tradespace.Lifetime - :members: survival, hazard, cumulative_hazard, sample + :members: survival, hazard, cumulative_hazard, sample, from_uniform, dimensions .. autoclass:: tatc.tradespace.Exponential diff --git a/docs/examples/SearchTradeSpace.ipynb b/docs/examples/SearchTradeSpace.ipynb index c90ffcba..be134171 100644 --- a/docs/examples/SearchTradeSpace.ipynb +++ b/docs/examples/SearchTradeSpace.ipynb @@ -28,10 +28,10 @@ "id": "c3d2e5f4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T16:24:11.112102Z", - "iopub.status.busy": "2026-11-11T16:24:11.111858Z", - "iopub.status.idle": "2026-11-11T16:24:11.842166Z", - "shell.execute_reply": "2026-11-11T16:24:11.841458Z" + "iopub.execute_input": "2026-11-11T17:04:53.647588Z", + "iopub.status.busy": "2026-11-11T17:04:53.647330Z", + "iopub.status.idle": "2026-11-11T17:04:54.363946Z", + "shell.execute_reply": "2026-11-11T17:04:54.363121Z" } }, "outputs": [], @@ -79,10 +79,10 @@ "id": "e5f4a7b6", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T16:24:11.844260Z", - "iopub.status.busy": "2026-11-11T16:24:11.843990Z", - "iopub.status.idle": "2026-11-11T16:24:13.012686Z", - "shell.execute_reply": "2026-11-11T16:24:13.011904Z" + "iopub.execute_input": "2026-11-11T17:04:54.366198Z", + "iopub.status.busy": "2026-11-11T17:04:54.365843Z", + "iopub.status.idle": "2026-11-11T17:04:55.532151Z", + "shell.execute_reply": "2026-11-11T17:04:55.531317Z" } }, "outputs": [ @@ -143,10 +143,10 @@ "id": "a7b6c9d8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T16:24:13.014527Z", - "iopub.status.busy": "2026-11-11T16:24:13.014184Z", - "iopub.status.idle": "2026-11-11T16:24:13.023994Z", - "shell.execute_reply": "2026-11-11T16:24:13.023258Z" + "iopub.execute_input": "2026-11-11T17:04:55.534055Z", + "iopub.status.busy": "2026-11-11T17:04:55.533755Z", + "iopub.status.idle": "2026-11-11T17:04:55.543543Z", + "shell.execute_reply": "2026-11-11T17:04:55.542789Z" } }, "outputs": [], @@ -260,7 +260,7 @@ " if failures:\n", " # histories of the mission in the replicate, with failures drawn from its seed, on its points\n", " missions = evaluate_missions(\n", - " deployment.simulate_many(failures, restoration, d.failure_seed, histories),\n", + " deployment.simulate_many(failures, restoration, d.failure_seed, histories, sampling=\"stratified\"),\n", " members,\n", " cache(members),\n", " phase_cache,\n", @@ -302,10 +302,10 @@ "id": "c9d8e1f0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T16:24:13.025616Z", - "iopub.status.busy": "2026-11-11T16:24:13.025388Z", - "iopub.status.idle": "2026-11-11T16:24:23.734510Z", - "shell.execute_reply": "2026-11-11T16:24:23.733836Z" + "iopub.execute_input": "2026-11-11T17:04:55.545098Z", + "iopub.status.busy": "2026-11-11T17:04:55.544918Z", + "iopub.status.idle": "2026-11-11T17:05:04.739423Z", + "shell.execute_reply": "2026-11-11T17:05:04.738706Z" } }, "outputs": [ @@ -463,10 +463,10 @@ "id": "d0e9f2a1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T16:24:23.736172Z", - "iopub.status.busy": "2026-11-11T16:24:23.735928Z", - "iopub.status.idle": "2026-11-11T16:24:23.940201Z", - "shell.execute_reply": "2026-11-11T16:24:23.939421Z" + "iopub.execute_input": "2026-11-11T17:05:04.741067Z", + "iopub.status.busy": "2026-11-11T17:05:04.740831Z", + "iopub.status.idle": "2026-11-11T17:05:04.950445Z", + "shell.execute_reply": "2026-11-11T17:05:04.949702Z" } }, "outputs": [ @@ -547,10 +547,10 @@ "id": "a2b3c4d5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T16:24:23.941898Z", - "iopub.status.busy": "2026-11-11T16:24:23.941702Z", - "iopub.status.idle": "2026-11-11T16:24:24.013001Z", - "shell.execute_reply": "2026-11-11T16:24:24.012215Z" + "iopub.execute_input": "2026-11-11T17:05:04.952090Z", + "iopub.status.busy": "2026-11-11T17:05:04.951864Z", + "iopub.status.idle": "2026-11-11T17:05:05.020207Z", + "shell.execute_reply": "2026-11-11T17:05:05.019457Z" } }, "outputs": [ @@ -747,10 +747,10 @@ "id": "b3c4d5e6", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T16:24:24.015389Z", - "iopub.status.busy": "2026-11-11T16:24:24.015093Z", - "iopub.status.idle": "2026-11-11T16:24:24.253642Z", - "shell.execute_reply": "2026-11-11T16:24:24.252785Z" + "iopub.execute_input": "2026-11-11T17:05:05.021810Z", + "iopub.status.busy": "2026-11-11T17:05:05.021636Z", + "iopub.status.idle": "2026-11-11T17:05:05.255447Z", + "shell.execute_reply": "2026-11-11T17:05:05.254691Z" } }, "outputs": [ @@ -800,10 +800,10 @@ "id": "d5e6f7a8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T16:24:24.255350Z", - "iopub.status.busy": "2026-11-11T16:24:24.255105Z", - "iopub.status.idle": "2026-11-11T16:24:24.342477Z", - "shell.execute_reply": "2026-11-11T16:24:24.341683Z" + "iopub.execute_input": "2026-11-11T17:05:05.257129Z", + "iopub.status.busy": "2026-11-11T17:05:05.256869Z", + "iopub.status.idle": "2026-11-11T17:05:05.323474Z", + "shell.execute_reply": "2026-11-11T17:05:05.322669Z" } }, "outputs": [ @@ -950,10 +950,10 @@ "id": "a8b9c0d1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T16:24:24.344173Z", - "iopub.status.busy": "2026-11-11T16:24:24.343933Z", - "iopub.status.idle": "2026-11-11T16:24:24.370388Z", - "shell.execute_reply": "2026-11-11T16:24:24.369688Z" + "iopub.execute_input": "2026-11-11T17:05:05.325140Z", + "iopub.status.busy": "2026-11-11T17:05:05.324947Z", + "iopub.status.idle": "2026-11-11T17:05:05.352759Z", + "shell.execute_reply": "2026-11-11T17:05:05.352015Z" } }, "outputs": [ @@ -1101,10 +1101,10 @@ "id": "a3b2c5d4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T16:24:24.372211Z", - "iopub.status.busy": "2026-11-11T16:24:24.371971Z", - "iopub.status.idle": "2026-11-11T16:24:25.911165Z", - "shell.execute_reply": "2026-11-11T16:24:25.910335Z" + "iopub.execute_input": "2026-11-11T17:05:05.354512Z", + "iopub.status.busy": "2026-11-11T17:05:05.354338Z", + "iopub.status.idle": "2026-11-11T17:05:06.927937Z", + "shell.execute_reply": "2026-11-11T17:05:06.927088Z" } }, "outputs": [ @@ -1353,10 +1353,10 @@ "id": "b5d3f7a9", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T16:24:25.913006Z", - "iopub.status.busy": "2026-11-11T16:24:25.912746Z", - "iopub.status.idle": "2026-11-11T16:24:52.827886Z", - "shell.execute_reply": "2026-11-11T16:24:52.827165Z" + "iopub.execute_input": "2026-11-11T17:05:06.929733Z", + "iopub.status.busy": "2026-11-11T17:05:06.929476Z", + "iopub.status.idle": "2026-11-11T17:05:33.853639Z", + "shell.execute_reply": "2026-11-11T17:05:33.852946Z" } }, "outputs": [ @@ -1506,10 +1506,10 @@ "id": "c6e4a8b0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T16:24:52.829551Z", - "iopub.status.busy": "2026-11-11T16:24:52.829312Z", - "iopub.status.idle": "2026-11-11T16:24:52.889724Z", - "shell.execute_reply": "2026-11-11T16:24:52.889031Z" + "iopub.execute_input": "2026-11-11T17:05:33.855225Z", + "iopub.status.busy": "2026-11-11T17:05:33.854996Z", + "iopub.status.idle": "2026-11-11T17:05:33.918358Z", + "shell.execute_reply": "2026-11-11T17:05:33.917661Z" } }, "outputs": [ @@ -2059,10 +2059,10 @@ "id": "f2a3b4c5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T16:24:52.891225Z", - "iopub.status.busy": "2026-11-11T16:24:52.891006Z", - "iopub.status.idle": "2026-11-11T16:24:53.765102Z", - "shell.execute_reply": "2026-11-11T16:24:53.764291Z" + "iopub.execute_input": "2026-11-11T17:05:33.920005Z", + "iopub.status.busy": "2026-11-11T17:05:33.919778Z", + "iopub.status.idle": "2026-11-11T17:05:34.651641Z", + "shell.execute_reply": "2026-11-11T17:05:34.651024Z" } }, "outputs": [ @@ -2564,10 +2564,10 @@ "id": "f9b7d1e3", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T16:24:53.766667Z", - "iopub.status.busy": "2026-11-11T16:24:53.766495Z", - "iopub.status.idle": "2026-11-11T16:24:55.082829Z", - "shell.execute_reply": "2026-11-11T16:24:55.082045Z" + "iopub.execute_input": "2026-11-11T17:05:34.653508Z", + "iopub.status.busy": "2026-11-11T17:05:34.653338Z", + "iopub.status.idle": "2026-11-11T17:05:35.969870Z", + "shell.execute_reply": "2026-11-11T17:05:35.969159Z" } }, "outputs": [ @@ -2797,7 +2797,7 @@ "\n", "The policy is a decision of each design: a fragment of the design space (`policy_space`) decides whether to restore failed satellites, and the spares in orbit (in each plane) and on the ground (here, none or one of each, and none without restoration, which would never use them), and configures the policy of each design (`configure`, from a base policy of half a year of procurement and spares that are produced again). The efficient designs by accuracy, each with each of the five policies, form a design space of both, in which each history gives both the cost of what is produced and launched (the restorations and spares, and the launches that fail) and the phases in which its satellites operate, evaluated as in the previous section: the share of points accurately sampled on average over the mission, and in the worst 10% of the histories, and the cost at 70% confidence.\n", "\n", - "The failures are cheap to simulate, but each phase's share is expensive to evaluate, and most phases repeat the same sets of operating satellites. Each replicate (a sample of points, the expensive part) therefore simulates 20 histories of the failures of its mission (`Deployment.simulate_many`), evaluates them together (`evaluate_missions`) with a cache that evaluates each set of satellites once (`PhaseCache`, shared by the histories, policies, and designs of a replicate), and summarizes them (`summarize_missions`): their mean share, and their worst 10% (the risk of the mission), and their cost at 70% confidence. Five replicates of 20 histories measure the risk of each mission with 100 histories, at a fraction of the cost of 100 replicates." + "The failures are cheap to simulate, but each phase's share is expensive to evaluate, and most phases repeat the same sets of operating satellites. Each replicate (a sample of points, the expensive part) therefore simulates 20 histories of the failures of its mission (`Deployment.simulate_many`, stratified: a Latin hypercube over the histories in which each satellite's life and each launch draws from its own stratum of its distribution, which estimates means several times more precisely than independent histories), evaluates them together (`evaluate_missions`) with a cache that evaluates each set of satellites once (`PhaseCache`, shared by the histories, policies, and designs of a replicate), and summarizes them (`summarize_missions`): their mean share, and their worst 10% (the risk of the mission), and their cost at 70% confidence. Five replicates of 20 histories measure the risk of each mission with 100 histories, at a fraction of the cost of 100 replicates." ] }, { @@ -2806,10 +2806,10 @@ "id": "d1e2f3a4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T16:24:55.084424Z", - "iopub.status.busy": "2026-11-11T16:24:55.084198Z", - "iopub.status.idle": "2026-11-11T16:24:58.861991Z", - "shell.execute_reply": "2026-11-11T16:24:58.861312Z" + "iopub.execute_input": "2026-11-11T17:05:35.971530Z", + "iopub.status.busy": "2026-11-11T17:05:35.971301Z", + "iopub.status.idle": "2026-11-11T17:05:38.964364Z", + "shell.execute_reply": "2026-11-11T17:05:38.963613Z" } }, "outputs": [ @@ -2904,241 +2904,241 @@ " de5bf5d3c148\n", " 800 km, 60 deg FOR, SSO: 1 at 06:00\n", " 3.9\n", - " 3.4\n", - " 4.3\n", - " 4.5\n", + " 3.5\n", + " 4.4\n", " 4.6\n", " 4.6\n", - " 0.6\n", - " 3.5\n", - " 4.2\n", - " 4.2\n", + " 4.6\n", + " 0.5\n", + " 4.0\n", + " 4.3\n", " 4.2\n", + " 4.3\n", " 110.2\n", - " 126.3\n", - " 144.3\n", - " 143.0\n", - " 159.0\n", + " 130.6\n", + " 147.6\n", + " 146.3\n", + " 162.2\n", " \n", " \n", " 7274d007018f\n", " 800 km, 60 deg FOR, SSO: 2 at 09:00\n", " 9.6\n", - " 8.1\n", + " 8.2\n", " 10.3\n", - " 10.8\n", + " 10.7\n", " 10.9\n", " 10.8\n", - " 2.8\n", - " 8.7\n", - " 9.9\n", + " 3.7\n", + " 8.6\n", + " 9.5\n", " 9.7\n", " 9.9\n", - " 128.8\n", - " 152.5\n", - " 168.6\n", - " 169.2\n", - " 182.7\n", + " 128.9\n", + " 153.4\n", + " 170.3\n", + " 170.0\n", + " 184.3\n", " \n", " \n", " b85daf65c3a4\n", " 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...\n", " 16.7\n", - " 11.9\n", - " 16.4\n", - " 16.4\n", - " 18.0\n", - " 16.6\n", - " 3.5\n", - " 13.6\n", + " 12.2\n", + " 16.7\n", + " 16.5\n", + " 18.1\n", + " 16.7\n", + " 5.0\n", + " 14.0\n", " 14.3\n", - " 15.6\n", - " 14.7\n", - " 145.8\n", - " 187.4\n", - " 212.3\n", - " 206.0\n", - " 225.6\n", + " 16.1\n", + " 14.8\n", + " 146.2\n", + " 188.2\n", + " 211.1\n", + " 204.4\n", + " 223.3\n", " \n", " \n", " 104e33a3c842\n", " 800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac...\n", " 28.6\n", - " 15.3\n", - " 21.4\n", - " 23.5\n", + " 15.6\n", + " 21.5\n", + " 23.4\n", " 23.3\n", - " 23.8\n", - " 7.2\n", - " 18.7\n", - " 20.5\n", - " 20.6\n", - " 21.3\n", - " 169.7\n", - " 221.9\n", - " 241.7\n", - " 246.0\n", - " 252.5\n", + " 23.9\n", + " 6.2\n", + " 17.8\n", + " 19.7\n", + " 20.4\n", + " 21.1\n", + " 170.2\n", + " 218.9\n", + " 237.7\n", + " 235.8\n", + " 249.8\n", " \n", " \n", " 33b006848799\n", " 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...\n", " 31.7\n", - " 15.9\n", - " 24.9\n", - " 27.7\n", - " 28.2\n", - " 27.9\n", - " 1.9\n", - " 18.7\n", - " 23.9\n", + " 16.3\n", + " 25.7\n", + " 27.8\n", + " 28.6\n", + " 28.1\n", + " 0.6\n", + " 19.1\n", " 24.7\n", - " 24.4\n", - " 136.2\n", - " 169.1\n", - " 203.5\n", - " 187.4\n", - " 216.1\n", + " 25.2\n", + " 25.2\n", + " 136.5\n", + " 159.4\n", + " 192.7\n", + " 175.2\n", + " 206.4\n", " \n", " \n", " ceabaa8327b8\n", " 800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00\n", " 54.8\n", - " 30.0\n", - " 44.8\n", - " 49.1\n", + " 31.9\n", + " 45.9\n", + " 48.9\n", + " 49.9\n", " 49.4\n", - " 49.2\n", " 8.7\n", - " 35.5\n", - " 44.4\n", - " 43.5\n", - " 44.3\n", - " 153.3\n", - " 197.1\n", - " 227.9\n", - " 213.3\n", - " 240.6\n", + " 37.7\n", + " 43.3\n", + " 44.2\n", + " 45.2\n", + " 153.9\n", + " 198.1\n", + " 229.3\n", + " 212.4\n", + " 240.1\n", " \n", " \n", " 92ff9cd17e00\n", " 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...\n", " 57.8\n", - " 30.3\n", - " 42.8\n", - " 46.4\n", - " 45.8\n", - " 46.7\n", - " 11.9\n", - " 36.1\n", - " 41.9\n", - " 40.9\n", - " 43.3\n", - " 160.7\n", - " 206.4\n", - " 252.0\n", - " 225.2\n", - " 263.8\n", + " 32.6\n", + " 44.2\n", + " 46.9\n", + " 46.9\n", + " 47.1\n", + " 11.2\n", + " 37.7\n", + " 42.7\n", + " 41.8\n", + " 43.1\n", + " 161.2\n", + " 201.0\n", + " 247.9\n", + " 216.8\n", + " 260.4\n", " \n", " \n", " 25d7b27dab28\n", " 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00\n", " 82.2\n", - " 50.8\n", - " 67.0\n", - " 67.7\n", - " 71.0\n", - " 68.0\n", - " 21.9\n", - " 57.8\n", - " 61.2\n", - " 64.3\n", - " 62.3\n", - " 169.9\n", - " 220.8\n", - " 249.5\n", - " 236.4\n", - " 261.4\n", + " 49.0\n", + " 66.4\n", + " 66.8\n", + " 70.4\n", + " 67.3\n", + " 12.8\n", + " 54.2\n", + " 59.0\n", + " 60.1\n", + " 61.4\n", + " 170.4\n", + " 218.3\n", + " 246.8\n", + " 235.4\n", + " 260.7\n", " \n", " \n", " 716cb479efda\n", " 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...\n", " 97.2\n", - " 64.8\n", - " 77.7\n", - " 74.6\n", + " 63.8\n", + " 77.8\n", + " 73.9\n", " 79.5\n", - " 74.8\n", - " 42.5\n", - " 71.2\n", - " 68.5\n", - " 73.2\n", - " 68.1\n", - " 209.1\n", - " 276.2\n", - " 315.4\n", - " 294.8\n", - " 328.9\n", + " 74.0\n", + " 39.3\n", + " 70.1\n", + " 67.9\n", + " 71.4\n", + " 67.6\n", + " 209.5\n", + " 278.8\n", + " 316.7\n", + " 294.4\n", + " 329.0\n", " \n", " \n", " 5529c21520be\n", " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " 98.0\n", - " 81.1\n", - " 83.9\n", - " 77.6\n", - " 83.9\n", - " 77.6\n", - " 74.1\n", - " 79.0\n", - " 72.8\n", - " 79.0\n", - " 72.8\n", - " 253.0\n", - " 338.0\n", - " 390.5\n", - " 357.4\n", - " 398.7\n", + " 80.1\n", + " 83.3\n", + " 77.1\n", + " 83.4\n", + " 77.1\n", + " 66.1\n", + " 78.5\n", + " 71.7\n", + " 78.5\n", + " 71.7\n", + " 253.5\n", + " 340.0\n", + " 394.6\n", + " 355.7\n", + " 405.7\n", " \n", " \n", " 679ca275c8fc\n", " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " 98.0\n", - " 81.0\n", - " 83.9\n", - " 77.6\n", - " 83.9\n", - " 77.6\n", - " 73.1\n", - " 78.7\n", - " 72.8\n", - " 78.7\n", - " 72.8\n", - " 253.0\n", - " 338.0\n", - " 390.5\n", - " 357.4\n", - " 398.7\n", + " 80.3\n", + " 83.4\n", + " 77.1\n", + " 83.4\n", + " 77.1\n", + " 67.6\n", + " 78.6\n", + " 72.0\n", + " 78.4\n", + " 72.0\n", + " 253.5\n", + " 340.0\n", + " 394.6\n", + " 355.7\n", + " 405.7\n", " \n", " \n", " de505bc89299\n", " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " 98.0\n", - " 81.1\n", - " 83.9\n", - " 77.5\n", - " 83.9\n", - " 77.5\n", - " 73.9\n", - " 78.7\n", - " 72.7\n", - " 78.7\n", - " 72.7\n", - " 253.0\n", - " 338.0\n", - " 390.5\n", - " 357.4\n", - " 398.7\n", + " 80.2\n", + " 83.3\n", + " 77.0\n", + " 83.3\n", + " 77.0\n", + " 66.9\n", + " 78.5\n", + " 71.8\n", + " 78.3\n", + " 71.8\n", + " 253.5\n", + " 340.0\n", + " 394.6\n", + " 355.7\n", + " 405.7\n", " \n", " \n", "\n", @@ -3164,82 +3164,82 @@ " full constellation accurate \\\n", "policy degrade produce spare in orbit \n", "base \n", - "de5bf5d3c148 3.9 3.4 4.3 4.5 \n", - "7274d007018f 9.6 8.1 10.3 10.8 \n", - "b85daf65c3a4 16.7 11.9 16.4 16.4 \n", - "104e33a3c842 28.6 15.3 21.4 23.5 \n", - "33b006848799 31.7 15.9 24.9 27.7 \n", - "ceabaa8327b8 54.8 30.0 44.8 49.1 \n", - "92ff9cd17e00 57.8 30.3 42.8 46.4 \n", - "25d7b27dab28 82.2 50.8 67.0 67.7 \n", - "716cb479efda 97.2 64.8 77.7 74.6 \n", - "5529c21520be 98.0 81.1 83.9 77.6 \n", - "679ca275c8fc 98.0 81.0 83.9 77.6 \n", - "de505bc89299 98.0 81.1 83.9 77.5 \n", + "de5bf5d3c148 3.9 3.5 4.4 4.6 \n", + "7274d007018f 9.6 8.2 10.3 10.7 \n", + "b85daf65c3a4 16.7 12.2 16.7 16.5 \n", + "104e33a3c842 28.6 15.6 21.5 23.4 \n", + "33b006848799 31.7 16.3 25.7 27.8 \n", + "ceabaa8327b8 54.8 31.9 45.9 48.9 \n", + "92ff9cd17e00 57.8 32.6 44.2 46.9 \n", + "25d7b27dab28 82.2 49.0 66.4 66.8 \n", + "716cb479efda 97.2 63.8 77.8 73.9 \n", + "5529c21520be 98.0 80.1 83.3 77.1 \n", + "679ca275c8fc 98.0 80.3 83.4 77.1 \n", + "de505bc89299 98.0 80.2 83.3 77.0 \n", "\n", " accurate p10 \\\n", "policy spare on ground spares in orbit and on ground degrade \n", "base \n", - "de5bf5d3c148 4.6 4.6 0.6 \n", - "7274d007018f 10.9 10.8 2.8 \n", - "b85daf65c3a4 18.0 16.6 3.5 \n", - "104e33a3c842 23.3 23.8 7.2 \n", - "33b006848799 28.2 27.9 1.9 \n", - "ceabaa8327b8 49.4 49.2 8.7 \n", - "92ff9cd17e00 45.8 46.7 11.9 \n", - "25d7b27dab28 71.0 68.0 21.9 \n", - "716cb479efda 79.5 74.8 42.5 \n", - "5529c21520be 83.9 77.6 74.1 \n", - "679ca275c8fc 83.9 77.6 73.1 \n", - "de505bc89299 83.9 77.5 73.9 \n", + "de5bf5d3c148 4.6 4.6 0.5 \n", + "7274d007018f 10.9 10.8 3.7 \n", + "b85daf65c3a4 18.1 16.7 5.0 \n", + "104e33a3c842 23.3 23.9 6.2 \n", + "33b006848799 28.6 28.1 0.6 \n", + "ceabaa8327b8 49.9 49.4 8.7 \n", + "92ff9cd17e00 46.9 47.1 11.2 \n", + "25d7b27dab28 70.4 67.3 12.8 \n", + "716cb479efda 79.5 74.0 39.3 \n", + "5529c21520be 83.4 77.1 66.1 \n", + "679ca275c8fc 83.4 77.1 67.6 \n", + "de505bc89299 83.3 77.0 66.9 \n", "\n", " \\\n", "policy produce spare in orbit spare on ground \n", "base \n", - "de5bf5d3c148 3.5 4.2 4.2 \n", - "7274d007018f 8.7 9.9 9.7 \n", - "b85daf65c3a4 13.6 14.3 15.6 \n", - "104e33a3c842 18.7 20.5 20.6 \n", - "33b006848799 18.7 23.9 24.7 \n", - "ceabaa8327b8 35.5 44.4 43.5 \n", - "92ff9cd17e00 36.1 41.9 40.9 \n", - "25d7b27dab28 57.8 61.2 64.3 \n", - "716cb479efda 71.2 68.5 73.2 \n", - "5529c21520be 79.0 72.8 79.0 \n", - "679ca275c8fc 78.7 72.8 78.7 \n", - "de505bc89299 78.7 72.7 78.7 \n", + "de5bf5d3c148 4.0 4.3 4.2 \n", + "7274d007018f 8.6 9.5 9.7 \n", + "b85daf65c3a4 14.0 14.3 16.1 \n", + "104e33a3c842 17.8 19.7 20.4 \n", + "33b006848799 19.1 24.7 25.2 \n", + "ceabaa8327b8 37.7 43.3 44.2 \n", + "92ff9cd17e00 37.7 42.7 41.8 \n", + "25d7b27dab28 54.2 59.0 60.1 \n", + "716cb479efda 70.1 67.9 71.4 \n", + "5529c21520be 78.5 71.7 78.5 \n", + "679ca275c8fc 78.6 72.0 78.4 \n", + "de505bc89299 78.5 71.8 78.3 \n", "\n", " cost p70 \\\n", "policy spares in orbit and on ground degrade produce spare in orbit \n", "base \n", - "de5bf5d3c148 4.2 110.2 126.3 144.3 \n", - "7274d007018f 9.9 128.8 152.5 168.6 \n", - "b85daf65c3a4 14.7 145.8 187.4 212.3 \n", - "104e33a3c842 21.3 169.7 221.9 241.7 \n", - "33b006848799 24.4 136.2 169.1 203.5 \n", - "ceabaa8327b8 44.3 153.3 197.1 227.9 \n", - "92ff9cd17e00 43.3 160.7 206.4 252.0 \n", - "25d7b27dab28 62.3 169.9 220.8 249.5 \n", - "716cb479efda 68.1 209.1 276.2 315.4 \n", - "5529c21520be 72.8 253.0 338.0 390.5 \n", - "679ca275c8fc 72.8 253.0 338.0 390.5 \n", - "de505bc89299 72.7 253.0 338.0 390.5 \n", + "de5bf5d3c148 4.3 110.2 130.6 147.6 \n", + "7274d007018f 9.9 128.9 153.4 170.3 \n", + "b85daf65c3a4 14.8 146.2 188.2 211.1 \n", + "104e33a3c842 21.1 170.2 218.9 237.7 \n", + "33b006848799 25.2 136.5 159.4 192.7 \n", + "ceabaa8327b8 45.2 153.9 198.1 229.3 \n", + "92ff9cd17e00 43.1 161.2 201.0 247.9 \n", + "25d7b27dab28 61.4 170.4 218.3 246.8 \n", + "716cb479efda 67.6 209.5 278.8 316.7 \n", + "5529c21520be 71.7 253.5 340.0 394.6 \n", + "679ca275c8fc 72.0 253.5 340.0 394.6 \n", + "de505bc89299 71.8 253.5 340.0 394.6 \n", "\n", " \n", "policy spare on ground spares in orbit and on ground \n", "base \n", - "de5bf5d3c148 143.0 159.0 \n", - "7274d007018f 169.2 182.7 \n", - "b85daf65c3a4 206.0 225.6 \n", - "104e33a3c842 246.0 252.5 \n", - "33b006848799 187.4 216.1 \n", - "ceabaa8327b8 213.3 240.6 \n", - "92ff9cd17e00 225.2 263.8 \n", - "25d7b27dab28 236.4 261.4 \n", - "716cb479efda 294.8 328.9 \n", - "5529c21520be 357.4 398.7 \n", - "679ca275c8fc 357.4 398.7 \n", - "de505bc89299 357.4 398.7 " + "de5bf5d3c148 146.3 162.2 \n", + "7274d007018f 170.0 184.3 \n", + "b85daf65c3a4 204.4 223.3 \n", + "104e33a3c842 235.8 249.8 \n", + "33b006848799 175.2 206.4 \n", + "ceabaa8327b8 212.4 240.1 \n", + "92ff9cd17e00 216.8 260.4 \n", + "25d7b27dab28 235.4 260.7 \n", + "716cb479efda 294.4 329.0 \n", + "5529c21520be 355.7 405.7 \n", + "679ca275c8fc 355.7 405.7 \n", + "de505bc89299 355.7 405.7 " ] }, "execution_count": 15, @@ -3313,10 +3313,10 @@ "source": [ "The 6,000 histories (100 of each of the 60 designs and policies) take a few seconds here, against about as long for 1,200 histories of one per replicate without the cache. The shares accurately sampled over the mission fall short of those of the full constellation under every policy, by the phases of deployment and the failures of launches as well as of satellites (37% of which fail within five years). The response to failures matters most for the designs of several satellites in several planes, and in their worst histories:\n", "\n", - "* **Degrading** is cheapest, but loses 13 to 16 points of the mean against producing replacements for the designs of three to six satellites in two or three planes, and more in their worst 10% of histories (43% against 71% for six satellites in three Walker planes; 2% against 19% for two satellites in two planes, which can lose both). Nine satellites in three planes lose only 3 points: a failure leaves eight.\n", - "* **Producing replacements** restores most of it, at 15 to 34% more cost at 70% confidence than degrading.\n", - "* **Spares** cost 30 to 57% more than degrading, and pay off in the worst histories of the small designs of several planes: two satellites in two planes keep 24 to 25% in their worst histories with a spare, against 19% by producing replacements. A spare on the ground costs less than a spare in each plane for the designs of several planes, and restores about as well.\n", - "* **A spare in orbit can hurt**: for six or nine satellites in three planes, the spares delay the deployment (each plane's spare takes longer to produce, and a fourth satellite in a plane takes a second launch of up to three), so that they sample less on average (75% against 78% for six satellites, 78% against 84% for nine) at a higher cost. Spares in orbit and on the ground together cost the most, and sample about as much as a spare on the ground alone, or less." + "* **Degrading** is cheapest, but loses 12 to 17 points of the mean against producing replacements for the designs of three to six satellites in two or three planes, and more in their worst 10% of histories (39% against 70% for six satellites in three Walker planes; 1% against 19% for two satellites in two planes, which can lose both). Nine satellites in three planes lose only 3 points: a failure leaves eight.\n", + "* **Producing replacements** restores most of it, at 17 to 34% more cost at 70% confidence than degrading.\n", + "* **Spares** cost 28 to 56% more than degrading, and pay off in the worst histories of the small designs of several planes: two satellites in two planes keep about 25% in their worst histories with a spare, against 19% by producing replacements. A spare on the ground costs less than a spare in each plane for the designs of several planes, and restores about as well.\n", + "* **A spare in orbit can hurt**: for six or nine satellites in three planes, the spares delay the deployment (each plane's spare takes longer to produce, and a fourth satellite in a plane takes a second launch of up to three), so that they sample less on average (74% against 78% for six satellites, 77% against 83% for nine) at a higher cost. Spares in orbit and on the ground together cost the most, and sample about as much as a spare on the ground alone, or less." ] }, { @@ -3325,10 +3325,10 @@ "id": "b8c9d0e1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T16:24:58.864067Z", - "iopub.status.busy": "2026-11-11T16:24:58.863784Z", - "iopub.status.idle": "2026-11-11T16:24:58.872763Z", - "shell.execute_reply": "2026-11-11T16:24:58.872043Z" + "iopub.execute_input": "2026-11-11T17:05:38.965953Z", + "iopub.status.busy": "2026-11-11T17:05:38.965737Z", + "iopub.status.idle": "2026-11-11T17:05:38.974167Z", + "shell.execute_reply": "2026-11-11T17:05:38.973472Z" } }, "outputs": [ @@ -3373,137 +3373,145 @@ " 56ce6ae8edc1\n", " 800 km, 60 deg FOR, SSO: 1 at 06:00\n", " degrade\n", - " 3.4\n", - " 0.6\n", + " 3.5\n", + " 0.5\n", " 110.2\n", " \n", " \n", + " 21919a7c8e69\n", + " 800 km, 60 deg FOR, SSO: 2 at 09:00\n", + " degrade\n", + " 8.2\n", + " 3.7\n", + " 128.9\n", + " \n", + " \n", " 098de5b3e423\n", " 800 km, 60 deg FOR, SSO: 1 at 06:00\n", " produce\n", - " 4.3\n", - " 3.5\n", - " 126.3\n", + " 4.4\n", + " 4.0\n", + " 130.6\n", " \n", " \n", - " 8961b8a2b01b\n", - " 800 km, 60 deg FOR, SSO: 1 at 06:00\n", - " spare on ground\n", - " 4.6\n", - " 4.2\n", - " 143.0\n", + " 638697713902\n", + " 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...\n", + " degrade\n", + " 12.2\n", + " 5.0\n", + " 146.2\n", " \n", " \n", " dcfeee8eff41\n", " 800 km, 60 deg FOR, SSO: 2 at 09:00\n", " produce\n", " 10.3\n", - " 8.7\n", - " 152.5\n", + " 8.6\n", + " 153.4\n", " \n", " \n", - " 99b1dc715f39\n", - " 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...\n", + " dbca2b91551b\n", + " 800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00\n", " degrade\n", - " 30.3\n", - " 11.9\n", - " 160.7\n", + " 31.9\n", + " 8.7\n", + " 153.9\n", " \n", " \n", " ad99c42082ab\n", " 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...\n", " produce\n", - " 24.9\n", - " 18.7\n", - " 169.1\n", - " \n", - " \n", - " a5094a34ed10\n", - " 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00\n", - " degrade\n", - " 50.8\n", - " 21.9\n", - " 169.9\n", + " 25.7\n", + " 19.1\n", + " 159.4\n", " \n", " \n", " cc2e14e787ff\n", " 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...\n", " spare on ground\n", - " 28.2\n", - " 24.7\n", - " 187.4\n", + " 28.6\n", + " 25.2\n", + " 175.2\n", " \n", " \n", " 2f843d5c75f6\n", " 800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00\n", " produce\n", - " 44.8\n", - " 35.5\n", - " 197.1\n", + " 45.9\n", + " 37.7\n", + " 198.1\n", " \n", " \n", " 13421e38f465\n", " 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...\n", " produce\n", - " 42.8\n", - " 36.1\n", - " 206.4\n", + " 44.2\n", + " 37.7\n", + " 201.0\n", " \n", " \n", " 3a902b976460\n", " 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...\n", " degrade\n", - " 64.8\n", - " 42.5\n", - " 209.1\n", + " 63.8\n", + " 39.3\n", + " 209.5\n", " \n", " \n", " 1b5495ba11a7\n", " 800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00\n", " spare on ground\n", - " 49.4\n", - " 43.5\n", - " 213.3\n", + " 49.9\n", + " 44.2\n", + " 212.4\n", " \n", " \n", " 13c5120fa410\n", " 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00\n", " produce\n", - " 67.0\n", - " 57.8\n", - " 220.8\n", + " 66.4\n", + " 54.2\n", + " 218.3\n", " \n", " \n", " fb6667b89846\n", " 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00\n", " spare on ground\n", - " 71.0\n", - " 64.3\n", - " 236.4\n", + " 70.4\n", + " 60.1\n", + " 235.4\n", " \n", " \n", - " de2b7982bdac\n", + " 46932f795a5a\n", " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " degrade\n", - " 81.1\n", - " 74.1\n", - " 253.0\n", + " 80.3\n", + " 67.6\n", + " 253.5\n", " \n", " \n", - " db5c6ac01a32\n", - " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", + " 6e4564d2ae2c\n", + " 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...\n", " produce\n", - " 83.9\n", - " 79.0\n", - " 338.0\n", + " 77.8\n", + " 70.1\n", + " 278.8\n", " \n", " \n", - " 6f15b1416c43\n", - " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", + " 570a452fdb8f\n", + " 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...\n", " spare on ground\n", - " 83.9\n", - " 79.0\n", - " 357.4\n", + " 79.5\n", + " 71.4\n", + " 294.4\n", + " \n", + " \n", + " a37619256b26\n", + " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", + " produce\n", + " 83.4\n", + " 78.6\n", + " 340.0\n", " \n", " \n", "\n", @@ -3513,12 +3521,12 @@ " description \\\n", "design \n", "56ce6ae8edc1 800 km, 60 deg FOR, SSO: 1 at 06:00 \n", + "21919a7c8e69 800 km, 60 deg FOR, SSO: 2 at 09:00 \n", "098de5b3e423 800 km, 60 deg FOR, SSO: 1 at 06:00 \n", - "8961b8a2b01b 800 km, 60 deg FOR, SSO: 1 at 06:00 \n", + "638697713902 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... \n", "dcfeee8eff41 800 km, 60 deg FOR, SSO: 2 at 09:00 \n", - "99b1dc715f39 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... \n", + "dbca2b91551b 800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00 \n", "ad99c42082ab 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", - "a5094a34ed10 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00 \n", "cc2e14e787ff 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", "2f843d5c75f6 800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00 \n", "13421e38f465 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... \n", @@ -3526,29 +3534,31 @@ "1b5495ba11a7 800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00 \n", "13c5120fa410 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00 \n", "fb6667b89846 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00 \n", - "de2b7982bdac 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", - "db5c6ac01a32 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", - "6f15b1416c43 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", + "46932f795a5a 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", + "6e4564d2ae2c 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", + "570a452fdb8f 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", + "a37619256b26 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", "\n", " policy accurate accurate p10 cost p70 \n", "design \n", - "56ce6ae8edc1 degrade 3.4 0.6 110.2 \n", - "098de5b3e423 produce 4.3 3.5 126.3 \n", - "8961b8a2b01b spare on ground 4.6 4.2 143.0 \n", - "dcfeee8eff41 produce 10.3 8.7 152.5 \n", - "99b1dc715f39 degrade 30.3 11.9 160.7 \n", - "ad99c42082ab produce 24.9 18.7 169.1 \n", - "a5094a34ed10 degrade 50.8 21.9 169.9 \n", - "cc2e14e787ff spare on ground 28.2 24.7 187.4 \n", - "2f843d5c75f6 produce 44.8 35.5 197.1 \n", - "13421e38f465 produce 42.8 36.1 206.4 \n", - "3a902b976460 degrade 64.8 42.5 209.1 \n", - "1b5495ba11a7 spare on ground 49.4 43.5 213.3 \n", - "13c5120fa410 produce 67.0 57.8 220.8 \n", - "fb6667b89846 spare on ground 71.0 64.3 236.4 \n", - "de2b7982bdac degrade 81.1 74.1 253.0 \n", - "db5c6ac01a32 produce 83.9 79.0 338.0 \n", - "6f15b1416c43 spare on ground 83.9 79.0 357.4 " + "56ce6ae8edc1 degrade 3.5 0.5 110.2 \n", + "21919a7c8e69 degrade 8.2 3.7 128.9 \n", + "098de5b3e423 produce 4.4 4.0 130.6 \n", + "638697713902 degrade 12.2 5.0 146.2 \n", + "dcfeee8eff41 produce 10.3 8.6 153.4 \n", + "dbca2b91551b degrade 31.9 8.7 153.9 \n", + "ad99c42082ab produce 25.7 19.1 159.4 \n", + "cc2e14e787ff spare on ground 28.6 25.2 175.2 \n", + "2f843d5c75f6 produce 45.9 37.7 198.1 \n", + "13421e38f465 produce 44.2 37.7 201.0 \n", + "3a902b976460 degrade 63.8 39.3 209.5 \n", + "1b5495ba11a7 spare on ground 49.9 44.2 212.4 \n", + "13c5120fa410 produce 66.4 54.2 218.3 \n", + "fb6667b89846 spare on ground 70.4 60.1 235.4 \n", + "46932f795a5a degrade 80.3 67.6 253.5 \n", + "6e4564d2ae2c produce 77.8 70.1 278.8 \n", + "570a452fdb8f spare on ground 79.5 71.4 294.4 \n", + "a37619256b26 produce 83.4 78.6 340.0 " ] }, "execution_count": 16, @@ -3569,7 +3579,7 @@ "id": "c9d0e1f2", "metadata": {}, "source": [ - "The front of cost at 70% confidence against the share accurately sampled in the worst 10% of the histories chooses designs and policies together. Along it, degrading is the cheapest policy of a design and restoring buys robustness: four satellites in two sun-synchronous planes keep 22% of the points accurately sampled in their worst histories if they degrade (170 million), 58% if they produce replacements (221 million), and 64% with a spare on the ground (236 million); nine satellites in three planes keep 74%, 79%, and 79% for 253, 338, and 357 million, as a failure leaves eight. A spare on the ground is efficient for designs of one to nine satellites, but a spare in orbit is not efficient for any design here, as it delays the deployment. The policy that a design deserves depends on the design, which is why the policy is a decision of the design rather than of the study." + "The front of cost at 70% confidence against the share accurately sampled in the worst 10% of the histories chooses designs and policies together. Along it, degrading is the cheapest policy of a design and restoring buys robustness: three satellites in two sun-synchronous planes keep 9% of the points accurately sampled in their worst histories if they degrade (154 million), 38% if they produce replacements (198 million), and 44% with a spare on the ground (212 million); six satellites in three Walker planes keep 39%, 70%, and 71% for 210, 279, and 294 million. Nine satellites in three planes degrade gracefully (68% in their worst histories for 254 million), and producing replacements raises them to 79% for 340 million. A spare on the ground is efficient for designs of two to six satellites, but a spare in orbit is not efficient for any design here, as it delays the deployment. The policy that a design deserves depends on the design, which is why the policy is a decision of the design rather than of the study." ] }, { @@ -3590,10 +3600,10 @@ "id": "c2d3e4f5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T16:24:58.874341Z", - "iopub.status.busy": "2026-11-11T16:24:58.874109Z", - "iopub.status.idle": "2026-11-11T16:25:00.514221Z", - "shell.execute_reply": "2026-11-11T16:25:00.513422Z" + "iopub.execute_input": "2026-11-11T17:05:38.975667Z", + "iopub.status.busy": "2026-11-11T17:05:38.975443Z", + "iopub.status.idle": "2026-11-11T17:05:40.636839Z", + "shell.execute_reply": "2026-11-11T17:05:40.636169Z" } }, "outputs": [ @@ -3903,10 +3913,10 @@ "id": "f5a6b7c8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T16:25:00.515972Z", - "iopub.status.busy": "2026-11-11T16:25:00.515729Z", - "iopub.status.idle": "2026-11-11T16:25:00.716288Z", - "shell.execute_reply": "2026-11-11T16:25:00.715464Z" + "iopub.execute_input": "2026-11-11T17:05:40.638413Z", + "iopub.status.busy": "2026-11-11T17:05:40.638183Z", + "iopub.status.idle": "2026-11-11T17:05:40.824879Z", + "shell.execute_reply": "2026-11-11T17:05:40.824101Z" } }, "outputs": [ @@ -4096,10 +4106,10 @@ "id": "d6e5f8a7", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T16:25:00.717945Z", - "iopub.status.busy": "2026-11-11T16:25:00.717717Z", - "iopub.status.idle": "2026-11-11T16:25:03.115122Z", - "shell.execute_reply": "2026-11-11T16:25:03.114367Z" + "iopub.execute_input": "2026-11-11T17:05:40.826446Z", + "iopub.status.busy": "2026-11-11T17:05:40.826232Z", + "iopub.status.idle": "2026-11-11T17:05:42.841203Z", + "shell.execute_reply": "2026-11-11T17:05:42.840413Z" } }, "outputs": [ @@ -4259,10 +4269,10 @@ "id": "a9b8c1d0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T16:25:03.116826Z", - "iopub.status.busy": "2026-11-11T16:25:03.116576Z", - "iopub.status.idle": "2026-11-11T16:25:04.177322Z", - "shell.execute_reply": "2026-11-11T16:25:04.176587Z" + "iopub.execute_input": "2026-11-11T17:05:42.842829Z", + "iopub.status.busy": "2026-11-11T17:05:42.842601Z", + "iopub.status.idle": "2026-11-11T17:05:43.982198Z", + "shell.execute_reply": "2026-11-11T17:05:43.981451Z" } }, "outputs": [ @@ -4373,10 +4383,10 @@ "id": "b0c9d2e1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T16:25:04.178880Z", - "iopub.status.busy": "2026-11-11T16:25:04.178651Z", - "iopub.status.idle": "2026-11-11T16:25:04.306680Z", - "shell.execute_reply": "2026-11-11T16:25:04.305975Z" + "iopub.execute_input": "2026-11-11T17:05:43.983687Z", + "iopub.status.busy": "2026-11-11T17:05:43.983462Z", + "iopub.status.idle": "2026-11-11T17:05:44.111120Z", + "shell.execute_reply": "2026-11-11T17:05:44.110357Z" } }, "outputs": [ diff --git a/src/tatc/tradespace/deployment.py b/src/tatc/tradespace/deployment.py index 7fc5504a..fe0f713f 100644 --- a/src/tatc/tradespace/deployment.py +++ b/src/tatc/tradespace/deployment.py @@ -223,6 +223,7 @@ def simulate_many( policy: RestorationPolicy | None, seed: int | None, histories: int, + sampling: str = "stratified", ) -> list[MissionHistory]: """ Simulates several histories of the mission in a replicate (see @@ -231,6 +232,15 @@ def simulate_many( the same failures in every design. Without a seed, the one history without failures. + The failures of the histories are stratified by default + (`"stratified"`: a Latin hypercube over the histories, in which each + life and launch of each history draws from its own stratum of its + distribution, see `Lifetime.from_uniform`), which spreads the + histories over the distributions of the failures and estimates the + means of the measures of the mission more precisely than independent + histories (`"random"`), several times so for missions of a few + satellites or many, at no cost. + Many histories of the failures of a replicate, whose sample of targets (the expensive part of an evaluation) they share, measure the risk of a mission at little cost (see `evaluate_missions` and @@ -242,15 +252,48 @@ def simulate_many( satellites. seed (int | None): The seed of the replicate. histories (int): The number of histories. + sampling (str): `"stratified"` or `"random"`. Returns: list[MissionHistory]: the histories """ + # pylint: disable=import-outside-toplevel + from .mission import _simulate_many + if histories < 1: raise ValueError("histories must be at least 1") if seed is None: return [self.simulate(failures, policy, None)] - return [self.simulate(failures, policy, (seed, k)) for k in range(histories)] + return _simulate_many(self, failures, policy, seed, histories, sampling) + + def expected_metrics( + self, + failures: FailureModel, + policy: RestorationPolicy | None = None, + histories: int = 1000, + seed: int = 0, + sampling: str = "stratified", + ) -> dict[str, float]: + """ + Estimates the expected measures of the mission (see + `MissionHistory.metrics`, such as its `availability`) from many + simulated histories (see `expected_metrics`). + + Args: + failures (FailureModel): The failures. + policy (RestorationPolicy | None): The policy for failed + satellites. + histories (int): The number of histories. + seed (int): The seed of the histories. + sampling (str): The sampling of their failures. + + Returns: + dict[str, float]: the mean of each measure + """ + # pylint: disable=import-outside-toplevel + from .mission import expected_metrics + + return expected_metrics(self, failures, policy, histories, seed, sampling) def phases(self, satellites: Sequence[Satellite | str]) -> list[Phase]: """ diff --git a/src/tatc/tradespace/failures.py b/src/tatc/tradespace/failures.py index b14c3764..c8f51676 100644 --- a/src/tatc/tradespace/failures.py +++ b/src/tatc/tradespace/failures.py @@ -84,6 +84,27 @@ def sample(self, rng: np.random.Generator) -> float: Returns: float: the life """ + return self.from_uniform(rng.random(self.dimensions)) + + @property + def dimensions(self) -> int: + """int: The uniform numbers that determine a life (see + `from_uniform`).""" + return 1 + + def from_uniform(self, uniform: Sequence[float]) -> float: + """ + Gets the life determined by uniform numbers in [0, 1) (as many as + `dimensions`): the life whose cumulative distribution is the uniform + number (the inverse of the distribution), so that stratified + uniform numbers give stratified lives (see `Deployment.simulate_many`). + + Args: + uniform (Sequence[float]): The uniform numbers. + + Returns: + float: the life (years, infinite if the satellite never fails) + """ raise NotImplementedError @@ -111,6 +132,11 @@ def hazard(self, age): def sample(self, rng): return math.inf if self.rate == 0 else float(rng.exponential(1 / self.rate)) + def from_uniform(self, uniform): + if self.rate == 0: + return math.inf + return float(-math.log1p(-float(uniform[0])) / self.rate) + @dataclass(frozen=True) class Weibull(Lifetime): @@ -142,6 +168,10 @@ def hazard(self, age): def sample(self, rng): return float(self.scale * rng.weibull(self.shape)) + def from_uniform(self, uniform): + hazard = -math.log1p(-float(uniform[0])) + return float(self.scale * hazard ** (1 / self.shape)) + @dataclass(frozen=True) class Bathtub(Lifetime): @@ -176,6 +206,17 @@ def hazard(self, age): def sample(self, rng): return min((c.sample(rng) for c in self.causes), default=math.inf) + @property + def dimensions(self) -> int: + return max(sum(c.dimensions for c in self.causes), 1) + + def from_uniform(self, uniform): + lives, start = [], 0 + for cause in self.causes: + lives.append(cause.from_uniform(uniform[start : start + cause.dimensions])) + start += cause.dimensions + return min(lives, default=math.inf) + @dataclass(frozen=True) class Piecewise(Lifetime): @@ -222,7 +263,13 @@ def hazard(self, age): def sample(self, rng): # the age at which the cumulative hazard reaches a unit exponential draw - target = float(rng.exponential(1.0)) + return self._age_at(float(rng.exponential(1.0))) + + def from_uniform(self, uniform): + return self._age_at(-math.log1p(-float(uniform[0]))) + + def _age_at(self, target: float) -> float: + """The age at which the cumulative hazard reaches a target.""" cumulative = 0.0 for start, end, rate in zip(self.breaks, self._ends(), self.rates): span = end - start diff --git a/src/tatc/tradespace/mission.py b/src/tatc/tradespace/mission.py index 3379684b..22562d98 100644 --- a/src/tatc/tradespace/mission.py +++ b/src/tatc/tradespace/mission.py @@ -229,9 +229,10 @@ def __init__( failures: FailureModel, policy: RestorationPolicy, seed: int | Sequence[int] | None, + uniforms: Callable[[tuple, int], np.ndarray] | None = None, ): self.deployment, self.failures, self.policy = deployment, failures, policy - self.seed = seed + self.seed, self.uniforms = seed, uniforms self.schedule = deployment.schedule self.end = deployment.end self.history = MissionHistory( @@ -281,11 +282,16 @@ def _life(self, plane: int, position: int, generation: int) -> float: life = self.failures.life_of(self.deployment.planes[plane][0]) if life is None: return math.inf + if self.uniforms is not None: + key = (0, plane, position, generation) + return life.from_uniform(self.uniforms(key, life.dimensions)) return life.sample(self._rng(0, plane, position, generation)) def _launch_fails(self, *key: int) -> bool: if self.seed is None or self.failures.launch == 0: return False + if self.uniforms is not None: + return bool(self.uniforms((1, *key), 1)[0] < self.failures.launch) return bool(self._rng(1, *key).random() < self.failures.launch) # --- events @@ -773,6 +779,7 @@ def summarize_missions( missions: pd.DataFrame, quantiles: Mapping[str, float | Sequence[float]] | None = None, requirements: Sequence[Requirement] = (), + controls: Mapping[str, float] | None = None, ) -> dict[str, float]: """ Summarizes histories of a mission (see `evaluate_missions`) as the @@ -782,6 +789,17 @@ def summarize_missions( risk of the mission), and the share of the histories that meet each requirement on a column (`P( )`). + With `controls`, the means are estimated with control variates: columns + whose expected values are known (such as the `availability` of a + mission, which simulations alone estimate precisely and cheaply, see + `Deployment.expected_metrics`), and which vary with the other columns + from history to history. The mean of each other column is corrected by + the deviation of the controls' means from their expected values, times + the regression of the column on the controls over the histories, + which removes the share of its variance that the controls explain (a + share of `rho ** 2` for a correlation `rho`): fewer histories give the + same precision. The quantiles and probabilities are not corrected. + The quantiles and probabilities are over the histories of a replicate, whose statistics over the replicates (such as their mean, see `aggregate`) combine the risk of the mission with the uncertainty of the @@ -791,12 +809,16 @@ def summarize_missions( missions (pandas.DataFrame): A row per history. quantiles (Mapping | None): The quantiles of columns, by column. requirements (Sequence[Requirement]): Requirements on columns. + controls (Mapping[str, float] | None): The expected values of + columns that are control variates, if any. Returns: dict[str, float]: the summary """ numeric = missions.select_dtypes("number") summary = {column: float(numeric[column].mean()) for column in numeric.columns} + if controls: + summary.update(_controlled_means(numeric, controls)) for column, values in (quantiles or {}).items(): for q in [values] if isinstance(values, (int, float)) else values: summary[f"{column} p{100 * q:g}"] = float(numeric[column].quantile(q)) @@ -807,3 +829,130 @@ def summarize_missions( statement = f"{requirement.name} {requirement.operator} {requirement.value:g}" summary[f"P({statement})"] = float(np.mean(met)) return summary + + +def _controlled_means(numeric: pd.DataFrame, controls: Mapping[str, float]) -> dict: + """ + Estimates the means of columns with control variates (see + `summarize_missions`): each column's mean less the regression of the + column on the controls applied to the deviations of the controls' means + from their expected values, over the histories in which the column and + the controls are known. + """ + names = list(controls) + missing = set(names) - set(numeric.columns) + if missing: + raise ValueError(f"no columns of controls {sorted(missing)}") + expected = np.array([float(controls[name]) for name in names]) + means = {name: float(value) for name, value in zip(names, expected)} + for column in numeric.columns: + if column in controls: + continue + data = numeric[[column, *names]].to_numpy(dtype=float) + data = data[np.all(np.isfinite(data), axis=1)] + if len(data) <= len(names) + 1: + continue + y, x = data[:, 0], data[:, 1:] + centered = x - x.mean(axis=0) + if not np.any(centered): + continue + beta = np.linalg.lstsq(centered, y - y.mean(), rcond=None)[0] + means[column] = float(y.mean() - (x.mean(axis=0) - expected) @ beta) + return means + + +class _Sampler: + """ + The uniform numbers of the failures of a history of a replicate, + stratified over the histories of the replicate (see + `Deployment.simulate_many`): a Latin hypercube in which, for each draw + (each life and launch), history `k` of `K` takes a uniform number in its + stratum of a permutation of the `K` strata of [0, 1). Each draw is keyed + by its key, so that the same draw of the same history of a replicate + takes the same number in every design (common random numbers). + """ + + def __init__(self, seed: int, index: int, histories: int): + self.seed, self.index, self.histories = seed, index, histories + + def __call__(self, key: tuple, dimensions: int) -> np.ndarray: + strata = np.random.default_rng([self.seed, 1, self.histories, *key]) + orders = [strata.permutation(self.histories) for _ in range(dimensions)] + jitter = np.random.default_rng([self.seed, 2, self.index, *key]) + offsets = jitter.random(dimensions) + return np.array( + [ + (order[self.index] + offset) / self.histories + for order, offset in zip(orders, offsets) + ] + ) + + +SAMPLINGS = ("random", "stratified") +"""The samplings of the failures of histories (see `Deployment.simulate_many`).""" + + +def _simulate_many( + deployment: Deployment, + failures: FailureModel, + policy: RestorationPolicy | None, + seed: int, + histories: int, + sampling: str, +) -> list[MissionHistory]: + """ + Simulates the histories of a replicate (see `Deployment.simulate_many`). + """ + if sampling not in SAMPLINGS: + raise ValueError(f"sampling must be one of {SAMPLINGS}, not {sampling!r}") + if sampling == "random": + return [ + deployment.simulate(failures, policy, (seed, k)) for k in range(histories) + ] + return [ + _Simulation( + deployment, + failures, + policy or RestorationPolicy(), + (seed, k), + _Sampler(seed, k, histories), + ).run() + for k in range(histories) + ] + + +def expected_metrics( + deployment: Deployment, + failures: FailureModel, + policy: RestorationPolicy | None = None, + histories: int = 1000, + seed: int = 0, + sampling: str = "stratified", +) -> dict[str, float]: + """ + Estimates the expected measures of a mission (see + `MissionHistory.metrics`, such as its `availability`) from many + simulated histories, without evaluating their phases: precise and + cheap, as the expected values of control variates (see + `summarize_missions`). + + Args: + deployment (Deployment): The deployment. + failures (FailureModel): The failures. + policy (RestorationPolicy | None): The policy for failed satellites. + histories (int): The number of histories. + seed (int): The seed of the histories. + sampling (str): The sampling of their failures. + + Returns: + dict[str, float]: the mean of each measure + """ + rows = pd.DataFrame( + [ + history.metrics() + for history in _simulate_many( + deployment, failures, policy, seed, histories, sampling + ) + ] + ) + return {column: float(rows[column].mean()) for column in rows.columns} diff --git a/tests/tradespace/test_failures.py b/tests/tradespace/test_failures.py index 3cb1438c..e3aa3ca5 100644 --- a/tests/tradespace/test_failures.py +++ b/tests/tradespace/test_failures.py @@ -478,13 +478,15 @@ def _metric(self, observations): def test_simulate_many(self): """Histories of a replicate differ, and are the same in every design.""" deployment = self.schedule.plan(self.layout) - histories = deployment.simulate_many(self.failures, RestorationPolicy(), 7, 10) + histories = deployment.simulate_many( + self.failures, RestorationPolicy(), 7, 10, sampling="random" + ) self.assertEqual(len(histories), 10) self.assertGreater(len({tuple(h.failures) for h in histories}), 1) again = deployment.simulate(self.failures, RestorationPolicy(), (7, 3)) self.assertEqual(again.failures, histories[3].failures) degraded = deployment.simulate_many( - self.failures, RestorationPolicy(restore=False), 7, 10 + self.failures, RestorationPolicy(restore=False), 7, 10, sampling="random" ) self.assertEqual(degraded[3].failures[0], histories[3].failures[0]) self.assertEqual( @@ -570,3 +572,121 @@ def test_evaluate_and_summarize(self): histories, self.satellites, self.observations, self._metric ) np.testing.assert_allclose(direct["share mean"], missions["share mean"]) + + +class TestVarianceReduction(unittest.TestCase): + """ + Unit tests for stratified histories and control variates. + """ + + def setUp(self): + self.schedule = DeploymentSchedule(years=5, development_years=1) + self.layout = _walker(2, 2) + self.failures = FailureModel(life=Exponential(0.3)) + + def test_lifetimes_from_uniform(self): + """Lives drawn from uniform numbers follow their distributions.""" + uniform = np.array([0.05, 0.5, 0.95]) + for life in ( + Exponential(0.2), + Weibull(0.5, 30), + Weibull(4, 7), + Piecewise([0, 1, 4], [0.3, 0.05, 0.2]), + ): + lives = np.array([life.from_uniform([u]) for u in uniform]) + np.testing.assert_allclose(1 - life.survival(lives), uniform) + parts = (Weibull(0.5, 30), Exponential(0.05), Weibull(5, 7)) + bathtub = Bathtub(*parts) + self.assertEqual(bathtub.dimensions, 3) + self.assertEqual( + bathtub.from_uniform([0.1, 0.2, 0.3]), + min(part.from_uniform([u]) for part, u in zip(parts, (0.1, 0.2, 0.3))), + ) + self.assertEqual(Exponential(0).from_uniform([0.5]), math.inf) + + def test_strata(self): + """Each draw of the histories of a replicate takes each stratum once.""" + from tatc.tradespace.mission import ( + _Sampler, + ) # pylint: disable=import-outside-toplevel + + count = 16 + draws = np.array([_Sampler(3, k, count)((0, 1, 2, 0), 2) for k in range(count)]) + for dimension in range(2): + strata = np.sort(np.floor(draws[:, dimension] * count).astype(int)) + np.testing.assert_array_equal(strata, np.arange(count)) + self.assertFalse(np.array_equal(draws[:, 0], draws[:, 1])) + + def test_stratified_histories(self): + """Stratified histories estimate means more precisely, without bias.""" + deployment = self.schedule.plan(self.layout) + estimates = {} + for sampling in ("random", "stratified"): + estimates[sampling] = np.array( + [ + np.mean( + [ + h.metrics()["availability"] + for h in deployment.simulate_many( + self.failures, + RestorationPolicy(restore=False), + seed, + 20, + sampling, + ) + ] + ) + for seed in range(40) + ] + ) + self.assertLess(estimates["stratified"].var(), 0.5 * estimates["random"].var()) + self.assertAlmostEqual( + estimates["stratified"].mean(), estimates["random"].mean(), delta=0.02 + ) + # common random numbers: the same failures of a slot under other policies + first = deployment.simulate_many( + self.failures, RestorationPolicy(restore=False), 1, 8 + ) + other = deployment.simulate_many(self.failures, RestorationPolicy(), 1, 8) + self.assertEqual(first[3].failures[0], other[3].failures[0]) + with self.assertRaises(ValueError): + deployment.simulate_many(self.failures, None, 1, 8, sampling="antithetic") + + def test_expected_metrics(self): + """Expected measures of a mission from many histories.""" + deployment = self.schedule.plan(self.layout) + expected = deployment.expected_metrics(self.failures, histories=200) + self.assertTrue(0 < expected["availability"] < 1) + self.assertEqual( + deployment.expected_metrics(FailureModel(), histories=10)["availability"], + 1.0, + ) + + def test_control_variates(self): + """Control variates correct means by the deviations of the controls.""" + rng = np.random.default_rng(0) + estimates = {"plain": [], "controlled": []} + for _ in range(200): + x = rng.normal(0.8, 0.1, 20) + y = 3 * x + rng.normal(0, 0.05, 20) + missions = pd.DataFrame( + {"availability": x, "share": y, "failures": rng.poisson(2, 20)} + ) + plain = summarize_missions(missions) + controlled = summarize_missions(missions, controls={"availability": 0.8}) + self.assertEqual(controlled["availability"], 0.8) + self.assertAlmostEqual(plain["failures"], missions.failures.mean(), delta=1) + estimates["plain"].append(plain["share"]) + estimates["controlled"].append(controlled["share"]) + plain, controlled = (np.array(v) for v in estimates.values()) + # the true mean is 3 * 0.8 = 2.4; the controls remove most of the variance + self.assertAlmostEqual(controlled.mean(), 2.4, delta=0.01) + self.assertLess(controlled.var(), 0.1 * plain.var()) + # histories without a value are left out of the regression + missions = pd.DataFrame( + {"availability": [0.7, 0.8, 0.9, 1.0], "years": [np.nan, 1.0, 2.0, 3.0]} + ) + summary = summarize_missions(missions, controls={"availability": 0.85}) + self.assertTrue(np.isfinite(summary["years"])) + with self.assertRaises(ValueError): + summarize_missions(missions, controls={"cost": 1.0}) From 0abff1291799de20292fa0f070e04bd4d17b53a8 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Wed, 11 Nov 2026 10:23:34 -0700 Subject: [PATCH 21/52] include a hash of the source of TAT-C in fingerprints of studies --- CHANGELOG.md | 2 +- docs/api_reference/tradespace.rst | 2 ++ src/tatc/tradespace/__init__.py | 3 +- src/tatc/tradespace/cache.py | 2 +- src/tatc/tradespace/fingerprint.py | 41 +++++++++++++++++++++++++--- src/tatc/tradespace/store.py | 2 +- src/tatc/tradespace/study.py | 5 ++-- tests/tradespace/test_fingerprint.py | 13 +++++++++ 8 files changed, 60 insertions(+), 10 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index e772d735..182e9d99 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -23,7 +23,7 @@ Added: - Deployment of constellations (`tradespace.DeploymentSchedule`): from the rates and durations of a study (the mission and design life, the development of each type of satellite, its production on a line at a production rate, and launches at a cadence and capacity, in number or mass, optionally in an order of planes), each design's deployment (`DeploymentSchedule.plan`, a `Deployment` of its `Production`, `Launch`es, and replacements), so that a design of more satellites and planes takes longer to deploy. Its launches divide the mission into phases of constant sets of operating satellites (`Deployment.phases`), evaluated over the study's representative period from the observations of the full constellation (`evaluate_phases`) and combined over the mission (`summarize_phases`: the time-weighted mean of each metric and the time until it first meets a requirement). - Simulated missions with failures (`Deployment.simulate`, a `MissionHistory` for each replicate, drawn from its seed with common random numbers between designs): lives of satellites whose failure rates vary over the lifecycle (`tradespace.Exponential`, `Weibull`, `Bathtub` of competing causes, and `Piecewise` rates by age, `Lifetime`), failures of launches (`FailureModel`), and a policy that degrades or restores failed satellites (`RestorationPolicy`) by spares in orbit (taking a failed satellite's place after drifting), spares on the ground (launched at the next launch slot), or satellites produced when needed (after procurement, on the production line), optionally replenishing spares and batching restorations in launches. A history gives the phases in which satellites operate (`MissionHistory.phases`), measures of the mission (`MissionHistory.metrics`: failures, restorations, spares used, time to restore, and availability), and, priced by a `CostModel`, the cost of what it produces and launches. Policies are decisions of designs with a fragment of a design space (`policy_space`: whether to restore, spares in orbit and on the ground, and other fields of the policy, without spares that would never be used), and `configure` makes a policy (or a deployment schedule, or another dataclass) from the values of a design. Many histories of a replicate's mission (`Deployment.simulate_many`) share its sample of targets: `evaluate_missions` evaluates them (with their measures and costs) with a cache that evaluates each set of operating satellites once (`PhaseCache`, keyed by the content of the satellites and shared by the histories, policies, and designs of a replicate), and `summarize_missions` gives their means, quantiles (the risk of the mission), and probabilities of meeting requirements, as one record of the replicate. The histories of a replicate are stratified by default (a Latin hypercube over the histories of each satellite's life and each launch, drawn from uniform numbers by `Lifetime.from_uniform`), which estimates the means of missions 3 to 15 times more precisely than independent histories, and means may be estimated with control variates (`summarize_missions(controls=...)`, such as the availability of the mission, whose expected value simulations alone estimate, `Deployment.expected_metrics`). - Life-cycle costs of deployments for trade studies (`tradespace.CostModel`): the development of each type of satellite, the production of its units on a learning curve (`SatelliteCost`), launches (per launch, or prices per satellite and kg, `LaunchCost`), operations (`OperationsCost`), replacements, and spares in orbit, dated by the deployment for their present value at a discount rate (`CostEstimate.present_value`, metric `cost present`) and annual costs (`CostEstimate.annual`, metric `cost peak annual`), with growth factors for cost risk (such as uncertain parameters, whose quantiles over replicates give the cost at a confidence level). TAT-C does not include cost-estimating relationships: the costs are given by the study. Fingerprints describe dataclasses (such as cost models) by their fields. - - Function `tradespace.confirm` (and class `Confirmation`), which evaluates selected designs (such as a front) with new replicates that played no part in their selection, removing the optimism of the selection (the winner's curse, `Confirmation.optimism`). `ResultStore` keys evaluations by the fingerprint of a study (`Study.fingerprint`, see `get_fingerprint`: its seed, use of common random numbers, design space, and build and evaluation functions, and the version of TAT-C), warning if it holds evaluations of other definitions, which are not reused; `SatelliteCache` keys results on disk by the fingerprint of its function. `refine` treats designs with fewer than `min_replicates` (5) as uncertain whatever their probability, adds the replicates left to `max_replicates` in a last partial step, and warns if designs remain uncertain without a tolerance. `sensitivity` gives adjusted shares (epsilon squared) by default, without the share that the levels of a variable explain by chance (`adjusted=False` for correlation ratios). + - Function `tradespace.confirm` (and class `Confirmation`), which evaluates selected designs (such as a front) with new replicates that played no part in their selection, removing the optimism of the selection (the winner's curse, `Confirmation.optimism`). `ResultStore` keys evaluations by the fingerprint of a study (`Study.fingerprint`, see `get_fingerprint`: its seed, use of common random numbers, design space, and build and evaluation functions, and the version of TAT-C), warning if it holds evaluations of other definitions, which are not reused; `SatelliteCache` keys results on disk by the fingerprint of its function. Fingerprints include a hash of the source of TAT-C (its code and resources, `get_source_hash`), so that results computed with other code of TAT-C, in development as well as in other versions, are not reused. `refine` treats designs with fewer than `min_replicates` (5) as uncertain whatever their probability, adds the replicates left to `max_replicates` in a last partial step, and warns if designs remain uncertain without a tolerance. `sensitivity` gives adjusted shares (epsilon squared) by default, without the share that the levels of a variable explain by chance (`adjusted=False` for correlation ratios). - Searches with Optuna accept categorical options that depend on earlier decisions (a parameter for each set of options), use TPE with a constant liar in batches by default (which spreads the trials of a batch), and stop after `max_designs` designs evaluated (trials that suggest designs evaluated before are told their objectives without evaluating them again). A design infeasible in some of its replicates violates its feasibility by their share (`Evaluations.infeasibility`), and the first design evaluated in a search is evaluated alone, to check that evaluations give one record each. `Study` records errors of evaluations as infeasible, without storing them, with `errors="record"`. Enumeration walks the items of unordered repetitions in one order only (the same designs, in the same order, four times faster for three sun-synchronous planes), and `DesignSpace.size` counts designs without keeping them. Pareto fronts are found by a vectorized sweep in lexicographic order that compares designs only with the efficient designs before them, and fronts with tolerances by comparing designs only with the efficient designs without tolerances (which dominate every design that any design dominates within the tolerances), in blocks of bounded memory: 20,000 designs in 0.05 s (0.11 s with tolerances) rather than 17 s, and the bootstraps of `pareto_probability` (and so `refine`) about 20 times faster. - Example `SearchTradeSpace`, which searches a hierarchical trade space of constellations for the designs that sample points sufficiently: by evaluating every design, ranking them with the uncertainty of their replicates, screening, and searching with Optuna and pymoo. - The `RunOSSEMonsoon` example declares its constellation trade as a design space, caches the looks of each satellite, evaluates its replicates in parallel, and finds its Pareto-efficient designs. diff --git a/docs/api_reference/tradespace.rst b/docs/api_reference/tradespace.rst index bc6063a6..7f432e17 100644 --- a/docs/api_reference/tradespace.rst +++ b/docs/api_reference/tradespace.rst @@ -195,6 +195,8 @@ Stores of Results .. autofunction:: tatc.tradespace.get_fingerprint +.. autofunction:: tatc.tradespace.get_source_hash + Caches ------ diff --git a/src/tatc/tradespace/__init__.py b/src/tatc/tradespace/__init__.py index f2456bbe..57c73323 100644 --- a/src/tatc/tradespace/__init__.py +++ b/src/tatc/tradespace/__init__.py @@ -75,7 +75,7 @@ optimize_optuna, optimize_pymoo, ) -from .fingerprint import get_fingerprint +from .fingerprint import get_fingerprint, get_source_hash from .pareto import hypervolume, pareto_front, pareto_probability, pareto_ranks from .refinement import Refinement, refine from .screening import Screening, screen @@ -158,6 +158,7 @@ "evaluate_phases", "get_fingerprint", "get_satellite_key", + "get_source_hash", "hours_to_time", "hypervolume", "main_effects", diff --git a/src/tatc/tradespace/cache.py b/src/tatc/tradespace/cache.py index 857f33da..d5b400c1 100644 --- a/src/tatc/tradespace/cache.py +++ b/src/tatc/tradespace/cache.py @@ -63,7 +63,7 @@ class SatelliteCache: the parallel workers of a trade study (see `Study`), each of which otherwise has its own cache in memory. Results in the directory are keyed by the satellite, the fingerprint of the function (its code, the plain - values it closes over or refers to, and the version of TAT-C, see + values it closes over or refers to, and the version and source of TAT-C, see `Study.fingerprint`), and the `namespace`, which must identify what the fingerprint cannot see: the data the function uses (such as its targets) and the code of other modules it calls. Change it whenever these change. diff --git a/src/tatc/tradespace/fingerprint.py b/src/tatc/tradespace/fingerprint.py index c30ba5d0..54dc4567 100644 --- a/src/tatc/tradespace/fingerprint.py +++ b/src/tatc/tradespace/fingerprint.py @@ -14,7 +14,10 @@ objects (such as data frames) are described by their type only: identify them by a namespace (see `ResultStore` and `SatelliteCache`). Functions of other modules (such as TAT-C's) are described by their names, as the version -of TAT-C is part of a fingerprint. +of TAT-C and a hash of its source (its code and resources, such as the +instrument catalog) are part of a fingerprint, so that results computed with +other code of TAT-C (another version, or a change in development) are not +reused. @author: Paul T. Grogan """ @@ -27,6 +30,7 @@ import json import types from datetime import date, datetime, time, timedelta +from pathlib import Path from typing import Any import numpy as np @@ -229,11 +233,36 @@ def _describe(value: Any, depth: int = 0, seen: set | None = None) -> Any: return _type(value) +_SOURCE_SUFFIXES = (".py", ".yml", ".yaml", ".json") +"""The files of TAT-C whose content is part of a fingerprint.""" + + +@functools.lru_cache(maxsize=1) +def get_source_hash() -> str: + """ + Gets a hash of the source of TAT-C: its code and resources (such as the + instrument catalog), the files of the package with the suffixes of + `_SOURCE_SUFFIXES` (by their paths in the package and their content), + computed once in a process. + + Returns: + str: the hash + """ + root = Path(__file__).resolve().parents[1] + digest = hashlib.sha1() + for path in sorted(root.rglob("*")): + if path.suffix in _SOURCE_SUFFIXES and "__pycache__" not in path.parts: + digest.update(path.relative_to(root).as_posix().encode()) + digest.update(path.read_bytes()) + return digest.hexdigest()[:16] + + def get_fingerprint(*values: Any) -> str: """ Gets a fingerprint of values (such as a design space and the functions - of a study) and of the version of TAT-C: a key that changes if their - definitions do (see the module for what it describes). + of a study) and of the version and source of TAT-C (see + `get_source_hash`): a key that changes if their definitions do (see the + module for what it describes). Args: *values (Any): The values. @@ -245,7 +274,11 @@ def get_fingerprint(*values: Any) -> str: from .. import __version__ text = json.dumps( - {"tatc": __version__, "values": [_describe(value) for value in values]}, + { + "tatc": __version__, + "source": get_source_hash(), + "values": [_describe(value) for value in values], + }, sort_keys=True, default=str, ) diff --git a/src/tatc/tradespace/store.py b/src/tatc/tradespace/store.py index ade31f8c..f8f226f3 100644 --- a/src/tatc/tradespace/store.py +++ b/src/tatc/tradespace/store.py @@ -25,7 +25,7 @@ class ResultStore: (see `Study.fingerprint`), which changes with its seed, its use of common random numbers, the definitions of its design space and its build and evaluation functions (their code, and the plain values they refer - to), and the version of TAT-C, so that records computed with other + to), and the version and source of TAT-C, so that records computed with other definitions are not reused. The `namespace` identifies what a fingerprint cannot see: the data the functions use (such as the targets of the analysis) and the code of other modules they call. Change it diff --git a/src/tatc/tradespace/study.py b/src/tatc/tradespace/study.py index 412041fd..6d26c5c6 100644 --- a/src/tatc/tradespace/study.py +++ b/src/tatc/tradespace/study.py @@ -198,7 +198,8 @@ def fingerprint(self) -> str: fixed values and the distributions of uncertain parameters), its build and evaluation functions (their code, the values they close over, and the plain values and functions of their module they refer - to), and the version of TAT-C. It keys the records of a store (see + to), and the version and source of TAT-C (see `get_source_hash`). It + keys the records of a store (see `ResultStore`); data that it cannot describe (such as data frames) must be identified by the store's namespace.""" return get_fingerprint( @@ -278,7 +279,7 @@ def run( warnings.warn( f"the store has {sum(others.values())} evaluations of namespace " + f"{self.store.namespace!r} by studies of other definitions " - + "(seed, design space, functions, or version of TAT-C), " + + "(seed, design space, functions, or version or source of TAT-C), " + "which are not reused (see Study.fingerprint)", stacklevel=2, ) diff --git a/tests/tradespace/test_fingerprint.py b/tests/tradespace/test_fingerprint.py index 79921bac..d31f01d4 100644 --- a/tests/tradespace/test_fingerprint.py +++ b/tests/tradespace/test_fingerprint.py @@ -8,6 +8,7 @@ import subprocess import sys import unittest +from unittest import mock from datetime import datetime, timedelta, timezone from functools import partial @@ -24,6 +25,7 @@ Study, Uncertain, get_fingerprint, + get_source_hash, ) THRESHOLD = 4 @@ -159,6 +161,17 @@ def study(**kwargs): # but not with the settings of its execution self.assertEqual(study().fingerprint, study(n_jobs=2).fingerprint) + def test_source(self): + """The source of TAT-C (its code and resources) changes the fingerprint.""" + self.assertEqual(len(get_source_hash()), 16) + self.assertIs(get_source_hash(), get_source_hash()) # computed once + before = get_fingerprint(_space()) + with mock.patch( + "tatc.tradespace.fingerprint.get_source_hash", return_value="changed" + ): + self.assertNotEqual(before, get_fingerprint(_space())) + self.assertEqual(before, get_fingerprint(_space())) + def test_stable_between_sessions(self): """Fingerprints do not change between sessions (with other hash seeds).""" prints = set() From c2b017dd5688f29bb71d138e88092ec977a8b690 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Wed, 11 Nov 2026 10:57:56 -0700 Subject: [PATCH 22/52] add rotated-lattice points and allocation of replicates and histories --- CHANGELOG.md | 3 +- docs/api_reference/generation/index.rst | 5 + docs/api_reference/tradespace.rst | 2 + src/tatc/generation/__init__.py | 2 + src/tatc/generation/points.py | 103 +++++++ src/tatc/tradespace/__init__.py | 4 +- src/tatc/tradespace/deployment.py | 4 +- src/tatc/tradespace/histories.py | 368 ++++++++++++++++++++++++ src/tatc/tradespace/mission.py | 232 --------------- tests/generation/test_points.py | 66 +++++ tests/tradespace/test_failures.py | 66 ++++- 11 files changed, 617 insertions(+), 238 deletions(-) create mode 100644 src/tatc/tradespace/histories.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 182e9d99..fec107a0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,6 +10,7 @@ Added: - Field `type` of a catalog configuration's `attitude` (`attitude`, `glint`, or `target`), which builds an `Attitude`, `GlintAttitude`, or `TargetAttitude`, as for OCO-2's glint mode. - Field `blind_intervals` of `Attitude`: intervals of argument of latitude in which a space system's instruments do not observe, for example while the body or a mechanism moves. Observations in them are not valid, so point observations, ground tracks (`valid_obs`, and the swaths of `compute_ground_track`), orbit tracks, and ground pixels omit them, and the periods and swaths of region observations end at them. Method `is_observing` of attitudes, schedules, and instruments. - Field `type` (`instrument`, `pointed`, or `conical`) of `Instrument`, `PointedInstrument`, and `ConicalInstrument`, which identifies the instrument class in serialized data. Data without a `type` loads as the class its fields imply. + - Function `generation.generate_points_rotated_lattice`, the points of a Fibonacci lattice in a random orientation: a stratified sample of the sphere (or of a mask), each point uniform by area, whose statistics vary 2 to 4 times less between replicates of trade studies than those of random points. - Analysis methods of the statistical sufficiency of observations (module `analysis.sufficiency`): `estimate_sampling_error`, the error of estimating the mean of a field over a period from each target's samples, for a field with a standard deviation and an exponential correlation in time (exact, see `sampling_error_variance`), with the effective number of independent samples; `sample_field`, which samples a field (an xarray `DataArray`, such as a nature run) at the time and place of each observation, and `compare_sampled_means`, which measures the sampling error against it; `compute_revisit_statistics`, the quantiles of revisits and the longest gap of each target (including the edges of the period); and `compute_local_time_coverage`, the distribution of samples in local time of day. The decorrelation time of `estimate_sampling_error` may differ between targets. The validation notebook `ValidateSamplingErrorIMERG` compares its predictions with the errors of monthly means of IMERG precipitation sampled by four constellation designs. `estimate_sampling_error` and `compute_revisit_statistics` compute the statistics of every target at once (the sum of the correlations between pairs of samples by a recursion over their times, and the gaps and their quantiles from the samples in order), with the same results 3 to 12 times faster. - Module `tradespace` (prototype) for trade studies. A `DesignSpace` declares design variables (`Real`, `Integer`, `Categorical`), fixed and `Derived` values, and `Uncertain` parameters (drawn per replicate, not searched), grouped hierarchically with `Choice` (one of several branches) and `Repeat` (a variable number of items, such as orbit planes, optionally unordered). Bounds, derived values, and constraints are callables of the values decided before them. `DesignSpace.enumerate` gives every feasible design (a full factorial design, including variables that exist only in some designs), and `sample` a Latin hypercube or random sample. A `Design` has a `key` from its decisions and `flat` values by path, and `realize` draws a replicate's uncertain parameters, with common random numbers between designs by default. `Study` builds and evaluates designs in replicates into a data frame, recording designs that fail validation as infeasible, in worker processes with `n_jobs` (or on an `executor`); `summarize` gives the mean, standard deviation, and standard error of metrics over replicates. - Class `tradespace.SatelliteCache`, which caches an analysis of single satellites by their content (orbit, instruments, and attitude, not their name, see `get_satellite_key`), in memory or on disk, so that designs that share satellites compute their results once. @@ -21,7 +22,7 @@ Added: - Function `tradespace.screen` (and class `Screening`), which screens designs with studies of increasing fidelity, keeping whole fronts of the best designs of each stage for the next. - Searches of design spaces with optional optimizers: `tradespace.optimize_optuna` suggests designs with Optuna trials (`DesignSpace.suggest`, define-by-run over the hierarchical space), and `optimize_pymoo` and `make_pymoo_problem` search the unit hypercube that encodes a design space (`DesignSpace.unit_paths`, `encode`, and `decode`) with pymoo. Each design is evaluated once, and the designs proposed together are evaluated together, in parallel if the study is. Constraints of a design space may return the amount of their violation (`Infeasible.violation`), which Optuna's trials record (`set_constraint`) for its constraint-aware samplers, and which is the constraint value of pymoo problems. Optional dependencies `tradespace` (joblib, Optuna, and pymoo). - Deployment of constellations (`tradespace.DeploymentSchedule`): from the rates and durations of a study (the mission and design life, the development of each type of satellite, its production on a line at a production rate, and launches at a cadence and capacity, in number or mass, optionally in an order of planes), each design's deployment (`DeploymentSchedule.plan`, a `Deployment` of its `Production`, `Launch`es, and replacements), so that a design of more satellites and planes takes longer to deploy. Its launches divide the mission into phases of constant sets of operating satellites (`Deployment.phases`), evaluated over the study's representative period from the observations of the full constellation (`evaluate_phases`) and combined over the mission (`summarize_phases`: the time-weighted mean of each metric and the time until it first meets a requirement). - - Simulated missions with failures (`Deployment.simulate`, a `MissionHistory` for each replicate, drawn from its seed with common random numbers between designs): lives of satellites whose failure rates vary over the lifecycle (`tradespace.Exponential`, `Weibull`, `Bathtub` of competing causes, and `Piecewise` rates by age, `Lifetime`), failures of launches (`FailureModel`), and a policy that degrades or restores failed satellites (`RestorationPolicy`) by spares in orbit (taking a failed satellite's place after drifting), spares on the ground (launched at the next launch slot), or satellites produced when needed (after procurement, on the production line), optionally replenishing spares and batching restorations in launches. A history gives the phases in which satellites operate (`MissionHistory.phases`), measures of the mission (`MissionHistory.metrics`: failures, restorations, spares used, time to restore, and availability), and, priced by a `CostModel`, the cost of what it produces and launches. Policies are decisions of designs with a fragment of a design space (`policy_space`: whether to restore, spares in orbit and on the ground, and other fields of the policy, without spares that would never be used), and `configure` makes a policy (or a deployment schedule, or another dataclass) from the values of a design. Many histories of a replicate's mission (`Deployment.simulate_many`) share its sample of targets: `evaluate_missions` evaluates them (with their measures and costs) with a cache that evaluates each set of operating satellites once (`PhaseCache`, keyed by the content of the satellites and shared by the histories, policies, and designs of a replicate), and `summarize_missions` gives their means, quantiles (the risk of the mission), and probabilities of meeting requirements, as one record of the replicate. The histories of a replicate are stratified by default (a Latin hypercube over the histories of each satellite's life and each launch, drawn from uniform numbers by `Lifetime.from_uniform`), which estimates the means of missions 3 to 15 times more precisely than independent histories, and means may be estimated with control variates (`summarize_missions(controls=...)`, such as the availability of the mission, whose expected value simulations alone estimate, `Deployment.expected_metrics`). + - Simulated missions with failures (`Deployment.simulate`, a `MissionHistory` for each replicate, drawn from its seed with common random numbers between designs): lives of satellites whose failure rates vary over the lifecycle (`tradespace.Exponential`, `Weibull`, `Bathtub` of competing causes, and `Piecewise` rates by age, `Lifetime`), failures of launches (`FailureModel`), and a policy that degrades or restores failed satellites (`RestorationPolicy`) by spares in orbit (taking a failed satellite's place after drifting), spares on the ground (launched at the next launch slot), or satellites produced when needed (after procurement, on the production line), optionally replenishing spares and batching restorations in launches. A history gives the phases in which satellites operate (`MissionHistory.phases`), measures of the mission (`MissionHistory.metrics`: failures, restorations, spares used, time to restore, and availability), and, priced by a `CostModel`, the cost of what it produces and launches. Policies are decisions of designs with a fragment of a design space (`policy_space`: whether to restore, spares in orbit and on the ground, and other fields of the policy, without spares that would never be used), and `configure` makes a policy (or a deployment schedule, or another dataclass) from the values of a design. Many histories of a replicate's mission (`Deployment.simulate_many`) share its sample of targets: `evaluate_missions` evaluates them (with their measures and costs) with a cache that evaluates each set of operating satellites once (`PhaseCache`, keyed by the content of the satellites and shared by the histories, policies, and designs of a replicate), and `summarize_missions` gives their means, quantiles (the risk of the mission), and probabilities of meeting requirements, as one record of the replicate. The histories of a replicate are stratified by default (a Latin hypercube over the histories of each satellite's life and each launch, drawn from uniform numbers by `Lifetime.from_uniform`), which estimates the means of missions 3 to 15 times more precisely than independent histories, and means may be estimated with control variates (`summarize_missions(controls=...)`, such as the availability of the mission, whose expected value simulations alone estimate, `Deployment.expected_metrics`). `allocate_histories` recommends the histories of each replicate (and the replicates, for a standard error) from a pilot with independent histories, by the variances between replicates and between histories and their costs (`summarize_missions(spread=True)` gives the standard deviations of the histories). - Life-cycle costs of deployments for trade studies (`tradespace.CostModel`): the development of each type of satellite, the production of its units on a learning curve (`SatelliteCost`), launches (per launch, or prices per satellite and kg, `LaunchCost`), operations (`OperationsCost`), replacements, and spares in orbit, dated by the deployment for their present value at a discount rate (`CostEstimate.present_value`, metric `cost present`) and annual costs (`CostEstimate.annual`, metric `cost peak annual`), with growth factors for cost risk (such as uncertain parameters, whose quantiles over replicates give the cost at a confidence level). TAT-C does not include cost-estimating relationships: the costs are given by the study. Fingerprints describe dataclasses (such as cost models) by their fields. - Function `tradespace.confirm` (and class `Confirmation`), which evaluates selected designs (such as a front) with new replicates that played no part in their selection, removing the optimism of the selection (the winner's curse, `Confirmation.optimism`). `ResultStore` keys evaluations by the fingerprint of a study (`Study.fingerprint`, see `get_fingerprint`: its seed, use of common random numbers, design space, and build and evaluation functions, and the version of TAT-C), warning if it holds evaluations of other definitions, which are not reused; `SatelliteCache` keys results on disk by the fingerprint of its function. Fingerprints include a hash of the source of TAT-C (its code and resources, `get_source_hash`), so that results computed with other code of TAT-C, in development as well as in other versions, are not reused. `refine` treats designs with fewer than `min_replicates` (5) as uncertain whatever their probability, adds the replicates left to `max_replicates` in a last partial step, and warns if designs remain uncertain without a tolerance. `sensitivity` gives adjusted shares (epsilon squared) by default, without the share that the levels of a variable explain by chance (`adjusted=False` for correlation ratios). - Searches with Optuna accept categorical options that depend on earlier decisions (a parameter for each set of options), use TPE with a constant liar in batches by default (which spreads the trials of a batch), and stop after `max_designs` designs evaluated (trials that suggest designs evaluated before are told their objectives without evaluating them again). A design infeasible in some of its replicates violates its feasibility by their share (`Evaluations.infeasibility`), and the first design evaluated in a search is evaluated alone, to check that evaluations give one record each. `Study` records errors of evaluations as infeasible, without storing them, with `errors="record"`. Enumeration walks the items of unordered repetitions in one order only (the same designs, in the same order, four times faster for three sun-synchronous planes), and `DesignSpace.size` counts designs without keeping them. Pareto fronts are found by a vectorized sweep in lexicographic order that compares designs only with the efficient designs before them, and fronts with tolerances by comparing designs only with the efficient designs without tolerances (which dominate every design that any design dominates within the tolerances), in blocks of bounded memory: 20,000 designs in 0.05 s (0.11 s with tolerances) rather than 17 s, and the bootstraps of `pareto_probability` (and so `refine`) about 20 times faster. diff --git a/docs/api_reference/generation/index.rst b/docs/api_reference/generation/index.rst index a376c326..426605cd 100644 --- a/docs/api_reference/generation/index.rst +++ b/docs/api_reference/generation/index.rst @@ -31,6 +31,11 @@ Weights for random points can be read from a GeoTIFF raster with :func:`tatc.preprocess.read_raster_weights` (requires the optional `preprocess` dependencies, ``pip install tatc[preprocess]``). +Rotated Lattice +--------------- + +.. autofunction:: tatc.generation.generate_points_rotated_lattice + Cells ===== diff --git a/docs/api_reference/tradespace.rst b/docs/api_reference/tradespace.rst index 7f432e17..5ab80510 100644 --- a/docs/api_reference/tradespace.rst +++ b/docs/api_reference/tradespace.rst @@ -132,6 +132,8 @@ Failures and Missions .. autofunction:: tatc.tradespace.summarize_missions +.. autofunction:: tatc.tradespace.allocate_histories + Costs ----- diff --git a/src/tatc/generation/__init__.py b/src/tatc/generation/__init__.py index 8d634a75..f493b2c9 100644 --- a/src/tatc/generation/__init__.py +++ b/src/tatc/generation/__init__.py @@ -9,6 +9,7 @@ from .points import ( generate_points_fibonacci_lattice, generate_points_random, + generate_points_rotated_lattice, generate_points_uniform_angular_distance, generate_points_uniform_spacing, ) @@ -18,6 +19,7 @@ "generate_cells_uniform_spacing", "generate_points_fibonacci_lattice", "generate_points_random", + "generate_points_rotated_lattice", "generate_points_uniform_angular_distance", "generate_points_uniform_spacing", ] diff --git a/src/tatc/generation/points.py b/src/tatc/generation/points.py index 57cb77a8..8b7e101c 100644 --- a/src/tatc/generation/points.py +++ b/src/tatc/generation/points.py @@ -100,6 +100,109 @@ def generate_points_fibonacci_lattice( return gdf +def _random_rotation(rng: np.random.Generator) -> np.ndarray: + """ + Draws a rotation matrix uniformly over the rotations of a sphere (from a + uniform random unit quaternion, after Shoemake, 1992). + """ + u1, u2, u3 = rng.random(3) + x, y = np.sqrt(1 - u1) * np.sin(2 * np.pi * u2), np.sqrt(1 - u1) * np.cos( + 2 * np.pi * u2 + ) + z, w = np.sqrt(u1) * np.sin(2 * np.pi * u3), np.sqrt(u1) * np.cos(2 * np.pi * u3) + return np.array( + [ + [1 - 2 * (y * y + z * z), 2 * (x * y - z * w), 2 * (x * z + y * w)], + [2 * (x * y + z * w), 1 - 2 * (x * x + z * z), 2 * (y * z - x * w)], + [2 * (x * z - y * w), 2 * (y * z + x * w), 1 - 2 * (x * x + y * y)], + ] + ) + + +def generate_points_rotated_lattice( + count: int, + elevation: float = 0, + mask: Polygon | MultiPolygon | None = None, + seed: int | np.random.Generator | None = None, +) -> gpd.GeoDataFrame: + """ + Generates geodetic points of a Fibonacci lattice (see + `generate_points_fibonacci_lattice`) in a random orientation: a + stratified sample of the sphere (randomized quasi-Monte Carlo). Each + point is distributed uniformly by surface area, as are those of + `generate_points_random`, but the points cover the sphere evenly rather + than clustering by chance, so that statistics of samples of points (such + as the share of points sampled sufficiently, over the replicates of a + trade study) vary several times less between samples of the same size. + + With a mask, the lattice covers the sphere with about `count` points + inside the mask (from the mask's share of the sphere's area), and the + number of points inside varies slightly with the orientation. + + Args: + count (int): The number of points (about, with a mask). + elevation (float): The elevation (meters) above the datum in the WGS 84 + coordinate system. + mask (shapely.geometry.Polygon | shapely.geometry.MultiPolygon | None): An + optional mask to constrain points using WGS84 (EPSG:4326) + geodetic coordinates in a Polygon or MultiPolygon. + seed (int | numpy.random.Generator | None): An optional seed (or + generator) of the orientation. + + Returns: + geopandas.GeoDataFrame: the data frame of generated points, each + identified by the hash of its geometry (`point_id`, see + `tatc.utils.geometry.hash_geometry`) + """ + if count < 0: + raise ValueError(f"Count must not be negative, got {count}.") + rng = np.random.default_rng(seed) + samples = count + if mask is not None: + if not isinstance(mask, (Polygon, MultiPolygon)) or not mask.is_valid: + raise ValueError("Mask is not a valid Polygon or MultiPolygon.") + # the mask's share of the sphere, with its edges straight in + # longitude and latitude (as clipped): its area in a cylindrical + # equal-area projection (longitude and the sine of latitude, in + # radians) of the mask with edges divided into short segments + dense = shapely.segmentize(mask, 0.5) + projected = shapely.transform( + dense, + lambda xy: np.column_stack( + [np.radians(xy[:, 0]), np.sin(np.radians(xy[:, 1]))] + ), + ) + share = projected.area / (4 * np.pi) + if share <= 0: + raise ValueError("Mask has no area.") + samples = int(round(count / min(share, 1.0))) + index = np.arange(samples) + # the lattice of generate_points_fibonacci_lattice, as unit vectors + sin_latitude = 2 * (index + 1) / (samples + 2) - 1 + longitude = 2 * np.pi * index / ((1 + np.sqrt(5)) / 2) + cos_latitude = np.sqrt(1 - sin_latitude**2) + vectors = np.column_stack( + [ + cos_latitude * np.cos(longitude), + cos_latitude * np.sin(longitude), + sin_latitude, + ] + ) + vectors = vectors @ _random_rotation(rng).T + latitudes = np.degrees(np.arcsin(np.clip(vectors[:, 2], -1, 1))) + longitudes = np.degrees(np.arctan2(vectors[:, 1], vectors[:, 0])) + gdf = gpd.GeoDataFrame( + geometry=shapely.points( + longitudes, latitudes, np.full_like(longitudes, elevation) + ), + crs="EPSG:4326", + ) + if mask is not None: + gdf = clip_to_mask(gdf, mask) + gdf.insert(0, "point_id", _hash_geometries(gdf.geometry)) + return gdf + + def generate_points_uniform_spacing( distance: float, elevation: float = 0, diff --git a/src/tatc/tradespace/__init__.py b/src/tatc/tradespace/__init__.py index 57c73323..452bb0c0 100644 --- a/src/tatc/tradespace/__init__.py +++ b/src/tatc/tradespace/__init__.py @@ -39,13 +39,12 @@ Launch, Production, ) +from .histories import allocate_histories, evaluate_missions, summarize_missions from .mission import ( MissionHistory, Phase, PhaseCache, - evaluate_missions, evaluate_phases, - summarize_missions, summarize_phases, ) from .failures import ( @@ -149,6 +148,7 @@ "Variable", "Weibull", "aggregate", + "allocate_histories", "build_constellation", "configure", "confirm", diff --git a/src/tatc/tradespace/deployment.py b/src/tatc/tradespace/deployment.py index fe0f713f..4ce950b3 100644 --- a/src/tatc/tradespace/deployment.py +++ b/src/tatc/tradespace/deployment.py @@ -258,7 +258,7 @@ def simulate_many( list[MissionHistory]: the histories """ # pylint: disable=import-outside-toplevel - from .mission import _simulate_many + from .histories import _simulate_many if histories < 1: raise ValueError("histories must be at least 1") @@ -291,7 +291,7 @@ def expected_metrics( dict[str, float]: the mean of each measure """ # pylint: disable=import-outside-toplevel - from .mission import expected_metrics + from .histories import expected_metrics return expected_metrics(self, failures, policy, histories, seed, sampling) diff --git a/src/tatc/tradespace/histories.py b/src/tatc/tradespace/histories.py new file mode 100644 index 00000000..ff29996c --- /dev/null +++ b/src/tatc/tradespace/histories.py @@ -0,0 +1,368 @@ +""" +Many histories of missions in a replicate (see `Deployment.simulate_many`): +their simulation (independent or stratified), evaluation with a cache of +the metrics of their phases (see `PhaseCache`), and summaries as the +records of evaluations, with control variates and the allocation of +evaluations between replicates and histories. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +import math +import warnings +from collections.abc import Callable, Mapping, Sequence +from typing import Any + +import numpy as np +import pandas as pd + +from ..schemas import Satellite +from .cache import get_satellite_key +from .criteria import _OPERATORS, Requirement +from .deployment import Deployment +from .failures import FailureModel, RestorationPolicy +from .mission import ( + MissionHistory, + PhaseCache, + _Simulation, + evaluate_phases, + summarize_phases, +) + + +def evaluate_missions( + histories: Sequence[MissionHistory], + satellites: Sequence[Satellite], + observations: pd.DataFrame, + metric: Callable[[pd.DataFrame], Mapping[str, float]] | PhaseCache, + context: Any = None, + cost_model: Any = None, + growth: Any = 1.0, +) -> pd.DataFrame: + """ + Evaluates histories of a mission (such as those of a replicate, see + `Deployment.simulate_many`): for each, the mean of each metric over the + phases of the mission (` mean`, see `summarize_phases`), its + measures (see `MissionHistory.metrics`), and its cost (see + `CostEstimate.metrics`, with a cost model). The histories share the + observations of the replicate, so that a `PhaseCache` (as the metric) + evaluates each set of operating satellites once. + + Args: + histories (Sequence[MissionHistory]): The histories. + satellites (Sequence[Satellite]): The satellites (see + `MissionHistory.phases`). + observations (pandas.DataFrame): The observations of every + satellite, with their names (`satellite`). + metric (Callable | PhaseCache): A function of the observations of a + phase that gives its metrics, or a cache of one. + context (Any): A hashable identifier of the observations, for a + cache. + cost_model (CostModel | None): A model of the cost of each history. + growth (float | Mapping[str, float]): The growth of the cost. + + Returns: + pandas.DataFrame: a row per history + """ + rows = [] + keys = {s.name: get_satellite_key(s) for s in satellites} + for history in histories: + phases = history.phases(satellites) + if isinstance(metric, PhaseCache): + capability = metric.evaluate(phases, observations, keys, context) + else: + capability = evaluate_phases(phases, observations, metric) + row = {**summarize_phases(capability), **history.metrics()} + if cost_model is not None: + row.update(cost_model.estimate(history, growth).metrics()) + rows.append(row) + return pd.DataFrame(rows) + + +def summarize_missions( + missions: pd.DataFrame, + quantiles: Mapping[str, float | Sequence[float]] | None = None, + requirements: Sequence[Requirement] = (), + controls: Mapping[str, float] | None = None, + spread: bool = False, +) -> dict[str, float]: + """ + Summarizes histories of a mission (see `evaluate_missions`) as the + metrics of an evaluation: the mean of each column over the histories + (by the same name), quantiles of columns over the histories (` + p`, such as `"accurate mean p10"` for the 0.1 quantile, the + risk of the mission), and the share of the histories that meet each + requirement on a column (`P( )`). + + With `controls`, the means are estimated with control variates: columns + whose expected values are known (such as the `availability` of a + mission, which simulations alone estimate precisely and cheaply, see + `Deployment.expected_metrics`), and which vary with the other columns + from history to history. The mean of each other column is corrected by + the deviation of the controls' means from their expected values, times + the regression of the column on the controls over the histories, + which removes the share of its variance that the controls explain (a + share of `rho ** 2` for a correlation `rho`): fewer histories give the + same precision. The quantiles and probabilities are not corrected. + + The quantiles and probabilities are over the histories of a replicate, + whose statistics over the replicates (such as their mean, see + `aggregate`) combine the risk of the mission with the uncertainty of the + replicates' other parameters (such as their targets). + + Args: + missions (pandas.DataFrame): A row per history. + quantiles (Mapping | None): The quantiles of columns, by column. + requirements (Sequence[Requirement]): Requirements on columns. + controls (Mapping[str, float] | None): The expected values of + columns that are control variates, if any. + spread (bool): `True` to add the standard deviation of each column + over the histories (` sd`), as for `allocate_histories`. + + Returns: + dict[str, float]: the summary + """ + numeric = missions.select_dtypes("number") + summary = {column: float(numeric[column].mean()) for column in numeric.columns} + if controls: + summary.update(_controlled_means(numeric, controls)) + if spread: + summary.update( + {f"{column} sd": float(numeric[column].std()) for column in numeric.columns} + ) + for column, values in (quantiles or {}).items(): + for q in [values] if isinstance(values, (int, float)) else values: + summary[f"{column} p{100 * q:g}"] = float(numeric[column].quantile(q)) + for requirement in requirements: + met = _OPERATORS[requirement.operator]( + missions[requirement.name].to_numpy(dtype=float), requirement.value + ) + statement = f"{requirement.name} {requirement.operator} {requirement.value:g}" + summary[f"P({statement})"] = float(np.mean(met)) + return summary + + +def _controlled_means(numeric: pd.DataFrame, controls: Mapping[str, float]) -> dict: + """ + Estimates the means of columns with control variates (see + `summarize_missions`): each column's mean less the regression of the + column on the controls applied to the deviations of the controls' means + from their expected values, over the histories in which the column and + the controls are known. + """ + names = list(controls) + missing = set(names) - set(numeric.columns) + if missing: + raise ValueError(f"no columns of controls {sorted(missing)}") + expected = np.array([float(controls[name]) for name in names]) + means = {name: float(value) for name, value in zip(names, expected)} + for column in numeric.columns: + if column in controls: + continue + data = numeric[[column, *names]].to_numpy(dtype=float) + data = data[np.all(np.isfinite(data), axis=1)] + if len(data) <= len(names) + 1: + continue + y, x = data[:, 0], data[:, 1:] + centered = x - x.mean(axis=0) + if not np.any(centered): + continue + beta = np.linalg.lstsq(centered, y - y.mean(), rcond=None)[0] + means[column] = float(y.mean() - (x.mean(axis=0) - expected) @ beta) + return means + + +class _Sampler: + """ + The uniform numbers of the failures of a history of a replicate, + stratified over the histories of the replicate (see + `Deployment.simulate_many`): a Latin hypercube in which, for each draw + (each life and launch), history `k` of `K` takes a uniform number in its + stratum of a permutation of the `K` strata of [0, 1). Each draw is keyed + by its key, so that the same draw of the same history of a replicate + takes the same number in every design (common random numbers). + """ + + def __init__(self, seed: int, index: int, histories: int): + self.seed, self.index, self.histories = seed, index, histories + + def __call__(self, key: tuple, dimensions: int) -> np.ndarray: + strata = np.random.default_rng([self.seed, 1, self.histories, *key]) + orders = [strata.permutation(self.histories) for _ in range(dimensions)] + jitter = np.random.default_rng([self.seed, 2, self.index, *key]) + offsets = jitter.random(dimensions) + return np.array( + [ + (order[self.index] + offset) / self.histories + for order, offset in zip(orders, offsets) + ] + ) + + +SAMPLINGS = ("random", "stratified") +"""The samplings of the failures of histories (see `Deployment.simulate_many`).""" + + +def _simulate_many( + deployment: Deployment, + failures: FailureModel, + policy: RestorationPolicy | None, + seed: int, + histories: int, + sampling: str, +) -> list[MissionHistory]: + """ + Simulates the histories of a replicate (see `Deployment.simulate_many`). + """ + if sampling not in SAMPLINGS: + raise ValueError(f"sampling must be one of {SAMPLINGS}, not {sampling!r}") + if sampling == "random": + return [ + deployment.simulate(failures, policy, (seed, k)) for k in range(histories) + ] + return [ + _Simulation( + deployment, + failures, + policy or RestorationPolicy(), + (seed, k), + _Sampler(seed, k, histories), + ).run() + for k in range(histories) + ] + + +def expected_metrics( + deployment: Deployment, + failures: FailureModel, + policy: RestorationPolicy | None = None, + histories: int = 1000, + seed: int = 0, + sampling: str = "stratified", +) -> dict[str, float]: + """ + Estimates the expected measures of a mission (see + `MissionHistory.metrics`, such as its `availability`) from many + simulated histories, without evaluating their phases: precise and + cheap, as the expected values of control variates (see + `summarize_missions`). + + Args: + deployment (Deployment): The deployment. + failures (FailureModel): The failures. + policy (RestorationPolicy | None): The policy for failed satellites. + histories (int): The number of histories. + seed (int): The seed of the histories. + sampling (str): The sampling of their failures. + + Returns: + dict[str, float]: the mean of each measure + """ + rows = pd.DataFrame( + [ + history.metrics() + for history in _simulate_many( + deployment, failures, policy, seed, histories, sampling + ) + ] + ) + return {column: float(rows[column].mean()) for column in rows.columns} + + +def allocate_histories( + records: pd.DataFrame, + metric: str, + histories: int, + replicate_seconds: float, + history_seconds: float, + standard_error: float | None = None, + max_histories: int = 10_000, +) -> dict[str, float]: + """ + Recommends how to divide the evaluations of a design between replicates + (each a sample of its uncertain parameters other than failures, such as + its targets, whose observations are expensive to compute) and histories + of the failures of its mission in each replicate (cheap, with a + `PhaseCache`), from a pilot study: the records of its replicates (see + `summarize_missions`, with `spread`), each the mean (``) and + standard deviation (` sd`) of a metric over `histories` + histories. + + The variance of a replicate's mean is `between + within / K` for `K` + histories, with `within` the variance between the histories of a + replicate and `between` the variance between replicates of their + expected values, at a cost of `replicate_seconds + K * history_seconds`. + The variance of the mean of the replicates per second of evaluation is + least for `K = sqrt(replicate_seconds * within / (history_seconds * + between))`: more histories where failures vary more than replicates, or + where a history costs less than a replicate. With a `standard_error` of + the mean, the replicates that achieve it at that number of histories. + + The variances are estimated from independent histories, so the pilot's + must be (`sampling="random"`, see `Deployment.simulate_many`): the means + of stratified histories vary less than those of independent ones, which + would hide the variance between replicates (a warning is given if the + means vary less than independent histories can). Studies with stratified + histories then need fewer histories than recommended. With a standard + error that the least replicates (two) achieve, the fewest histories that + achieve it are recommended. + + Args: + records (pandas.DataFrame): The records of the pilot replicates of a + design. + metric (str): The metric. + histories (int): The histories of each pilot replicate. + replicate_seconds (float): The cost of a replicate without its + histories (such as computing the observations of its targets). + history_seconds (float): The cost of a history. + standard_error (float | None): A standard error of the mean of the + metric over the replicates to achieve, if any. + max_histories (int): The most histories to recommend. + + Returns: + dict[str, float]: the recommended `histories` (and `replicates`, with + a standard error), the standard deviations `between` and + `within`, and the cost of a replicate (`replicate cost`, seconds) + and of the evaluations (`cost`, seconds, with a standard error) + """ + if len(records) < 2: + raise ValueError("a pilot needs at least two replicates") + if histories < 2 or replicate_seconds <= 0 or history_seconds <= 0: + raise ValueError("a pilot needs two or more histories and positive costs") + means = records[metric].to_numpy(dtype=float) + within = float(np.mean(records[f"{metric} sd"].to_numpy(dtype=float) ** 2)) + observed = float(np.var(means, ddof=1)) + if observed < 0.5 * within / histories: + warnings.warn( + "the replicates' means vary less than independent histories can: " + + "pilots need independent histories (sampling='random')", + stacklevel=2, + ) + between = max(observed - within / histories, 0.0) + if between == 0: + count = max_histories if within > 0 else 1 + else: + count = math.sqrt(replicate_seconds * within / (history_seconds * between)) + count = int(min(max(round(count), 1), max_histories)) + cost = replicate_seconds + count * history_seconds + result = { + "histories": float(count), + "between": math.sqrt(between), + "within": math.sqrt(within), + "replicate cost": cost, + } + if standard_error is not None: + if standard_error <= 0: + raise ValueError("standard_error must be positive") + variance = between + within / count + replicates = max(math.ceil(variance / standard_error**2), 2) + if replicates == 2 and 2 * standard_error**2 > between: + # the least replicates suffice: the fewest histories that do + needed = math.ceil(within / (2 * standard_error**2 - between)) + count = int(min(max(needed, 1), count)) + cost = replicate_seconds + count * history_seconds + result.update(histories=float(count), **{"replicate cost": cost}) + result.update(replicates=float(replicates), cost=replicates * cost) + return result diff --git a/src/tatc/tradespace/mission.py b/src/tatc/tradespace/mission.py index 22562d98..931199e3 100644 --- a/src/tatc/tradespace/mission.py +++ b/src/tatc/tradespace/mission.py @@ -724,235 +724,3 @@ def __repr__(self) -> str: f"PhaseCache({len(self._memory)} results, " + f"{self.hits} hits, {self.misses} misses)" ) - - -def evaluate_missions( - histories: Sequence[MissionHistory], - satellites: Sequence[Satellite], - observations: pd.DataFrame, - metric: Callable[[pd.DataFrame], Mapping[str, float]] | PhaseCache, - context: Any = None, - cost_model: Any = None, - growth: Any = 1.0, -) -> pd.DataFrame: - """ - Evaluates histories of a mission (such as those of a replicate, see - `Deployment.simulate_many`): for each, the mean of each metric over the - phases of the mission (` mean`, see `summarize_phases`), its - measures (see `MissionHistory.metrics`), and its cost (see - `CostEstimate.metrics`, with a cost model). The histories share the - observations of the replicate, so that a `PhaseCache` (as the metric) - evaluates each set of operating satellites once. - - Args: - histories (Sequence[MissionHistory]): The histories. - satellites (Sequence[Satellite]): The satellites (see - `MissionHistory.phases`). - observations (pandas.DataFrame): The observations of every - satellite, with their names (`satellite`). - metric (Callable | PhaseCache): A function of the observations of a - phase that gives its metrics, or a cache of one. - context (Any): A hashable identifier of the observations, for a - cache. - cost_model (CostModel | None): A model of the cost of each history. - growth (float | Mapping[str, float]): The growth of the cost. - - Returns: - pandas.DataFrame: a row per history - """ - rows = [] - keys = {s.name: get_satellite_key(s) for s in satellites} - for history in histories: - phases = history.phases(satellites) - if isinstance(metric, PhaseCache): - capability = metric.evaluate(phases, observations, keys, context) - else: - capability = evaluate_phases(phases, observations, metric) - row = {**summarize_phases(capability), **history.metrics()} - if cost_model is not None: - row.update(cost_model.estimate(history, growth).metrics()) - rows.append(row) - return pd.DataFrame(rows) - - -def summarize_missions( - missions: pd.DataFrame, - quantiles: Mapping[str, float | Sequence[float]] | None = None, - requirements: Sequence[Requirement] = (), - controls: Mapping[str, float] | None = None, -) -> dict[str, float]: - """ - Summarizes histories of a mission (see `evaluate_missions`) as the - metrics of an evaluation: the mean of each column over the histories - (by the same name), quantiles of columns over the histories (` - p`, such as `"accurate mean p10"` for the 0.1 quantile, the - risk of the mission), and the share of the histories that meet each - requirement on a column (`P( )`). - - With `controls`, the means are estimated with control variates: columns - whose expected values are known (such as the `availability` of a - mission, which simulations alone estimate precisely and cheaply, see - `Deployment.expected_metrics`), and which vary with the other columns - from history to history. The mean of each other column is corrected by - the deviation of the controls' means from their expected values, times - the regression of the column on the controls over the histories, - which removes the share of its variance that the controls explain (a - share of `rho ** 2` for a correlation `rho`): fewer histories give the - same precision. The quantiles and probabilities are not corrected. - - The quantiles and probabilities are over the histories of a replicate, - whose statistics over the replicates (such as their mean, see - `aggregate`) combine the risk of the mission with the uncertainty of the - replicates' other parameters (such as their targets). - - Args: - missions (pandas.DataFrame): A row per history. - quantiles (Mapping | None): The quantiles of columns, by column. - requirements (Sequence[Requirement]): Requirements on columns. - controls (Mapping[str, float] | None): The expected values of - columns that are control variates, if any. - - Returns: - dict[str, float]: the summary - """ - numeric = missions.select_dtypes("number") - summary = {column: float(numeric[column].mean()) for column in numeric.columns} - if controls: - summary.update(_controlled_means(numeric, controls)) - for column, values in (quantiles or {}).items(): - for q in [values] if isinstance(values, (int, float)) else values: - summary[f"{column} p{100 * q:g}"] = float(numeric[column].quantile(q)) - for requirement in requirements: - met = _OPERATORS[requirement.operator]( - missions[requirement.name].to_numpy(dtype=float), requirement.value - ) - statement = f"{requirement.name} {requirement.operator} {requirement.value:g}" - summary[f"P({statement})"] = float(np.mean(met)) - return summary - - -def _controlled_means(numeric: pd.DataFrame, controls: Mapping[str, float]) -> dict: - """ - Estimates the means of columns with control variates (see - `summarize_missions`): each column's mean less the regression of the - column on the controls applied to the deviations of the controls' means - from their expected values, over the histories in which the column and - the controls are known. - """ - names = list(controls) - missing = set(names) - set(numeric.columns) - if missing: - raise ValueError(f"no columns of controls {sorted(missing)}") - expected = np.array([float(controls[name]) for name in names]) - means = {name: float(value) for name, value in zip(names, expected)} - for column in numeric.columns: - if column in controls: - continue - data = numeric[[column, *names]].to_numpy(dtype=float) - data = data[np.all(np.isfinite(data), axis=1)] - if len(data) <= len(names) + 1: - continue - y, x = data[:, 0], data[:, 1:] - centered = x - x.mean(axis=0) - if not np.any(centered): - continue - beta = np.linalg.lstsq(centered, y - y.mean(), rcond=None)[0] - means[column] = float(y.mean() - (x.mean(axis=0) - expected) @ beta) - return means - - -class _Sampler: - """ - The uniform numbers of the failures of a history of a replicate, - stratified over the histories of the replicate (see - `Deployment.simulate_many`): a Latin hypercube in which, for each draw - (each life and launch), history `k` of `K` takes a uniform number in its - stratum of a permutation of the `K` strata of [0, 1). Each draw is keyed - by its key, so that the same draw of the same history of a replicate - takes the same number in every design (common random numbers). - """ - - def __init__(self, seed: int, index: int, histories: int): - self.seed, self.index, self.histories = seed, index, histories - - def __call__(self, key: tuple, dimensions: int) -> np.ndarray: - strata = np.random.default_rng([self.seed, 1, self.histories, *key]) - orders = [strata.permutation(self.histories) for _ in range(dimensions)] - jitter = np.random.default_rng([self.seed, 2, self.index, *key]) - offsets = jitter.random(dimensions) - return np.array( - [ - (order[self.index] + offset) / self.histories - for order, offset in zip(orders, offsets) - ] - ) - - -SAMPLINGS = ("random", "stratified") -"""The samplings of the failures of histories (see `Deployment.simulate_many`).""" - - -def _simulate_many( - deployment: Deployment, - failures: FailureModel, - policy: RestorationPolicy | None, - seed: int, - histories: int, - sampling: str, -) -> list[MissionHistory]: - """ - Simulates the histories of a replicate (see `Deployment.simulate_many`). - """ - if sampling not in SAMPLINGS: - raise ValueError(f"sampling must be one of {SAMPLINGS}, not {sampling!r}") - if sampling == "random": - return [ - deployment.simulate(failures, policy, (seed, k)) for k in range(histories) - ] - return [ - _Simulation( - deployment, - failures, - policy or RestorationPolicy(), - (seed, k), - _Sampler(seed, k, histories), - ).run() - for k in range(histories) - ] - - -def expected_metrics( - deployment: Deployment, - failures: FailureModel, - policy: RestorationPolicy | None = None, - histories: int = 1000, - seed: int = 0, - sampling: str = "stratified", -) -> dict[str, float]: - """ - Estimates the expected measures of a mission (see - `MissionHistory.metrics`, such as its `availability`) from many - simulated histories, without evaluating their phases: precise and - cheap, as the expected values of control variates (see - `summarize_missions`). - - Args: - deployment (Deployment): The deployment. - failures (FailureModel): The failures. - policy (RestorationPolicy | None): The policy for failed satellites. - histories (int): The number of histories. - seed (int): The seed of the histories. - sampling (str): The sampling of their failures. - - Returns: - dict[str, float]: the mean of each measure - """ - rows = pd.DataFrame( - [ - history.metrics() - for history in _simulate_many( - deployment, failures, policy, seed, histories, sampling - ) - ] - ) - return {column: float(rows[column].mean()) for column in rows.columns} diff --git a/tests/generation/test_points.py b/tests/generation/test_points.py index 549f69d7..ce0850e1 100644 --- a/tests/generation/test_points.py +++ b/tests/generation/test_points.py @@ -15,6 +15,7 @@ from tatc.generation import ( generate_points_fibonacci_lattice, generate_points_random, + generate_points_rotated_lattice, generate_points_uniform_angular_distance, generate_points_uniform_spacing, ) @@ -496,3 +497,68 @@ def test_weights_invalid(self): ]: with self.subTest(kwargs=kwargs), self.assertRaises(ValueError): generate_points_random(10, **kwargs) + + +class TestGeneratePointsRotatedLattice(unittest.TestCase): + """ + Unit tests for randomly rotated Fibonacci lattices. + """ + + def test_points(self): + """Lattices have the number of points, reproducibly, uniform by area.""" + points = generate_points_rotated_lattice(500, seed=3) + self.assertEqual(len(points), 500) + self.assertEqual(list(points.columns), ["point_id", "geometry"]) + self.assertEqual(points.crs, "EPSG:4326") + same = generate_points_rotated_lattice(500, seed=3) + self.assertTrue(points.geometry.geom_equals(same.geometry).all()) + other = generate_points_rotated_lattice(500, seed=4) + self.assertFalse(points.geometry.geom_equals(other.geometry).all()) + self.assertEqual(len(generate_points_rotated_lattice(0, seed=1)), 0) + with self.assertRaises(ValueError): + generate_points_rotated_lattice(-1) + # uniform by area: the sine of latitude is uniform on [-1, 1] + sines = np.concatenate( + [ + np.sin( + np.radians(generate_points_rotated_lattice(200, seed=k).geometry.y) + ) + for k in range(100) + ] + ) + self.assertAlmostEqual(sines.mean(), 0, delta=0.01) + self.assertAlmostEqual(sines.var(), 1 / 3, delta=0.01) + elevated = generate_points_rotated_lattice(10, elevation=100, seed=1) + self.assertTrue((elevated.geometry.z == 100).all()) + + def test_mask(self): + """About the number of points fall in a mask.""" + for mask in ( + box(-30, -20, 40, 35), + box(-180, 60, 180, 90), + Polygon([(-100, 20), (-80, 25), (-90, 45)]), + ): + counts = [ + len(generate_points_rotated_lattice(100, mask=mask, seed=k)) + for k in range(50) + ] + self.assertAlmostEqual(np.mean(counts), 100, delta=2) + self.assertLess(max(counts) - min(counts), 15) + with self.assertRaises(ValueError): + generate_points_rotated_lattice( + 10, mask=Polygon([(0, 0), (1, 1), (0, 1), (1, 0)]) + ) + + def test_stratification(self): + """Lattices estimate shares of the surface with less variance.""" + region = box(-60, -10, 30, 50) + + def share(points): + return points.geometry.within(region).mean() + + lattices = [ + share(generate_points_rotated_lattice(200, seed=k)) for k in range(60) + ] + randoms = [share(generate_points_random(200, seed=k)) for k in range(60)] + self.assertAlmostEqual(np.mean(lattices), np.mean(randoms), delta=0.02) + self.assertLess(np.var(lattices), 0.5 * np.var(randoms)) diff --git a/tests/tradespace/test_failures.py b/tests/tradespace/test_failures.py index e3aa3ca5..f69ab5de 100644 --- a/tests/tradespace/test_failures.py +++ b/tests/tradespace/test_failures.py @@ -32,6 +32,7 @@ Uncertain, Weibull, aggregate, + allocate_histories, build_constellation, configure, evaluate_missions, @@ -606,7 +607,7 @@ def test_lifetimes_from_uniform(self): def test_strata(self): """Each draw of the histories of a replicate takes each stratum once.""" - from tatc.tradespace.mission import ( + from tatc.tradespace.histories import ( _Sampler, ) # pylint: disable=import-outside-toplevel @@ -690,3 +691,66 @@ def test_control_variates(self): self.assertTrue(np.isfinite(summary["years"])) with self.assertRaises(ValueError): summarize_missions(missions, controls={"cost": 1.0}) + + +class TestAllocateHistories(unittest.TestCase): + """ + Unit tests for dividing evaluations between replicates and histories. + """ + + def _pilot(self, between, within, replicates=200, histories=20, seed=0): + rng = np.random.default_rng(seed) + rows = [] + for _ in range(replicates): + expected = rng.normal(50, between) + missions = pd.DataFrame({"share": rng.normal(expected, within, histories)}) + rows.append(summarize_missions(missions, spread=True)) + return pd.DataFrame(rows) + + def test_recommendation(self): + """Histories balance the variances and costs of the two levels.""" + records = self._pilot(between=2, within=6) + self.assertIn("share sd", records.columns) + result = allocate_histories( + records, + "share", + 20, + replicate_seconds=100, + history_seconds=1, + standard_error=0.5, + ) + # sqrt(100 * 36 / (1 * 4)) = 30 + self.assertAlmostEqual(result["histories"], 30, delta=6) + self.assertAlmostEqual(result["between"], 2, delta=0.4) + self.assertAlmostEqual(result["within"], 6, delta=0.3) + variance = result["between"] ** 2 + result["within"] ** 2 / result["histories"] + self.assertEqual(result["replicates"], math.ceil(variance / 0.25)) + self.assertAlmostEqual( + result["cost"], result["replicates"] * result["replicate cost"] + ) + # costlier histories call for fewer of them + fewer = allocate_histories(records, "share", 20, 100, 10) + self.assertLess(fewer["histories"], result["histories"]) + + def test_limits(self): + """Without variance between replicates, the most histories.""" + records = self._pilot(between=0, within=6, replicates=50) + result = allocate_histories(records, "share", 20, 100, 1, max_histories=500) + self.assertLessEqual(result["histories"], 500) + self.assertGreater(result["histories"], 100) + # a standard error that two replicates achieve: the fewest histories + enough = allocate_histories(records, "share", 20, 100, 1, standard_error=0.5) + self.assertEqual(enough["replicates"], 2) + self.assertLess(enough["histories"], 100) + self.assertLessEqual( + enough["between"] ** 2 + enough["within"] ** 2 / enough["histories"], + 2 * 0.5**2 + 1e-9, + ) + # means that vary less than independent histories can (stratified) + steady = records.assign(share=50.0) + with self.assertWarns(UserWarning): + allocate_histories(steady, "share", 20, 100, 1) + with self.assertRaises(ValueError): + allocate_histories(records.iloc[:1], "share", 20, 100, 1) + with self.assertRaises(ValueError): + allocate_histories(records, "share", 20, 0, 1) From 9322cf47026ce561a6e0ac569e70404f749d3956 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Wed, 11 Nov 2026 11:22:32 -0700 Subject: [PATCH 23/52] add exact expectations of missions without restoration and importance sampling of failures --- CHANGELOG.md | 2 +- docs/api_reference/tradespace.rst | 4 +- src/tatc/tradespace/__init__.py | 8 +- src/tatc/tradespace/deployment.py | 22 ++- src/tatc/tradespace/failures.py | 48 +++++ src/tatc/tradespace/histories.py | 293 ++++++++++++++++++++++++++++-- src/tatc/tradespace/mission.py | 43 ++++- tests/tradespace/test_failures.py | 216 ++++++++++++++++++++++ 8 files changed, 609 insertions(+), 27 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index fec107a0..bb9602fe 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -22,7 +22,7 @@ Added: - Function `tradespace.screen` (and class `Screening`), which screens designs with studies of increasing fidelity, keeping whole fronts of the best designs of each stage for the next. - Searches of design spaces with optional optimizers: `tradespace.optimize_optuna` suggests designs with Optuna trials (`DesignSpace.suggest`, define-by-run over the hierarchical space), and `optimize_pymoo` and `make_pymoo_problem` search the unit hypercube that encodes a design space (`DesignSpace.unit_paths`, `encode`, and `decode`) with pymoo. Each design is evaluated once, and the designs proposed together are evaluated together, in parallel if the study is. Constraints of a design space may return the amount of their violation (`Infeasible.violation`), which Optuna's trials record (`set_constraint`) for its constraint-aware samplers, and which is the constraint value of pymoo problems. Optional dependencies `tradespace` (joblib, Optuna, and pymoo). - Deployment of constellations (`tradespace.DeploymentSchedule`): from the rates and durations of a study (the mission and design life, the development of each type of satellite, its production on a line at a production rate, and launches at a cadence and capacity, in number or mass, optionally in an order of planes), each design's deployment (`DeploymentSchedule.plan`, a `Deployment` of its `Production`, `Launch`es, and replacements), so that a design of more satellites and planes takes longer to deploy. Its launches divide the mission into phases of constant sets of operating satellites (`Deployment.phases`), evaluated over the study's representative period from the observations of the full constellation (`evaluate_phases`) and combined over the mission (`summarize_phases`: the time-weighted mean of each metric and the time until it first meets a requirement). - - Simulated missions with failures (`Deployment.simulate`, a `MissionHistory` for each replicate, drawn from its seed with common random numbers between designs): lives of satellites whose failure rates vary over the lifecycle (`tradespace.Exponential`, `Weibull`, `Bathtub` of competing causes, and `Piecewise` rates by age, `Lifetime`), failures of launches (`FailureModel`), and a policy that degrades or restores failed satellites (`RestorationPolicy`) by spares in orbit (taking a failed satellite's place after drifting), spares on the ground (launched at the next launch slot), or satellites produced when needed (after procurement, on the production line), optionally replenishing spares and batching restorations in launches. A history gives the phases in which satellites operate (`MissionHistory.phases`), measures of the mission (`MissionHistory.metrics`: failures, restorations, spares used, time to restore, and availability), and, priced by a `CostModel`, the cost of what it produces and launches. Policies are decisions of designs with a fragment of a design space (`policy_space`: whether to restore, spares in orbit and on the ground, and other fields of the policy, without spares that would never be used), and `configure` makes a policy (or a deployment schedule, or another dataclass) from the values of a design. Many histories of a replicate's mission (`Deployment.simulate_many`) share its sample of targets: `evaluate_missions` evaluates them (with their measures and costs) with a cache that evaluates each set of operating satellites once (`PhaseCache`, keyed by the content of the satellites and shared by the histories, policies, and designs of a replicate), and `summarize_missions` gives their means, quantiles (the risk of the mission), and probabilities of meeting requirements, as one record of the replicate. The histories of a replicate are stratified by default (a Latin hypercube over the histories of each satellite's life and each launch, drawn from uniform numbers by `Lifetime.from_uniform`), which estimates the means of missions 3 to 15 times more precisely than independent histories, and means may be estimated with control variates (`summarize_missions(controls=...)`, such as the availability of the mission, whose expected value simulations alone estimate, `Deployment.expected_metrics`). `allocate_histories` recommends the histories of each replicate (and the replicates, for a standard error) from a pilot with independent histories, by the variances between replicates and between histories and their costs (`summarize_missions(spread=True)` gives the standard deviations of the histories). + - Simulated missions with failures (`Deployment.simulate`, a `MissionHistory` for each replicate, drawn from its seed with common random numbers between designs): lives of satellites whose failure rates vary over the lifecycle (`tradespace.Exponential`, `Weibull`, `Bathtub` of competing causes, and `Piecewise` rates by age, `Lifetime`), failures of launches (`FailureModel`), and a policy that degrades or restores failed satellites (`RestorationPolicy`) by spares in orbit (taking a failed satellite's place after drifting), spares on the ground (launched at the next launch slot), or satellites produced when needed (after procurement, on the production line), optionally replenishing spares and batching restorations in launches. A history gives the phases in which satellites operate (`MissionHistory.phases`), measures of the mission (`MissionHistory.metrics`: failures, restorations, spares used, time to restore, and availability), and, priced by a `CostModel`, the cost of what it produces and launches. Policies are decisions of designs with a fragment of a design space (`policy_space`: whether to restore, spares in orbit and on the ground, and other fields of the policy, without spares that would never be used), and `configure` makes a policy (or a deployment schedule, or another dataclass) from the values of a design. Many histories of a replicate's mission (`Deployment.simulate_many`) share its sample of targets: `evaluate_missions` evaluates them (with their measures and costs) with a cache that evaluates each set of operating satellites once (`PhaseCache`, keyed by the content of the satellites and shared by the histories, policies, and designs of a replicate), and `summarize_missions` gives their means, quantiles (the risk of the mission), and probabilities of meeting requirements, as one record of the replicate. The histories of a replicate are stratified by default (a Latin hypercube over the histories of each satellite's life and each launch, drawn from uniform numbers by `Lifetime.from_uniform`), which estimates the means of missions 3 to 15 times more precisely than independent histories, and means may be estimated with control variates (`summarize_missions(controls=...)`, such as the availability of the mission, whose expected value simulations alone estimate, `Deployment.expected_metrics`). `allocate_histories` recommends the histories of each replicate (and the replicates, for a standard error) from a pilot with independent histories, by the variances between replicates and between histories and their costs (`summarize_missions(spread=True)` gives the standard deviations of the histories). `expected_missions` computes the expected capability and availability of a mission without restoration exactly (the sets of operating satellites by their probabilities, from the survival of each launch group, with planned replacements), without sampling error. Histories may be drawn from stressed failures for importance sampling (`simulate_many(stress=...)`: hazards and launch failures times a factor, each history weighted by its likelihood ratio censored at the end of the mission, `Lifetime.stressed` and `MissionHistory.weight`), which `summarize_missions` weighs in every statistic, with the effective number of histories: the probabilities of rare losses with 30 to 70 times less variance. - Life-cycle costs of deployments for trade studies (`tradespace.CostModel`): the development of each type of satellite, the production of its units on a learning curve (`SatelliteCost`), launches (per launch, or prices per satellite and kg, `LaunchCost`), operations (`OperationsCost`), replacements, and spares in orbit, dated by the deployment for their present value at a discount rate (`CostEstimate.present_value`, metric `cost present`) and annual costs (`CostEstimate.annual`, metric `cost peak annual`), with growth factors for cost risk (such as uncertain parameters, whose quantiles over replicates give the cost at a confidence level). TAT-C does not include cost-estimating relationships: the costs are given by the study. Fingerprints describe dataclasses (such as cost models) by their fields. - Function `tradespace.confirm` (and class `Confirmation`), which evaluates selected designs (such as a front) with new replicates that played no part in their selection, removing the optimism of the selection (the winner's curse, `Confirmation.optimism`). `ResultStore` keys evaluations by the fingerprint of a study (`Study.fingerprint`, see `get_fingerprint`: its seed, use of common random numbers, design space, and build and evaluation functions, and the version of TAT-C), warning if it holds evaluations of other definitions, which are not reused; `SatelliteCache` keys results on disk by the fingerprint of its function. Fingerprints include a hash of the source of TAT-C (its code and resources, `get_source_hash`), so that results computed with other code of TAT-C, in development as well as in other versions, are not reused. `refine` treats designs with fewer than `min_replicates` (5) as uncertain whatever their probability, adds the replicates left to `max_replicates` in a last partial step, and warns if designs remain uncertain without a tolerance. `sensitivity` gives adjusted shares (epsilon squared) by default, without the share that the levels of a variable explain by chance (`adjusted=False` for correlation ratios). - Searches with Optuna accept categorical options that depend on earlier decisions (a parameter for each set of options), use TPE with a constant liar in batches by default (which spreads the trials of a batch), and stop after `max_designs` designs evaluated (trials that suggest designs evaluated before are told their objectives without evaluating them again). A design infeasible in some of its replicates violates its feasibility by their share (`Evaluations.infeasibility`), and the first design evaluated in a search is evaluated alone, to check that evaluations give one record each. `Study` records errors of evaluations as infeasible, without storing them, with `errors="record"`. Enumeration walks the items of unordered repetitions in one order only (the same designs, in the same order, four times faster for three sun-synchronous planes), and `DesignSpace.size` counts designs without keeping them. Pareto fronts are found by a vectorized sweep in lexicographic order that compares designs only with the efficient designs before them, and fronts with tolerances by comparing designs only with the efficient designs without tolerances (which dominate every design that any design dominates within the tolerances), in blocks of bounded memory: 20,000 designs in 0.05 s (0.11 s with tolerances) rather than 17 s, and the bootstraps of `pareto_probability` (and so `refine`) about 20 times faster. diff --git a/docs/api_reference/tradespace.rst b/docs/api_reference/tradespace.rst index 5ab80510..08a65f6c 100644 --- a/docs/api_reference/tradespace.rst +++ b/docs/api_reference/tradespace.rst @@ -97,7 +97,7 @@ Failures and Missions :members: life_of .. autoclass:: tatc.tradespace.Lifetime - :members: survival, hazard, cumulative_hazard, sample, from_uniform, dimensions + :members: survival, hazard, cumulative_hazard, sample, from_uniform, dimensions, stressed .. autoclass:: tatc.tradespace.Exponential @@ -134,6 +134,8 @@ Failures and Missions .. autofunction:: tatc.tradespace.allocate_histories +.. autofunction:: tatc.tradespace.expected_missions + Costs ----- diff --git a/src/tatc/tradespace/__init__.py b/src/tatc/tradespace/__init__.py index 452bb0c0..41425443 100644 --- a/src/tatc/tradespace/__init__.py +++ b/src/tatc/tradespace/__init__.py @@ -39,7 +39,12 @@ Launch, Production, ) -from .histories import allocate_histories, evaluate_missions, summarize_missions +from .histories import ( + allocate_histories, + evaluate_missions, + expected_missions, + summarize_missions, +) from .mission import ( MissionHistory, Phase, @@ -156,6 +161,7 @@ "count_satellites", "evaluate_missions", "evaluate_phases", + "expected_missions", "get_fingerprint", "get_satellite_key", "get_source_hash", diff --git a/src/tatc/tradespace/deployment.py b/src/tatc/tradespace/deployment.py index 4ce950b3..3d4558b4 100644 --- a/src/tatc/tradespace/deployment.py +++ b/src/tatc/tradespace/deployment.py @@ -224,6 +224,8 @@ def simulate_many( seed: int | None, histories: int, sampling: str = "stratified", + stress: float = 1.0, + launch_stress: float | None = None, ) -> list[MissionHistory]: """ Simulates several histories of the mission in a replicate (see @@ -241,6 +243,19 @@ def simulate_many( histories (`"random"`), several times so for missions of a few satellites or many, at no cost. + With a `stress`, the failures are drawn from stressed distributions + for importance sampling, which samples rare outcomes (such as the + loss of several satellites of a reliable constellation) more often: + the hazards of the lives of the satellites times the stress, and the + probability that a launch fails times the `launch_stress` (by + default the stress, at most 0.5). Each history is weighted by its + likelihood ratio (`MissionHistory.weight`, see `Lifetime.stressed`), + which `summarize_missions` applies to every statistic. A stress + that samples the outcomes of interest about as often as the others + estimates their probabilities (and the quantiles of their tails) + with far fewer histories; too large a stress makes a few weights + dominate (see the effective number of histories). + Many histories of the failures of a replicate, whose sample of targets (the expensive part of an evaluation) they share, measure the risk of a mission at little cost (see `evaluate_missions` and @@ -253,6 +268,9 @@ def simulate_many( seed (int | None): The seed of the replicate. histories (int): The number of histories. sampling (str): `"stratified"` or `"random"`. + stress (float): The factor of the hazards of stressed failures. + launch_stress (float | None): The factor of the probability that + a launch fails, or `None` for the stress. Returns: list[MissionHistory]: the histories @@ -264,7 +282,9 @@ def simulate_many( raise ValueError("histories must be at least 1") if seed is None: return [self.simulate(failures, policy, None)] - return _simulate_many(self, failures, policy, seed, histories, sampling) + return _simulate_many( + self, failures, policy, seed, histories, sampling, stress, launch_stress + ) def expected_metrics( self, diff --git a/src/tatc/tradespace/failures.py b/src/tatc/tradespace/failures.py index c8f51676..d98dc024 100644 --- a/src/tatc/tradespace/failures.py +++ b/src/tatc/tradespace/failures.py @@ -107,6 +107,44 @@ def from_uniform(self, uniform: Sequence[float]) -> float: """ raise NotImplementedError + def stressed( + self, uniform: Sequence[float], factor: float, horizon: float = math.inf + ) -> tuple[float, float]: + """ + Gets a life from a stressed distribution, whose hazard is `factor` + times this one's (its survival this one's to the power `factor`), for + importance sampling (see `Deployment.simulate_many`), and the + logarithm of its likelihood ratio for what a mission observes of it + up to a `horizon` (such as the end of the mission): the density of a + failure before the horizon in this distribution over its density in + the stressed one, `S(life) ** (1 - factor) / factor` for the survival + `S`, or the ratio of the survivals to the horizon, + `S(horizon) ** (1 - factor)`, for a life that outlasts it (whose + length past the horizon does not matter, and whose ratio would + otherwise be unbounded). + + Args: + uniform (Sequence[float]): The uniform numbers (see + `from_uniform`). + factor (float): The factor of the hazard. + horizon (float): The age to which the life is observed. + + Returns: + tuple[float, float]: the life and the logarithm of its ratio + """ + life = self._stressed_life(uniform, factor) + if life > horizon: + survival = float(self.survival(np.array([horizon]))[0]) + return life, (1.0 - factor) * math.log(survival) if survival > 0 else 0.0 + survival = float(self.survival(np.array([life]))[0]) + if survival <= 0: + return life, -math.inf + return life, (1.0 - factor) * math.log(survival) - math.log(factor) + + def _stressed_life(self, uniform: Sequence[float], factor: float) -> float: + """Gets a life from the stressed distribution (see `stressed`).""" + return self.from_uniform([1.0 - (1.0 - float(uniform[0])) ** (1.0 / factor)]) + @dataclass(frozen=True) class Exponential(Lifetime): @@ -217,6 +255,16 @@ def from_uniform(self, uniform): start += cause.dimensions return min(lives, default=math.inf) + def _stressed_life(self, uniform, factor): + # each cause stressed: the sum of their hazards times the factor + lives, start = [], 0 + for cause in self.causes: + part = uniform[start : start + cause.dimensions] + # pylint: disable-next=protected-access + lives.append(cause._stressed_life(part, factor)) + start += cause.dimensions + return min(lives, default=math.inf) + @dataclass(frozen=True) class Piecewise(Lifetime): diff --git a/src/tatc/tradespace/histories.py b/src/tatc/tradespace/histories.py index ff29996c..0234822c 100644 --- a/src/tatc/tradespace/histories.py +++ b/src/tatc/tradespace/histories.py @@ -10,6 +10,7 @@ from __future__ import annotations +import itertools import math import warnings from collections.abc import Callable, Mapping, Sequence @@ -25,6 +26,7 @@ from .failures import FailureModel, RestorationPolicy from .mission import ( MissionHistory, + Phase, PhaseCache, _Simulation, evaluate_phases, @@ -64,9 +66,11 @@ def evaluate_missions( growth (float | Mapping[str, float]): The growth of the cost. Returns: - pandas.DataFrame: a row per history + pandas.DataFrame: a row per history (with its likelihood ratio, + `weight`, if the histories are of stressed failures) """ rows = [] + weighted = any(history.weight != 1.0 for history in histories) keys = {s.name: get_satellite_key(s) for s in satellites} for history in histories: phases = history.phases(satellites) @@ -75,6 +79,8 @@ def evaluate_missions( else: capability = evaluate_phases(phases, observations, metric) row = {**summarize_phases(capability), **history.metrics()} + if weighted: + row["weight"] = history.weight if cost_model is not None: row.update(cost_model.estimate(history, growth).metrics()) rows.append(row) @@ -107,6 +113,12 @@ def summarize_missions( share of `rho ** 2` for a correlation `rho`): fewer histories give the same precision. The quantiles and probabilities are not corrected. + Histories of stressed failures (see `Deployment.simulate_many`) are + weighted by their likelihood ratios (`weight`), for every statistic, and + the effective number of histories (`effective histories`, the square of + the sum of the weights over the sum of their squares) measures how much + a few weights dominate. + The quantiles and probabilities are over the histories of a replicate, whose statistics over the replicates (such as their mean, see `aggregate`) combine the risk of the mission with the uncertainty of the @@ -125,26 +137,72 @@ def summarize_missions( dict[str, float]: the summary """ numeric = missions.select_dtypes("number") - summary = {column: float(numeric[column].mean()) for column in numeric.columns} + weights = np.ones(len(numeric)) + if "weight" in numeric.columns: + weights = numeric.pop("weight").to_numpy(dtype=float) + summary = { + column: _weighted_mean(numeric[column].to_numpy(dtype=float), weights) + for column in numeric.columns + } + if "weight" in missions.columns: + summary["effective histories"] = float(weights.sum() ** 2 / np.sum(weights**2)) if controls: - summary.update(_controlled_means(numeric, controls)) + summary.update(_controlled_means(numeric, controls, weights)) if spread: - summary.update( - {f"{column} sd": float(numeric[column].std()) for column in numeric.columns} - ) + for column in numeric.columns: + values = numeric[column].to_numpy(dtype=float) + known = np.isfinite(values) + mean = _weighted_mean(values, weights) + variance = _weighted_mean((values - mean) ** 2, weights) + count = known.sum() + summary[f"{column} sd"] = ( + float(np.sqrt(variance * count / (count - 1))) + if count > 1 + else math.nan + ) for column, values in (quantiles or {}).items(): for q in [values] if isinstance(values, (int, float)) else values: - summary[f"{column} p{100 * q:g}"] = float(numeric[column].quantile(q)) + summary[f"{column} p{100 * q:g}"] = _weighted_quantile( + numeric[column].to_numpy(dtype=float), weights, q + ) for requirement in requirements: met = _OPERATORS[requirement.operator]( missions[requirement.name].to_numpy(dtype=float), requirement.value ) statement = f"{requirement.name} {requirement.operator} {requirement.value:g}" - summary[f"P({statement})"] = float(np.mean(met)) + summary[f"P({statement})"] = float(np.sum(weights * met) / np.sum(weights)) return summary -def _controlled_means(numeric: pd.DataFrame, controls: Mapping[str, float]) -> dict: +def _weighted_mean(values: np.ndarray, weights: np.ndarray) -> float: + """The weighted mean of the known values (`NaN` without any).""" + known = np.isfinite(values) + if not known.any() or weights[known].sum() <= 0: + return math.nan + return float(np.sum(weights[known] * values[known]) / np.sum(weights[known])) + + +def _weighted_quantile(values: np.ndarray, weights: np.ndarray, q: float) -> float: + """ + The quantile of the known values, by their weights: the least value + whose cumulative weight reaches the share `q` of the total (as numpy's + `inverted_cdf`), or numpy's linear quantile without weights. + """ + known = np.isfinite(values) + values, weights = values[known], weights[known] + if len(values) == 0: + return math.nan + if np.all(weights == weights[0]): + return float(np.quantile(values, q)) + order = np.argsort(values) + cumulative = np.cumsum(weights[order]) / weights.sum() + position = min(int(np.searchsorted(cumulative, q - 1e-12)), len(values) - 1) + return float(values[order][position]) + + +def _controlled_means( + numeric: pd.DataFrame, controls: Mapping[str, float], weights: np.ndarray +) -> dict: """ Estimates the means of columns with control variates (see `summarize_missions`): each column's mean less the regression of the @@ -162,15 +220,20 @@ def _controlled_means(numeric: pd.DataFrame, controls: Mapping[str, float]) -> d if column in controls: continue data = numeric[[column, *names]].to_numpy(dtype=float) - data = data[np.all(np.isfinite(data), axis=1)] - if len(data) <= len(names) + 1: + known = np.all(np.isfinite(data), axis=1) + data, w = data[known], weights[known] + if len(data) <= len(names) + 1 or w.sum() <= 0: continue y, x = data[:, 0], data[:, 1:] - centered = x - x.mean(axis=0) + y_mean, x_mean = np.average(y, weights=w), np.average(x, axis=0, weights=w) + centered = x - x_mean if not np.any(centered): continue - beta = np.linalg.lstsq(centered, y - y.mean(), rcond=None)[0] - means[column] = float(y.mean() - (x.mean(axis=0) - expected) @ beta) + root = np.sqrt(w)[:, None] + beta = np.linalg.lstsq(root * centered, root[:, 0] * (y - y_mean), rcond=None)[ + 0 + ] + means[column] = float(y_mean - (x_mean - expected) @ beta) return means @@ -212,13 +275,18 @@ def _simulate_many( seed: int, histories: int, sampling: str, + stress: float = 1.0, + launch_stress: float | None = None, ) -> list[MissionHistory]: """ Simulates the histories of a replicate (see `Deployment.simulate_many`). """ if sampling not in SAMPLINGS: raise ValueError(f"sampling must be one of {SAMPLINGS}, not {sampling!r}") - if sampling == "random": + if stress <= 0 or (launch_stress is not None and launch_stress <= 0): + raise ValueError("stress must be positive") + launch_stress = stress if launch_stress is None else launch_stress + if sampling == "random" and stress == 1 and launch_stress == 1: return [ deployment.simulate(failures, policy, (seed, k)) for k in range(histories) ] @@ -228,7 +296,9 @@ def _simulate_many( failures, policy or RestorationPolicy(), (seed, k), - _Sampler(seed, k, histories), + _Sampler(seed, k, histories) if sampling == "stratified" else None, + stress, + launch_stress, ).run() for k in range(histories) ] @@ -366,3 +436,194 @@ def allocate_histories( result.update(histories=float(count), **{"replicate cost": cost}) result.update(replicates=float(replicates), cost=replicates * cost) return result + + +def _launch_groups( + deployment: Deployment, failures: FailureModel, times: np.ndarray +) -> tuple[int, list[tuple]]: + """ + Gets the launch groups of a deployment without restoration: the + positions of each launch of the deployment (in order of the planes' + positions), which its planned replacements carry again. For each group, + at each time: the probability that each of its launches so far is the + latest that succeeded (`weights`, launches by times), the survival of + the satellites of each since its launch (`survival`, launches by times), + the probability that none has succeeded (`none`), and whether the group + has launched. + """ + offsets = np.cumsum([0] + [built for _, built, _ in deployment.planes]) + launches: dict[tuple[int, int], list] = {} + for launch in sorted(deployment.launches, key=lambda l: l.time): + launches.setdefault((launch.plane, launch.first), []).append(launch) + p = failures.launch + groups = [] + for (plane, first), sequence in launches.items(): + built = deployment.planes[plane][1] + members = [ + int(offsets[plane]) + position + for position in range(first, min(first + sequence[0].satellites, built)) + ] + if not members: + continue + life = failures.life_of(sequence[0].kind) + flown = np.array([[t >= launch.time for t in times] for launch in sequence]) + # launches after each one, up to each time + later = np.flip(np.cumsum(np.flip(flown, axis=0), axis=0), axis=0) - flown + weights = np.where(flown, (1 - p) * p**later, 0.0) + survival = np.array( + [ + ( + np.ones(len(times)) + if life is None + else life.survival(np.maximum(times - launch.time, 0.0)) + ) + for launch in sequence + ] + ) + none = p ** flown.sum(axis=0) + groups.append((members, weights, survival, none, flown.any(axis=0))) + return int(offsets[-1]), groups + + +def _set_weight(active: np.ndarray, groups: list) -> float: + """ + Gets the share of the mission's time in which exactly the active + positions operate, in expectation: at each time, the product over the + launch groups of the probability that exactly the active satellites of + the group operate, which (as they are of one type and launched together) + depends only on their number `a` of the `n` of the group: the sum over + its launches of the probability that the launch is the latest that + succeeded times `S ** a * (1 - S) ** (n - a)`, for the survival `S` of + its satellites, and the probability that none has succeeded if `a` is 0. + """ + probability = 1.0 + for members, weights, survival, none, _ in groups: + count = int(active[members].sum()) + size = len(members) + group = np.sum( + weights * survival**count * (1 - survival) ** (size - count), axis=0 + ) + if count == 0: + group = group + none + probability = probability * group + return float(np.mean(probability)) + + +def expected_missions( + deployment: Deployment, + failures: FailureModel, + satellites: Sequence[Satellite], + observations: pd.DataFrame, + metric: Callable[[pd.DataFrame], Mapping[str, float]] | PhaseCache, + context: Any = None, + tolerance: float = 1e-3, + steps: int = 400, + max_sets: int = 200_000, +) -> dict[str, float]: + """ + Computes the expected capability of a mission without restoration + (failed satellites are not restored, but may be replaced as planned at + the end of their design life) over its failures: the expectation of the + mean of each metric over the phases of the mission (` mean`, as + `summarize_phases` gives for one history) and of its availability + (`availability`), exactly rather than from samples of histories. + + Without restoration, the satellites fail independently (but for the + satellites of a launch, which a failed launch loses together), so that + the probability that a set of satellites operates at a time is a product + over the launches of their survival (see `Lifetime.survival`). The + expected mean of a metric is the sum over the sets of satellites of the + metric of each set (evaluated once, as with a `PhaseCache`) times the + share of the mission's time in which exactly that set operates, in + expectation (integrated over `steps` times). The sets are enumerated by + the number of satellites missing until their shares cover all but + `tolerance` of the mission's time, and evaluated in order of their + shares until they do (`coverage`, the share covered, and `sets`, the + sets evaluated); the expectation is over the sets evaluated. + + Without sampling error, an expectation estimates the mean of many + histories with none of their variance (see `Deployment.simulate_many`), + for missions of a few to a dozen or two satellites; for larger ones, or + with restoration (whose shared production and launches make failures + dependent), simulate histories. + + Args: + deployment (Deployment): The deployment. + failures (FailureModel): The failures. + satellites (Sequence[Satellite]): The satellites, in the order of the + planes (see `MissionHistory.phases`). + observations (pandas.DataFrame): The observations of every + satellite, with their names (`satellite`). + metric (Callable | PhaseCache): A function of the observations of a + set of satellites that gives its metrics, or a cache of one. + context (Any): A hashable identifier of the observations, for a + cache. + tolerance (float): The share of the mission's time that the sets + evaluated may leave out. + steps (int): The times at which the probabilities are integrated. + max_sets (int): The most sets to enumerate. + + Returns: + dict[str, float]: the expected metrics + """ + # pylint: disable=too-many-locals + names = [s.name for s in satellites] + built = sum(b for _, b, _ in deployment.planes) + if len(names) != built: + raise ValueError( + f"expected {built} satellites for the planes, not {len(names)}" + ) + begin, end = deployment.begin, deployment.end + times = begin + (np.arange(steps) + 0.5) * (end - begin) / steps + count, groups = _launch_groups(deployment, failures, times) + # availability: the expected years of operation of the positions, as a + # share of those of the planned deployment + operating = sum( + len(members) * float(np.mean(np.sum(weights * survival, axis=0))) + for members, weights, survival, _, _ in groups + ) + planned = sum( + len(members) * float(np.mean(launched)) for members, _, _, _, launched in groups + ) + availability = operating / planned if planned > 0 else math.nan + # enumerate the sets by the number of positions missing + weights: list[tuple[float, tuple[int, ...]]] = [] + covered, enumerated = 0.0, 0 + for missing in range(count + 1): + for gone in itertools.combinations(range(count), missing): + enumerated += 1 + if enumerated > max_sets: + raise ValueError( + "too many sets of satellites to enumerate: simulate histories" + ) + active = np.ones(count, dtype=bool) + active[list(gone)] = False + weight = _set_weight(active, groups) + if weight > 0: + weights.append((weight, tuple(np.flatnonzero(active)))) + covered += weight + if covered >= 1 - tolerance: + break + weights.sort(key=lambda item: -item[0]) + keys = {s.name: get_satellite_key(s) for s in satellites} + totals: dict[str, float] = {} + evaluated, sets = 0.0, 0 + for weight, members in weights: + phase = Phase(begin, end, tuple(names[k] for k in members)) + if isinstance(metric, PhaseCache): + values = metric.evaluate([phase], observations, keys, context).iloc[0] + else: + values = evaluate_phases([phase], observations, metric).iloc[0] + for name, value in values.items(): + if name in ("start", "end", "duration", "satellites"): + continue + totals[f"{name} mean"] = totals.get(f"{name} mean", 0.0) + weight * float( + value + ) + evaluated += weight + sets += 1 + if evaluated >= 1 - tolerance: + break + result = {name: total / evaluated for name, total in totals.items()} + result.update(availability=availability, coverage=evaluated, sets=float(sets)) + return result diff --git a/src/tatc/tradespace/mission.py b/src/tatc/tradespace/mission.py index 931199e3..d13a05b8 100644 --- a/src/tatc/tradespace/mission.py +++ b/src/tatc/tradespace/mission.py @@ -78,6 +78,9 @@ class MissionHistory: """list: The restorations: their plane, position, the time of the failure and of the restoration, and the source (`"orbit"`, `"ground"`, or `"production"`).""" + weight: float = 1.0 + """float: The likelihood ratio of the history, drawn from stressed + failures (see `Deployment.simulate_many`), or 1.""" @property def schedule(self) -> DeploymentSchedule: @@ -230,9 +233,13 @@ def __init__( policy: RestorationPolicy, seed: int | Sequence[int] | None, uniforms: Callable[[tuple, int], np.ndarray] | None = None, + stress: float = 1.0, + launch_stress: float = 1.0, ): self.deployment, self.failures, self.policy = deployment, failures, policy self.seed, self.uniforms = seed, uniforms + self.stress, self.launch_stress = stress, launch_stress + self.log_weight = 0.0 self.schedule = deployment.schedule self.end = deployment.end self.history = MissionHistory( @@ -276,23 +283,44 @@ def _rng(self, *key: int) -> np.random.Generator: seed = list(self.seed) if isinstance(self.seed, Sequence) else [self.seed] return np.random.default_rng([*seed, *key]) - def _life(self, plane: int, position: int, generation: int) -> float: + def _life( + self, plane: int, position: int, generation: int, start: float = 0.0 + ) -> float: if self.seed is None: return math.inf life = self.failures.life_of(self.deployment.planes[plane][0]) if life is None: return math.inf + key = (0, plane, position, generation) + if self.stress != 1.0: + uniform = ( + self.uniforms(key, life.dimensions) + if self.uniforms is not None + else self._rng(*key).random(life.dimensions) + ) + value, log_ratio = life.stressed(uniform, self.stress, self.end - start) + self.log_weight += log_ratio + return value if self.uniforms is not None: - key = (0, plane, position, generation) return life.from_uniform(self.uniforms(key, life.dimensions)) - return life.sample(self._rng(0, plane, position, generation)) + return life.sample(self._rng(*key)) def _launch_fails(self, *key: int) -> bool: if self.seed is None or self.failures.launch == 0: return False - if self.uniforms is not None: - return bool(self.uniforms((1, *key), 1)[0] < self.failures.launch) - return bool(self._rng(1, *key).random() < self.failures.launch) + uniform = ( + self.uniforms((1, *key), 1)[0] + if self.uniforms is not None + else self._rng(1, *key).random() + ) + p = self.failures.launch + if self.launch_stress == 1.0: + return bool(uniform < p) + stressed = min(p * self.launch_stress, 0.5) + failed = bool(uniform < stressed) + ratio = p / stressed if failed else (1 - p) / (1 - stressed) + self.log_weight += math.log(ratio) + return failed # --- events @@ -330,6 +358,7 @@ def run(self) -> MissionHistory: for plane, since in self.spares_since.items(): if self.spares[plane] > 0: self.history.parked.append((since, self.end, self.spares[plane])) + self.history.weight = math.exp(self.log_weight) self.history.production.sort(key=lambda batch: batch.begin) self.history.launches.sort(key=lambda launch: (launch.time, launch.plane)) return self.history @@ -459,7 +488,7 @@ def _up(self, time: float, plane: int, position: int) -> None: slot = self.slots[plane, position] slot["generation"] += 1 slot["up"], slot["pending"] = time, False - life = self._life(plane, position, slot["generation"]) + life = self._life(plane, position, slot["generation"], time) if time + life < self.end: self._push(time + life, "fail", plane, position, slot["generation"]) diff --git a/tests/tradespace/test_failures.py b/tests/tradespace/test_failures.py index f69ab5de..e2b5ecf2 100644 --- a/tests/tradespace/test_failures.py +++ b/tests/tradespace/test_failures.py @@ -37,9 +37,11 @@ configure, evaluate_missions, evaluate_phases, + expected_missions, pareto_front, policy_space, summarize_missions, + summarize_phases, walker_space, ) @@ -754,3 +756,217 @@ def test_limits(self): allocate_histories(records.iloc[:1], "share", 20, 100, 1) with self.assertRaises(ValueError): allocate_histories(records, "share", 20, 0, 1) + + +class TestExpectedMissions(unittest.TestCase): + """ + Unit tests for exact expectations of missions without restoration. + """ + + def setUp(self): + from datetime import ( + datetime, + timezone, + ) # pylint: disable=import-outside-toplevel + + from tatc.schemas import Instrument # pylint: disable=import-outside-toplevel + + self.layout = _walker(2, 2) + self.satellites = build_constellation( + self.layout, + Instrument(name="imager", field_of_regard=60), + epoch=datetime(2026, 1, 1, tzinfo=timezone.utc), + altitude=700e3, + ) + names = [s.name for s in self.satellites] + self.observations = pd.DataFrame({"satellite": names * 3, "target": range(12)}) + + @staticmethod + def _metric(observations): + # a nonlinear metric of the operating satellites (the first counts double) + names = set(observations["satellite"]) if len(observations) else set() + score = len(names) + ("satellite 1" in names) + return {"score": float(score**2)} + + def _compare(self, schedule, failures): + deployment = schedule.plan(self.layout) + exact = expected_missions( + deployment, + failures, + self.satellites, + self.observations, + PhaseCache(self._metric), + ) + histories = deployment.simulate_many( + failures, RestorationPolicy(restore=False), 3, 4000 + ) + missions = evaluate_missions( + histories, self.satellites, self.observations, PhaseCache(self._metric) + ) + error = missions["score mean"].std() / np.sqrt(len(missions)) + self.assertAlmostEqual( + exact["score mean"], missions["score mean"].mean(), delta=4 * error + ) + self.assertAlmostEqual( + exact["availability"], missions["availability"].mean(), delta=0.01 + ) + self.assertGreaterEqual(exact["coverage"], 0.999) + return exact + + def test_matches_simulation(self): + """Expectations are the means of many simulated histories.""" + failures = FailureModel(life=Exponential(0.2), launch=0.1) + self._compare( + DeploymentSchedule(years=5, development_years=1, production_rate=2), + failures, + ) + # planned replacements, which a failed launch leaves to the old satellites + self._compare( + DeploymentSchedule(years=6, design_life=2, development_years=1), failures + ) + bathtub = FailureModel( + life=Bathtub(Weibull(0.5, 40), Exponential(0.05), Weibull(4, 5)), + launch=0.05, + ) + self._compare(DeploymentSchedule(years=5, launch_interval=0.5), bathtub) + + def test_without_failures(self): + """Without failures, the expectation is the mission's.""" + deployment = DeploymentSchedule( + years=4, development_years=1, production_rate=2 + ).plan(self.layout) + exact = expected_missions( + deployment, FailureModel(), self.satellites, self.observations, self._metric + ) + phases = deployment.phases(self.satellites) + planned = summarize_phases( + evaluate_phases(phases, self.observations, self._metric) + ) + self.assertAlmostEqual(exact["score mean"], planned["score mean"], places=6) + self.assertEqual(exact["availability"], 1.0) + # every launch fails: nothing operates + lost = expected_missions( + deployment, + FailureModel(launch=1.0), + self.satellites, + self.observations, + self._metric, + ) + self.assertEqual(lost["availability"], 0.0) + self.assertEqual(lost["score mean"], 0.0) + + def test_limits(self): + """Sets are enumerated within limits.""" + deployment = DeploymentSchedule(years=4).plan(self.layout) + failures = FailureModel(life=Exponential(0.5)) + with self.assertRaises(ValueError): + expected_missions( + deployment, + failures, + self.satellites, + self.observations, + self._metric, + max_sets=3, + ) + with self.assertRaises(ValueError): + expected_missions( + deployment, + failures, + self.satellites[:3], + self.observations, + self._metric, + ) + + +class TestImportanceSampling(unittest.TestCase): + """ + Unit tests for histories of stressed failures and their weights. + """ + + def test_stressed_lives(self): + """Stressed lives are weighted to their distribution, up to a horizon.""" + rng = np.random.default_rng(0) + for life in ( + Exponential(0.1), + Weibull(2, 8), + Bathtub(Weibull(0.5, 40), Exponential(0.05)), + ): + draws = [ + life.stressed(rng.random(life.dimensions), 4.0, 5.0) + for _ in range(20000) + ] + lives = np.array([d[0] for d in draws]) + weights = np.exp([d[1] for d in draws]) + self.assertAlmostEqual(weights.mean(), 1.0, delta=0.03) + # the weighted share that survives the horizon is this distribution's + survived = np.sum(weights * (lives > 5)) / weights.sum() + self.assertAlmostEqual( + survived, float(life.survival(np.array([5.0]))[0]), delta=0.02 + ) + # the stressed lives fail more often + self.assertGreater( + (lives <= 5).mean(), 1 - life.survival(np.array([5.0]))[0] + ) + + def test_rare_losses(self): + """Stress estimates the probability of a rare loss with less variance.""" + deployment = DeploymentSchedule(years=5).plan(_walker(1, 3)) + failures = FailureModel(life=Exponential(0.01)) + p = 1 - math.exp(-0.05) + exact = 3 * p**2 * (1 - p) + p**3 + estimates = {} + for stress in (1.0, 8.0): + values = [] + for seed in range(25): + histories = deployment.simulate_many( + failures, RestorationPolicy(restore=False), seed, 200, stress=stress + ) + rows = pd.DataFrame( + [{**h.metrics(), "weight": h.weight} for h in histories] + ) + summary = summarize_missions( + rows, requirements=[Requirement("failures", ">=", 2)] + ) + values.append(summary["P(failures >= 2)"]) + if stress > 1: + self.assertGreater(summary["effective histories"], 30) + estimates[stress] = np.array(values) + self.assertAlmostEqual(estimates[8.0].mean(), exact, delta=0.001) + self.assertLess(estimates[8.0].var(), estimates[1.0].var() / 5) + # without stress, histories are not weighted + plain = deployment.simulate_many(failures, None, 1, 5) + self.assertTrue(all(h.weight == 1.0 for h in plain)) + with self.assertRaises(ValueError): + deployment.simulate_many(failures, None, 1, 5, stress=0) + + def test_stressed_launches(self): + """Stressed launches are weighted to their probability of failure.""" + deployment = DeploymentSchedule(years=2).plan(_walker(1, 2)) + failures = FailureModel(launch=0.02) + histories = deployment.simulate_many( + failures, RestorationPolicy(restore=False), 4, 3000, stress=10.0 + ) + weights = np.array([h.weight for h in histories]) + lost = np.array([h.launches[0].failed for h in histories]) + self.assertGreater(lost.mean(), 0.1) # stressed: failures are common + self.assertAlmostEqual( + np.sum(weights * lost) / weights.sum(), 0.02, delta=0.005 + ) + + def test_weighted_summaries(self): + """Weighted histories give weighted statistics.""" + missions = pd.DataFrame( + {"value": [1.0, 2.0, 3.0, 4.0], "weight": [4.0, 1.0, 1.0, 2.0]} + ) + summary = summarize_missions( + missions, + quantiles={"value": 0.5}, + requirements=[Requirement("value", ">=", 3)], + spread=True, + ) + self.assertAlmostEqual(summary["value"], (4 + 2 + 3 + 8) / 8) + self.assertEqual(summary["value p50"], 1.0) # half the weight is at 1 + self.assertAlmostEqual(summary["P(value >= 3)"], 3 / 8) + self.assertAlmostEqual(summary["effective histories"], 64 / 22) + self.assertNotIn("weight", summary) + self.assertGreater(summary["value sd"], 0) From 4d66e11742ff2213775ec59041c8a749b613f435 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Wed, 11 Nov 2026 11:40:12 -0700 Subject: [PATCH 24/52] use rotated-lattice points and exact expectations of degraded missions in the trade space example --- CHANGELOG.md | 2 +- docs/examples/SearchTradeSpace.ipynb | 2373 ++++++++++++++------------ src/tatc/generation/points.py | 4 +- 3 files changed, 1239 insertions(+), 1140 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index bb9602fe..805ee2ac 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,7 +10,7 @@ Added: - Field `type` of a catalog configuration's `attitude` (`attitude`, `glint`, or `target`), which builds an `Attitude`, `GlintAttitude`, or `TargetAttitude`, as for OCO-2's glint mode. - Field `blind_intervals` of `Attitude`: intervals of argument of latitude in which a space system's instruments do not observe, for example while the body or a mechanism moves. Observations in them are not valid, so point observations, ground tracks (`valid_obs`, and the swaths of `compute_ground_track`), orbit tracks, and ground pixels omit them, and the periods and swaths of region observations end at them. Method `is_observing` of attitudes, schedules, and instruments. - Field `type` (`instrument`, `pointed`, or `conical`) of `Instrument`, `PointedInstrument`, and `ConicalInstrument`, which identifies the instrument class in serialized data. Data without a `type` loads as the class its fields imply. - - Function `generation.generate_points_rotated_lattice`, the points of a Fibonacci lattice in a random orientation: a stratified sample of the sphere (or of a mask), each point uniform by area, whose statistics vary 2 to 4 times less between replicates of trade studies than those of random points. + - Function `generation.generate_points_rotated_lattice`, the points of a Fibonacci lattice in a random orientation: a stratified sample of the sphere (or of a mask), each point uniform by area, whose statistics have about 1.5 to 4 times less variance between replicates of trade studies than those of random points. - Analysis methods of the statistical sufficiency of observations (module `analysis.sufficiency`): `estimate_sampling_error`, the error of estimating the mean of a field over a period from each target's samples, for a field with a standard deviation and an exponential correlation in time (exact, see `sampling_error_variance`), with the effective number of independent samples; `sample_field`, which samples a field (an xarray `DataArray`, such as a nature run) at the time and place of each observation, and `compare_sampled_means`, which measures the sampling error against it; `compute_revisit_statistics`, the quantiles of revisits and the longest gap of each target (including the edges of the period); and `compute_local_time_coverage`, the distribution of samples in local time of day. The decorrelation time of `estimate_sampling_error` may differ between targets. The validation notebook `ValidateSamplingErrorIMERG` compares its predictions with the errors of monthly means of IMERG precipitation sampled by four constellation designs. `estimate_sampling_error` and `compute_revisit_statistics` compute the statistics of every target at once (the sum of the correlations between pairs of samples by a recursion over their times, and the gaps and their quantiles from the samples in order), with the same results 3 to 12 times faster. - Module `tradespace` (prototype) for trade studies. A `DesignSpace` declares design variables (`Real`, `Integer`, `Categorical`), fixed and `Derived` values, and `Uncertain` parameters (drawn per replicate, not searched), grouped hierarchically with `Choice` (one of several branches) and `Repeat` (a variable number of items, such as orbit planes, optionally unordered). Bounds, derived values, and constraints are callables of the values decided before them. `DesignSpace.enumerate` gives every feasible design (a full factorial design, including variables that exist only in some designs), and `sample` a Latin hypercube or random sample. A `Design` has a `key` from its decisions and `flat` values by path, and `realize` draws a replicate's uncertain parameters, with common random numbers between designs by default. `Study` builds and evaluates designs in replicates into a data frame, recording designs that fail validation as infeasible, in worker processes with `n_jobs` (or on an `executor`); `summarize` gives the mean, standard deviation, and standard error of metrics over replicates. - Class `tradespace.SatelliteCache`, which caches an analysis of single satellites by their content (orbit, instruments, and attitude, not their name, see `get_satellite_key`), in memory or on disk, so that designs that share satellites compute their results once. diff --git a/docs/examples/SearchTradeSpace.ipynb b/docs/examples/SearchTradeSpace.ipynb index be134171..558ba191 100644 --- a/docs/examples/SearchTradeSpace.ipynb +++ b/docs/examples/SearchTradeSpace.ipynb @@ -9,7 +9,7 @@ "\n", "This example demonstrates how to search a trade space of constellation designs for Pareto-efficient designs with the `tatc.tradespace` module: declaring a hierarchical design space, evaluating designs in replicates (in parallel, with a cache of the analysis of each satellite), ranking them with the uncertainty of their replicates, screening them with a cheaper analysis, and searching the space with optimizers (Optuna and pymoo, installed with `pip install tatc[tradespace]`).\n", "\n", - "The trade is a sampling problem of a pre-Phase A study: how many satellites, in how many orbit planes (each of which needs its own launch), sample the Earth sufficiently often? A point is **sufficiently sampled** if an imager observes it at least four times in a day, and the objective is the share of points that are. A second objective measures sufficiency by its purpose: a point is **accurately sampled** if the mean of its samples estimates the daily mean of a field that varies within hours (such as convective precipitation) with an error of at most half the field's standard deviation. The points are a random sample of the Earth, so the share is a statistical estimate: each replicate of a design draws a different sample of points, which is the uncertainty of the estimate." + "The trade is a sampling problem of a pre-Phase A study: how many satellites, in how many orbit planes (each of which needs its own launch), sample the Earth sufficiently often? A point is **sufficiently sampled** if an imager observes it at least four times in a day, and the objective is the share of points that are. A second objective measures sufficiency by its purpose: a point is **accurately sampled** if the mean of its samples estimates the daily mean of a field that varies within hours (such as convective precipitation) with an error of at most half the field's standard deviation. The points are a random sample of the Earth (a lattice of points in a random orientation), so the share is a statistical estimate: each replicate of a design draws a different sample of points, which is the uncertainty of the estimate." ] }, { @@ -19,7 +19,7 @@ "source": [ "## Configure the Scenario\n", "\n", - "The analysis covers one day, with 100 random points in each of five replicates. A design may have at most 10 satellites." + "The analysis covers one day, with 100 points in each of five replicates. A design may have at most 10 satellites." ] }, { @@ -28,10 +28,10 @@ "id": "c3d2e5f4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T17:04:53.647588Z", - "iopub.status.busy": "2026-11-11T17:04:53.647330Z", - "iopub.status.idle": "2026-11-11T17:04:54.363946Z", - "shell.execute_reply": "2026-11-11T17:04:54.363121Z" + "iopub.execute_input": "2026-11-11T18:29:30.102760Z", + "iopub.status.busy": "2026-11-11T18:29:30.102510Z", + "iopub.status.idle": "2026-11-11T18:29:30.830083Z", + "shell.execute_reply": "2026-11-11T18:29:30.829355Z" } }, "outputs": [], @@ -46,7 +46,7 @@ "\n", "START = datetime(2026, 7, 1, tzinfo=timezone.utc)\n", "DURATION = timedelta(days=1) # the period of the analysis\n", - "N_POINTS = 100 # random points sampled in each replicate\n", + "N_POINTS = 100 # points sampled in each replicate\n", "N_REPLICATES = 5 # replicates (samples of points) of each design\n", "SAMPLES_PER_DAY = 4 # a point is sufficiently sampled if it is observed at least this often\n", "MAX_SATELLITES = 10\n", @@ -68,7 +68,7 @@ "* a **Walker delta** constellation (`walker_space`), with an inclination, a number of planes, a number of satellites in each plane, and the relative spacing of the satellites between planes (whose upper bound depends on the number of planes), or\n", "* one or two **sun-synchronous** planes (`sso_planes_space`, a `Repeat` of planes), each with its own equator crossing time and number of satellites. The planes are unordered: two planes in either order are the same design. A constraint of the building block requires the planes to have different crossing times (otherwise, they would be the same plane).\n", "\n", - "The points sampled in each replicate are an `Uncertain` parameter (the seed of a random sample, `Uncertain.seed`), drawn for each replicate rather than designed, as are the failures of satellites and the growth of the cost of developing the satellites (both used below). The replicates use common random numbers: every design samples the same points in the same replicate, so that differences between designs are not differences between their samples.\n", + "The points sampled in each replicate are an `Uncertain` parameter (the seed of a random orientation of a lattice of points, `Uncertain.seed`), drawn for each replicate rather than designed, as are the failures of satellites and the growth of the cost of developing the satellites (both used below). The replicates use common random numbers: every design samples the same points in the same replicate, so that differences between designs are not differences between their samples. The points of a replicate are a Fibonacci lattice in a random orientation (`generate_points_rotated_lattice`): each point is as likely to fall anywhere as a random point, but the points cover the Earth evenly rather than clustering by chance, so that the shares of points vary less between replicates than with random points (`generate_points_random`; here, with 1.5 to 4 times less variance), and fewer replicates estimate them as precisely.\n", "\n", "The constraint on the number of satellites returns the number in excess of the limit (a number that is not positive if the design satisfies it), rather than `True` or `False`, so that optimizers can tell how far an infeasible design is from a feasible one." ] @@ -79,10 +79,10 @@ "id": "e5f4a7b6", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T17:04:54.366198Z", - "iopub.status.busy": "2026-11-11T17:04:54.365843Z", - "iopub.status.idle": "2026-11-11T17:04:55.532151Z", - "shell.execute_reply": "2026-11-11T17:04:55.531317Z" + "iopub.execute_input": "2026-11-11T18:29:30.832202Z", + "iopub.status.busy": "2026-11-11T18:29:30.831943Z", + "iopub.status.idle": "2026-11-11T18:29:32.013063Z", + "shell.execute_reply": "2026-11-11T18:29:32.012311Z" } }, "outputs": [ @@ -143,16 +143,16 @@ "id": "a7b6c9d8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T17:04:55.534055Z", - "iopub.status.busy": "2026-11-11T17:04:55.533755Z", - "iopub.status.idle": "2026-11-11T17:04:55.543543Z", - "shell.execute_reply": "2026-11-11T17:04:55.542789Z" + "iopub.execute_input": "2026-11-11T18:29:32.015114Z", + "iopub.status.busy": "2026-11-11T18:29:32.014747Z", + "iopub.status.idle": "2026-11-11T18:29:32.027309Z", + "shell.execute_reply": "2026-11-11T18:29:32.026505Z" } }, "outputs": [], "source": [ "from tatc.analysis import collect_observations, estimate_sampling_error\n", - "from tatc.generation import generate_points_random\n", + "from tatc.generation import generate_points_rotated_lattice\n", "from tatc.schemas import Instrument\n", "from tatc.tradespace import (\n", " CostModel,\n", @@ -171,6 +171,7 @@ " count_planes,\n", " evaluate_missions,\n", " evaluate_phases,\n", + " expected_missions,\n", " summarize_missions,\n", " summarize_phases,\n", ")\n", @@ -195,13 +196,13 @@ "\n", "\n", "def get_cache(seed, duration):\n", - " \"\"\"A cache of the observations by each satellite of the random points of a seed over a duration.\"\"\"\n", + " \"\"\"A cache of the observations by each satellite of the points of a seed over a duration.\"\"\"\n", " if (seed, duration) not in caches:\n", - " points = generate_points_random(N_POINTS, seed=seed)\n", + " points = generate_points_rotated_lattice(N_POINTS, seed=seed)\n", " caches[seed, duration] = SatelliteCache(\n", " lambda satellite: collect_observations(points, satellite, START, START + duration),\n", " directory=CACHE_DIRECTORY,\n", - " namespace=f\"{N_POINTS} points, seed {seed}, start {START.isoformat()}, duration {duration}\",\n", + " namespace=f\"{N_POINTS} lattice points, seed {seed}, start {START.isoformat()}, duration {duration}\",\n", " )\n", " return caches[seed, duration]\n", "\n", @@ -220,7 +221,8 @@ " each design, and (if phased) their means over the phases of the mission as the satellites are deployed and the\n", " time until half of the points are sampled sufficiently, or (with failures) their means over the phases of\n", " histories of the mission in which satellites fail and are restored (by a policy, or the policy of each design of\n", - " a design space with one), and their worst 10% of the histories, and the cost at 70% confidence.\"\"\"\n", + " a design space with one), and their worst 10% of the histories, and the cost at 70% confidence (with the exact expectation over the\n", + " failures of the means of a policy that does not restore satellites).\"\"\"\n", " threshold = SAMPLES_PER_DAY * duration / timedelta(days=1)\n", "\n", " def sample(observations):\n", @@ -269,6 +271,12 @@ " growth=growth,\n", " )\n", " record.update(summarize_missions(missions, quantiles={\"accurate mean\": 0.1, \"cost\": 0.7}))\n", + " if restoration is not None and not restoration.restore:\n", + " # without restoration, the satellites fail independently: the exact expectation of the means\n", + " exact = expected_missions(\n", + " deployment, failures, members, cache(members), phase_cache, context=(d.points_seed, duration)\n", + " )\n", + " record.update({key: exact[key] for key in (\"sufficient mean\", \"accurate mean\", \"availability\")})\n", " elif phased:\n", " capability = evaluate_phases(deployment.phases(members), cache(members), sample)\n", " record.update(summarize_phases(capability, requirements=[Requirement(\"sufficient\", \">=\", 50)]))\n", @@ -276,7 +284,7 @@ "\n", " store = ResultStore(\n", " CACHE_DIRECTORY / \"results.sqlite\",\n", - " namespace=f\"{N_POINTS} points, start {START.isoformat()}, duration {duration}, \"\n", + " namespace=f\"{N_POINTS} lattice points, start {START.isoformat()}, duration {duration}, \"\n", " + f\"accuracy {MAX_RELATIVE_ERROR} at {DECORRELATION_TIME}\",\n", " )\n", " return Study(design_space or space, build, evaluate, replicates=replicates, n_jobs=-1, store=store)\n", @@ -302,10 +310,10 @@ "id": "c9d8e1f0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T17:04:55.545098Z", - "iopub.status.busy": "2026-11-11T17:04:55.544918Z", - "iopub.status.idle": "2026-11-11T17:05:04.739423Z", - "shell.execute_reply": "2026-11-11T17:05:04.738706Z" + "iopub.execute_input": "2026-11-11T18:29:32.029044Z", + "iopub.status.busy": "2026-11-11T18:29:32.028785Z", + "iopub.status.idle": "2026-11-11T18:30:12.233126Z", + "shell.execute_reply": "2026-11-11T18:30:12.232400Z" } }, "outputs": [ @@ -346,52 +354,60 @@ " \n", " \n", " \n", - " 1048\n", - " 800 km, 60 deg FOR, SSO: 1 at 09:00\n", + " 1054\n", + " 800 km, 60 deg FOR, SSO: 1 at 18:00\n", " 1.0\n", " 1.0\n", - " 4.2\n", - " 0.7\n", + " 3.2\n", + " 0.9\n", " \n", " \n", " 960\n", " 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...\n", " 2.0\n", " 1.0\n", - " 13.8\n", - " 1.0\n", + " 16.6\n", + " 1.2\n", " \n", " \n", " 963\n", " 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...\n", " 2.0\n", " 2.0\n", - " 28.6\n", - " 1.1\n", + " 30.2\n", + " 2.2\n", " \n", " \n", " 961\n", " 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...\n", " 3.0\n", " 1.0\n", - " 37.0\n", - " 1.8\n", + " 38.0\n", + " 1.2\n", " \n", " \n", " 962\n", " 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...\n", " 4.0\n", " 1.0\n", - " 66.4\n", - " 2.2\n", + " 68.2\n", + " 1.8\n", " \n", " \n", - " 1026\n", + " 965\n", + " 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...\n", + " 4.0\n", + " 2.0\n", + " 69.6\n", + " 0.8\n", + " \n", + " \n", + " 1025\n", " 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...\n", " 6.0\n", " 2.0\n", - " 98.0\n", - " 0.5\n", + " 97.8\n", + " 0.2\n", " \n", " \n", "\n", @@ -399,20 +415,22 @@ ], "text/plain": [ " description satellites planes \\\n", - "1048 800 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", + "1054 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", "960 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 1.0 \n", "963 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", "961 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 1.0 \n", "962 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", - "1026 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "965 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", + "1025 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", "\n", " sufficient sufficient sem \n", - "1048 4.2 0.7 \n", - "960 13.8 1.0 \n", - "963 28.6 1.1 \n", - "961 37.0 1.8 \n", - "962 66.4 2.2 \n", - "1026 98.0 0.5 " + "1054 3.2 0.9 \n", + "960 16.6 1.2 \n", + "963 30.2 2.2 \n", + "961 38.0 1.2 \n", + "962 68.2 1.8 \n", + "965 69.6 0.8 \n", + "1025 97.8 0.2 " ] }, "execution_count": 4, @@ -463,16 +481,16 @@ "id": "d0e9f2a1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T17:05:04.741067Z", - "iopub.status.busy": "2026-11-11T17:05:04.740831Z", - "iopub.status.idle": "2026-11-11T17:05:04.950445Z", - "shell.execute_reply": "2026-11-11T17:05:04.949702Z" + "iopub.execute_input": "2026-11-11T18:30:12.234938Z", + "iopub.status.busy": "2026-11-11T18:30:12.234678Z", + "iopub.status.idle": "2026-11-11T18:30:12.444235Z", + "shell.execute_reply": "2026-11-11T18:30:12.443408Z" } }, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3oAAAG4CAYAAAAT7JXuAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjIsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvgI3uAAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQeYE+XXxc+kZwvb6b1KR5ooCiJYUGyIilhQQVGxF2zY+9/uJ3ZFLGAXBKQpSJOO9N6Xur2ll/me+2YnJNlkN7ubbdn788HslEwmk8nkPXPvPVeSZVkGwzAMwzAMwzAMEzWoanoHGIZhGIZhGIZhmMjCQo9hGIZhGIZhGCbKYKHHMAzDMAzDMAwTZbDQYxiGYRiGYRiGiTJY6DEMwzAMwzAMw0QZLPQYhmEYhmEYhmGiDBZ6DMMwDMMwDMMwUQYLPYZhGIZhGIZhmCiDhR7DMAzDMAzDMEyUwUKPYZiIMnnyZAwbNixi23vwwQcxYsSIiG2PYVq3bo0vvvgi5HRdYsWKFWjfvj0cDketPqY1cYxrwz5UhH379kGSJBw9ejTkOsuXL0e3bt2g1Wojfn3ctGmTeP2srKwq3S6duzRttVrDfk5Z0xXhwIEDaNSoEbKzsyu8DYaprbDQY5haxPPPPy9+tAL/xcXF1fSuMUyF+O6774Ke03l5eVF9RJs3b46vv/66yl+HboQ888wzYsBfl/a7ul6nvPtQG/YrHO677z5ceeWVQiTNmTOnpnen1rB+/fpyX1/atm2Lyy+/XPz+Mky0oanpHWAYxp9WrVrh0KFDfFiKee+99/hY1HHobvnJkydRW6mr37d//vlHRH+uv/561HZq4hgHvmZd/ZyDQZ/7gAEDoFarUVfo1asXZFmO6HMqss1gjB8/XmSivPzyy0hISKj09himtsARPYapQyxYsAA6na5EislTTz2Fnj17+kVRKK3HYDCItK7XXnsNLpfL70ftiiuuwD333IPk5GS0adMGixcvFtvOzMz02/bjjz+O3r17B90ft9uNJ598EikpKUhLS8O1116LjIyMEuuVtT/r1q3Deeedh/j4eCF06TUtFkvQ1E163qOPPur3mnfeeadfuqjy/u6//360bNkSSUlJuOmmm1BUVFSu403bufTSS3HbbbehRYsWIrJ66623CtEyduxYJCYmin2g41/e9/z66697o1s0sBg8eLA4DoGvX973QYMe2jYdR/o8u3btip9++qlazqFIEWrbFL14+OGH0bRpU8TGxqJ///5YtGiR33NTU1Px3HPPYejQoeK40uf26aeflvp6gSl9dO498sgj3s98+PDhYmCtQANs5bOjfaHzw/d40uDz2LFjYj6tQ8cw3P2nfe3YsSNiYmLE5+H72QUyY8YMXHjhhd7tl/X8qtzvsvA9xtV1fEpL3Qy2D5XZLzrvKCJ0/vnnw2g0iusWsWfPHnEu07WN1rnmmmtw5MgRv+f+/fff4ntK2+7Tpw8WLlwY8j1t27ZN7JvJZBLbpb/pu0r8+++/GDhwoNjvhg0b4t577/VeR31TJadNmya+0xqNRtwsCIdw3sf8+fPRuXNn7/v46KOP/FJQQ6VZ0nlM1xr6TPv164eNGzd6l5WVmum7nIQ8PZ+gayXNp5sg9LkH3jDcuXOnWL5lyxbvd4Ne/48//gjreDBMnUFmGKbW8Nxzz8mtWrUKudzpdMqNGzeWP/74Y+88t9stt27dWv7f//4npqdNmyY3adJE/uuvv2STySRv2LBB7tChg/zaa695nzNu3Di6BSo/++yzck5Ojnc77dq1k99++22/16Nt/d///V/Q/Xnvvffk1NRUefHixXJeXp7YB9ru0KFDveuEsz8tWrSQH3/8cTk/P18+fvy4/NZbb8lz584Vyx544AH5sssu86775ptvitdcsmSJeE3a38DXVN7fq6++Kufm5so7d+4Ux/WZZ57xrrN8+XKxzrp160Ieb2U79L7otdasWSPHxMTISUlJ8vvvvy/2l7aj0+nk+fPnl+s9+0KfwfPPPy+npaWJ1ynP+whkypQpcmJiojxv3jyxrU8++URWqVTyypUrq/wcCsa3334rq9VqsU/0b/DgwfKyZctCrl/atq+++mr54osvlnfv3i0XFRXJ06dPl41Go7xlyxbvOikpKbLBYJB/+ukn8fl89913slarlf/++2/vOnQMP//885DTI0aMkDt37iz/+++/ckFBgfhs6fMJhI7bvn375GHDhsnXXXed37JmzZrJU6dO9ZtX1v6vX79enEsLFiyQLRaLvG3bNnn06NHiMwtGly5d5Ndff907He7zI73f4RzTwOnqOD4V2YeKvn867xo0aCDPmTNHtlqtYt6pU6fkRo0ayS+++KKclZUlZ2ZmynfccYfcvXt32W63i3XoekfXFLr207lO31P67tH5n56eLodCr9fLs2fP9k6fPHlSjo+Plx977DE5Oztb3rhxo7ie33nnnSWuef379xfXEjoPgvHff/+J9Wh/w30ftK/0vaP3QdeqVatWiWPp+z4Ct6vsD33Xtm7d6t0uXZ/ouhPsOWVN0/WcpmkfFF544QWxr748+uijcp8+ffzmXXrppfL48eNDHnOGqYuw0GOYWgT9SNKPVOA/XxFDwufcc8/1TtOPJQ3kjx49Kqbbtm3rN5hRBu7t27f3G0h36tSpxOuToOjatat3+o8//hADilAD+ZYtW8pvvPGG37yzzjrLb3/L2h8aKND+L126NOhrBAq95s2bewWJwtlnn11C6J155pl+6zz11FPy+eefX26h17t3b795tC/nnHOO3zwSL5MnTw77PYeCBkazZs0q1/sIhAazNCDz5corrxT/quMcCmTmzJnyRx99JAaLx44dkx966CFZo9GIQXsogm2bBtWSJIntBA7CadDmO+CmwaIvN954o985VJoAoAEynRerV6+Ww4XOIRKTvoIjUDCEs/+//vqrEPsOhyOs1yVh8dVXX3mny/v8SO13JIReVRyfSAi98px3kyZN8luHvocDBw70m2ez2YQgWrFihZimmxkkdHyhmzDlFXr020HfT1/x9vvvv4ubLCTOfK95dAOjNALFUzjvg65/dOPBl08//TQsoafc1CNIwNOxVD6nSAg9en06Dsq1ns4fEq50U8yX2267TQh6hokmOHWTYWoZlHJXfBPG+++vv/7yLqfUvZUrV+Lw4cNi+vvvvxfpQs2aNUNubq5wEJswYYJIy6H6DZVKJdIMDx486Pc6Xbp0KfHalJa4e/durF27Vkx/9dVXuOqqq0QaTCCUOkSpO3379vWbr6TOEOHsD5lIUOolvQ6l6v38888oKCgIemzoNSkNiNKCfAncB6JDhw5+0/QeaH8Uzj33XHFsgz3XF0px8oXSNYPNU7Yd7meQnp6OMWPGiHQwWofSiChtLDAdqqz34YvZbBbnxVlnneU3/+yzz8aOHTuq5RwKhAwj7r77bpFKRu/1nXfeESly77//fqnPC9w2mSzQ50Xb8N2v33//XeyvL8HOSd/3Xxr//fefSH2j9LxQ0PeRUo2V9DDaPrlenjhxIuRzwtl/SjelVFVKSaT002XLlvmlywYSWJtU1vOrar8jQVUcn+raLwVKvwx8LqVT+j5Pr9eLVFDluXRelnYNDRfaDj2PPlff7z0dH7qml7afZRHO+9i1a1dY1+Vg+K5H373u3buH/X0NBzLYufjii8XvGTF37lzk5+eL6y/DRDss9BimjkE/ilSjMn36dDFII2FEA3elZo6YPXs2nE6n+JGneTRQoWlfqE4rkCZNmoiaNPpBpFo7+kEcN25cqfvjO7AIJNz9+fjjj0VdCg2mqJaCxG6w2hFlYBv4msGK8Uvbr/IQbDuReM833nijqJ+h90kCjZa3a9euxOdUnvcRypSA5vtupyrPoXCgepy9e/eWuk7gtmkfaBBos9lK7Nevv/4asc++LGMHEuNUq3T11VeLwS3ty9atW8WywONT3v2nmsLNmzeLGksaiN5yyy1i8BzKQZBqCH1Nbkp7flXudySoiuNTXftV2jk7atSoEs+jfzfffHNEr1XBzttQ18vyfm/DeR+B15hQ+xSMSF2ry6r7pVpAEqf0+zZy5Ehxg86XU6dOCVHIMNEECz2GqYOQSKAoDBW/U5SLCuMJMigh04558+ZVeNt33HEHfvjhB3z22WdC+NFd9GBQwT29VqCBiO90efaHxAf14KNIExmrfPjhhyXWIWMM+iGmO8y++Bbv1zThvGcaAK1evRoTJ04UgovujtMgQ4mwVRT6TEgkKxFZhTVr1giThOo6h8qCDCVI1JcHMgSiQVo45hHBzsnA91/W6wRuwzfiRxENMucgN1GKcAQebyVSrYjm8uw/nQtk9U43PCiqQVHUUPb5ZLwRuJ+hnl/V+11equP4lHcfKrNfwaDnUtSRbuSUFrkOvJ6FOvdKg6J09DxfcUXfe/qc6RpTGcJ5H/T92rBhQ4Wuy77vl4413YAI9/saiNJmJPBzpXOGBDvdVPzzzz9x++23B92PQYMGVeh1Gaa2wkKPYeogNEjfvn276J9Fd+kbNGjgXfbCCy8IZ7opU6YIRz1Ky6IB/QMPPBDWtslhkATVSy+9JFI5aXAYioceeghvvvmmGATRHXb6mwYXvpS1PxRpuO6668TzaCBB7obkiEbRrWDQ89566y0x8KDXpAEfpRWVF8WBLnCQFQnKes/0ujT4+vbbb8V7oPQniqiVFlkJl0mTJon0SIqQUgosuQxSdI7mV9c5FHjjgAZWlBJK2yGhQaKD+oCVhzPPPFOkgdL2yCGWxCmlpFEKH92p94WOq5ICTPtNzox0rob7OhTVpoEgnZOFhYXCqZSOCUGfG0Viabt0vi5ZsgRPP/10ie2Q4Kbn2+32sPef3BDpdSjaSREkZXBNfb6CMXr0aOHYqDgrlvb8qtzvilAdx6e8+xDp90+p6CS8brjhBrHP5Ja7atUqcVNFcTulFGkSq+TYSZFJWk7X3vJC6dF0s4hckHNycoQb5WOPPSYyMujmTWUI933s379f7Du9DzqG4b4P2k+6+UPOmeQwTOK0ommVdCOQfrPohqGv6KW0U0o/f+KJJ8Q6F1xwgd/z6KaH4mTKMFFFTRcJMgxTthmLb7G5rwEJzSfDlEB+/PFHYSJCBftkLnDLLbfI+/fv9zO7uP7660Me+qeffloYEBw8eLDUj8flcgkDAnKhJCfMa665Rhhh+BqjhLM/5JA4YMAA4T5Hy++9917ZbDYHNWMh44hHHnnE7zVvvvlm4ZhW2vsjt86ePXuW24wlcDtk7DF27Fi/eWR0MnHixHK9ZzL96Nevn1hOLntPPPGEfMYZZ8jvvvtuud5HIGTGQO6Y5GRKRhtkkED7EoyqPIcUyE1v5MiRwmCBPi86N+jYl0aobZNRw5NPPilMNch9kY7Xyy+/7HXoI+h1yOBiyJAhwqyE9p3MYMpj0kHbu//++4X7X1xcnDx8+HDhUqnw2WefeY9vt27dhEssHUff7ws5i5KxEe0nHcNw9r+wsFC4e5LDKbk60vN9zVaCQZ+Rsk5Zz6+q/Q7nmAZOV8fxqcg+VPT903k3Y8aMEvtA582oUaPE9YrOJTJBIpMUXxYuXCgMWeg9kfnShx9+WG4zFoIcO+k7Tcvou0bXJOU66nvNo/dTGoEGJ+G+D3L6JRMl5X0o51dGRkbQ7Sr78+WXX4pjTuYu5ITpe00urxkLQQZhdE2l3zDf68jevXvFusEcdOl3K/AazjDRgET/q2mxyTBM7YLMUSjK5GsCU5uhXmKdOnUKmu7J1C+oxxedBxTtqg9QZJoiFVR3p6StMR7IXIiyDNh0o2ag6DFFAymaX1pmSHVBmR9kRkS/bRS5VaBpMq6hDAe6fjBMNFHz3zyGYWoVlEJDP9DhprpVNzSgpZQgSvmktCFKU6SUKjJmYJj6BrnHUsocizx/qM6LUhkrWuvFlB9KD6c6PUqBpLRaSg0ms5baIPIoxZd+N8iExVfkEZT6S+cKizwmGqn5bx/DMLVq0EjW/ORQdtlll6E2Qu0GKBGB7sy2bt1aGMeQO2hpdvgMw9QfqG6X2oVQPSjV2DHVA9W23nvvvcLs57bbbhOR1LfffrvGDz/VKcfHxwsn6Xfffbemd4dhqhVO3WQYhmEYhmEYhokyOKLHMAzDMAzDMAwTZbDQYxiGYRiGYRiGiTJY6DEMwzAMwzAMw0QZLPSKIXMHaq7L3SYYhmEYhmEYhqnrsNArprCwEAkJCeKRYRiGYRiGYRimLsNCj2EYhmEYhmEYJspgoccwDMMwDMMwDBNlsNBjGIZhGIZhGIaJMljoMQzDMAzDMAzDRBks9BiGYRiGYRiGYaIMFnoMwzAMwzAMwzBRBgs9hmEYhmEYhmGYKIOFHsMwDMMwDMMwTJTBQo9hGIZhGIZhGCbKYKFXT9m+fTuee+65mt4NhmEYhmEYhmGqAE1VbJSpOgoLC3HbbbeJv2NjYzFt2rQKbSczMxNLly6N8N4xDMMwDMMwDFMbqBVCb/Xq1di1axcuueQSNG7cuMRyp9OJ5cuX49SpU+jevTu6du1aoXWqk3yLC1vTLcgzu5AYo0b3FkYkGNWV3q5er8fo0aNx8uRJTJ48OSL7yjAMwzAMwzBMdFGjQm/+/Pl44okn4HK5sG3bNixZsqSE0MvJycGFF14oHrt16yaiULfffjvee++9cq1TnWw/ZsG8LQWQ5dPzVu83YXiPBujazFipbet0OowaNQr79u0rU+ht2rQJc+fORadOncSx7ty5Mx544AFoNP4f+6FDh/Doo49CkiSkpaXhhhtuwHnnnee3DRLOc+bMQbt27fDwww8LwUkcOHAAn376qRDYAwYMwPjx40tsn2EYhmEYhmGYelSjRwLv66+/xrx580Ku89RTT8FisWDr1q2YPXs2Fi1ahA8++AALFiwo1zrVGckLFHkETdN8Wl5dUNTvjTfewB9//IFzzz0XM2fOxIMPPlhivaSkJBElvP7664Wgu+WWW7Bz507vNv73v/8JsTdo0CBxfGlaEYiXX345mjZtimHDhol1Hn/88Wp7fwzDMAzDMAzD1EKhd9lll6FXr14hl8uyjB9++EFE5+Li4sS8s846S/ybPn162OtUJ5SuGSjyFGg+La9OKEJHdXy33norfv31V3z11VfimPmSkJAAh8OBhQsX4p9//oFWq/Wr32vVqhU+//xzIQDJwGXVqlViPkXy1Gq1SJklEUnps7NmzarW98cwDMMwDMMwTElqdY5deno68vPzS9TbUXrmxo0bw14nGDabTfxTKCgoEI9ut1v8qyi5JmcJIeVLnslZqe0rKNsobVu0rHnz5mJ/6F9qaqpIz6T36vv8qVOnijTXu+66S6xjNpuF6YtyLJo0aeJd32g0iuU0ffz4cfTt21fUVioYDIaIvD+GYRiGYRiGqW+oVKr6IfRIwBGJiYl+85OTk73LwlknGK+99hpeeOGFEvMzMk7AYimq8D7LNifMJmfI5W6bFadOVXz7CllZp4R4O3XqeMh18vKyRY3djh1bkZKSgjVr1orjZDYXIjc3G3a7TTx/xYrlGDnyKowceSXsdjteeuklFBbmi2W0DWU9Iicnyzvdvn1bzJs3H88//4yIAiqUtk8MwzBMdELlGP/+u0pkfdDNQrrx16NHdwwdOhQxMTE1vXsMwzB1giZNmtcPoUfRI8JkMvnNpx8QZVk46wTjySefFKYiChTlatGiBRo2bIIGDRpUeJ/Pa+DCnpxsuIME9VQScF73lEq7b44bNw4nTpAgteDeex8QUbVgtXGJiSnC3GbMmJtFVG7t2rX4+OOP0ahRUyQlpUCn04u/r7/eU5+3bt0G7N+/X/wgx8cniGW0DWU9Ijk51Tv92GOPY+XKVRg0aAh69uwpTFjOPvtsv+PKMAzDRD/z5v2Jt99+CxkZGX7zqRzgyy+/wi23jMWECXdF9E41wzAMU4eFXsuWLUWkiEw/fKFpcn8Md51gkGuk4hzpC/0IVeaHKClWheE9E0oYskgShOtmUuzpyFdFGTlypEg7JYdLgkRcsH2meW3atBG1ihs2bECHDh3QunVrsYxaUFBEk9ah1Mv//vsPe/bsQY8ePYR7Kbl70rI+ffrgmWee8W6fUmSV59HdWnLzJBMcEohUo0epovxDzjAMU3+gOvmXX37Rm01z5ZVXid9m+i2ZM2c2Dh48iI8//kjcoHzppZdFCUF9Ze/evUIU33//AzW9KwzD1AMkubSCsmri6NGjIppG7RXOP//8EoYtlE5ITpoE2fiTOciHH37oFTrhrFMWFNEjUxJK96xMRC+wj16+2YWECPbRKw8kwqj2jh4ZhmEYJtJQa6QxY0aL2myK2j344EPiRqECDTFmzvwdzz//nEjtfPbZ53DdddcH3RbdLPztt1+xbt062GxWXHLJpbj00ksjsp+7d+/GokULce+991V4G5QVM2/eXBo64dJLL0O/fv0qtI2PPpqCr7+eVuH9YBiGqRMRPeoFt2LFCuTm5oppEiQUiSMnTsWNk9oDDBw4ENddd53o00bGIbRs7Nix3u2Es051Q6Lu3I4eF9Ca4swzz+Sm6gzDMExEEPeFbRZAb/RG5b777lsh8i666CI89tikEtE6mr766pHid/6dd97Gt99+g2uvvS5oVO+ZZyaL7BBq90M3Xtu0aRuxTy4nh2rW/6vw8//880/88svPGD58uCgNuffee/DBB/+Hs84aELF9ZCJ7bnrnO02AJrbkfJsFss4AyWUWywVB1mU8x8vk9BgYxmr0QY8PrWN22RGj1vHxq0XUaESPRN4XX3xRYv5VV10l/imQ+KO2ABSpo5RDitJR2qAv4axTnRE9hmEYhokWXDknYVs3H3JRHqS4ROj7XYIitRHnnz9ItOeZMeMHdOvQvsRAW4Hq6IcMGSxcm6dOnVYiGrZr1y7ceustWLjwrzJ/g6l0gQQj9Xt1OOwYOPBcUWtO2UH/+9/rIuJGKaQUdevfv794ztixN4sUUroJ3LZtOxF5LA95eXl+pm8vv/ySaOkUbDs7d+4QtYmtWrXGypUr0LZtWxHtpDITjuhV0bm5dj7c+VmQGqRA32cQ1Glt4So6DPvuL+CWzVBrEqHrMBbquFbec9ldcBBu9Q6oGqZCMiaIbUmyE5I+Fbo2N0ClT4GsjoFkt4Y8r6MZRbjl2syYdmgNNuQcAWSgb0or3NK6P5L0MV5Rd8ych9+Pbkau3YwkXQyubt4TzWISw34NFodRGtGjJt70ryyoruzFF1+s9DoMwzAMw5QPGowpIk9MF+WJ6SNNewuRl5aagnbHN8K8Z7FXBKqTG/ttIzY2FgMGnI3Fi//Gvn17Swi9zZs3oW/ffqKmj9yizzjjDIwZc2PQG7ZffvmFSBm94oorhHhq1szjUEc3a6k+kMjOzsazz07GlCkfoV279jj77HNQWFgklge6dIeD73MogkmvP378HUHXpdeeOvUrEeWkLCPqYXvs2DGRtspE/ty0Lv0ZjgNbILtygLh0OPO+g6p5JziPLobsKAScMiRNMzgOboVx0PtwbFgId2EuXM4NgMME14lCSPEeQz91Sn+4iw7AtGoCJENryJnZULm6QNWgTdDzOlpRhFuOzYRdBaeQ77CQxhOszDyA7XnH0alBIyTrY3FVsx6YeWyLEHkEPdJzJ3YYFFIc0+e2rzAT80/sQJ7DUi5xyESRGQvDMAzDMDUMpbgVizwFmnZaLeJvrdtZQgQaLxpbYpCn1O5RLV6wiNnGjRvQrFkzDBo0SKRJ7tixA2+99XaJdclxOj4+Hi1atBSCUK321L/TPJPJjLVr14gsHXr99evXC6FHztDr16/D0KHDKn04Xn31FRGlGzYs9LaSk1Pw0kuviH2giONFFw3D5MnPVPq1GX9kq9kj8ijqFncQsmyDK98Cl/sQ4MoCHFpSFZDt6XBb42Bb/StgdQGwA7JH3MkOM0D/JAmy7IA7fxdkpxnuPCckhwsuaQNQmBjyvI42SIQp0Tmn7Ea23YRsmwkN9Z5ypFO2Qrhkl1hG6/yUvhFFDpvfcaH5FpcDMZrT9bp+IjJ9Exaf2kPBd7SPSxPzyxKHTMVgn2OGYRiGYUJDaWtx/nfaabphU08k7VReATIKTrc4EqKPBt4+kBHLtm1bxd+NGjUq8RIpKalIS0vDk08+hREjLhciacmSxZ5aqgCoTQO5TU+e/DSGDDkff/zxh5hPkbNp0zw1+ldccaUQeJQqGiloX1588QVRo0fuoaXRuHEj74CV0kjpbxKoTBUhOSGrPDVkkF2AS/nbXbyCA5B1kC0OqIxUj6cDJE9dnqSN8fzTGD2i0GkGVHrAXnxDQghCe9DzOhoR6ZrF0TmNpEKM2uMW74Ys/hGUaknLCBJ58Vr/yDtF6IzFzwsmIjNshbC6nbC6nNhXlCnmK+KQiSws9BiGYRiGCQmJFEpbU8Sekp5J0bfevfvA5Zbx+/qdp9en9XT+A7/ly5eLGjqqvzvvvEElXoNq6Siqp/TETU9PF+sGu7uv1Mb9/vtMvP32O/j004/F/F27dgqROGrUtSIqePz4ce9zqJ2SzWav8KdM6ZokLEmsvfrqa94oYiio5pBSOAlyEaXUT0pfZSKLZIiBpm0PQBsLya0H1GpICY0haWIAieruiiNKcgxUmrOgbpAM3YARUMUnQa3pA8mQCnWTNlCnDRT/JKo506dCndQFkr74HBaCUBf0vI5GSMSRUCPo+9chviFaxSaL+fSP/m4fn3b6RoY+Fte2ONP7HCUNM9h3VxGRGkkNg8qTVEhij6KDocQhUzk4dbOeQj+4q1evxqhRo2p6VxiGYZhaDtUmUdqaiGiQU2HxIO6GG8aIlMtvVmxC9xYNMfDMHh5R6DPII7O0F17w1KeRA6fRaCyxfeq7N2LECFxxxQhhlrJ9+zZMnvxs0H35/PPPsHXrFrjdshB3FL0jLrjgAjz44ANYtWoVjh5N9xNWFN07ePAA7rzzDnTp0gW33nqbqOF7++13RZ0fQc+dPHkyUlM9qWS+/PjjD6J+kETqQw95euBR3R+9/2BQdHL8+HFISUnG9u3b8eKLL5VYh4Rt4D4w5YPOM+PgayEZ4+DObwS3ZjfUjdIAqQtcJw7CLedBtjqhNp4HTWJbb52duvhclrV6SC4LQMKQcJrhsmbBcWgG0FgDd0aWp0YvPqnEeR2tCKfc5j296ZstY5Nxf8fzvUKO5ik1eb61dZR2SRE5EmuhjpMiIum5JBapTo/SN9P0cSHFIRMFffRqA3XJdZOa0C5YsEB8IS6++GIkJSWVexvkCPb888+LR4ZhGIapaKTrscceEb9JFOW66KKLRfsEEm65uTkirZJ641GkrkOHDvjmm+9ELV1pDcUzMjLQqVPHoIKL2LJlMzIzM6HRaNG6dSvhbqlw/PgxHD58GB06dER+fp4QUC1btvL+du7YsV0IzW7dumPFiuUYMuQCqFQq4cj5xBOP4/vvp0OjKXkP/PDhQ6IllC8U0TzjjM4l1qXtfvvtt6K+kBw4qZaQUk0JajNBgpMioeQe6rsPTMURQ9kA4SbmWXIgG5Kgctr9blCEtT2nGbLaCMlhK9dzowU6BqGEW2nLysLPoVNrxCVNu6JdXGq9O77VBQu9Oib0KP2FWkf06dNH7CtZNf/777/iB7Q8sNBjGIZhIgG1OKAbh7NmzQy5DpmhfPDBh0hJSamVB/3ECUrzlLyCrDIoQu/TTz+LyL4xTLRRGaHIlA8WelUk9NymAjgPb4e7KB+quARoWnWFKrby292yZQuaN28uiruJMWPGoH379kFbS9Bdzf/++0/0FSSB2LlzZ5x11lklhB7dGf3+++/Fl43STS655BLv9pVtUHE7rduuXTucd9553tew2+3iTi71L6Rt02spUGooPZfuWvbo0UOk1TAMwzDRCblkUoojmajQbypFzvr06SsaoJ9zzsB6E7Wi2jyqMaTfTYZhmJqkflx1qxnn4Z2wLPgajp1r4ErfJR5pmuZXFhJMiggjyFGsadOmQdelZrIPPPAAbrjhBtGcnprQf/yxp2jdFxJrVENBqSuzZ88WP06UOqNs48EHH8RNN90kIofXX389vvnmG7GMnMfOOeccMU0W1ldeeSU+//xzsWzq1Km48cYbsXXrVrFtpSidYRiGiU6o9u2FF17EsmUrsGnTFqxatQYffjgF5557Xr0ReQRFLVnkMQxTG2AzlghDkTzbhkU+lr7FyG4xX5XaLCKRPYKicEeOHMHYsWNDrkNCcMmSJaIonRq8DhkyBHfffXeJOgMShBT1o/oB2ua8efO826UQ++LFi0UPpF9++UW87i233IIpU6aI+sCBAweK9aju4oMPPsAdd9whUkpvv/12PPnkk/XqB55hGIZhGIZhagM8Ao8wlK5ZQuQpyG7P8ggwffp0vP322yJtMpiDmULXrl29zmPdunUTwo9SanwhEdevXz+xrQMHDohUy6ysLO9ySvlUGt02btxYiEEl2keF+BSxo38OhwNXX321WEbCce7cueLOJs3bvHlzRN43wzAMwzAMwzBlwxG9CEM1eaUhm/xFVkX48ssv8eGHH2LRokVITU0tdV1yCXM6ncJFjOrtyBUtsAbx999/F5bSlKJJDB8+PGiT2kBatfI4mb333nsllp1xxhki1ZNSNr/77jvcfPPNor6QYRiGYRiGYZiqh4VehCHjFVcpy6VKpm3OnDlTpF4+/vjjQkApkbphw4YFXZ/q76g30bnnnosZM2bgoYceClr398Ybb4hGsJs2bcKGDRswdOjQMvfl3nvvFe6f1113nWh2S2KS3D8vu+wyUeu3f/9+EfFbtmyZMHFhGIZhGIZhGKZ6YKEX6QPaqiscu9YFT9+UVGJ5ZaA6uHvuuUcYodA/ojQ76N69e4toHUX/nn32WWGmQpBzp9Isndo1UHonOaaROxoZr8TFxYllrVu39qZjKvV8yvMaNmwo6v4ojZREHUUOExMTxTIyc6F0TuphRMKP3EEZhmEYhmGY6IUywswuu2iOzq0Tah5ur1AF7RXIXbOEIYukgr7PhdC0KtlctaqYP3++SKukR4ZhGIZhGIapKo6acvFT+kYUOWxI1sfi6uY90SzGEwBgagaO6FXFQW3VWbhrkvEK1eRRumak+uiVh8BoHMMwDMMwDMNUhch7fPMs5NrNMKg1aB+Xht+PbsbEDoM4sleDsNCrIkjU6bqcjZqEDFHoH8MwDMMwDMNUVbrmz+kbhcgjrC4n9hVlIk6jh8XlQIzG49zOVD/cXoFhGIZhGIZhmApBNXmFDhsMqtPxIxJ7cVo9jGotH9UahIUewzAMwzAMwzAVgoxXqCavfXyaV+wl6WJwXYvenLZZw3DqJsMwDMMwDMMwFYLcNcl4hWryKF0zXmvAtS3ORPPYJD6iNQy7blaB6ybDMAzDMAzD1LdaParJo3RNbq1QO+DUzXosbKlvHsMwDMMwDMNUFhJ3ZLzCIq/2wEKvjnL8+HHs2rVLNCmvCBs3bhSN1xmGYRiGYRiGiT64Rq8ORuJuv/12rFu3DlqtFg6HA3PmzEH37t1retcYhmEYhmEYhqklcESvisizW/DPqb34PX2zeKTpSJCRkYHx48fj8OHD2LdvH6644gpMmTIl6LpUb0hRP5fLJR6LioqCrmc2m7F69WqsWbMGBw4cEDnWgdtwu93iMS8vr8TzMzMzsW3bNlitVr/59Hr//fef2PbBgwcr/d4ZhmEYhmEYhgkPjuhVAVvyjuGPo1sh47RgWpG5H1c0744eic0qte327dujTZs2Qjzl5uZi7dq1eOSRR4Kuu2rVKjz++ONCuJFQO3bsGH755RcMHTrUbz2a/+CDD4q/T506hebNm+Ovv/6CXq8X23jiiSegVqtF9PDIkSOYPXs2zjvvPLHN2267DUuWLEFycrIQoT/88AMGDRqExYsX47rrrkPLli2h0+kwcuRITJo0qVLvnWEYhmEYhmGY8GChF2Eochco8giapvktY5KRqDNW6jUsFosQZidPnhRCioRVKPbu3YutW7eiXbt2mDlzJiZOnCgic7506NABK1asENE8Eo9PPvkk/vjjD1x77bViOYk72kazZs3w8ccf46OPPhJCb+rUqcjKysJPP/0k1qOIIAlLEoc076WXXsLdd99dqffKMAzDMAzDMEz5YaEXYTblHi0h8hRoPi0/v1GHSr1GXFyciOgRFCW79957RaQuGH379hUij7jqqqswZsyYEimcu3fvxsUXXyyidqmpqTh69CjS09O9y/v06SNEHkG1gIqw+/fff4VoVKKBBD2foAjeTTfdhN9++w3Dhg3DnXfeiaQk7qfCMAzDMEztQZSrOE2AJpbdIpmog2v0Ikyu3Vzq8jxH6cvLwmaz+U2fc845QpiFgurnfI1cKN3SaPSPKH766ae49dZbsX//fhGVu+CCC8R6CiQAfVFq+Kjf4KhRo4ToVP6RMQxx0UUX4dChQ3jooYewc+dOIfwYhmGYugdd82Wr2a9+uyLrMEyVnJuOIm+Jirsww2/8Utb56So6Auu2N2DZ/Lx4pOmyXieaofdnctpKvE+aLnJYxb9oPwbRBkf0IkySLqbU5Yna0peXxbfffovt27dj+PDhIs3y+eefx9ixY0OuT+mYVGNHUTVKuSTBFSjcqL7un3/+EbV2mzZtElG4nj17lrkv5P5JKZyNGjVC//79odFokJKSIlJB9+zZg5ycHCQmJoqaQhJ7DMMwTN3ClXMStnXzIRflQYpLhL7fJVAnNy7XOjQwNLvsiFFzfy0mgudm0RHYD06H25oJt7UQrpNHAbsJKkNDGM6aBG2jziJK5849FfT8JEFo2zcVsqNARPJkW5bYnr7rJMBmAdRuSNo4uE3pYj4tl/Sp0LUZA3Vcy6j7KI+Z8/D70c0iYEFj2aub90SzmEQxf9rBNViffRiQgD7JLXFrmwFimS/Bvudlfff52lD1sNCLML2SmgvjlWDpmxIksbwyjBs3Dp9//jneffddGAwGPPbYYyIaF4ohQ4agcePGePPNN9GlSxdRN6dE42iaoKgbGam88sorIk2TxGPTpk3FMhJqnTt39m7P93mUxkni8L333hPikHr6UTTw1VdfxZdffomlS5eKFhAdO3bE9OnTK/W+GYZhmOqFBmHKAFlMF+WJaeNFY/0GcqWtE2rwyDCVPTeFyCs6AGfeDrgytwFOF2BtDHfRKZiW3gJtx+FQG9LgTtcBFrXf+akfOAT2/V/DcXQ2JI0R6oTOkLQN4Mo/DPO8N+AqWAlonVC36A1J44Yke3oWK2LQ0O3xqErzpOOpfE8JeqTpe9qfh9/TNwmRZ3V7jsGGnCNooDHg3o6Dvccg2PecKO27z9eG6kGSOQbrTWtMSEgQ7QRIzETadZNEXiRcN8vD/PnzhQijR4ZhGIYpD5TqZp77WYn5MSMmQNIby1wHOgOm7F3mV9JAA76JHQZF1SCZqX4ojdK86Tm4stfCbS+EO3uPcEKAM06MuKCSoet8LSSVFs6D+6HWDvW7OaFuXwS3Mw/OzLWQnUWQNLFQp/aH6/ARyDYzIFloK5A1akhxFmjSBvids8aeL0DSxkbNR0/pmu/sWuw3j47T2DZn4Yv9/2JD7mnfBqJvcks80eUixGh0Yr0S33OtUYyA8xyWoN/9oM/ha0OVwBG9KoDEHLlrkvEK1eRRuiZF8irrtlleAqNxDMMwDBM2eqNIdVOidQRNk4ALZx1K2QqsW6dpi8shBogMU2HIOEXbALLTUmw3IQmdB8nlWS7rAEkDaDQiMgfY6WT1nJ+xRridRwFHIeC2QbZmQkYmVMaOcJGe0R0mcwJI+hjIBSZItiI4TVugbtIeKkOsSN+EpnJlOLUNSq0koaV8XwsdVhyz5OPrA6txoChLBCuU4IVBrUGaLhZu2e1NvQz8nmfYCsVnolWpS3z3jWotMm1FyLGZ/MQzXxuqBjZjqSJI1JG75lXNe4rH6hZ5xIABA0SKJ8MwDMOUFxqEUT2TEG7FAk5M+wzOSltHGTz6QtM00GPzFqYy0Pmla3erEF2SSgVoUwE5lkJwgBwDKaYdJK1WCBRNyz6Q4hqePj/7XwlJlwpX/k5AdkNlbAxVbEu4svIBdwIktx5wOSHnk5mdBEndFnDq4Tp5EJI+RdToRVtEmt4PpVbS95O+myTymhkToFKpRLoliTuDSiMeO8U3QoHTiv/tXIQpe5Yi1+ZJzfSloT4eaXqKrp6G1iFxR5G8T/Yux+7CDCEoA68NTGTh1M0qSN1kGIZhmGhBVHjYrSJK5zvAVcSaWaP2mC04bCXWCVaH08hiQe66eTCa8qGKSwpq8MIw4eAqOgz7/mlwFRyHKyMLkqMtpLg0qBrmQVLZvOYpqtgWfuewM28nzKsnQHaaIWlioIptD1f6QUjuQXBl7oGs3gm4CqBKaQuNcSAg0Y0MO2JG3AeVIbqieb7QdzrLVoSP9y4v8V2/u/15Qoi9v+cfUadHNXsk/vqmtMItrftj5rEtpdboXdWsh3cd36hhp/iGSNbHcv1uFcFCrxgWegzDMAwTHuS0eXDNbMy2ZCJXp0Vq884Y2aoPmiU2LhHtoEGikrJFwu/nJVM9gz+oMELWo1lcip/BC8OUvw+eGbLa6BFzKpcntdNlESmWodwerdteh9tyElBRFBBwHToICeeBVnc7HXBl7IemyRlQqSRvNLA+nKel1c9RLd8tq77xGrMQJPa+PXusSMdWvue+9ZDKPErxDFYHeE+HQUjRcw/DqoJTNxmGYRiGCRsxSF47zyPy4IZsKULGln/w0+KpMC/4WohAX0QaZ3FN3szDG5BjN0N2u5EDN+ZINriLcj0DdIapAHR+kTGKbD4K294PYN3yAmzb/we3LdtPcPj2wROpn21uhMrYRESlXelHAFs7uE8eEGYsmqSGiBsxEeoGSZ714xKh63uxaLsQ7R6G3jROrREOt1M80rRX4AbqXMn/ex6Y2q3MC5bKTZE8FnlVC5uxMAzDMAwTPjYLTKY85EpuYc/gNhWImqZcOGE25UEKaMGgQHf0s025wrhFpjRPtQY5sQ1gjW+MWF+DF4apYLsFan8Q2AYhVB88+kc98ywLP4fKbYZklCAbZEjGOBguvEXUp2nadBc3IVxFebCvX1BqP8loo1gS+zULi9XoRR89kbrpcoqaPZoOx1xJEZCBqdzRHiGtaVjoMQzDMAwTPnojYmMTkWS2IIdSuFxOIdqSoIEBMoqKcmGwWSAF1DIZVVo0OJWOHGMsZLdLPC/BVISEIf4GLwxTbpwmIeREtE12AJIWoGmHKaQAFJFAiiSbLN7zTzxaTZ56U3KUpVYAOoNX5IXqJxlNKD31qDUCuWbSI00rrRGoWTr10SPnTDJcGdmiV9jHgYxdaDuBKZ5M1cGpm/WUf/75B+eff35N7wbDMAxTx6DBmaH/cFxuTEOSpIak1SMlJgH9ocEXkhUf6p346PBaUY/n9zy7FSNsMpLVeqgapCAloRGuiGsKTbwnPY5hKowmFrKkEX31nBn/ikeapriUIvIUxLTT7NcexO88DWwhQumaPu1DxDZoOkrTjakOL8Na6JeiqrQ+UMQaNUunPnr06NsEPRyCpXgyVQdH9Ooo9AW88MILsXr1ahQVFdX07jAMwzD1CEpba3fJeDxos6CoIAuqDX/hc8tJYcyibtwGuQFRAIHeKIxX7ijKBXU/M1Jf67gk/0E1w1QKyf+RTFn0qX5iT0yTcYujSCynNEyK0PmmZfqJkHD6SUYJwiU3fRO25R0Xh7B9XBritYYSrQ98627Li9J7Tzj1stircljoVRFuWy6cWWshUzGwPgWa1P5Q6SN31/Kjjz5Cu3bthNBjGIZhmOpGpL4ZYtDA0BJFw8agcMciaFRqT7qbLIuogNlpR6xW79dzjwbVMaEG1QxTEZwmSLIT6tR+ZJkpnDRpmpw3qSbPt0ZP02iwMGvxTKdA13SkqMkL1h4k8LwNKQajKGWTbtK0j0/DvsJM7CvKxJCGHSNWSxes3Up5I4JM+eDUzSrAmb0B1m2vwXliEVw5G8WjmM7eEJHtHzhwAL/88gsmTZpU6nrz58/H4MGDMXr0aCQmJuLss8/Gvn37Sqy3adMmzw+2JKFhw4Z49NFHS2zj5ptvFtvo06ePeH2Fjz/+WAjOuLg4DBs2DAcPHhTz9+7dKxq26/V6sd277rorIu+dYRiGqX2QSUOysYG43lN/rE15R0VUYOqBVX4pnBQJpNqmmBETxGO0G1ow1URx5I4apEsqT6N0mqb2CmS6QjV5xp4vCPMV56mlQuS5rSbYdy9F0cJHYFk4DW5TfkgxUx/OW4qyKS0VKIrXK6k5uiU0xe1tz46IGPMKyeLXoEeajnYX05qGhV4VRPLsh34EZLf/Atkt5tPyyiCaVt59Nz788EOo1eoy11++fDmuv/56HD16FBdffDHGjRtXYp1evXp5rIdlGVu3bsXGjRuxcOFC73KKGt544404fvy4qOt7/fXXvSJw7ty5WLZsGbKysnD11Vfj3nvvFcvef/99XHLJJSgs9OR5f/LJJ5V63wzDMEztRXHUS9QaRRSArPooKqCkcPoO5sSNxWKjC4aJ1PlHkTsh7orTM8W0j8kKtWCQXGaPaQtkuE4eBOw2QDZBLsrwROxKER3Rft4Gtj8QN/8N8RVO0SxNSAar/WOqBhZ6EYbSNUuIPAXZ7VleCT744AMhtrp27RrW+n379hUCjCJukydPxpo1a2Cz2fzWycvLwzXXXIPk5GQ0btwYS5Yswc6dO73LKRJIoi0mJgZXXHEF9u/fL+b/8ccfQug1b94cRqNRiLzNmzeLZd27d8eMGTPw0ksvYenSpZV6zwzDMEzth+7639Z2gIgCUDSAogIED+aY6sA3ckePNB0q8gen0yPyhF1LjBB47sL63c/R2z+vWOxFuv1BsD56gbV/TORhoRdhqCav1OX2nEpt//fff8dTTz0lvnht2rSByWQSf5886d+gViGcL+g777yD2NhY7N69G263W0QMHY7Td1gMhtMFxxRFdLlcnvciyyK6p0QD6R9FDokJEybg22+/Fa//4IMP4vbbb6/U+2YYhmHqRgpnQ30cnLLLGx3hwRxTXXgjdyHGPkrkTxXbGNDpIUMFCVa47PPhkpbBZT9Vrz8spf3BI2cMFY+RrJ+raiHJBIeFXoShwt5Sl+uSK90WQRFVVA9HAo3+pkhcMNatW4eZM2cKZ86XX34ZZ511lqib88VisQgxR1E/StP88ccfw9oXiu5RhPHff/+Fk+6OBdC/f388//zzeO6559g0hmEYph5w3JKPfKcV2/JPYFPuUaglFQ/mmFoY+XsCMedNgaRPgiybIauOQ9YchHn1XXAVHQ76PBprucxFcJlOiJvi0UpVtj+oSiHJBIeFXoQhd01IIQ6rpPIsr0bOO+88/PDDD2jWrBkWLFiAL7/8ssQ69913nzBkSUtLwxNPPCHaNoTD8OHD8eKLL+K2224TQpEuCqNGjRLLrrrqKo9TlV6Pp59+Gu+9917E3xvDMAxTe1DMFtyyjF6JzdEtsSniNXo0NSbU9K4xjB80PtEkN4K6ZUtISSqo4htAUms8DdX3TytRq+fKOQnTnGdQ8FtfFMw6B4ULhsKRsYqPagXgPnrViySz3Y2goKAACQkJyM/PR4MGDSp1UMlds4Qhi6SCrvX10KT0QXVBZikksOiRYRiGYaoKGkpk2orwyd7lJSIBdPc+UoYODBPJc9ay+UU4js72zpPIpTO1H2J6vihSQJX1TPOnwpH9P2HcIlBroE7rhLihf0Kl4pgJE0V99OiE/++//4TTolKP1aJFCwwaNAhnnnlmVexjnYPEnCquraePnj1HpGtGuo8ewzAMw9QGlN5YOTYTdhdmoJkxwWvEwvV5TG1F1Ou1uxXOzFWennqaGKgSzoBKnybaMnixWSAXHT0t8giXE7I1E6BG7MaGNbL/DBPRiB4ZcHz++ed49913sWfPHrRs2RKNGjUSy06dOoUjR47gjDPOEMYb48ePD8v6P1ojegzDMAxTH6AhxJS9y7y26dRD75glH53iGyJZH8sNkZlaD9XkUbqm25EvRB6Ztfg6dnJEj6kXQo/s8sms44477sCIESNEY21fSOzNmTMHX3zxhXCC3LJlC+q70CNxTCF9dhRiGIZhohGT04Z3di32m0fDins6DEKKPrT7IcPUJsRQ2GkWkbxg5yzV6FlWfghH/i+AygZVUmvE9HkV2oZn18j+MkzEhd68efOE+Uak140moUfOlnPmzMZvv/2Kw4cPC8Gr0WiQlJQket9df/1onHFG54jvO8MwDMPUhoiekq5Jjnos8phoQbidO4rgdkqQYIJkSOPaPKZOwGYsERB6OTk5mDLlQ8ye/QfM5tM/dsHo2bMX7rxzAgYPHlzxT41hGIZhalmNHok9pTcW26Yz0YKr6AjsB6d76vj0qSVSOxkmaoVebm6u6M22fPlycbeDrPyfeeYZEcGqL0KPetndffcErzENNTGnyN25554ntmOz2XDo0EH8+uuv+OuvRd5+cw8++BDGjRvPdzwZhmGY6HAwdDlgVGv5d42JqvPauu0NIfIUSOwZuj3O5zkT/ULvsssuQ0xMjOijRkydOlU036Zavfog9I4dO4Ybb7wBWVlZaN68hWgOftZZA0J++bOyMvHJJ5/ghx9miOkHHngQd9xxZ0TfB8MwDMMwTP2rsTMBmsjWhVK6pmXz8yXmG3u+4G2/wDBRI/Q+++wzYcaifIni4+NFJIsEEpGXlyfcOEk0RbvQczjsuPbaUdi3bx86dOiIL774EikpKWG91tSpX+Htt98Sf//f/32IIUMuQH2BUluffPJJ0aCdevxRDeOzzz4r6hkXLlxY07vHMAzDVCPC0dBpE3/HavQcJWFqVWolR/SYuk65ujzOnTsXQ4YMEe0VCErVnDBhgjBfoX933XWXmBdpSAQsXrxYpD+uW7cupMMlpZD+8ssv2L17N6qaRYv+EiIvOTkZH3/8Sdgij7jtttsxZswY8fenn35artel93buueeKfxdffDGeeuopIU4jCR1LMo+pCuhmQXp6Ol566SW0bdsWDz30EM4++2y88MIL2LFjhzifyoLad1T2M6YoNH1+DMMwTM3V9r26YwFuWf0Nbln1DV7bsVDMY5hwcbvdsO+fCrctU0yT2BOir4wYhmKuUtZ6otdemzFCQIrpYiHJRkNMVDZMnzVrFn766SdcdNFFIrL31Vdf4Y033hB1eQSJjylTpkR0B0ngXXvttWjdurX4t2rVKjRt2lREf0hkKbWCJHpOnjyJrl27YsWKFUIwvPWWJ2pWFfz4oyf9cvToG9C4ceNyP/+uu+7Bzz//jG3btmLr1q2ifUU4FBYWCqH922+/CQH82muvic+CPpdIQRc+OoZVwc6dO3HVVVdh0KBB3mnad/os6b1NnDixzG3cd999aNasWaX247///hMuqQzDMEz1Q78zv6VvwoacI7C6PLXr67MPo4FGj4kdB/NAmgkrkmfbNxWOo7NPNzvXNvDU01GrhBCpleWNANIyqskrrf0CE/p7bnbZEaPW8XGrCxE94rrrrhOD5AMHDghxdcMNN2D9+vXiH6XilSeyFQ6PPvqoEJYbNmwQET0SBtSc/cMPP/Su8/TTT4vUy+3bt4vI4oIFC/DOO+9g0aJFqApIaNH+UFP4UaOurdA2SNhcfPElfqIxXHQ6nTeiR0JvyZIlYj5F92j+sGHDRKQsM9Nzh4sg4Tt79myMGzcODz/8sLf3ITW4p+3cfffd4rgqx5yiekrkkP6m6BdF0qhtxosvvgir1Rpy/6hOkyJ2l156KW688UasXbtWzH/33Xcxc+ZMvPLKK95tZ2RkiFpP+pu27XujgLZDZj+0HVpO9Y3E//3f/4n6yNJei7jlllvEuXDrrbfiyiuvFDcNCNoOvR+K6tF2KZLIMAzDVB80+Mu0FXlFHmF1O5FhKxKmLgxTloAQYs1RAEljhOw0w52/CzJkT/RNE1P684rNVcKNAJK4o5o8FnnhQ9F5ar1CfTbpkaP1dSCip0Cuml9++aUQGDSYvuSSS8TgPTY28oWpDocDLVq08E5THV1iYqLXvZK+nDNmzBAih2oGiXPOOQf9+/fH999/jwsvvDDi+7RkiUcwDB58fonG8eWBIpXUd08RIBWBat3S0tLE3zfffLMQPHTMSPDeeeed+P3338WyzZs3Y82aNXjuuefQoUMHIdRIWJF4u+KKK4Rwpelt27YJAURC+vXXX/fW1Slputdcc40Q0fv378e0adOC7hOJ/x49euCRRx4RNZz0PikSS2KLxHffvn2FeCdGjBgh9ikuLk4ILooS+x4f4t577xV1k8p5QO+Zon+lvRZFfTdu3CgE3RNPPIETJ06IZZQ2Su/z7bffxgMPPID27dv7nV8MwzBM1UN3+NP0cTCoNV6xZ1Bp0FAfJ5w7GaZUnCZPRE6SoE7oDFf+TiH2VNqE0lMri5/nS1kRQKb80NhcablC0CNNc3/NWi70KGr25ptvetP6aPC/bNkyMfDv2bOniLREulH6+++/L1IT9Xo9WrVqJYRCo0aNcP/994vlNHAnE5hu3br5PY9SIWmgHwpqe0D/fN+bku9N/8rqm0e0adO6zHVLo1Wr1t7XttvtwpikLOj1KFJHkShK3aTIKrmd0nwSeCSUDh06JIQciRzf/aMUWxJbBDmjUlP36dOne5eTeKPndu7c2SuYCRKLHTt2FKYpRK9evUQbiS+++EKIRxJSimgj4U8ik5xIFQFL+7ly5UohEkmUkrhStk3vmUQ5iXeVyhNgpn0+fvy4qLkkgWYwGPzev+86pb0WQTcglJ6FSiSPzhW6KUECkd6L73YZhmGY6knRuqpZDxQ4LNiQkw6Kp/RJboErm/Xw1E9V3BCcqQfIKiOgS/GINE08VMn9IGkToO36FCSVKuRvut/ziqEIoFtlgMTjgIhBBks5NpPfPJo2OWyI0egi90JRiqp4PFztQo8G8SQmKM2PoIgO/U0plRRZoejQd999JyJpkYJqscjJk9IOybyDxNvll18uIkCEYkQS2LuPUiNLMymhlEcyAAkkI+MELJbSa7fy8jxCj47FqVPHUVEo7VAhPf2QaFVRFjk5mSJy+eijD8NoNKJt2zbiWBw/ni6il3feeQcuueQisW933nmXd//IJVSv13qnDx7cj/bt24nt+CLLTu86ymN6+mEkJDTwTlMqJ/07fPgAUlISvdto2DANe/bs9O6fL/Ra9Hyr1YyCgjzvtuhiTMfcZjMjJydL7Cct27dvt4ji5efnIPBjpHXoOJjNhaW+ltNJ6T8u72upVJI4TmlpyeL4ZGdnVurzYxiGYYCTtkLMz96LPIcViVoDLknpgMZ6T4ZNWQOQ25K7YXRCJzEtevAVmnGq0BMFYJhSibsA6qKZgCMH0CbDlXoJkHmy/M9LuQDIOMEHO4LQjRqt3SmuCQp0bSjIykQh1ziWSZMmzVEjQo+iJlTHRdEXgtLvSIQRFNFbvXq1qNOLFCQCKBWRas4Ud0pK2aMoDNWpUfodiR0i0FiD1lOWBYMs/pVaNSWqRil8DRs2KbO9QlpaI/FINxwbNWpa4fdHNXIE1fq1bt0urLugycnHRYTriiuu8pufnZ0tonhPPPGkeN90vGh7yv5ptTokJ6d6p4cNuwjPP/8iOnXqjE6dPD+yvl9QirQlJCSL1xo8eAheffV1SJJGpKr+8MMPQnS3bdtBrN+pUxfvcyky6XkfKpESGojBEIMGDRK9+0F3LeiY0zmVnHxE7CctS0xMERHXrVt3iM/fF897SRMRudJeS6PRIiWlYcAxSBPTlAJM+1KZz49hGKa+Q78Xv+zbB4dOg1hdHOj22grbKdzToiPXMzFVTFPIrfoCLjOgLo9JSkWfx5SHmxrEYuaxLSJtM0kXIyL4jWM8+oGpPsol9CjFjmqhyNyCoJTBs846y7ucBAstjxRkuEGpiSNHjvTOowgOCcylS5eKaRJnWq1WpCH6QtMkRkJBqaD0LxASHmWFTBVxS8JWFOhW8CKxZs1q8di8eXNx7MJB2bfAfaSUyKFDh4r6OzLEoW0Gruf73sidlIxOqLUBHSeKJpLYUprdU3SQxDulydKxpno/Sumk9FlKmfzxxx+DHicShpQOStFfMslRIq3U9oLcSelYBR5jZdr3vZFY/frrr4XBCtXb0ed+0003iRYeyjplvVbge/adJgOa66+/Xrx3avnQpctpscowDMOEn6KV57D4/Q7StE12iTROhqly1GVHj4Mhq+KqpMk646FFXDLu7ThYmCuJaD0f49rfMJ3aF0yePNlbo0d1YlQDRWKgKqDoEKUlkimIb/SNrPlJzChGI1QXSNE/clgkqIaNxBjV95FAiXTDdFr3ggvOFxG0b775Fr1796nQ+xs9+nrRXuHBBx/C+PF3hPUcilyS82i/fv1KLKOPkgxN6JiRAKb6ORJyxJYtW0RdnWJY47s9chElwxUSzIpwp+NJLqZ0POhzJsghk2rmqF6vtGip8tnRdql+kqD9JWG9d+9eISgVAxnaRzJnIaFLUdiDBw+KSJ1veiv1zKP9pPdEQpOMZdq1a+dN3w31WuQOS9FKJSWWjgEJO+V5VK9HUVV6vcDjwjAMw5QN/e6Qo55iukDQ3Xs2XWDqa5N1hqmzQq8moDo66tVH5is0SKf+eRR1IhMYijAqA/iBAwcKMxASNmRIQqKFTDkoxTPSQo947rln8euvv2D48Evx5pvl79dH7pajR18n9vPvv5d4ewIyDMMwTF2CbNMVhz0SeVc374lmnKLF1FJo2Gvd9kYJQxbqlcdRJybaCNvWhWq+lJYGpUHrKPV0kYCs9+fOnSv+XrdunajPo+iNIvIIisiQ5T5FrCjaQ6mllG4YrsirCKNHjxaP8+fPw8KFnkhiuFB06tlnPU3mL7roYhZ5DMMwTJ2FRB1F8B45Y6h4ZJHH1GpKa7HAMPU1okfpkZRCRw23yfWSaryUujJyYCSB9ccff4i6KqrlItv7ukR5I3rEq6++gunTvxeC8o03/ocLL/T0hiuN3Nxc3Hffvdi06T+kpqZixowf0KQJG4IwDMMwDMNUNRzRY+oT5UrdJPFGffSoUTrVQJFQoadTHzOqkyIzEDJjiXQvvdoq9EjgPvroI1i0aKEI948YcbloM9G9u+IGeZr8/DzMnDkT3333rahzo9f44ouv2ASEYRiGYRimGuEaPaa+UKEaPTKw+Pfff0WzchI05PBINXJkvV9XqYjQU8Te66+/hhkzTjceJwfHgQPPFQYfJICpCTmJQaVBO7lIfvzxJ2jXrn2VvBeGYRiGiZbG6gxT2vkUyjlTNE23ZgCGhkFdwj3PNUNWGyHZrYDe6N1GsO2KeTaL33r1kXC/w6Wtx9eB6qPWm7HUdqGnsHXrFtFfbt68P4W4C0bHjp1ExO+yy0aE1RydYRiGYWo74Q7ajppyMfPwBuS47EjWx7JpC1NlUTlHxipYNr/gXWbs+Ry0Dc8uuY2ck7Ctmw+5KA9SXCL0/S4BdPYS24VdV2I9dbKnjVN9IlzjpdLWY/Om6oWFXoSEngJZ/M+ZMxtHjhxGQUGhSHGldgLnnz9EGMnU57tADMMwTHQR7qDNkXUc76yagSKHGZLOAHXjNkiJT8U9LftBMnDTaiZydXa0rOjvS0ssixv6p19kj9azLJwmxJuX2ASomp2EbMv2eW4K3McaA6b80/PiEmG8aGy9GtOF20qltPUIbsdSixumM2VDou6mm27mQ8UwDMNENTSgU0QeQY80HTjwo0je96tnYImzAHoA7ewWxKXvRobmILK3/YfYuKR6GyFhqsA501EYfBn9M/qUGNks/iKP1ivKgNt8CpL69PDYbToJuUgFSdL7rJcHFKd71hcoau8r3giapoboMRpdWOvJkMPaBlMD7RUYhmEYhmHCGdD5ikFK1yyyW6CXAasE7IELzvwsJNpsMBYPmkVaHFeSMOFCtXP6VL9ZYloTI2ryxN+y23+Z3mMgKDuKPOca1drF+UefpbiGkIyNIDsdnnVddsCQBMSmBayXCOgMUf950TEwOW3ikVKzKTKnzHe4nUjSGmFQabzrEL7rKdC0Ua0tdRlTNXBEj2EYhmGYcqMM2gJTtHwHbSQGs025Qsw1kp3YFKOHTa2BQavGcOgAWYLsckIurH8REqbiUMSYaucCa+lovjv3FFTWvnDk/wKobFAltRY1erL5KGwB61Mk2bf2TtuhN+y7FsGZtw1uHAS0TqhiGkGdeBYgtwEsam+NXrSnbQZLy6Z/0w6uwfqcw4AEdIx34fWdi+CS3X6p2/QY+FzleJW2jIk8XKMX4Ro9hmEYhqkvlFWjR86H7//5HrIt+djiNMMKGVpJjV76OKQ4XLgt/Rgkuw1SXAJixzwFTUqTGn0/TN3CzznTRY8xxXV3GXC7NZAkM6S4Zoi5+FbYtv8vaE2fwG6FrNXDuugbuAtz4bD9Bdm1HVAD6oRUSBojNE2Hw9DxQUj1wHUzVJ3dPe3PE/MzbUVQQ8Lm/GOADPRKai6OiW/NnqiBdDnEjZ9grpuhljE1FNGj2rPyGJIwDMMwDBPdkKijgV3goM1rRS/LGGGT8ZtaB5sGMMoy2kIDbZMOyNmzHmaHHZLegLjkRrCvXwB1PTO4YCoHnSsuW7Y3sie73HDkbAZkJyDFQ63p7jFRMWd7lpMqcTsgSxpIluOQHSaodHGeSLLVLCJ7bitFoA8BmkJAUkGO9dz8l61UuyfXi/MzVFp2tt2EPIcFWpUadpcTZqcdKkhwym5xA4fWMTlsMLsdSNXFhqy7o2PINXm1TOh9/fXX3r+3bt2K1157Dbfffjv69esn5q1btw5fffUVnnzyyarZU4ZhGIZhaiVGpxMoTtn0tawnF8OmKh3ucUuU6YVCuIXrpsoQA01sIn5on4A8lYRkqDCiKBvtOX2TKQd0Q8Er8mQZzoyVcFvTAVssoC2EW7cNqphecLmvgiyp4Tq1Am5HIeDMh2RoBNvu/4OuzY2etgwUqYtNhOvQNkCnA8iQRXJBNhdCSm4OydBYRA7hKAraty+aMKq0iNPoUOiwed8nRetSdLHi8YgpB3sLMpBlM0EjqWB1OYT4I+F357oZQgzSeg93ugB9UjwtLwLhXnq1OHVz8ODBePDBB3H11Vf7zf/999/x/vvv459//kFdg1M3GYZhGKZ8BPYh0/W9WETmfN0MZZUaKmM8jpmyMUcvoaBxSyTHpyJnzzq4HDbvejQwfODSB4M2t2aYYJCximXz8+Jvt9sGx745kJ12wE4RPTugdkBKaAOVPhXuQkC27wOQBahUkHTJ0DYbDnV8W5HCSYLGeeIgiqa/Crf9FGDYAcTmAyo1dB2vhv6MW+A8tTRo375oTMcmMXfMko9mxgS0jE32pmWTi+7jm2eJ6J0idfUqDYY07IB/Mvf5mTHRd/rbAbeU+E5zL71absby33//YejQoSXm07yxY8dGYr8YhmEYhqnF0H1ib+ROcc9cPRuyxQzfYIfkdsFw/nVoL0l4gOqg3E64ZTfeLswCTh4E7DZApxcCkJbFqNhmnSmf+6aovXNJgFsCJB0pD8q1BBXZUasEV94Bz3KZBIcacKtJJcKVtx2SLt7TlkEbC3Xj1tB2OQf2bcshWwYANheg1UEu6gvnqX+8/fXo9SiSqAjEaGyZEq81oJNGjzitXtTmKWItSR+DTvENRbomRfMI+vvyZt0x7+ROv+3RdnLsZqQa4oK+RmltWZjIUKHbZmRaQtG7QGheUlJSJPaLYRiGYZjaTLA+ZBYTVMZYv3kU6RMGFnqjGCxSbU6sRo+UBmnQtOoKTbue4pGm2WadqYj7Jok9SauFytAZKnVbSFJxHEPdQKwjudTFz3B6hB61XpBI8Nmg0iZ42jIUb0/f63xIFIWWVFBp46Bt3BGSOUv01wvaty+Ka/PoeJicdnEDxtdtN1kfK1I1xbGVJDQ0xKNFTFLQ1gnJAfPCacvC1HBE77nnnsP48eMxd+5cUaNH6nz9+vVC6H322WcR3D2GYRiGYWolxX3IfMWeKj7JL30zlBU9TbPNOhMJKH1SuGc6zXC1KRBRZlf+brjccyDFaESkTtLHQ3JqILuPQXa7AJUDkj7Zk4LZzt8ASET1up4DuSBbpG2KZbEJUMW4vRE9v7599axlSqjvrlqtFjV57+xe7J1P04Fpm+G8BlML2issX74c7733Hnbs2CGmu3TpgocffhgDBw5EXYRr9BiGYRimcjV6JOrUyY09rptkrKIzlJqOxTbrTKRRzj2X/RTs+7+B7MgHZAOQlQxX4RG43H8BBjVUMQ1h7PUidI3OCeu8hs5eom9fNNfohWqZUtZ3l1qqULomRfJC1dtyjV71wX30imGhxzAMwzDlJ1xRxzA11WePIm+ipnTLK3A78jztF1QaqPRpIevsgp3XvtuL5nO9Om7A8E2e6qFS1lbUXJyMWRiGYRiGqT/QIE2mvmOyp69YfWgizdQ9xLlJqZuiTs8Mmdoq0N8qLajhR2l1dsHOa9/tRTNKn7vKvk+6PpicNo9ArqLXYKpA6JHAGzVqlGii3rt3b+/8kSNHYs2aNXzMGYZhGCZKobQ2y8JpMM/9TDzSNMPUFYdOX6Kxzq62QOmZU/Yuwzu7FotHmmbqiNB74oknRKrj9u3b/ebfeeedePHFFyO1bwzDMAzD1BDB7sYHbalA0xUr92eYGnHoFNPFdXYcUYo8oVoo8HWijrhuzpo1C6tWrUKrVq385p911lki0scwDMMwTN0lpFlCsJYKNE21THpj2NunAR/ZrJMDHw+0mZpw6Iz2OruapLQWCpSuydTyiF5OTg5SUlLE375fEpPJxF8ahmEYhonWu/HFLRV8EdM6Q9jb55QuJtLnq+woCjtaVF/q7GoSpYWCL9xCoQ4JvT59+oioHuH7RXnzzTcxYMCAyO0dwzAMwzC15m68aChNffGKxV6oPnmh4JQuJpK4io7Auu0NWDY/Lx5pmql5lF57ithTsgJYXNeR1M1XX30VI0aMEL306KL9wgsvYMGCBdi4cSP++eefyO8lwzAMwzDVQlkNjalPnvGisRVqqcApXUykoPGn0tdOTNuyxHSodglM9dLUmIBb25wl3E3ZXbOORfQGDx4sBF1ubi7atGmDr7/+Gk2aNMHKlSs5oscwDMMwUXg3nqhsSwVO6WIihtPkFXkKpbVLYKoPJT373d1LMPXgahy35PPhryG4YXox3DCdYRiGYYI3NHbnnvK6bSrpmhTZi6jRC8OU8/ykdE1fsUdOmhWN6HmaoZs8bRg4Ilhh6DiSyAvMCJjYYRAf17qSuskwDMMwTHSjNDQO1VKB0jcrMiAmUUeDPkVE8qCaqej5Se0RlPTNyrRLoNq+wO2QQydTfjg9u44KvcaNw79zd/IkN09lGIZhmKggQi0VgolIhqkMqtgW0HeaSGdUhZ00udavemt8mVoq9N56662q3ROGYRiGYWofxS0VfMVeeVsqENw7j4kkEYvClVbrp42N3A7XsxrfwPRsjtzXDFyjVwzX6DEMwzBMcJzZJ5C7bh6Mpnyo4pLKXaPHdXlMba3Pi3StH3P6uHJ6dh2v0Vu1ahV27twp/u7SpQs7bjIMwzBMlCFEWvYe5DRrjGR1S1zVqg+axyaF/fxQvfPYnIGpMBGMwkWy1o/xP66cnl1Hhd6RI0dw3XXXYc2aNUhNTRXzsrKycPbZZ+Onn35C8+bNI72fDMMwDMNUM74ijQZuuW4HZh7bUi6RxuYMTMQhZ0x9aokoHDSeliDlhVI+KYInhKImhkUeU7/76N1xxx2Ii4vDgQMHkJmZKf7R3zExMRg/fnzk95JhGIZhmGrH5LQhx5zvsZ4vhkQfpWQFQusoffZ84d55TKRRonBC3BWLvMpG4URvyAoaujBMVNXoGY1G7NmzBy1atPCbn56ejo4dO8JisaCuwTV6DMPUFbKzs3Hq1CmoVCo0a9YM8fHxNb1LTBTiyjkJ69p5+Mx8Ark6LdSN20BliA3aE4vWLa3PHtfoMVWBp/dd5KNw3FOPqdepm02bNg25jAYdDMMwTGShgceKFcsxffp08ajco9PpdLj44ktw4403oVu3bnzYmYidbyTcYMrHCOgxx25D7smDSOnQz+ugJ85Bar2gM5TZZ4975zFVgTi/IuyMyT31GNT31M1x48aJFM3Dhw9759HfNJ/+MQzDMJHD5XLhxRdfwN1334Xly5eJAXZaWhqSk5Nht9sxe/YfuOGG6/Hdd9/yYQewc+cOuN1uPhYR6p3XFGrcIRtxn02De1r1F6KNIniWhdNgnvsZrH9+CVfWseB99oKYM3BqHFNbCdVTrwLJbwxTdyN6X3zxBQ4ePIg2bdqIwQZ9AahOj9i/fz++/PJL77r79u2L3N4yDMPUQ9555y38/PNPIlVzzJgbccMNN6BVq9bi2rtt21Z8/fVULFiwAK+//ppI47zyyqtK3Z7VahXXZrqGx8ZG7m74jh070Llz5woP5KnW22z2ODO2bdsGMTEV27dbbrkZS5cuq/DzmZK98yRIiI1LhKQ3eqN9yjK31QR3zklITdp6P/tgffa4jx5T6+GeekyUUSGhN2nSpMjvCcMwDBPU5XjatGni79dffwOXXnqZdxkNqrt374G33noHLVq8hy+++BxvvfUmLrlkOPR6fcijSev89tuv+OSTz9C/f/+IHfWbbhqDVavWlPrapfHVV19gz5692L9/Hz7//Av07t0nYvvGlA86t6jOLrDuTqRskuGKb/N0CVAlN4ZkjAOsJr91FbhGj6mPbp4MUyeF3l133RX5PWEYhmG8dU8ioiJJ+OmnH8VROe+88/xEni+03sSJ92LO7D9w8tQpLFy4AJdffsXpKIpdhlELSC4z1mzYCpPJhJYtW5Z6tCn1MT39CAoLi6DVatGpUycxf/fu3XA4HCISSK10aJkiSOm1KKpH8yiyp1ary/WJvvzyq+Lx8suDv09ftm/fjq5duwpTGno9SmNlIguZqVCdnUjB1BlOC7eAaJ9YN7UZDBfeAslh8183zD56gec9w9QE3FOPiTYq1TCdYRiGiRzBnAsXL/5bLBs16tpSn+dYNx+Xd2mOz0+dwl/z5gqhdzzPgbmb8uEoPIyu7ploFZeP9z/chI+mfIzb7nky5Pby8/MxduzNsNlsiI9vgJSUFHz88Sdi2XvvvStcP61Wi0iz/OijT4Tb8o8//gCn04nXXntFJPp9/fXXVZo6OWbMaAwbdiF27dopSgduvfU23HPPxCp7vfqKEF16Y1jRPkotDlw3nD56ZTl2Mkx1wj31GNR3oUd3g9977z2sWLECubm5JZavXr06EvvGMAxTbwise1KcC/PyPNOtW7cu83ktUxLEvLxjh0REjkRensmJHrbfATkb//t2D8Ze2hKG7Nml7st///2HJk2aesWdLzQvK8vTP/Xvv/8W9YGvvvoaHntsEmbMmI5vv/2+wqmb5YXSTt9++x1kZGRg1KiRuOyyy0TtIlOD0b4gKH30fMUeTRvV2pDnva9jJ8NEg5snw9QZoUeOmyTmrrnmGiQmJkZ+rxiGYeqxy6ECTVPfUurzqQi+0p6Xb/a4HOpVgLnIgjyzCxqYYZCzsftgLo5lmJHYwIDtu/bBZrPi0KGD6NChA5KSkvw22aNHD/zvf68LJ89+/foLc5d27dqJlM2HHnoQ//23EY0bNxaOn2lpDVFTXHbZCPHYsGFD9O3bFzt27GShV8PRvlDrUUsGJX2TRJ63RUNAvZ+fY2cY22YYhmEiLPTmzJmDTZs2iR9+hmEYJgIEqXui6d69e2PevHmYPXs2+vTpW+rz5m3eK2b16tAGMXFGJMZYkGeKgVVKQX7hKTidbrz17TZIkhYZGUX45ptpSE1NxQUXDPXbJNW7zZ49F1u2bMGaNatFGidN7927R0Tyli1bIerv5s+fhx9++OH0/lZzBIbEb1xcnPg7NzcPsbFsmFCdhOOiqazT1JggavIoXZMieaXV+wVz7GQYhmGqSejRD2tCgidFiGEYhqk8oeqerk/pJoTenDmzcdNNN6F9+w5Bn7do6v9h+7FMaNVqjJrwgKiXuqxXgkjf3O++Gv37Shh7SWvEN2gIXZsxuOame/HUU5ODum5SSv6xY8eEyYnyelR/R60bTp06iZUrV4jo3pQpHyIlJdX7PBKNZATTpk1bYcZCEcPU1DTv7wUZtpCJC9X8BYNek16bagMPHjwEnU5fahP4V199Bbfeeiu2bduGgwcPiKheIOTg6bsPTGQIx0Uz1Dok/kxOm1cghnL3ZBiGYWpA6FFT9GeeeQbvv/8+dDpdJXeBYRiGCVX31CepkUifXLduLcaNux0vvPASBg0a5DG+oMxNmw1//L0Mr0//U0xfN/oGNGzXWfzdNFGL8YNTYHEkw6A5E5LLImzCabsk4EL10KPUzE8++USsR+KN3DCpZyr9u+OOO/HVV1+hUaNGmDDhLmzYsN77vCeffArfffcdCgsLMXXqVHz22acYOfIanHXWALGcmr5fffXV3pTLQGbNmol//vkHiYlJwtyF+Omnn0OeHNRPkFpPkCD9/PMvveYvXbp0gUrlcfwM3Aem8oTroum7To7NhJ+ObMCo5mdi1vGt/uKvHPV+DMMwTPhIsvA0Lh90V7ZXr17iDm+LFi1KXJTp7mpdg2pg6I4vuc01aNCgpneHYRjGL0Vx3LjbRGsDonnzFiKlk67Bq1b96zXFuuCCC/D22+96Wx7UJqie7/nnn8Mrr7wakYF8z57dsWHDf9Bo2Dy6uqFo3Du7FpeY/8gZQ4WLZuA6hQ4r9hVmwupyoIHOiJYxSYjXelIzSez5CkSGYRgmclToF3Ls2LGi+H306NFsxsIwDBMBxD03p8nTsDdg0EumV9OmfYuPP56C33//HUePpot/CmSMMmbMjRg79tZy966rLij7g9w5IwX10GNxUDOU5qIZuA5F8oTIczuhVWuQb7dgn8uJXknNxefn22aBYRiGqQURPXKB27VrF1q1aoVogSN6DMPUFK6iI7AfnA7ZlgVJnypq6KiXUzAsFguWLFmCkydPiPRNqocbOHAgR7aYWlmjR+mai07uhkGtQfvYNOwzUWTPib7JLaFVqTmixzAMU9uEXtu2bUV7BYrqRQss9BiGqQnoEmzd9oYQeQok9gzdHueIFVPrz90SLpoBUD/H9/YsQZHDJtahNM5jlnx0im+IZH1sUIHIMAzDRAZPNX85GTNmDCZNmiTuLDMMwzCVwGnyE3mEmHaeTour7GBcdhR5UkMZJoKQcKOUy9JSaCnqfH3LPkLUES1jk/FGzyvxaOdhojaPRR7DMEwtjOgdPHgQBoMBTZs2LXGR37dvH+oaHNFjGCbaInrlSQllmJqO/jEMwzC1wIyFonkMwzBM5aFBLwmwQEFW2cEwDayVbYppW5aY5pRQpqaQwVFlhmGYWh/Ri0Y4oscwTM27bpq9fe4qvT1HESybny8x39jzBUja4P3zGKbC55ssw+yye5ugl9e4hWEYhok83ICIYRimFiAGx5EUYNSmQZ9aIiWUhCTDRJLShFxZzdVLE4gMwzBMDQm9TZs24bfffhPN06lpry/fffddJXeLYRiGqY0poQzjS1lCjkScb789ZR2q11PW5UgfwzBMLXLd/PXXX3H22Wdjy5YtmDZtmhB6a9aswffff4+ioqLI7yXDMAxTbsh4hWryKF2THtmIhYk0pQk538bpvtC0QaUJKhC5moRhGKaGhd6LL76Ib775BjNnzhTTP/zwg2igPnHiRCQkJERw9xiGYZjKQFEVqsnjSB5TFYQScuSuqZx/lMqprKOkdlrcnoheKIHIMEzdgm7SmJw2vlkTDWYs1FYhJycHMTEx0Gq1yM/PF39nZGSgc+fOyM7OrhKzlLVr14rX6d+/PzQa/6xTehvr16/HqVOn0K1bN7Ru3brc2yeRSu+lQYMGEd57hmEYholOwjFbCWyvQNNT9i7zE3v0XCXlk2GYugMbLkWZ0FMu0kSrVq1EZO/MM8/E0aNHccYZZ0Q8ffOTTz7BY489hh49egihR2KMXpN6+Cki7dJLL8X+/fvF65MgfOihh/Dyyy+H/Ros9BiGYRim+vrkBQ4Or2rWA0n6GDZmYZg6BN+0iXLXzauuugq33XYbRo8eLcTX+eefj0gyd+5ckRI6a9YsjBgxQszbunUrTCaTd53JkyeLSN7OnTuRmJiIpUuXiv244IILxD+GYRiGYaoOEncxGp3fvLIcNSnqRxE8Eog5NhNmHtvCxiwME0V1uoHXBKaO1OgtWrTI+/drr72GIUOGCJFH0bQvvvgikvuHV155BVdccYVX5BHdu3dHhw4dvD8k5PI5btw4IfKIwYMHo1+/fuz+yTBM1EPXQNlq5roIplZB0TpKzXxn12LxSNPBIAFIUUBF5BFszMIw0VOny9TBiN6wYcO8f1Mq5bvvvouqwGq1ijTMKVOmID09Xbh8Urpmz549oVJ5NCqli+bm5oq0Tl9omlpAhMJms4l/vqmbhNvtFv8YhmFqO66ck7CvXwC5KA9SXCJ0fS+GOrlxTe8WU8+hmw+/pW/yCjeK1tH0Pe3PCxrZIwMHWscXmjY5bBwRYJg6wJVNu/tF5Gla3IQsf3UYA3g1To0JPUqTJKfNBx54QEx//PHHeOONN9CuXTvhxtmsWbOI7ByZurhcLvz999949dVX0bVrVyH20tLSMHv2bDRv3lzU6xFJSUl+z01JSUFeXvA7iEok8oUXXigxPyPjBCwWbhHBMEwtR5ahWvkbYC70TFM6+5Kf4R44ksIkNb13TD3G7HLgaG6G3zyTqQiHTxwJepefBoNauxN5Dqt3XqLWgIKsTBTyucwwtacO1+2EUaUpccOGxMQ18e1gdTtF6xSp0IxThf7pnEz4NGnSHDUq9B555BFvKuXx48fx8MMP4/nnn8eqVavEMhKBkUCv14vHbdu2YceOHYiNjYXFYhE9/Oh1fvzxR+86ZrP/CUWGMOQOGoonn3xS7LdvRK9FixZo2LAJu24yDFProXRNi+QGYmN95rphTEqGpDfW4J4x9R0aEDY3HS7hqNmqScuQRi03NYj1iwiQMUvjAOdOhmFqBkq9Dvx+BjrrMrWTCgm9BQsW4MMPPxR/z58/HxdeeCEef/xxnDhxQqRVRorU1FTR8uCyyy4TIo8wGo1CZE6fPl1MkzijVgtHjhzxey5Nt23bNuS2SSAqIjEwXBrJkCnDMExVIBtjoYpPEmmbCpS+qTLEsD09U+OMbNGrRMsFtVodcv0Wccm4t+Pgcjt3MgxT9TduZh3fijyHRXwv6ZGmuRVK3aBCisbpdIr6OcWYZejQoV4RZrfbI7qDJPL27NnjN4+mKW2ToKgdmcH88ssvfimflO45fPjwiO4LwzBMbYF+cPX9LhHiTkzHJXqmeYDM1AIUR81HzhgqHsO5+684d/I5zDB1w1WTidI+euSCSRdicrek1gaUWknRM4ruffDBB/jzzz8jtoMHDhzAWWedhZEjR2LgwIFYs2aNcPak1yKBR2zcuBHnnXcerrvuOpHW+fnnn8PhcIh1g0XtgsF99BiGqW2Iy7PTBGhiQw5+xTp2K6Az8ACZYRiGifjvEDnnBqZic0QviiN65IJJ6Y3U1oCEnZIi+dlnn+HZZ5+N6A7Stv/77z+Rxrlw4UKRykmGLIrII3r37o0NGzYIQxbqoXfNNddg+fLlYYs8hmGY2oar6Ais296AZfPz4pGmg0ECkGrySouCCPczRxE7oDEMwzDlgn5bKPVaaaGgpGJz5D2KI3rRCEf0GIapLdBlmcSdbMvyzpP0qTB0e7zcP64kEO0Hp4tt0TZ0bcZAHdeyCvaaYRim7mRDMOU/plxDW0/MWBiGYZgqxGnyE3mEmHaaAa2vy2bZP8yKyFO2QdMVEYwMwzB1Ab65VTUoNbRM3YLtJRmGYWqQoGmVdBdanwLZ6YAMz3yKxkHjSZ2JiGBkmNpw7lvNnFLMRPScCnZzi5PXqhY6vianjY9zLYQjegzDMLXszrM79xTc6To48/cDWic0LftA32ZM+aNwQjCmlkgBLbdgZJgI48o5Cdu6+aI9iOIYq05uzMeZqRXZEEz5euwFtlLhHnt1PKJXWFgY+T1hGIaph3ee3dZMyG67eBTTbrcYAMOihlo7FGoMAXLaQxXbotyREBKGJB6FuCsWeWKa0zaZGoTOW0XkiemiPM80WwYwlaX45pYvfHOr6qDvrCLyCHqkaf4u1/GIXpMmTTBq1CjcfvvtGDRoUOT3imEYJtpxmuAuOgBX/k7ITgskjRFI6AyYs70DYI8g0wOmfE8LBb2x3JEQihBSTZ64o63hZupMLcBm8Z7jCmK6+BxnmIqi3NwKzJTgm1vV32OP6/nqcERv6tSpOHXqlGhx0KFDB7z22ms4fvx45PeOYRgmSpHVMSJ1k0SemHZaPNPGZG8TdAUxrTOUKxLiG/UTLRi07D7H1BKoHUiIc5xhKotyc8vY8wXxyC7DVUeMWudtu6BA00a1tgpflalyoXfttddi3rx5OHLkCG699VZ89dVXaNmyJS677DL8+uuvolk5wzAMExrJZYYqriWk4no5eqRpldsqonTKQFiJ2ok70iEiITLN90nlpKifZeE0mOd+Jh5pmmFqC3QuhzzHGSZC5xjf3Kp6gxXusVeP+uj93//9Hx599FHY7XakpaVh4sSJmDRpEozGupGGwX30GIapiV55blsm4HYCKg1U+jRv6wOq1UNhLhCfBJVKdbqP0cJpfmJPVqmhMsZDNnlSOXV9L4Z9/QK/dWi+8aKxPJBmahVi+EHpmjoDn5sMU4cNVrjHXpQKvby8PEyfPl1E9DZt2oRLLrkE48ePR0ZGBt555x20b98ec+bMQV2AhR7DMLXFdbO0OjzfZYhNACxFgNt1eqOGGMgWMwKDIzEjJkDi+ieGYRimFEgWTNm7zK/2jsTexA6D+IZMfTFj+euvv4S4+/3339G4cWNhyjJr1iw0a9bMu87IkSPRtGnTSO4rwzBMVBHMKCVoHd7a+XCffzNi9Soh+Cg6R5EQ2e2G5c/P/bYpW0xQGeMgW03eeVz/xDAMU35ELMRp8rh51pPU4vIarNAxoudQvV64x6giz2GqUehRLd6VV16JP/74A8OGDQv6IaWmpuKee+6p4G4xDMPUD4S4ozo96v+kiS1Rh1dkc+NA+gmsth9FXINYXNYrAU0TtR53QjJaiUv0W18Vn+SXvsn1TwzDMJHLuKgvBiuBEb1gBisV6aHHfffqQOpmVlaWEHLRBKduMgxTOwYTN8C2conHZEUGth61IF+Kx9b2o0gVIjFGjfGDU7w32EKleQrXTZsFULkgaePEuma7jBidxHdQGYaJWsSwlq595O5awWiRUkPt23ydrs9KDXW0E44YK0+KpxLBM6q0+Gjfck4Lre0RvWgTeQzDMDXZNF0ZTNCj/eAM6PqOFRE5R36uEHkHmg0WIo/IM7tgcXgEG+GbyulrauE2pXu3XehOwuKcoTjqao3EWM3pqCDDMEwUUd4+oyGhDAsfkUeIaUqz18Yi2iFRR4KN0jUpkhdM3Iab4nnUlIuf0jeiyGFDnFaPk5YCxGtPt1Lhvnu1ROhRLV64nDzJVt4MwzAVHUyoGzQQ4s1gsyB9lQkmi7t4oYwUnQOGgCu3+BH2MVrxFZBuSxHy9mxCD+syJDlH4ECz8zF3E/yiggzDMHWdUH1GK+Q4TDV5+tQSET2qpa4v0DErrel5OCmeJPIe3zxLrGNQa9AuNhXHrQXopNF7PxPuu1dLhN5bb71VtXvCMAxT3wgYTMiQoVInQFYboaI+UIYYXHamFnM35cORdQJdM5fjjAQrrIuSS79TXSwgaXv2E4cAuw0aFWC0Z6PtsaXYahzlFxVkGIap84ToMyqyHcrpOEwihGryAmv0+OaY/zGilM7AFE/lGJHw/jl9o1cIWl1O7DdloX1smojoFTltJZ7D1KDQu+mmm7x/v/zyy5g8eXLQ9WgZwzAMU77BhCv/MNwZWZBdXWDN+MYr5CjFctygZBTOmw11mh2SpCr7TrUiIE0noHLaoFYBNmcMZGhhsBcgRe+EUcs/rEz01FQxjDh/AsypKuM4HMwVmQk/xZNSOwsdNhhUGlipV2yx2Gsc0wAPdDxfzAuVFspEDk8X3nLyzDPPVGgZwzAMU3Iwoe86CVJRL6jc50BSJXmFnOKVJdmt0Fjz/Xrjee9UlyIgVbGNIWn1SDDGwmLvSiFDMfC5pE9D/nFlak1NlWXhNJjnfiYeaZphwkEYTlnNp6+TkiRukAlxVyzyxHQlhAQ9V9LWn9YKlUnxDDxGlNqZrI9F+/g0IfYIiuBd16I3VCpV0OcwtcSMJRS7d+9moxaGYZhyQkIOJovfj55fylEF7lSTgNQ2vRWOzXaodq9FG9cuSKnNEXfR5dAlha67YJg6WVPF1CtCma6EMqdiaja1M06jF+ma17Y4E81jk/jjqK1Cr3nz5kH/JtxuNzIzMzF+/PjI7R3DMEx9oAwhp9ypDhzYlDaIoUG0ZenPcO7aADicgEoFyWmDc+9GaNt25wEQE1U1VUz9oawbBIHmVEztdu9kapHQU+rvbrvtthK1eFqtFq1bt8bAgQMju4cMwzBRTjhCrrx3qimlybl/E2S7zTPD7YY7PxPu/CweSDNRWVPF1BP4BkFUuXcytUjo3Xrrrd4+eiNGjKiqfWIYhql3hCPkyn2nWlJBUqkhu12nZ8Um8ECaqRVUJFLNMHyDgGGquEbPV+Q5nc6SG9VEtPSPYRimXhDJlCNqzaBr1xN2pwPIy4QsAaqUZtB2GyhSn3gwzdQGuKaKKS98g4BhwkeSFbuicnDgwAFMnDgRK1euRGFhYYnlFdhkjVNQUICEhATk5+ejQYMGNb07DMPUQyJtMy8MC9bOhys/E7LdCldGujB+keISEHPZHdC27RGR/WbqB3R+kmU6uenxjQKmVlwv2XSlVsHXiCgRekOGDIFarRZiLymppHvO+eefj7oGCz2GYWqji1xloUu822pG4edPAKZ873wSe/ET3xc21wxTFsfMeSUaI5PRQnnPRRaKTKThPozRc41gIk+FcizXrVsnonoNGzaM/B4xDMPUcxc5d2EurGtmwnjxnWUKMTHIcZo8TdJD1PVJdoufyBPPK8oH6PUaJEf43TDRBp1jygCOoEeaJje9cCN7PAhkIn1O0nXPVVAI+/oFEb9BxkT+GsE3euqQ0GvatKlop8AwDMNE1kVOdufC5dwA5Jpg25IJXfuxoideMFxFR2A/OB2yLQuSPlU0SQ+6bnyyiOAJcVcMTaO4sTDDlAZF4ZQBnAJNk2V6OG56kRCKDBN43XPbMuE6cgQqVxdIqiTuw1iLrxF8o6fmqFDOzoQJE/D444/DYrFEfo8YhmHqq828LHtEnmwCdHq4nXkeISfLnn9Ws7cGmh4VkSembVnedQOhqCDV5AlxVyzyaJrTNplwoJo8SsXyhaapL1ZZ0PloMuUjx2YKOghkmPLgd91zOiFbs8Q103tdVPowlrEN2VFUJ/0k6uI1ItSNHj7+tTii99FHH4nUzR9//BHNmjUrcUdu3759kdo/hmGYeuMiR+maFMkjkadu3AYSJDGgcWUehP2/ZX7pSar4OK/IU/AMfsyANrbEa5DxCtXkiXTNuEQWeUy5zk+qtwmsvykrGqfUnaIoF/F6GQWNW0JliC2XUGQYP5ym09c9cnjX6QE73USw0x2zMvswhp0FwUTsGmFy2iqVEcDUgNB77LHHKvmyDMMwTAmb+YvvFOmaFMkjkUdI+hTYNi711tiR2KPBs+HCW8RAxVfs0TQ0/ndVfRERPK7JYyoAmSpQqiUNzkiglSXyfOtO6VweYXNjzskjKGx1BpL1sWEJRYYpAdUiF1/36LyiG2LujCzArSuzD2OoLAhDt8f5XKzCa4QS7fMVe3yjp5YLvbvuuivye8IwDFPPjQUkTayoyfO749z0alj3zPNbVy48JdKT6G504N1pHjwzVQWdWzSAC8s506fulGgKNe6wyZDaDkRMTAM+T5kKn4O+1z11QisYez0BlbahiOSVek76RgOLoTo/2ZoBGBr6mYaUZnDFlP75BEbpKpoRwNRgewUF6jlHKZxnnnkm6jrcXoFhmJogWCqRKraFJwWzODpnWThNDJq9Ri1aJ3SdBkPX5ka/dfmHk6lKymOoQEML5bxVoIiL8aKxfJ4ylcYjxsp33aPnWLe94RV7bkcB3EVHoE7sCpUhTVx7CU7trBrENSHMjACmhs1YSOCNGjUKiYmJ6N27t3f+yJEjsWbNmgjuHsMwTPQSKpWIkLSeu8lK/R5iE7wiT92oNdymk7Af/N5v3XBej00ImIqeq+UxVFDOW1EzVSzySkurY5jyIK6NYV73fJ8jsh4o9ROyR+TFtRTz6dprO/C9uKaGY3DFVDzax9eAOpC6+cQTT4gI2Pbt29G1a1fv/DvvvBMvvvgi5s6dG8l9ZBiGiU6CpBIFM1QR9XsXjILlv82Q7Va4Th0C7DZAtxvaRtdDndamzFQjNiFgqrvFgjhvLxrrcUEsK62OYaoBEnZUk0fpmpZt//M7J2XrCchU+afShmVwxTBRK/RmzZqFVatWoVWrVn7zzzrrLBHpYxiGYcpnLFCWoYqkjYMqphHs6Us9Io9waGBZ+yvUzc2QnQVQ6dOCushR31P73q/hduV7nTzZhIApD4qhgmiT4HICao0wVSnLOVMMpPVGPthMrUGck4aGIl3T79praAJaJNuywza4YpioTN3MyclBSkqK+Nv3bojJZOI7dgzDMBVIJRLTpRiqiHWbjhTizjMjFpKqHZx5X8KR/gdcWevgKjrgaSTsdsNkc3v68uWchGXBZ7DvXALnoe1wW03+d6oZJsxz9Yq4pog/vAvOA1vEI01zlI6Jlmuvvu2Nou45nOsxw0R1RK9Pnz4iqnfjjTf6fQHefPNNDBgwIJL7xzAMUy9SicIxFlAld4Qm6RrIRRmQZS1cjoWAykYFUJCdZrjzd8HsisWMf9KRbTUg0ajC5flzEee0CGFI/aZcJw9Cat1VRP/4TjUTLnTTIHXrStxhk2BBLIw2QLV1JeQm7XkgzNQIlXXHDHbtpW3q298HqOVy1wAyTNQIvVdffRUjRozA8uXLxZfihRdewIIFC7Bx40b8888/kd9LhmGYKEYMJsKoAaH1DP2Hi/5kbmqxoJWhMjaiYj+xnMTe3gwVsnU6ka9RVGjCwUMZ6N7cCLWmj8fMxW6CSpPId6qZ8lHcLoFSf5VENuGoSfV3nJrJVDORqjn2vfZS9oO392OxeRDVmXK7BabepW4OHjxYCLrc3Fy0adMGX3/9NZo0aYKVK1dyRI9hGKYKUQwuYkbcB/0Z50OT0gOSxgjZ5YSr0AYcVKH7/l8Ra86AU21AvhQPp1uGpEqCWjsUmuTR0Pd4ukKDIqZ+QgNdk1olnF99EY6aOkON7RdTPwnlVlwZd0x6riLyxHRRnph2FR0WLRksm58XjyQwGabe9NGLJriPHsMwtYHy3D1W7mq7rBlwHTkIydkd208YYXPIsOoaYGv7UWiCHIxUr4Vs8r9LzTDl7Z2X6HRh+IkTaGI28bnE1BjUIoaEVyDGni+IdMsKbdNqhnnuZ/7zZBnq9kWQnfneeRQ9pHRPTukM45jKsnDrJSMnPl51LHWTYRiGqf50pEAR6LUKN2XBfPg7SBoJbRu6cSDDBtgLkKJ34oK+HWBM6MwW90y5ofPtt/RNyLQVQSOpkKdRY37bDrinVX9IeiMP3pha71YcNnQ+xyV6I3pim7FGuJ1HRbqyArdbKP8NInLrvbp5TzSL8fTUZGqp0Gvc2HMH+OTJk96/Q0HrMAzDMJVPR1LuHntE4PeiUboqtrFwh1Oa/SI2Far4JDFIidOrRE2ey5iAQRc0hUpVnKHPdVRMOdlXlIklGXtgdTlhUGvQPi5NzLdqNIhhkwqmhh0zA2+KVSZqRM+lbAffGj1d34vhOD4tsoKynvyWKSKPoMff0zfh1rYDEKvR8w2iaiZsoffWW28F/ZthGIap2ubpsiYG1h2fwnlkg7dRuttShJh+L4sfzcBBiio+EcZ+l5wWeQxTgcHaguM7gOLiDhJ7JPyGNOxYZu88hqlNbsXlrX8WBkM6g+faqo+soKwPULqmIvKIArsF67MP45S1EI2MDTi6V1uF3k033RT0b4ZhGKZq05GoJsUr8gi7TUzLvUyQdHEhBykMU6nBmsOC9vFp2FeYCavbKUTf8CZd+Nxi6pRbcbm36ZP9UBWCMtqhmjxK1ySxV2i3YnnmfjhlN9SSCja3U0T7JnYYxMeymqjQ7V5qxrt3794S82keLWMYhmEi2DzdpTrdKF2Bpt3+l3DPHeiya6coWkPikb24mLIGa/FaA3olNUff5Ja4oFFHtIv3pG8yTLQSeH0U11XuqRc2dLyoJi9Ra8TuolNC5CXqjOJmEWUF5NhMsLgcVfcBMpU3Y3nnnXdw6tQp0SDdl88++0y0WXj44YcrslmGYZh6Tai7x5IhBpqEIXDmLwFkk2h+TtMk6mqq/xRTPwZrSq1NQ328mOaIBlPXEQLOZvEYsATcFOPrY2Qg45Xb2g5AprUQKngieUoKeJxWz+nftb29QqtWrbBixQq0aNHCb/6RI0cwZMgQ7N+/H3UNbq/AMExthpr5WtfOg1yUASmuoWicXt42CXS5p15QgemhbBfOlHbO0N13qstjkcfUdUI1RSf4+hhZ6HhO2bsMR0w53vRvyhJ4o+eVaB6bFOFXYyIa0cvMzIROpysxX6/X4/jx4xXZJMMwDFMKNBiJufjWEjV4pfXdK7GsFMOXSNe6MNEBnTcxGl2ZPbK4ZxZTWwh1TQzVFN1w4S2Q7FbIKleZ18fy9Dmt7/hmBcRp9CIN/NoWZ7LIqwtCr0+fPvjkk0/w3HPP+c2fMmWKWMYwDMNENqUomFFAaWlGwZapYltEvv8Ug/reI+vslDZYlX2Qe2YxNU6pqZc2i1+fPLF+1jFY5n0JWE1AbAKQrIeksgW9PnJaZ8VSOMl4hbMC6ljq5tKlS3HhhRfi/PPPx6BBg8TgZNmyZWL+okWLMHjwYNQ1OHWTYZiaxJl9Ara1syCbLKInnm9KkS/KHWVZHQPb9v8FTcMkQqVouk3pXKPHVDodS7FPp+ndhRnoFN/Qe3OCxB+76jHVTVmplyINeeG00xE9GXCd2A91k7anb6wZXVC1sEO2ZfsJRU7rZOpVRI+EHNXovfHGG/jyyy/FF+TMM88U8/r37x/5vWQYholiXEWHYV76KGRrljBaQUEfkVJE7RJ8I3u+d5ShiYfbcgwqbYOSaUaQQ6YgsV04E8keWeSoR9P0qJXUYh5N0x38YCmfDFNllJGa7ttv1F2YC0mvgZTUyD97wqKGvsMDkNSyfzsFTnsPmrLNRKnQI0jQ/frrr5HdG4ZhmHoG/XDa904TIk+kV7gL4XJuAAoTPfV4xamaYj1F5NG0owDuoiOQkrpCglQizai0FM2q6D/F1L8eWYRGUolpelSgaW6qztSmXqSi9Zc1A1JiQ+gHDoF93zdwO/IAxxHIri6QVB5zEDJoCdqippRt19eUbaq/o9RMJgr76DEMwzARwmmC25UPWVLBXZANd14WXPlHhDEAma74ruc3yJAkEZ2TNA0gu+2ALsXbd6/UnnwMEwGDBRroEcn6WDzc6QLxSCgDQD7XmOom1HXPmbkaRX9fisLFI8SjZesbkJ35Yn1Vw1S41TvEjTTFhTNUfXR9vqbS8VFEHkGPNM29WKMoovfoo4+Kx7feesv7dyhoHYZhGCaMxrxOCZIutTgm50FyGyAhIO1NEyvEnGw9AUjFVve6ZEBF65G481+dUzSZ6jRY6J3cgg0XmBon8Lon6vJW3QnZliFiG/ToLNgFTYuRUKlUUBliIbWMgbHzzZBiUkoVbvX5mhqYsh1OijanedYxobdt2zbv32+//TYuvvjiqtonhmGYetXPSdZKkJ1qqBqkQIIRkrov4LZAtllEs3SCTFRkRz5cOZtEDZ469RzPhuzZkFRaYR5AqZ2+PfE4RZOprrYLodowMEx143vdc2ZvgCtvGyA7AUkDSZ8MmZp3u62AynNtVenThMgjZKs5pOtx4LajHV+hFpiyXVaKNqd51kGhN3nyZJx77rne6fnz51fVPjEMw0Q1gf2cYNcDeR2hbtwCkCmVcyNcaidse93Qth4DlT4Z9oPfQ5KdUKf2A9xOSHS32lFAIw/PNuk/0wnIDhMkXVzNvkGGYZgaRtQ1H1sISaWB7HIKsSfbcqCKaw3J2AyyIwcqdQJ0bW6AO/dUyEbq9ZFgQk3piec7L5ggDpXmyU68tby9gmJNG/h3tMDtFRiGqS7orrF57md+89xWE1QJaXAW/gFonVA3bgNJ7RJOm6qEDnDnbIYq4QyvyyYJO0mTADgLxHNdJw8CDg3U8ZfDcPYV0KQ0Cbs/H8MwTLQhO4pg2fw83ObjcGb+C7fTBMnthKbJhZCM7YGsOMBihCouCW5LISS3y/tcEnuBrsf1tYWKb8sUoqyeeCanDe/sWlxi/iNnDOWof202Y4mLi8ORI0dQk2RmZmLOnDnYsWNH0OVbt27FX3/9hePHj1f7vjEMw4QNCa44f7cydWozGC4cDU3b9tC07gpJHwNX/k6PAYsbkN0uuGna480p0o107cZC0qcIkSdb3HCfjIdz60qYpr8q+vIpKaLUO4qEpWXBNBSePB51N+oYhmECoV6j1IZGMjaBusXVUMW3g5TQBVJsc7jSN8JV8K9Yz52fBeeBLX7XRZFtQa7HvvXUjqJ6ce0srR5PSdFWRB4dDxJ2vsdFSfP0hZ1460Dq5vXXX49u3bqhRYsWYpr+DqeeL1KQNS7tw/LlyzFx4kS899573mVFRUW48sorsXnzZnTo0AGbNm3C008/LdJNGYZhahu+/Zx8U4VUunioYhoLcSfLdshOi7hMu9L3Qra74VZlQhWTD1VSe28jX1X7++HcJcGZsQ+S3S62Lxflw756DlTDx3lfo8jmxoH0E8jf/RsOdLkOV/VNRNMkrqliGCY6EGLDaRLGVVTTTDXL1GuU2tCoYppApdJCndAZcLkAuw0A/bMDar1nAxTRU3uGxeJGXLHrsW//Ut8m6tFKuPV4oerwFGfecNI8mVok9D7//HOMGjUK+/btw3333Yfx48ejOnn55ZeRlJSErl27llj2zDPP4ODBg9i9ezdSUlKwaNEiXHTRRRg0aJD4xzAMU9ug+g9KDRJ3jXUG748gDSLEoMKa6enblGcFHDZIkgGQOwCmvtCfe6dwjCPIrEUVk+wVeZ6N6OG2mICiXI/ZiwwcyLCh0OpGoTkH/+7MxqZ0K567ujGasdhjGKaO4y/GUuC254uaZkp1F71GNQ0gxXWA5MjxZEXo9CLVXZZ1Ip1T3bo7YNRCNluhik/ytlko0b/UllXC9CraCEeolVWHF8yZl6nlQu/JJ5/E66+/Lv4moffggw+iulixYgW+/PJLbNy4EUOHDvVbRifbt99+i4cffliIPOLCCy9E79698c0337DQYxim1iJ+/Iobogez8HYVpMO0kNrZmAApFhpNH0hmKySHzfs8ER0ccDmcB7aKSB4NYNSNW0MVnwjEJYk70478XFgdMvLNLuRL8bBLetjNLszakI+7h6byjzDDMHWWQDHmtpyAK+c/qFP6e/qKUvMaZyH07cfDkT4TsGVB07IP5HQdnId2QFYVQdXEBHXDplA3bQZd+5FQxzUO2r9UvB5NU4uFKHbfLEuohdNugZ1465jQ+9///ofXXnut2gcEOTk5uOmmm4TQU4ScL8eOHUN2djZ69uzpN79Xr14ilTMUNptN/PM1Y1FSROkfwzBMjaI2QkrsAHXiSMhF1ANK53HYjE2Am2okfK5TqqRGiBn9BOxr5opIHok8bZ+LxDJ6lNctgFZtQZ4Uh3UJAyFLgEEjodDqhMnmQowu7HJthmGYWgXVzrmtmaenJYrUUV2zA1B50g0pO0KK7wBdl8cAlxmyyghr9jdQNTPC7V4K2W2G6+QhwBAD24Hp0Hed5InoqYye/qU+Yo+25VYZ/K7B0YqBHEupPjGgNtEgaZCoNQpxR8ucshtp+jjoJTWPoSOAkrFTrUKPavOmT5+Oc87x9G46dOhQyHVbt24dmb0DMG7cOFxzzTUYNmxY0OV5eR578uTkZL/5JAqVZcEg0frCCy+UmJ+RcQIWS1Gl95thGCYitDkTqq3LAHMhEBMPd+teKMjwGK2UoPdwkeYJLaUluYFTxcZUPYchvoUZK5YBBRQMdDvQJE4FrexCQc4JFHJaDcMwdRVZhtqhAxw5p+fF9ACcMYAzF9Amw5VyAeB73bSfhCqDro82qJDvmedwQC4sAMwm5J/YD5CZCxF3AdRFMz3bD7atespAXUPMyNmCHaZMcQ+yR1xjbEnfg8b6+JretTpPkybNq1/oUY3cHXfcAYuFzAGANm3ahFw3Uq5Ev/zyC5YsWSIieuS2qUTeqB6Ppi+77DLodJ4QsdnsH0KmaWVZqFRUSvdUoO2SmG3YsAkaNPDYlzMMw9Q4jZpC7tCjRC1fuTfTGHiliR2zNhagyOZCUqwGl/VsgMaJwRveMgzD1BXc8RNgPzjDxzDlBkgxLUT0jgRb4HWTxqnWRs3gLsyF25kIWTZB0uqhjm8gHI31Tdr5PKcp5FZ9Q26rPkJGLCvy92KfIx8arRYd4xvCoDVghe0U7mnRkY9RLSJsoXfzzTcL10tqXUAib+/evVW7ZwCMRqNo0j516lTvPErTpDYKn3zyCS699FK0bNkSarUaR48e9Xtuenp6qWJUr9eLf8HCpZEMmTIMw0QEY+XrQZqnGHDPMD0sDhlGrcQ/xgzDRAWq+NZQd3/CUzun8RFj6pLRJRJ5kt0qDFfs6xdAKugDt3oHVA1ToTY09LhqqtUlXyTItqIZOk5Ui0cunIFGLLOOb0WW3QRbce/B/UVZ6JXUHHkOC2yySzyHqWNCj6AIGaVlzpgxA+3bt0dVQxE7+hdYe3f++ed72ysYDAYMHjwYv/32G8aOHSvmUcrm33//7TWPYRimZiksLBQ3iWTZjUaNGgsHXSayduJl3WX2bZrONXkMw0Qb4hpYhkEK9RX1bWuj63sx1HGJkLV6SC6Lv0isx4RqneBrxKKRVDCoNbC6nLC6naJOr6E+vkQbBqYOCT2F0aNHozZB9XbURuHuu+/G2WefLaJ9JEipvo9hmJpj69Yt+O6777Bw4QI4HA4xjyLmdHNmzJgbcfbZnppfpnTxJorhrWZvOwWaX1pvp8BtBA5u6E42tXdgGIapL9B1UbkOiumiPBHRozY3KrrWqqLXRbM8lNU6wbfPXvu4NOwrygR1rGioj+N+edEi9BITPao+FKWZoFQWEnSBvfT69++PtWvXCoE3a9Ys0UOP2j9Q6ifDMDXDV199iXfeeds7TYZJJPKysrJE7a2n/vZmTJr0eL1PlyZzq8aNG0PrzCgh3mDXwbr0ZzgObBHHUdO2B/TnXQPnsalwOwqEdbhvbyelUbBvrYpt3RK/wQ0Ndmhww3euGYapN9gs3uuggpim+ueANjf1mbJaJ/j22SOGNOyI4U26oF18Gv+mRIvQ++KLL/ymqR0B1ey98847eOihh1CVfPDBB0Hn9+jRAx999FGVvjbDMOHx888/eUXe8OGX4pZbxqJ79+5iev/+/Zg+/Xv8+OMP+O67bxETE4P7738g5LZcLheOHk1HamoaYmMje8eVjJ2aNGkiUsArwokTx5Gf73Fso+0kJJR+EywUkyY9hmeffRbt5LkBjXm/hyu9ERwHNgB2lxB1jkP/wun6G5LhKCRNDFQJZ4imwLS+7DCVbO67dxrchfH+NRY8uGEYpr6hN4qMBl+xR9NkcsWcxjdip0DTvimZ3BA9yoXeqFGjgs7v168f3nrrrcruE8MwdRhyvFVE3t1334OJE+/1W96uXTs888yz6NatG555ZjK++OJzXHvtdUIoBbJo0SK8/vqrQgyeOnUKY8feWmJ7leHRRx/GK6+8ijPO6Fyh5//6669YsmSx6Of56KOTQl4bw8Jpgez0b8zrytsLZ+4/kEnU6fRwW1pD0hyCbI2DFKOH7DTDnb8LUmo/4RRH+TOBzX3drnxIcY0Ak8cxmeDBDcMw9Q262UVp64Fp7JzZUPI4KRE73xq9wOPEDdHrBhG1lxw4cKBIoWQYpv7y559/CvMValdCQi8w999kc4vHq68eiX79+ouMgF9++TnotvLz8/DbbzMxe/Zc/PLLr/jkk49hNptCvvbJkyexa9cu7Nq109u09ciRI2Kaond2u927bmZmJmw2Gw4ePCSWK61jysO9996HX3/9XaSPlwW9Pr0etXKh1w5EdkmQ9Cmnp2UZbutxSDoJUKshq2xAzH7IWgdU+hiok7pA0hiF2FNpE0Sap6SNE+mavgir8H5XeMRdscjjwQ3DMNGEUsdcVnsvqk2mtPWYERPEI9cqB0eJ2D1yxlDxqBixMPUkoheK2bNnIyEhIZKbZBimjrF48d/icdSoa/1q747nOTB3Uz7yzC4kxqhxWa8EEclbt26teM59991fYlu0jRMnToh2KWvWrEaXLl1hNBY3sfWBRN3EiXdj586dSEnxiKXvv58hUjKnTv0KW7ZsFmYwVD/82mtviJtSCxbMF9ueMuX/RKsVmt+xY8cqOy4PPfQAOnToiE2b/kNRURHOP38IXnvtdWGU4i7Igm3lTLjbJwOpekgqGyRtA6jIXEUnQ3Y64M4nceiGKqEF1E1aQaWNhZTSH5I2Afruk73HmgRfSZOWJlBfNLbSvfgYhmFqG+U1mxLXP67JK5OqitiFatvA1CKhN2DAgBLzcnNzRZ3ehx9+GIn9YhimjkJROKJVq9Z+F3ZF5BH0SNPntGpVpoHTzJm/iyhhdnYWnn32uaA/DFTDR4YmS5YsLbH8ueeeFxHGU6dOYtu2bULYkdAjI5jff/+tUqmb5SUpKRGLFv0Nk8mEG2+8AUuXLkU/60HKr/SsYFEDOe1huOBauAoKYFn2ANzWLEhqLbRn9Ic6oSW07W6Gc/+3IiVTZUgTQs5XUJPzJpmyUD8pWW2ExQHEUN8oHtwwtQzflh884GMi5aRZEbOpUOdieVrYMGULu+OW/JBtG5haJPRGjBhRYh71xaLm5j179ozEfjEMU0dR3G59xZvZLntFHl30HXAg16RFhipXzCvNDIXSP+nfgQMHMGbMaHTv3gPNmjXzW6dJk6biGjRqlCcdlPpv0nrEm2++gV9++QWNGjUSTXCr0hW4LEaMuFw8kqnMBRcMxfbN/6Gv/1sBTPmAWwXHhoWAuTXkgsNwyya484ugPfdaOFYt9ZirxDWCtt8VIloXCA1Ijpt0mLspxy+C2jSR+xsxtQNu+cHUFifNUOdiaS1smAr049Make+0wl2cXhvYtoGpRUJv8uTJkd8ThmGigl69zsTq1asxZ85srzlJjE4SYuOIKQ+73bthlS3ibt7xOX+J5b179wm6LUq31Gq1Qhw2atlMtGg4efJECaFH61Cq5o4dO7B27RpMnDgRn376qXDq/OOPP7B48T9CXO3Zswd33HG6v2Z1/7hQfZ4CuXVSHaMUF1DgTrV0VJ9XmAf3KRqwdIIkOSG71bAunAVNkzYAuZ+ZLKIHlEjJJHzuOoeKoI4fnMI/qEzURGEYprJOmqHORcOFt5R0MC5uYcPnaMX68WXYCrEt/wR6JTb3HkPftg1MLTJjIfe7999/3zv98ccfiwblQ4cOFe5zDMPUX6iujiJn69evw8qVK8U8uqhf2rMBjqj3CJGn16oQYz6KJYs8Qm/06NH+hi1Om3i888478MOc3/HM7KkY+8xDyC4qQEKrpkGdPnfv3gW1WoUuXbogPj4ORUUmUXtHYnHFiuWixu/VV1/2e15KSiqWL1/uNWM5fvyY6POnQKYpZPASiuzsbPHcwsIiIUDpb1/Dl0D+7//+D6tXrxLic968P3HBBReIu8dQqT3HKS4R2S16IbvIBEmvhmy3ipYKkkyROAmuk4fg2L8ZzsPb4baaxKDEnbsX1m1vwLL5efFId6F9I6gKNG1xlG5UwDA1HoVhmAo4aVbYbCrUuWjOLuFgLKad/v3lmPD78WkktWis7pQ9RmnB2jYwtUToPfLIIyINijh+/Dgefvhh3H333YiPjxfLGIapfygCja4N5KhJPPjg/aLGzuGwIzFeRrtmQM8WBiSf3Ie1b34Ol8OJs84+G926dfemeUzZuwzv7FosHsc9dJ8Qeium/QK72Yrzn70b83P2lnBWO3LkMJ5++ilMnvy0iORR3z5q99KgQQO88MKLmDFjOr7//juMGXMjOnTo4H0eRf7Wr18vnkeGLz/++CP++ecf7/LPP/9M9AQMxbJlS8XrFhTkizYL9HcwR02FG2+8CdOnT8fs2X/gzTffQsuWrUSKUNsefZF44RgR0fhp9kz8Nf1JyInbgZT9kNUmyFodjWggaTSApALsNiH6EJMA+7FfS9x1NmqBRKMKGqdFRAcJiqgatRwtYWpPFMYXbvnBVMhp01EEVVKjMp00lXUDfztkivzFGPzmi3MxJqWEg7GY1pQ0A2NK78fnPX6ShL4prZCmjxPTodo2MJFFksvyog1CWlqaMF5JTEzEV199hZkzZ4o71ORgRzV6GRkZqGtQShU5hlI6FQ0OGYapYB6+LgaXNeyMN56YjBUrVojl5IQ5YMDZ2GvOwrFte2DKzBHz09q1xO/TfhDXEroUkbjzvQMYp9Gh0GEr8UNAls/VkepBwu2pp56OSKP2q666Am+++baf0AyEjgFF5RTh5rYUwXUqA5LjLLiP74MqsSHceRlC6EGnR+z1D8JxcmqJ7eha3oOsf5fg4KEM5EvxyGp/AS4Y2IFr9JhaA9foMZU6f8pRPxdqXWW+K/8w3BlZkJxdoI5pDt3ZI6BJacI1elUwNiBh19SYINI1KZLHIq+W1ug5nU5YrVZvQ2NK2VRMGEpLW2IYJvrz8OlxbsZOfPDBh6K1wQ8/zBBRrrlz53ifo4s1ovOwgXjhoSeEyAuW5kGQyIvT6mFy2msk1YMcOSNFmzZtRSppqThNfulCKmMcpNaxMJxxO2wr5kI25UGVkCpcOqUGKVA37Qxnbqp4jkw5MW4HJEMT2DYuRbyrEN2bG+F0O6BTr4UxoXqcRRkmHJR+Ztzyg6nIb0649XOh1tV3neSdrzLEAmkyXKe2ApYEUfss9bsEqqQW0Le/D1DLkKidDUeeKtyPL1DYcU1eLRd65513HiZMmIDBgwdj1qxZeOWVV8R8MmA455xzIr2PDMPUYoIJNJp2qoAJE+7C7bePw/Lly0T7A/rRbdKkCQacdy6S4hr4/XAaVdoSEbxkfSyuatYDM49t8bsjWBd/cN99972yVyIzFb1HuPk2PFfFpkLf/xJhEgByhmuQCl3PweI40N1p6+6P4Mr8l4YxUCdp4C4ogKRqKJZr1ZIQiOVxoWOY6oBbfjAVIuCGmF/9nDY2vHWtmafFH0jkHRKZEpLOIWr0rEt/BoxxwgU5nN58TPX342OqUOhNmTIF999/P7777jt88MEHaNu2rZj/2Wef4dlnn63IJhmGqeN5+L5izzfqRo6Y1EqgtEapSnrHCUsBjlny0cyYgJaxyd4eO8HuCEYjinALTDOi+UoExHXqMGyblsD27ywxANH1vVg0TVcnnwm30wxX7jq4XKcgOTtAo+0LSZXE9U8Mw0QPQW6IhayfC7WuIe30fKfTkw4vkUjUibJm54Et0LToBEmtYVdYpv7V6EUjXKPHMJHNww9sghpqncDaPJqmdM0HOw7xawRen3C73cL1jQwBfI8BHRvLwmli4CGu3C4npPg4oOFesdyVtQ4yNUp30cAlFZLTAE3SNTD0H853oxmGiRoiUaPnLDwM+/6v4Xbkw52eDpWri7gxJjudcB7dDU2rLn43FsnsReKsCKY+RPQYhmF8KSvqFqyOT2mUGpj6Sc+lmjyr24kYVf1L9yjVpKLYCpxaKwjXTbsNsk4HXVIKoLYIkUeo9PFQNe0Bye2G8cxrodJ5XM4YJpKI+8Q2i8dFM4oj7Uztg4Qa1eSJdE1NTKnnX7B1Sfw5Ds2A7CyAWpcIXf8b4Ny+XVxfqQ5ao9NDcp9uUcOusExdhYUewzBVnocfqo5PNEotI/WzPlFmI2kaUMcmwnVouyfVSHTXkyDnpEHVwgFJpC7JUJPxiiRBpUtmO3CmSmDXTKamEdfEwJq8MNb1NWgR109HAVy5f8Nw4SRIDnI0NsCde6rEDTe+mcHURepnXhTDMDXaT8dXzNGPJ6VxKsvrsuFKVTeSFjV8PQefXqjTQ924NSSrBoaODyBmwGfQNL0UsksN15EjcO1zwbroGzEoZ5iqviHBlSBMnSCEQYvksojUTN+a6NJ68zFMXYAjegzDVDmKmAus0VPEXH0yXAmnkbSf2ItNgEw1e7LsGYA0bg1t13MgF2QDKrWYR8+hAYrGcAZUDR6HecFnkOwFgEbrHYQbLrwFkotSl9gmnKnCGxJ6Y0jTJYapS2Yu7ApbOvw9j2IzllOnTuGHH37AAw88IKY//vhjvPHGG2jXrh2++eYbNGvWDHUNNmNhmKq/0Aszkfou5sqREieTkKOZ1DfPp16vtLQ554mDKJr+qrepuoj46exQd9BAduaXaVzAMGXhawqkQOchRT6OW/LLNGZimLpk5sJUzICNqcNC76abbsKIESMwevRoHD9+XAi8559/HqtWrYLBYBAisK7BQo9hygdf6KsOuizLNgus//zk6YEXMJgmkSwu3RRB0Rm8olkMwBdMg337Sm8NH5m1qFrnQdOqlahHEdvRpwZtLsww4RLsZoMqqRGm7FmKDFshNJIn2kyDQIrW87nG1DZTIPG8MsxcfLctcJrqfVZEoFM2wd/z2kuFUjcXLFiADz/8UPw9f/58XHjhhXj88cdx4sQJ9OzZM9L7yDBMLaM0F00e0FUer3DzEXmB6XFB04oopc6UJ6J4iisn4IQ6Nckr8kptLswwYaLUMPnebNhbkIHFp/YIx1yDSoP28WliXWG6xA2TmWq44UB9RdUN4sMSY2WZufhuG0YXkJoDSWWr9xHAUs3V+HseHWYsTqcTVqvHHGDRokUYOtTTDNloNMJut0d2DxmGqVMXeiay9Xq+lGnxXfwclSEWmlZdoWnXA7oug6FObuu/nVDNhRmmHIj60OKbDnTzZ/6JHWQDKyCxt68wE0laY7100GWq3xTIXXAQ5qX3w7z5OVi3vSHSM2kdt70QboupXGZBvtumv535S+A8sgEy/WfL8qR91tM21KWZqzFRIvTOO+88TJgwAe+88w5mzZqFyy+/XMxfvXo1zjnnnEjvI8MwtQy+0Fc9NHgWlt7FYi8ci2/f59BqUoMU6PsMEvUnQtwVizwxzWmbTIRv/uQ5LGgflwaDujhZSAIuadqVzzWmyk2BSHS5nBsgW7MAl0uIMevuj2Ba+zQK/7gWhTOvh3neO+E7EPsZDtkpvcKTIeFy+WdF1EMCnbITtUZc3LhzubZBn5fJaau3YrnW1+ilp6fj/vvvx+HDh3HPPfdg/PjxYv7IkSMxadIkDBgwAHUNrtFjmKqp0WNnrsoRrBavrPoUMejJ2QP7kR8hu/Kh0qdB2/oGqA2eSB6LPKYq63ZEBER2I00fh3s7DubzjalyUyBZtsFlny8MqDStu4rlrqy1cBfqITmKG59LsdAkXYOYi28tvSaP2i+oY0RrGiWi53L8DWidYtuUBs91zp5jtb8oC/OPb0euwyLGAVc164EkfUypBm1c318HhN7LL7+MyZMnl3tZbYaFHsOUn7JcNPmCXrWEct90Zp8QKUzi7rZw3mwDdUIrNmBhqpTyfN/5BhATyWuguzAXbtW/UDVMhaSPgewywZm9BcjzFxxq3SWIvfx+kXJclhOnJnkYHNu2cY1emKYshQ4rjlny0Sm+IeK1elzbojeaxyaV+hyCjVxqodDzOr6Vc1lthoUew0QWvqDXjMU99cuzLPgMztwfPevRfI0WmjbdEdPrRUhswMJU9XlZRgsVvgHEVEXWg9uRAevuj+HKXOmZDxXkAkByqsqM6InzduvrkK0nAMlz7pLY03ed5MmoULk8Bi8uC2dFFEOpl+/sWuw9fpvyjqLAYUWsRgeH2y0E3Bs9r/QTe77P8eWRM4aykUtdaJi+e/dupKZ66kAYpq5SVFSEuXPnYNeunXA4HEhJScWll16GTp061fSu1SnYmauGmlYX5UI2WcSgRnbmwW0q8NSVqOLgalsATQo7bTJVBw2QS3PeY8depirOOUpdV+laQqVLAJJ7AyoNZEchXPJeyEU6SE4tNAlDYOg/POgNCHf+LjiP/wnZaYGkMUKd4Kk5kwv2wJ4+07/fHt8s86vVp+gcpWpbnQ4UOWzQSWr6UMT8n9I34qFOF3iPue9zFNjIpRYJvebNmwf9m3C73cjMzPTW6zFMXcPhsOO9997DTz/9CIvF4rfsyy+/wJln9sbkyc+w4AsTvqBXMcUOm4ERPcQlQRWfBDm/D5y58wDZBUmKhcrdDfb1C6Au7sPHMDUB3wBiqgyqrbNlQ1J53B8lbQNIab1hGDwJkire6xAb7OaDEHMy/e2C7DAD+TuhanwJbId+EIJRZKsVu21yD1J/UxZK186xmdBAZ4BddgmRR5ApEwk/37YLvs/xTfHm36RaIvSo/o647bbbvH8raLVatG7dGgMHDozsHjJMNYm8++67FytWrBDTbdq0xUUXXSRahuzYsR2LFy/Gf/9txC233ITPP/8CPXrU736RP//8Ezp06IhevXqFXIcv6FXb/Fdx2CzRtFql8sz/dzac+Z0g6dRQN2oPlTrOrw8fw9QEfAOIqTIotVKf6nHELIaMqFTGhqULCacJ7qKDgNsG2ZopZrnlFKhsJ+HIXOWN8JFw5B6k/lANLvXPJTGXbS3CE1v+EAKORB458CbrY0u0XfB9Tmkp3kwNCL1bb71VPFJ65ogRIyK0CwxT87z//vtC5JGwe/XV1zFs2DC/i09GRgYmTXoM69evw733TsTcufMQHx9fYjsulwtz587F1q1bRNT7mmtGIS4uLmL7+cMPP6BLl84VFpqR2r/169fDYDAIoVeaqQJf0CNjrhJu02rCZHMjJqkRDJeOg5t6PllyIEn68PrwMUwVwzeAmKo8tyi10tdQJZxWMuSwSUYskN1QGRuLR9lZBFnSQNLEQHaa4crfCXVKf6gMadyDNMhxp4hdTFyyqMmjdE2K5JHICxWtKyvFm6nhGj1fkUfN00tsVBPR0j+GqfKaPErXJEjkXXjhhX7LScikNYjDlClTcN1114q2In/8MQs33nhTiW099NCDQjh169YNy5cvw+zZf+Cnn34RUZZIQEKzQYMGFRZ6kd6/cEwV+IJesea/9EjTJOTKiuxRhO54ngNzN+Ujz+xCYowal3XIQ0LqXrjStwIOjahPKasPH8NUB8FuAIUbyWaY0lDHtfQYqJizgZiUsH7bJJcZqriWcLvMQtRJGgMgO6GiW2UJZ4j6PTFfm8A9SMuAjFeoJo+jdbWHCimyAwcOYOLEiVi5ciUKCwtLLK+LrptM/YWMV8xms0jXpEheaRGWMVdfidfe+0AIw2BC76mnnkbjxp4IzLXXXoezzz4Lx44dQ4sWLUqse/ToUfz2268iWkjfmXvumYhmzZoJ8bV69WqRDt2qVSuxHRJnGzduEJG4rKxMrFy5Atdccw169+5Trvdanv2bMWO6SM+k16T62+HDh6N79x7e5fQ1V0QeQY80TQM4HqhF0FwljFRLOn8UkUc4Cg4hb8UkxMYWQIo3QhXXEaoEO1RJjSqyZwwTcXxvAJU3ks0woajQuaSJhTquLSRtPOB2kk0xXHnbxaOK6vxS+0GlTYC+++SI3bSNZvjmbu2iQmfsuHHjhBvhtGnTsGTJkhL/GKYuQe6aBNXk+QqUYBGWwYmegfT+/fvFdyAQRUQRR44cgV6vR+PGwQfXd9wxTpgY9enTB/369UNsrMcNkcQdTXfr1h2HDh0SUTglZTo5ORlt27YTyyvicFue/Vu7di2eeGKSMKahNNUJE+4UzroKdtnp55xF0DTdyaNjJ1s9jZOZ8pmr+BJuqqXZLntFHinwDrafoHblwE3mAk4L3EV74aa6Faf/58UwtTWSzdcOprrOJSXlk+r5yMiF0jONPZ/zpGkW1/np2nlaMsiOIj43meiP6K1bt05E9Ro2bBj5PWKYakYRbFSfV1aExUBuXN7n2UXULRi5ubl49NFH8OKLL0GrLZmHTj88FA3v0aMH+vc/y69OrnXrNti0aRMOHjwoUqM3bFgv9rFly1Zo1qw5+vbth0svvbRS77ms/VMYOfIaEWkk6Efu119/EVFBQidpgtok6/KzYVm/gO/Ol5NQ5iqlRUfFAMZpglEbI9I1SexpYIaOmkepjFBJnnOb0o7ojjQ0MeXdLYaptZFshgk8l6hxOmCnXyiPMAvzXKKUT3LTFDfDNDHiuZq0Ad5ptykd1m1v+LdZiGvJHwATnRG9pk2bikgEw0QDqameu3bkrllWhGVXrlU8xsTEwGgMPmim1Mrx42/HnXdOwNCh/qmgCvQj8tZbb+PHH3/EsGEXiGhZVpbHKeyBB+7Hli1b0KnTGSJyR+sGtnuoDOHsn4JvSmfLli2RnX3azYz0B9XkkbgjwZGk0uLKpt2FhX/gHVW6XlCjVOXOKkf8TiOORfFdYsVcJWbEBPFYWsoRmQfQwMOy+XnYtv8Pl3XMF2LPiRhAn4akxl2FW5z4rGhg0o7bKjDRFclmGF/czky4Vf/CZZ8Pl+NvyO7ccp1Lokm6NtZ7c02ZJhSDF0JpsxBtUWd6P/Q7Hfh7Xdb60XYcoo0KRfQmTJiAxx9/HJ988knJKAjD1DGGD78UX3zxuWihQPVySqQ6WITl96V7xTJqoB4s0nLy5ElMmHAH7r77HlxyyfBSX3fAgLPFP4raPfnkE8Lg5fbbx2Hz5k1YtmyFiPLt2LEDNpvN+xydThc0ZTRcyrN/irvm5ZdfIf5et26tqGMMNFW4K6Uj8tbNg8GUD+ngAbjyMqEynG7KfawoGwt2LUau2yFE4RVxTZG6dWXIiF99MmUgsRboECfuEodRkxc48EjK/hnjBk2C1Qno7eNhPzgDbmuCx0Cg3Vio41pV07timKqNZDNM8GviDKgapsJ1shCwm+BW74Ch712VP5dEf74s/9dTUuGjpHm6Yqx2xJSDY5Z8NDMmoGVsclCDtXCN2Jg6LPQ++ugjkbpJ0Qgyjwj8Eu3bty9S+8cwVU6nTp3Qu3dvbNy4UbRQoPM7Jia2hH39zD/nYcFiTw3q9ddfH3RbDz30AOx2O5YvXy7+ERMm3CWiYb6YzSa88sorxX+bhZvmLbfcIqbPPfc83HzzTaIvJTl8+t5M6dq1Kz755COsWbMao0aNEimYOTk5wliFIMMWeh/jx99Rqf1T2LlzJ26//Tbx99Gj6Zgxw+NO6vvjunDqh8jJzsLVfTtDtpjgyj4BuWFLWDQaxEjAHL2EQpddXCeoqeovu//AjXYJsZAAH2dJwnniIOwb/4LbaoI1LgFJ/YZDk9IE0UgwsRZuM16KALpNJ8jiGBIdR5+Bh5EmY0umITFMTVBa+5VQbUL4fGUqKsboJqPUuiv1EgLUaqgbNKiS/nw0HS2p8PQdVZqe7yvKhNXlhMVpR5xGH9RgTVmfjdiiWOg99thjkd8ThqlBnn76GdEMnQTXtdeOwk033YwLL7wIMTFGbN++Az/8MAMLFswX644deys6d+4SdDu33z4eJlOR37xgfeo0Gq1IyyRiY+Pw9NNPe1NI33nnXfz770rh7nXmmb2xdOlSGI2e1BNy+qSUTnLKJDMWSiFNTDx9F23ZsmWi/UIowt0/hfHjx6Np02bIyDglagOVbV933XVo2LCRiLw1MUhokObZB9lmxnG7GX8WHcX/t3ce4HGVV/p/b5m5UzUz6pLlIveCC5jQm2nG9JYECAvZUJKQsmmb/g/JphCyu+kJIZ0OCwkEMKaEGsDGNNu4d7mpa0bT59b/c77RjCVZLrIFtkbnx2M0986dok937nzvd855T1RRECyrRGfFOJT12KdHM3G8bcTRLrlQDRkXOhrqkzFYrU3IvP44jHf+iV2KhKdHjUa3U4HyxQ/gw/P+XVg2lxwHsEo8UHSTXOWySxfBjG4CXCaU2kZIHh9gOciu/RWgd3INCXNEMJhV/0KbEIY5VDEmFr8UdcjE2MH25xsu0EIMfUZNxxYij8japtguGKz17nlXOL43Ax3HHBlIDifXCuLxOEKhELq7u/c5UWZKlxUrlotm6BQh2xsk8r785a8csRbL1PLkhBNOgKIoh/xc5PZJLRXOPXf+XlfnKZc/+9SfRAQOcGA0rcafwj7EgmE4qW7xmE0VVWioHItNuQS2Z7uh5DI4yVYQgIyQLeFT/nzETn/vX7Dad+Ivo2oR09yQPEHIoQpUT5yLzxw1/4gd84OFxrJQ3F+AJhCFiN5ANuHUHiHz7F1iH9WfWObbcJCB5IoAehRwu4TwE6vavZ6LYYbifO392d9fijXd/5sNr+xh1sTtV5gPPBX+ICmYXQkRWTjnSzBLovBZpYjestgOIfY8soo5kQbR9HygiB5/tocPLPR6YKHHEOSESX3sHnroQdFCgaCoGdXkXXXVVZg6ddqIGShqr9DQMEpE9Iqr89uXoSsTR7m3DBcHR4laO6tjJ+yuFkihSiQ7duKOhjrY6TjQszKYCoaww9IR83gQlYCwJwBvNoeGbhM6NJweOhvndSyEsvFNdJhZ3DVmNCRZgaR5ALcXcjCC//DVI3Lc+SXXW2tvExP6Ii0IOoK2Jb8XntOvRXbRH4uPJ6FtblsBZdREOPbz+Z1uDeq4GWJV2zv7e0UzAYYZqsjc/upsCTJp+OnaF/Z4ri9PPYtX/Zn3jaESY0MtGkdSjd6BpGszR6DQK/TfIjOH3r24BoKOGW6w0GP6Q+0TyPiE3DVH+sWKLhO/Xr4Q7TvWAHoOcGkImyZutj1CUIjLiOYXPdx+r7ehs7st/0BJhs92kJIc2OFKrJFs5BQFnVIItXYVvHIZZuEonPTe7XgrmEVMlrDRq6E2pyMgu6CU16Bc1XCTQ02/I6KOp9T+FgNNTKgHYXrh7/O3eyJ3cFJwTZsHp9kPZPIRW8c0YO5YD2XMdNjm8+IYQp0wG7KvNl+nR4wQcxtm6Om/ek+LC56mtbhFlyD3GHeT2Ov/2Rzsqv9IMmFihne2RakiFhgtQ0TzKHXTq7j2296Hju99HJu0DOMavf/5n/8Z8DbDlCrUX25fPeZGErQ6XxR5opYsg85kFOnAaPgppSWXhtW0GkpVAxYkOvGkYiIKCxFHwvyWFjzZMBoZScEESNhoWSINU5I15KBjqb0Yi8eWY6KRhD+bQp1pozlYhgmqDxFFE3V8QkyWaG8t8QXZK+om2i2ICF4YdnK3yKNInWN1A5U5oGsiQC6noUq4yDrctiCpc/PHukzIvhqxAm1HW/dI/yy1qCjz/tK7HidhZLGxuxVpMw5IblzueFAPZcDPJp3XtMrff9V/oInjQGnKfJ4yh40R4LI5EPTZLNTY+WT3oI4n2KRlmAu9a6+9dsDbDMOUPj7TQkQ3QK1oBbKMiGXDa1twZBlWy1axW/KVocEbxA1Nq6hyDFFLx6LKSrSqClphog4KzlD8yHrPxrvZTcghC0uSEXe7sNUXxqxgBbyWg7Ch4uh2PxrsNMqqyaRhZPTW6j3hdWQFkK2iyBOmK2QyIOfgOfPDkBwFjktDqq0FyrJnASoliVwB7ZjToVQ1iufLvNYr/bOXw2kpr0ozQwulX5FIKzryORY0WUXScvCklCtG2wf6bFIqF0Xw+q/694Ymh4VzXmzzecocbkrcZfP9gk1ajkzkoahporRHhmFKF3J1vMhbhUjPJaMcMi4pb4RcVlmsxVNqx+UbzFJ0KZuG17axKBxAzOdDwHYw0bBQHY/hhmQOV6VfhYr8xM7rUhGKVIiUTlOW0WW4kfZORLT6JMQRxOa2nIhulXpvrf4TXhpHeMtFuibV3BV6E9KEg+rumjMq/vRKF373joL7tAvQfeon4Jv/cajV4/PjlMsUn6v4GoXIC8McIIXIXMCl5U0aFBcm10yA5NYQhY2sP7TPz2Zh1X+vn10+T5kjjILLphB3PdfcUnLZPFj21yC9sCjUG9qmRR5mmLVXEPU6v/41br/9dmHzTlA/PWqi/tnPfnbEfxgYptSgL7jG4y/CzUsXIZ2KwecPw3PcAuECSWmcmZceEqmEdG2wbQeOnkNGdSGm9rh/0kTPE0DapUF3/Ki2kjhOTaCrYYroApe1G7DTF4DqKUd6axYLmlswKrMJWXcQK2rPwax5R0PRDt1J9EhFpGvGO2EnYug9l5DScWhjr4K+8+99TAGIhcu6EU1ZMC0H0bSNhat13Hh6ryelWqdAuI/YGwlRUWboocjcFybPExFlSt8UDoT+MMoVN8qnntnHEXfQRgx8njJHIGS8wr1Id3MgtXeDSddmjnChd9ttt+G///u/8eUvf1lYudMfcfHixfjOd74jInzf/OY3h/6dMgxzWKGaGYoY+fo1NaZoH4m+zMsPw9y8ArBscb8XkkjvjLrdkD1ewMyhXFJRqOI5IWHidztNRC1DfCF8afYFmFJRhreW/gnI5E1FPHoc09pfg0c9GqWermknorCaN0Mur90dvQuEIUcmwRPp2/w8lbOxo8vA5vYccoYDzSVhfJWGjOHA5+75u0iSiLT0r33iL13mYCAx95ExxxQncWS7TpO43iLvYIwY+Dxlhkv99EhlMLV3B5KuzQyD9gpjxozBH//4R5x77rl99j/zzDO46aabsG3bNgw32HWTYQZPwSnPcXuQffZu2PEOQFZgNq0W97WNnoSFqomY242IpODCXP5y8wRyWJuRECubiQnyBESkCCJ+FTcc70X7o3eKdE07k0JFegfKNQv+o0+D58SLSs6goX8bBepHSK0qlLoJkIN7N6Ug58NP/XUHYmmruC/sU/C7jzfs0W9Q/I36iXOGOaRzdoBJ3MH21up9DZGMHJ+nDHOEwa1SRmBEj9onUCSvP7SvtbV1KN4XwxwxsO33/o1D4PHBjrUXI1FUr0cGLaMkBZ/0V8Oeeza8siqO/326GZ2qC51SDQxkscnZjGOluUK0ZGQPghXlmOmOQt+yCZLPhuT2wMkkS9NIpFd9knDaVN2QaxvhO/c6IBCGZKXz+3ua9TpGErBkpCUP6sIqMoZdjOjltx345GSxwS8hHkvpmuQk12s/wxwsDpwBJ4Nd6W5AUYvnGIm+tKnDZ1kDtk0Y0G2zxFx1GWa4U6i967+Iw7V3JSz0Jk+ejIceekhE73rz4IMPYtKkSUP13hjmsMO23wOzh1NeJh+JkuomiBozEnzKjJPhOeMjkHpN8LJnXY3E6uegyQrkHVnAsJF1MjAdA7VuMmaR4FC64etPQDb1HrfJvMlLSbZX6KlPoqbzwrlUz0EKhGDGN8Fqer5Yl6fWnA5965Mwt70NGCrUsnmYpC2Av6Ecpg2oMlCvtUBefxcyuc4+DX5HWuNf5v1jb6mZdJ2Uli5CMN2MqNslHGLpGhA2LeD5+5GmViD92iaw2ybDDA+49m4Epm4+8sgjuOqqq3DhhRfiuOOOE/veeOMNLFy4UIi9K6+8EsMNTt1k9pdWt7fGwCOR3g29C1DaoRKuhpNN7bUXVu/0rmTWwuZ2HVrawI1tHZgWyolonqgjC1cjs+hPIpJXjEyV6Nibnc1I3f8jOMluIWzlmrGAbzmUMWOKzeit2Co4dBpSahsh+ZHxXIonwpcglrER9sq4OPB7BKViAwwh6rQZX0Vu1U9GXONfZujZW2rmLRNPRfa5u8V1chcs0XKBxF7VpA9hweYNqEvn6237f4YHuoYQvgs/KRaHGIYZHmnbTAlG9EjIvfbaa8KQ5Z577hF/8OnTp4t9xx9//NC/S4Y5HOzL9nukT0QGcMpTKkfBc851+6yzoX2XjpqFh7e/A0fL4bTx5Th7w3qMrjIgSXKfHlpUkzcSjEQUf0jU5ME2AZkuyTlY2Q7AGiXS4OAYcLJtcIwAJPQ4jzopBKxO3HCiH1nZAw9SyK7YLfLEISTusu0jsvEv8wH2yErHgZ7rADVPp756mRxQXnMUsiuX7f36yW6bDDOs6N8g/VAZtEMv88EIvTvvvBOPP/64+ANdcsklIrrHMCUJT0QG7ZQnjED2IYJ3pKL4v21vI55JoswbxKVVk1FOk0Fpz8kgRQNJ8JW8kYjmFcYru2v1qBVFJaD0iDrJBclTDWT7RvSkQLWIfPhE/V5g4Aa/nipu/MsMeZ2OSASyTJR7y+D1lSHba9GHotB+qi8tK99new9222SYkcvBOPQyH0DD9J/+9Ke45ZZbkM1mkcvlxO2f/exnB/nSDHNkU5iIiMlJzySlVKNKB0NBiFGqFf0cKE2T0rMK2eEk8r725v/h2fWv492t72LHxrfw6LZ3AH+oz+P6TwZ71/iNhPNMDkbgPf5rkLWq/LanCt7Zt0IdO1ekdpLIU0PzREuL3oYrhQa/ZJQhKWVwN14thDc3/mWG6jylyRjV3ZlNqxDcvBLnbd4AJ9aWP3/9YTimKX4WFn32d/3c3zWEYZiR067hICrJmKGu0Zs2bZrolXf11VeL7XvvvRc//OEPsWbNGgx3uEaP2RtsT3/oJjbuY+fjl22r8ez61wA73xJAc4BZLj++ctxHob71jDB0IZGzt5YCI+08E9s9vfPE/SSaFRuSrexV/FK9X+7Nx+Ek033GsvdzlbJoZt4fCilWXtkl6pbTqZjoh0nRu8LnO7t0EZxoK6RIDbzHn9/HdOVAo/LscMwcbvgcfP/hdg1HsNDzeDyIxWLiJ5HJZBCJRESEb7jDQo9hhtbExk7ERHoX1ZllAmX4bU0F3tn6DnqSDwXzDOAzvlFANg3Z64f7hAuhVtTxn+IgnF/ZPIh531OsZBfmr1kuavF2n3f0z4a1bY1wjaWoszp+FvyXfnZAYbe3uhx2OGYOt4jjc/CD4WB7bjIfQOompWsWRB7h9XrFPoZhmN0XioxoF0DpXebmFeKn1rkL5ZofE1QftJ7Dwo6EizqiALl0ShSxSkGnyF6/taf+KaAjib1Z0A84FvsyD2KYIUix6rJ0/F0DbNjFYySPD2bT6rzII/Sc+Nw7NKEeQDTSBO+na18QP2l70Oc5wxwEJOJENHrh78VP2u5/rvM5+MGmgZO4Iwo1eizyjhAzls9+9rP73ffrX//60N4VwzDDdrXUdmmip17viZ/T1YpLxxyDx/QsAtvXwG/ouFyNoDbU16a5v6vpiF9hHYzzK5sHMe+j02bCyGJjoh0ZjwrJMXGZbmFUoAKumafBWPemaKGekSR4Hae3t9J+63JoFZ8djpn3CzrvbD2BzJJHgXS22JO14O5c/P5hl+0PFDJeoc8+t2s4woTe3LlzsWTJkv3uG2ooarh69WqoqiqatWtaISbQlw0bNqC1tRVTp05FZWXl+/qeGGYksrfUl96CDB4fJF8ZHBIjPalccnktGlxefHb2BUhNP1vc5/UEoD/9F9F/r/BUvY1YuKHy4MQbuxgy75fTZlcuJURe1jbh1bzIVI/CM6qGW6aeKc679vEz8I+uLYjCRgQyLilvRKjfQsTe2jOkTR2OIkMiU6ZU937Pc4Y5UKzkNmTX/RZmyyuwunZBksfD5T4VkhzZc8GMF8qGfbsGZgiE3ltvvYUPEprokfnL73//e4waNQrpdBrRaBR33HEHLr/88uJxtL/Q22/8+PFYu3Ytvv/97+MrX/nKB/p+GaaU2Vt0jT6nwoihuyPf9y2TgpOOQxkzHZJjAbIijEFo0rYr0y1W8Tvj7Shr2Ybz4ynUdrYJIShX1MM96/TdL0jRwUQMpu1AkQDJNuEkoiOqj+Fgxdu+WlKwyQBzMOcfpVRRSxQSeR5FxcRAlXDUjNpGXvgpLjzdOBFx1YCsZxB3e/H06In47D7aMxSQJQl/2bwYUSODcG0VFjSbosE6Oxwzhwpd7/Qt98FseQF2ehfFpOHYy2DogEu7qPiddLDXWoYp6YbpH+QHlaJ3FKkrKysT+2677TZ87GMfw6ZNm1BfXy/23XrrrVi1apU4rrq6Gk899RQuuOACnHTSSeIfwzCH/lnsXb9AAiz3+hPwnH8D7NYmGKteL0bvlJqxkEKVonYH6XjxC5MgkUfRAatlC6J6Dk95FNxY1yj8+4jc6/8oHt+KCDa1SJDj7ajI7ES5ZkELhWElY1BLROgdiPgi8UaN6JHuBHwVYpKdd9FMAap/j8eJ7X7jQyK9IMbpb0OtGUaisylzcClW/zF5nkjNTBq54vlGoo1EHkXqYqoCddyMvKOurCAmSSIlq/dqfUE0FtI3wy4vEmZOiDyCnuPp8ZNwy9jjSr6lCvMBYKZgpXfBTm6HQ4sLtOhoG3CcjYDfO6CI29tC2b6ut8yhwU3TR7jQownNt7/97T77PvGJT+Cb3/wmli1bVhR6d911Fz73uc8JkUecf/75mDNnDv7617+y0GOYoaBX/QKlWlotW4Wws2n6V6jFo4t2Jglj7VLAH4Yc64ASroLcI+KKqVvkxNnzGEr1ommeu2k1pNFTICmqeJ3MSw9jQ4sMNd6G2q6VsGQXuhDAqEitMGxRetdWDFMOtP6Q0o/0LfeLZujUJ0+tOR1m68vFbeqTpwTG7PV1hBvnyw8Lg4yCGKe/095cERlmoO/ij46Zi79vX4b2XBJVWqBontAnUkcR/V4isP8krnddju3Y+Nm6F4vnqOlY6NLTyKoqfHxeMoe6SEaizF0Bx8gCDpkHSYDsAlQNnjOvgaLlgwf96b9Q1v/6u7/rLXPgcNP0D4YjWugNRKEecNKkSeLnzp070d7ejmOOOabPcbRNYnBfdX+9HUOpvQJh27b4xzCDodTT4hyXJhqbUyTPat4Ch1b2XRqseBTOjnWQ68bDat0Ku7tDjIVMTpmpGMxcGo7LA3vJU9BOuxJh1YMu+ny5NPEcEUeCx6RJnwNHUoRXez7lZiXgjIGpuKErPtiyirbARNS4vJASUdjZtFj1H64U010LLoOJqNimyF3/dMvc5vvEJIOws20wln8Pcmh63lQg2y7u12Z8da/nnZ1Jwdy0XIy3QM+KbYv6FlLUlWEOAPG92PP5pJ+9vysvqZ+Jx3auyLdgcPvE9o5UtM++S0fNEkKP8MiqeB6K6m1LdWFjsh1ZU0e5FkBHJoEGf4T/Jsw+F8mEQ3OvPq0DLZK5Gj4CfdU9cJC/fkIKQcYYwJL3O88Tbs9GErnN9wK5zvy+A7jeMgcGjS8tHBUdfXMpsX3LxFN5bJFfXBuRQq+lpUU4fF577bVFoUc1e0R5eXmfYysqKor3DQSlgH7ve9/bY39bWzMymeSQv3emhOluh/zeK0A6AfiCsGeeBoSqUHKMmwN52QuQ0klAdcPxBiGRIOtuAxU+OBX1kFJxQHHDNgyRJoNMG4yeurpU0zqcUlmNx2trkPVHUN7VhjPTJjIeP1AzHkin8q9jmZBMHVBt6AagSwpUMwfJziKXdaD7ypCIdtHSK4YtegZy686++1IpxHds6WtAYaagRLfu3rYNyKlm2Gp9fnWaSCfR3bwJUPYi2nJpKLoOmMbufY6E9rbmEVPryBz6pOze5ncRo+gIgB2ZDO5NvYrr644WkzKaSFwRnJCv45NVIJ7CXb2OT6WSuDe5+/gCJ7ur8fK2FUgmOqHZNsqlKO7Ds7i+8RSe7DF7Oxkhv/b3/Pdt/uQCXnwY9smX7/md4AQhu66FnP0XecICTgCG+2RkYlFA6utm3IfMTigtjwG5VsiJVbD9EwE1cGDX2xJAZIFQ/a2svm+fw7RlYEe0rc8+uk40NW8T2QAjnbq6hpEn9Lq6unDeeeehsbERd955Z3G/2+0uNm/vDRm0FO4biG984xv40pe+1CeiN3r0aFRX1xXrARlmf9E6EZlZ/hwcyQb8fpqJQ9q6bI/ITElQUw974kxkn/4z7HQS9rbVcGjRKVIjhB+SXZAiNZAj1SK10+5sFvU6hT5urdkoXrA90Lc0o9wfweXeSjSedA7kmrGwo63FFVqKHDrhckzJGNjcpqPLGQt3og2648HaVASTTr0QdbWjMJwR503NqD3cND0NjXtG9KLjihE9Bw5ssw6yP1w8jtKJtLoJ+Qhfv3O10IMwM+VYWFtWFCOxyvhZ8I0eX3rnKPO+kDJzMDpV+N09k10AtGxQVlk1oGvegR7vN8ox7b0sDKhQZUquk5Dp2oHgsZXwUxYBw/RDXM+K37cFbHgj5QNmeVhnfRK5N8fCSbZBClTvNUW+TxSv/XnApcNRw7CybkDfBqXsQ+L87H29LdV0yr1F4ocSGuuGVNMeTdPH1o0p2bE9XAwLoUeRubPPPhuBQEAYrfh8u1dSSJxRiHPHjh19HkPb48aN2+tzksnLQG0a6LmGMmTKoKTrqOhLhyzB+1yYUt2QTX1YpxbuDfpseE+6WBix6IYOye2BUjsOkuYTRgzaqVfAWPGyqIlwYu1iDOxMQlinL/S5EEt3i+NSsLAw14mbV7wM3/yPQ6mshzr/48UieBJ+yptPY6Y7irdbvFg2+aPQPSGYioYN21Tc2CgN+y8DMkTZ49xSlD5ijcZbG/+xYo2IrFVBm/1hUaNn59phqpUIjL9GHEfiOrf8pfz5GAjDNekYGBveyT+/rEAdPxswc5DLKqEdl38thjkQAi4PyjX/HpMyEmMDfQ4P9PiA7aDcNBHt1XkvYhjwU9SGv4eZAXC8fuGY2X+RjNLQBzoXZfpuOe/fB3Qi7k2hFs/O7ILVtQxyaCpkVxmk8DRY3WuEg7TsrYO78WrIdqYkjVnou+cfu95DzMiI341+0jbV1Q7F79q7Zpc+35ePnlM0Zyo0TefvpREo9Aoij8TdokWLhNjrjdfrxamnnorHHnsM1113ndiXSCTw/PPP4wc/+MFhetdMKXBAfdxGYO8d4QJ5/g2U/SdMPYqRpVAl1Npx4p+TyyDz0kNwujthbl+LtGkg5lbzrnxk2CDJwoglnYrB19MuoXcRPL0G1V0kXn0CyLRjQvMr2DzqdJi+asTSFjKGA597eH/JDuTwNvDCwhh4jvoaYKYBNT+ZaXfNxdPvNqMzo6FuZxfONv4Mz6Z8/bIQ3vSFuvAPUMTKM7WmsESk1HvGDexoyAya/o6ZhUnZ3iZ/B3o8OfNe5K3CE5n2Yg8+2i7FRTJmaDiYNggDORH3Jl8Xnl9Mg0Rpgw7s7rWQKj8EyVUGtf58eKZ+DnauE/qWB0rWmGVvvS77O+gOpfEKN01//zmihZ6u65g/f76IzlG65htvvFG8b/r06UXXzR/96EeYN28evvjFL+LEE0/Eb37zG9F378YbbzyM754pJafJAv2brI7U3jtClBw3H8rbzxcjSL1/b5rA0Xb0zUXQzHHwdbWi3BdGNJeC5PWL9Xua1Pn8A4ti8cX71jNwGWlobhnQ4xi/82W8N/FKhP0qvK7SGN/eE5D9Liy4/MXjFi6PI5alcXNQufEFbLWimKLnxLhSZE8ZNQlOkqKnZtEJsRB5LvVzk3l/GOykrHA8NUQnh02/ZYtzt/fj6Hbj8Rfh5qWL8os+vjC0OWfwn5DZJ/vqF3pQmKliejw9lxLKR/Ho+imJKN41kFx+GOt+vTuNPtchxCEtwpXKNXWgXpcFB91DgT73BZFH0E/aLkQKuWn6CBZ62WxW1MvNnDkTv/71r/vc9+Uvf7ko9KhXHjVL/+1vfytaLZDYo2bp/j453AwzSA4wWjfkXzpHOH1W5hobcWnNVIwK1fT5vcUxnevRNaoW5WPG4JIxx+Cjpo6/b30LHTvWIKIbYuWe0hcHqntMpbqBZFTcN75aw+a2nBB7FZqJ8+ZUlOYYH8DCApHWHRHVJFQrC48eRxYyHNWdN7GhFgok6AIhgIwxesZU8nuFe2oJjhzzATHYSdmuTDf+vv5VtPf6zJOw653+TrcpfVtrbUJu2Yt9emlyr0dmX+fikJlJURqmVrlb7PWK4pHAE/XORrJ4fwGxTZkWPYtwIy1yfyRECpn9IzmiIIQhM5ZQKITu7m42Y2EG3etspECXi99seGWPFb/eOfz7OoagFX6vZQ2YQlgQkWS1HGxaiwtzDupBdWuA5Q0huOD6kq3dEU5nz961x8JCn1ThnuP++HJnXuw5DmZufBhhpxPTK1TYbU3iGNeMk+CePFfU6NnxLbCV1ZAqy6EEKuCedDPU4N7rlxlmf+dp7954+zruN+tfRtuGN4t9MymKf7OvTgi7/uf0gZz7DPN+sb9+ecJAa+XtfcQeHVdKEb0+n8cDjNwP1byBGaERPYY53Iy0aN1QrMzt7xj6l7Yd+PaR3kHjHK8dgydbtuGmnCOK770fOq9kRd5g0oBp+4I5ISxc1g0j0YSyUZsxwVwNx3HBNXUetLlXQKkZm09BGncUcit+CCfugtX+LMyWDPSmR+A76a9w15x02H5XpvQbHNN1oCsTL4o8on9d7mCj2QxzKIi4hpka0EiFRF3/Wuje0DaJv/5isBTnBEOdTvl+RQqZA4OFHsN8kCkiIyCHf1/H7IoZQqBQNCrsU3DB7DLUeU0xvv0FouzxIzF2KqTxJ8PrKxsRXwoHurBQH3bhhtPKkVzxBygmid+jAMuC7NOLIo+QrDQsIwqrfTEcK9+CxjHiyC6/FerZz5S0cGaGlv3V2fSHrgPl3jK0ubU+Eb0B63JHoKkV88G0QDrQiB3RuxZ6IPYnBpm9w8Yrhw/+lmcYZtArcyTciIjLi0urJu/7mJ7VO2LhuzEk40mRcmh0NGPDg39E6snfi7Qtrbur+JgCZNHu9QbzK/4jJMtcGKbsY8JS6I1HK9Oq2Znv7UT/KSqcXGd+ElJA9UNWPEWRl38BFWYuCifb/gH8NkypsK9IfbG21swVP6fiOjB6DqoapgFureioOVBdbiGaTc6wKTji50gwtWKGpryCvj/SC/PfI7S9T1fNXkYqB/OdIq7PPXV7zMFFCnnsPli4Rq8HrtFjmAOHviCTHTsgv/1P4e5I0Tf3iRfm6xd7VlaJ3nn+iZZdeO2hv+fNQ1xBuM0UZMfGnLFeuBQyDwmj65RL+jRrvThQj8r3XuMayQFqRmkyjPKNkOTcPmtGzMRWJP95rojkWVAQN8NISDVYWvMgLjgmIqKDDHModTZkurK3lE5R07ePutw+aaHbl6EzE0dQ8+EjY+aiwR/hPwxz6HXNRhKZ5d/d4/He2d8Too1hShmO6DHMEFCIsoyUqBOhvPM87M5dMJtWQX/vX0jedStSj/46H6Fb+EchSgqrdzQuyrJnEXIS4rG+XBTV0TXQVAmq3GPikoxhlOoRE8cvTz0Lt0w8tSjyCvcLkTNCxlicU+T01vP79m+/QO0S0FEOSasQm3urGSHjFarJU8JHIWZVCZH3ru/LiGUdkUY7UsaTOTT2FakfKKWzd2SPGqXvraF177TQbekolida8M/W9fja8n9gRyrKfzZm7+yrtnMAV80+5zNtq/0rxRmm9OAaPYY5yJz/Ee3MmcvATsREzzaqvxGipG0HjGwGEtXkGDr0LSsgffQrKKsak/9CTsVEq4RNbVnEDRlVsoTxlYpo6N27JqeQ3iGE8wg1aBionkRWK/cYD2QUaJP+A5Li7LNmhIxXcqc+jUXPr0UWFUBPbV6pNJ9nPhinzXpvaI9eepSuuS/zpd4uncRAjp20rzObxLpEK3SK/EmSeI6Ht7+LL0yZx6lezMAcYG3n3oxUxLlNafAH8D3PMMMVFnoMcwjCbb9NrksVzSvSNYuOeiT06Ee8E3JZOVpcLizUbMSXPIiqKceLOr6Irwwxsw2vjLYRp0bf0hRc7I0gkE6JcXYfOz8v7noarvf+EhfC2zIhhSpL3qBhb/Uk2oyvDjip2Vc6XG8CHgWeQC2yPT34CDLEKZXm88z7cy7ujLXgsbZ1iBoZEcW7dNQsRDTfAZkv9XbplKm2CRIsx94jvTOaS2NNogVNqShUSUbY7UWZ6kHCyHKvLeaQnYoHMlKxo63IvHbXHt/z+3LmZJjhCAs9ZkTTP3JXEG6dLc3Y3B6FaW1Hxa42zLr+KwM7FI5QW3CxQnrihTC2rBA1etA8kKUK2IlOOJKEhSEfom43pGwa7evewMPLX8I5O3fh+xU+xGwXvB4/JtdNwNORetwy9jjYqW5kX3kE5uYV4vnVxpnwnHiREH+997vcHvEFXdIRUzM1YGNeycoUJzV2IioaoNP47CsdrveEpXdbhqLr6ZwQT2aYvS54ZZcuwsPpZkRdLtg1Y7DNyIqUyinBamGUVBBrBet06n8ZcGlCDBIFkUfn4tvR7aBVnDmRhmJ6J6Vn0zX0sR3LMcZXjq3JLmRtE0kjh6PDDXkzpl6OvgxzKC2QCq6ae1ug1U6eB33LA/t05mSY4QYLPWbEpmIOFLlbuXkb/vLnR/Dimi2w7N21S+P//jKuuvoaXHnlh+F29+ovM4JtwdWKOviv+SZyS56Ek0kCsgpz63tI6zkh8mRfGZxsCo6ioiPWikeQQsyhtE4bWdWNTXoSQUrxUhTgzafzYk7PwTZ16G8/K7ZdR50sJofq6Cni+WFbpR8x7akn6d+Yl1ahlXJ/fjKy8W7Y5g4Yu+6CpO05GdmblTgZr9x4eoVI16RIXsmOIXNIFCbCqVQM2yULm8wccs3rEPN4hZCbEKjs016BxB6JO0q1pCgcGSrNr5tWjPKZjo2sZRZvuyQFnfF2dD37V7HI06aZ8Nc24rTqiViXaINhmajzhbjXFvP+tEAaYIGWFs/ouuqY3X0yKUqxITozsmChx5Q8Awk6OVKzx4reg7/8MW7/+z9h27bY11BeBq/Lhe1d3di8ZQt+9KMf4tlnn8GvfvUbBIPBQaeOlBLr1q1DeXk5qqrqoJx/Y3E1lcZaXfwEKnLtiKkqIAGObcGX7EZSlqGRUFMUONkkMmZOTBq9pol0d0dR5Nlkj21ZcKgvXPMW2F3NUMdOL9bylXrEdF+NefNpnQ+IyQilwQ00Gdlb6mfhGFEDyTV5zAFMhL1wsAsWKEHbti1kqZWCBCj0v161eBR1I3GXNHPF+rpndq1G2OVFzMiIdEyPouYXbSRZnKNlLdvgyeWfJ6IbiLZsQWDsDMyNjEbQ5cF/TD6D+zwy7w8DLdD6vWLxjK6rBcQ1lFI92ZmTGcaw0GNKmv4pGrRql138ODzzrulzkX9pzRbc9shz4va5887AdUePxQTNFKIj7SvH01u6cOdzS/DWW2/hi1/8An7/+z8UJyH9U0eSySQ2vPM26utHobZ2aFMM165di8rKClRWVh3U43fs2IGtW7eI26NGNaCxsfGgnufPf/4TTjnlFFx00cV9VlNFlO+Cm/BhquvZtRLtm5chlErg3J278HRtDRpTaWwJBJCTHURkFz4y+hhRjydq71xu2N3tQuRBOHFKsDp3ISNJ8BgG3C4ycBgZEdNCPYljpOCYefFXSMUcKK2zz2TkQI5hmAOYCGeSUdRDRsbJL9B4FBcCqgYLjrDsLtTikZkKpW2ajgVVIoMlSdT0XT1mLp5uWSOE39zyMbtr9GQX5uccSD3G3xc6Gp7Uc0jYlmiyTqmgA6bKM8wQMNACLaXBU4bEQJkUDDOcYaHHlDa9UjTsbKroEikcP2RFpALatoNfPfuGOObqq6/BN7/5rXx/nkV/gqT5UCZJ+MjREcwaNwqfuvNhLFmyGK+99ipOOeXUvumgmhf33nuPEEEkojZt2oiPfOSj+MIXvjhkv84f//gHnHnmWTj//PMP6vErV76HRx99FE1NW3HWWWfjP//zqxhqqIau4s1n8O/JKDKyGy41AtMGFrS0YlF9HfyOg6Cs4mNzryz2yaImynYyCqt9JxxFEc6drZFyPBHQsNVbCVfWwtkdKRw3uhZVIyBiSgizgJcf3l2fOH4WtNOu3GtaZ9/UzwrYqRZAVfPN1HnCwhzERNhZugij0xn4XR44NWORU13YlY2LqFzBUEWIulxapFySoPPIKiYGqzDGX44JwSp8JlhVjPoRdJuOyW7fUbw210PBzb46YPq53FCZOWy1fZQGvzuTogLu0ZfwX4MZ9rDQY0bEyjRF8ooiz63lLZUVBbI/jKXL38OOrjgCfj+++MUv5UUECbhsqo+gmBrx4IrLLsO999+PB+75K+amNkOPR+EqC0ObfQaU2nHw+/146qmn4fF4sH37dlx44fn42MeuRVXVwBG4DRs2oK2tDQ41Dp9zNAKBADZt2oTm5l1wuVwYM2YM6urqxbGtra3o6OjAunVrUVYWxKRJk1FTUzOo4TjvvAXi389+9lOYZr5mZm+sXbtGRA4Nw0BHRzumTp0Kl2t3fWLOdIQg7tOYtlcElQSGz3YgBSLQrv4GRj15Jz7R2omsL4jKSz4DT7Cyz5eu//IvQPYEYHU2w2rfjoVlGnZBQ1twAgzVh/vLXWgJnoibIgcXzRxO0DiSEYaxaTmQy9LMG8bmFZC8QWinXC3SN+1cO2QlBHfj1X3+BiQQ7e1umN2bAJcJdcxcaAP012OYfUGfSd/8j+PD3a14rHWtiNDVun34jynziiYphUgzpW2O8oaQsXRRi7cz043PTz6jeM5Rm4UC9Di6/hpHz4P6zguiH2QxpZ6Oo8U5trtnDvK6ORjHzP61fYVMCqt7HfRtjyK3kRZ72ZSFGd6w0GNGxMo0pWsWRB4JMvEdYFvwnPERLH17uzj2/AsuhM/n26fJyhUfvkAIvdeWLMW70yYKMViZeheRZa/BP+dkXHz6AiiefFphRUU5FEWB2z2wa9xXvvJlrF69Cg0No8X7HD16tBB6b765FC+++CIsyxSi75prPoabbrpZ3Ka0y0QiLlI4r7/+44MWeoPhzjvvRCKRQHt7m9hWFBV//etdaNNlbGzNoXtVAtFIp3BuJJOPvbqQpmLwzvso3HPPBqKtQKRGjEt/KFXLc9LFQihm/EHEVAM7rDoh8oi0ZKAjo4+Mvm/Up7C1CU7HLlHjKFH02R+CHe+A7KqGq/565N58HFYyjVzbiyLtSCkLwlF8Yvyov57iOguADnRVQ/aPPty/ETMMoetSQ7gWnwnV9Omd1xtK26RIHtXVzQk3CLMViviRGOwP1fBueeMJPJFpR9TtQmXDNFw+bgFGhWryEexn97S7Z5gDYW8GVAeDsf0xQO8Ut9mUhRnusNBjSh4yXqGaPErXpJXk3g26yfEttuE9sV2VahETEZpc7M1kpcEbEsdato1sPIbx3aug0Cp2WoGndVsfR8jbb78dV155JUKhfK+o/iuPL7/8El5++RX4fH0nRFdddTXmzTsTTU1N6O6O4dZbvyOE3kknnYRjj/3QIaVuDpZQKIQ//vFP4vZnv/R5fOHXP0Li6OPQYnYg4GSETT/Z9ZOTY2F1tNj7Dg7Ic8/vz9fUKXR/ZT46ub90Gk8ug9qmpVi/uUu4dEq2CU0OoNKnjYi+bw4Z23RTq4qebdsCcilIwQo4Lg36W88AqYwYczu+BemXPg9lVH0+ZTNOwjDSMyHXRMSklM1rmPcfYeDTKyrXm9599Og4ctQs1O4NFKUWIg+2WHjr2LEGj3kDuKWsemT2I2WGhP0ZUA0KrnFmSgwWesyIcdwUNXkUSaIISU/xNU2YfXK+jUJHZ2efycVAOfzt27aJY+mrozq7S4g8wrEBo3UbZH9IHP/jn/0cqVQK3/nOrQO+L3ouatUwf/65mDVrNs455xxcfPElIqr1m9/8Gg8++AAmTJgATfMgnU6LyFrB6fOD5PTTzyh+kSrTR2PXknfhPupYWLDQ7DRjhuMIsVeIshUEMq3aP55uR6fLhZraKlyR6S42Rx6o1UX/sSGDlstHz0Ey9gq2bFiFQDaHk61ynDgrXxNUqgjH12wbHASgVNTCScdhx9pp1PIpsEfPg6Rnd0+IHQdmdrGox7OzbZDcXsByQ5HmFcdpJJjXMIcPOs8KffRI7BWaqu+RgpnLiHYNUSnvaizQc+jKJpBJx4ER2I+UGSKGUpzto70NwwxHWOgxI8ZxkwQe1eRRuqZEk4eeNMO5jfV4eOkqPPveJnz2nE4RTRL0Mlkp8I9/PCZ+jmmcBpns7ckZzpFgeIKQLUMIlO/d9mMh8m6//ScDpigW+NrXvo5PfvJTwsnzzjvvEJP8yy+/Anfd9VcsWvQMKioqhMA75ZST8uKoJ70x7yTzwVBI26T0rI72dmgBL9yuvBue4RgwYaLK5+kTZaMI6sP1E/DujhCyloz1zTpS0jv4+qx5eeG95Ak4mRTkYGSP9KzeIrDeG8Lno51IeTxwuTW4ZBvyuufhjC3NVX6jbTEyy79XTD2Sy46F2jAZlqzAMXRIvjLApfWNmjp63nSFkGTAyMGRDEh+H5DOjJh2H8zhhRZxqJ8epXe6uzuhv/oPpPunYGpeEd2PpDP5iB7h1lDuCcLrK0N2hPYjZYaAIRRn+2pvwzDDERZ6TOmyl3qxQi8xsdocCOPUKWNRVeZHezyFe19/D58oewhOvBNSqAL2nPkI1NSJ47dt2yYibcT1x02AkmtFyh0BaZxQQIXsDeInr23A2ytW4j+/+jUsXvy6OHb27Dl7ROPI4OSNN5aI29SfSpJkUQNHkHHLfffdK8xPHnnkkT5fMFSTR/V79HyTJ09BLpdFJpPFlClTioYtbW2tmDlz1oBD0tnZiTVrVos2CyQsX331X5g2bboQlQPxwAP3o6ysTAiwdU+8hJO/8u/wVLmxU6RouUQq5ZzKbqxf31l8Dykzh3d2xZCz8oIwZ9hiO167Dfi//4GT7C7WSvaOoPbvd+iedbpIO/TT769IJb3KT3+Lgsgj6KelvAY7Oh2SZULyeEWEjyLQNF7FtOKuNsB2QQp4it2fJHjhOePa/KJATySaYd5v6DyjdM3MW8/sNQWT3HUv6lWjV9UwDZeNniPO1ZHYj5QZGoZanBVMWUREUPXxecgMa1joMaVLP0MVChbJHr+ocRJd2nrSDPHm07jx9Lm47YlXcOfzSxFr2YErJ1ZCkj3YtbIVG+Zcj0hqOX73ix+ju7sbUxtqMH9KLaSESzghOkYOyPpgRyqRWfc2amQJ9/zyvyGHKiG5NNFPr7/Qy+VyuOeee8TtQMCPK664AhdffLHY/tnPfoG//OXPQrRdf/314rEqNR8ngXn99bjjjjtw//334d/+7Xp0dnagvb29KLKeffZZrFq1Ej/+8cBCj5xAC69L0O1Pf/qWvQq9T33q09iyZYtwBv3W976LnWP9Ij1r+lHjcf6HTsSlp1fgycdexnuxbkyePDkvrh03JMMNyU7CkfPvm7btJU9DIpFH6DnhgkrtK0i4UU0a1e9QahetwTqJKHJvPwfHVwaJ0rpKfZWf0jX7pR7B6oZSUwOpulGcvJLqKgpdipBoJ88DNtwFe0MAjt4Kx4lAkiughuZBpt6EPElmjoTFtV6LM3TeTjjvRvxHLoOMovRppTBQqjzDHC5xJh7PfUeZEkByCjlhI5x4PC6MJ2giTxEMpjQoRImsjp2i+blcXgulYhTcs0/vcd+UYHTsQvLVJ/GXRc/jz6/ljVkogDQ14ofbpWJ91oVUd34SPmH8ePzy8pNQEfDBbFoFPZ1GtqsDWcmDgBGDS9OgaB5Ik4+DVtMA7/wPNs3wjjt+iw9/+MMH3VC9N9QYfsGCBTj33PnFfaK/YI/7Hrnk9a5/pAuJZFtwJAUv7ErhJU8WMZcbemACjgnMxM2JZ2A2rc67n/bgmnUqfOffiJ2xFjz84l9ESlfYNLGguRl16QzUSUcDiiqetxSd+Ap24LbsReqFC/ZIPZLiC2BtXVl0jKVeer5LPyvuz668XRwv+kM2bwFMCUr4w/Aef35JjREzfBDXhx7nzAL0uWVTFYZhmMMDR/SYkoYmvJ5zris2P3dyaeirXoO+8lWoUz+E+PTzsOWJhxBqW4WLyoHGWUE81JTBym4Tq7pSxefR/CFc9ZErcfONN8K15FHYsQ44eg7daQuabSFgdkGxDWEtnjMsdK9bj3iXgrHHJFBf/cEtHFB0bqig1NHKyt297nq771GqYe71J4TIIApNvZUx02FtW4ETTAeVRiPipg1fohkTr74E8lsRIa4L/QylQAjaCReKxz3Wtk6kcjm5HDqTMTzpUXGDriJFtiSegGjPQHWVpbTK39cOvALahOuQ23R3MfXIO/s7yL32dp/HFFflSBzm2gHTFOe1Ojof0fUe8xHI7sAer7U/AxyGGQr25lbM5xzDMMzhgYUeU/KQSyH1u6PqJYp8CCfDdBL28n8htvRNlJMtOBxYjoQTyl04OeRgQ0rC+rSDTimMV8bfgAVnn4pPnZ2v1bNoIrP0adiqGxSbIjtxEckSfi9Ub2cIN84EvFi4Kocbq/o2FR8ukFHM3qKk1JfQeO/VfK1dZcPuKB2lseo5kBH7UeUmzLbtkBI6tCX3wDXteHGIpPkhe/1wn3Ah1Io6JI0sujJxyOFq0SCc/j7bZRm/C6hIJbejwo7jw5luNJBgKRGh0tsO3DbisDuWChkn154HrWEB5MhsSOlOwHoD6tjpwkhIuMZaJpxEFyxKfd22DXayGU4mCckbgByogz0pAbmir9DrU/voD/eJZjPMUMMpmAzDMEcOLPSYEVOrZ7c0waIG1Jkk2VfC8QYhZ3VoRhI5d0iIPaqFsiFjdJkXNWUqomo51oyZhfmze/rEFaKE516H5oYT8d7f/4EZqRgqkIAk/nNgQUHOHcDG0WcilbFLqsF30ck0kxIiT9TatW/Pu0HSr0g/3Zo4zm7fDtnUAZcbdjIGY/07YtwkEoM9NTgkQqSlixBINaMz0Q7HMETPuBavhkBOF0YkneluPPzq/bhZlyFTi4FSSN/ssQOnXoN291o4VFciFiXaoDf9H+TmZ2CTCJS3QbamA3IYdjYKO9qF1DN3w27ZDPhqYMdWwpEykJI5SNIJwqxF6dV7rLfzrEjx3LpKRLRdM04SxhjDfhyZI5L+bsX94QgzwzDMBwMLPWZE4Jp5GvR1P9ud/EZ1X5kE4K5CRlZFXZlq68Ki3pYlET1RJRk+j4yTJvnRWLW7WfCumIEn343hX+s15EKXorprDXRVQZmdhCLZyMlevDrjM9DdZQh75dJq8N1jtiD6DPZKw+xdSyePnwXbNGBtXAaHHE5NA+bm94QAdM85A2rtuD4ihJw1z0wDj0W7kJaBgK6jlv4G1FPOIwOWhaieQgZB+EqlkXLBDjyza7fIU71woMBufw0oPwaS7IJcXQmr5S04OsSxUrgKsMqEcLZbooAxGpAsOI4C2+6C7Y3CiXcBZeX58en5e1HmZuFvRZCrbEmMIzPs6O+uWxILNwzDMEcoLPSYkWHGEm2HnU1CbpwJe9sawKBG5w4iY8dhY9qPhO1B2IoiIqUhWTpsw6b2eJDdHiw4tqZPhGThsm50JC3kDAeqY6JNrYJXNhF3XKLfW7NUjok7nkOZYqKxsQZ29ILSmcj0cjIlB1Np7HSRNuhdcEN+jHoc84Qpw1N/grF2KRwjK0SbRMJu2YtQ5n+8KELsRAy7rBweyGXhkMgzDFzQ0o7naqsQ19z510rHEYGCQnygFFos7LYDvw9QvHAcC7JvIuW+ihRjSCoMy4Gq+SAF4lAC02A0UcViBqb5Dhyljnp05NM5bQkSmeFk07B2bkT6ubtFj0L3sfMhk2upPwyHzIT0nIggwq3AkeSSGEfmyKZ/5K5/b9NC+wVRR20b8Cm7XTgZhmGYQ4eFHlOyFCYV5LhpNW+FE20F4p1QRk2EvXMjHMuCJ9OFD114BYyGGfBko0g/cSesli1Qc1nYLg/K6xsR8Pc096XG4bqDWNqCKgOaS0LW1tCm1gCKD14YqPQBU2KrEMx1QiU78ZRTUpGT/mYLhabn+UbueSFYPG7u2cL0xqaehBRIVVTYnbuK4sJKdcNs3oTH3Daytgy3JCOmubGovhYLmlvx/Oh6JDQfyl0eXGS7RWJsKbVYIDtwEntWbCuM7S/CpDRWbSpyFUdhy44scqYNj2JivNuBR7YBZzucXDdA/QmlEyC5NVHv6ORSALWpMHXIFfX5lNiOnUjd/yModePFuFNKreMxAG0TpKAbttkBOTSvJMaROTIxO5vRtfQpOOluBPwRkSpMCw/92y/sTHbimbUvIGobiLh9uKxhtmjAzjAMwxw6LPSY0kVEjKJC5Fl6FrIvBDvVDWvnBkjhGrhqxkDylsFc8wa8jUdBcldAqRoFyeMHbBOQVcjBvqKCau3CPkWIvfFVbmxu17GrfAaO7fwbwk4SvmgKfq8LKgkfo2+vuFKJnByo2YJcMxaSLwjZskj5iYgetbigPoaUS0j1ZNnyGnTrncjqBjaEypBRXNAsCx9Ka/hU/XRkzvw0ynMxGG8/W3IufgVDFqu1CRJGAbIFGDI2ra9DojILD7oQs6uxQfdgRvcyOHZOuGw6IoK3AfL4K+CqHgs7kxCij851Mrnpk6ZJbSkokuIrg+v40bB2UrpnDnCZQGXX4R4CpkTZkYriT6/fi3fMpAhQH5NO42NvPIHx82/o29sUDp7UJCQsXZyn1KPz0R3L8ZlJp5XEZ5xhGOZww0KPKV00L5LworszBdtxoMoSQsEqUYvn1E8BzAysptWwjJxI0/SceNF+rcHp9gVzQiJ9kzh1kg/nR3cg1DgNZi4HZ9sqgFw9KVWRDshlRWpjqUVO9mW2QAImbenwGiaUijoxviJt0K0JYRckgdiTthXw+FHhkbDcySFlWLBkFYpiYfGUKmzXzkTXK3FE/G5ccNw1qPNZpdVImVokpFryrSbEDgWWk4KRsLC67iZAtWHCh5C1AdOst/MCTdYgWWWidtGJ7oDn6m+IaCqJ5+yzd8OKtQOWAYdSYTU3bKQg2UFIqXYgnIVS1yCiz5LLBYk8Y6k+kJsCM0MIff4f3fqWEHmiIlQC3nEMBDNt+IKe7XONzfhDiFeWQe71mSaxR706qY0LwzAMc2iw0GNKluaYgZ+1HYsLjbdE/Z3mpJBNWULo6R1dUCQHHk2FGqkSTpyFFMv9Ravqwy7ceHqFcNP0WBlknsq7eLo8XpiaF7aehZOOCQdJyeuHa+rxpSNO9sPOdEysyNNkLeLy4rzyatRqfuyydTypmIhpLlQ3LcWlDbNRTimYyRjOgoaXZR1enwa3P4K6ZByvZjMYFXsKln8iGjEXC5dDjHlJjaPqh+yvBdzriiYpiuwHAlUwVY+IghJScCrcofnI7aC0TdGWHpKtics3jQf1F6RIqdXVDGP1YjjUW88fh1SxC1bOACQ/oMyCs+kVwE4JsahWnQRX/YmA6jvMg8AMR/blmkmLPG1mFjlRP2qJfTkJaFddyCgK/L0yArwuDRUb/yWuFwUofdOruD7w34lhGKYU6SmsYZjSm4g89nY3NugR/Dr472i3gzAMGzlbggEFipGBpGcQT1vC9IImzwVzisLkeV+igp4/lbHykTt/vp6EDqd0RTg2ZH8ESlUDXJPmwtz4Tn5iNBJW8ntEHhE1MlhUVwf4y7BQzYs8pbZR7H9s5wphFkJR0wlQcLqrDMfWTsasdBrNti4MN11WDnJyI9aaaxBNmUJYlxIFQxa1YWa+LYXjhVo2D5MWXIywP78GR66tF8xUoU26Hkp4Qo+zqQaYU+AaP1ucpzTu2aWLYDVvhuQPQSoLAzWb4dhJ4TFrORkY2YXI5GwYlgTHSMHc+TKMrQpsqltlmEEaXKWf+SvaF94pftJ2b8hQpcYThDdYnjcLouQKRUVdw7RilK5wjaVoNNXkkbgjCjV6JbWgwzAMcxjhiB5TkpBpSjJnIZWzIclB7FDrEbCTkOGgEt0wocKRFcSVIKykCZ9lQgpX5uvHsukBV6oLLNuWxn0L12BKyyuokJKYPc6Paj85JUpQItWQJs0VNVNU40dPMVLcDWklv/fKPBFTFaTPuBKJ9S9DlZXimNJxeqiiuLL/ETOLx5rexk6qnwRQZUnYojnQ5Qx0ZyuO9kyB11WDUsJKboO+5QHYRgKO5IGsTKcCSNSU5SPG6VgT5B0PwNnaCUOrhPeU/wd9xdvQY3FokSp4jl+Qr7/LpouumqKTo6IDMtXh+WAHKtDanUUVdBhWALKpinPfRfPvVLqkjIKY9x9aVNjyxhN4ItOOqGQjks7gojeewITzbiy6atJ1gCL2cTOHt9QmsfA1t2Isrhh/4oDnGRmvUE0epWtSJI/PRYZhmKGDhR5TkpBpSkBT4NcUdFseRJUIDMUDL3RYlgIoCmJKBLbigi7LMAMV8E86Btnn7h6wv1MhVcl2afjtc+04ruUVBKy4qPOLrlyHSI0G17TjYR59Plwr/gkntdtZrlRcIvcHreTTinz/NKxKLYByb9mA6VmFWr8GzYtbpp6JzqYm3J1pxos+A4ZJzesVKIoMVO4AMAmlQsGIxc61w2reAkdPwZaXQ0pUIrv4cXjOuwHyjgdhZzsAx4CdbUN8+0I87v4Usr5O+OUAzpPKUU9PRosSocpiA3vYHhEdhCIjmgFytgsW3PkWkj1BUcf2wpECI2YRghkaaFFBiDzknYjpJ23/Ry4j0rOLadtuH64bdxz+Y/IZ4jiK5O1PwHlNE+CUTYZhmCGFhR5TktCk4tK5ISzbloFLlbDJfwamZkyUx9cglZWQhhsd3lFApA6ZxuMwdf6HoD9/7x79nSjaQeltdJtcDTOSD1rXNATMbnjNBKakVsMFA3q7C5vsrejY9Bg6JszD2coSePQ43GX59gMjYZWafkdKu+o92aPtQnrWo9uXoSsTF6JvoPQsOq78+AtwzpJ/4JXcLvg8LmiBckwpr4el5ErLoMFMwcl1wO7eBTu+XPTPcxwVdkyFbIYAJwc7sBJOtgl2LgEnlUY66cFJ5mtQ5Bwsy4utW05F9YdvgFpRJ6zrnXQS5sZlkNQ04B8HR22ClmtFyq5CZ/NMVIY2QlENOJYGKTUVTnwdnAmzRsQiBDM0pFUFUberWFNK0HZalvHotl5p23papGcfiHsmN1BnGIZ5/2Chx5Qs9RE3br2sFv94uxvJnBedzsU4OhsB0t1Y3e1DwjcODdkmHJ9bDP3plbC620QT8AIk9uxsGrnXn4AVa4PVuhWqnsW1Xa/DsmxU6a3w2mmYslv0PNNiO6FF/NiS8eE78bMxtdJBUPPjAjmcj7yMAPaWhlWbzeLft2xBOhWDzx+GVjkFKbd3jwbJFEE96rybcPbaF9BuZIrpniVn0KD6AXc5zNbHAcnKR9pMA460Fo7rFOQSOqTEckh+F5xUNxzTgKZ2QUmbop40o0UQsv6F5OJ6hC7493zE2aNCGj0ZUJdAqZkKaB9Cy/YoyttWIhEdjZ0d9SiXWhBwDDhuGba7FU42dbhHghlG+FUNVQ3T0L5jTV7sufPblG/dP237QNwz99ZAndOJGYZhhgYWekxJMyrixqfPqkRatyG9+DQcKQtbMXFMbjmslmchh2ughhthZ2XhXCjVjS8KD6rhyz5/H/QV/xJNf0V/PVnFWLShFQFxDB3rkS202mGY2Sx2pN14r8WG5TjIVHlhZWzRiqHkHCN7UajLKYg2+td7cleYzCHVDR8k7Ep14cnFDyAxdirKNf8eDZIpsnf5uGP3iAyW0vgJI5aa85Bb8UfA5QZ0C06O6kZ1bDYjyDW1Yow/B082BklPQIIKRTJh2zogqaIPoaamISd2wWh7B5lXbwNynbDI5dDcAmeHCqW8AeO8NbCdTridMkguHd7y7ZAUAw6iQGI0rKY1cHIZSB5232QO7Ly9fPIpeNQbQFc2gXJPEJeNniME4EBp2/tdnMllhLijfnr0SHEWcjoxwzDMkMFCjyl5hPBwciKaVGgmTZNbx9Dh6Bnou7ZAa5wBubw23/OOohz+EJBOQk8lAdUFh/rAkWFLoFykgo6JeGBJAch6CslYNxxHQlIO4AXvqdjaacKvyVi7K4fx1XnBQ46RVDdYSpCA2xlrwaOta9Gup1ClBXD56Dl9RJs4LpuGTf3dFFWs/D8p5RDVbai2tdcGySPBoEGumgPZewycXBtsUFSvGYauQou3wWcbMF0BZGMSvKYNx7ag+CxIZgY5VxAqLJSZSZjRx5D6511wLBKA5YCzlc42OKYGO+uHK90qjF5Unw7UrYUkZwBbgWTS32In7HhgRDjCMkOH+GxOPn2Pz+ZAadv7/dxqXjT7/MW6vwhkXOStwgROJ2YYhhkSWOgxIwMyrAiE4cQ6oGey6E7bkA0ViU4TLlcKCSWFcePrUL3g3yEZOTRHc2h68A7kDAd+1GOs0g7F0iG53JBCVeKnVjMO+vb1sKQUZLcHzVojknre8aLMKyNnOtjcruPUyX54XaUlVKiuJvPGU/hjagfedUnQ/WXwal7EzSy+OX1+cYJndjYjt/gJGNvXiX3Z2rGIku+HcCVVoFsGWjNxpJKU0hmC1GMMMlBksNSgyKXvhK8jveTHQHw9HDWMeOdoqFYOmpFAW+44jJZeoD7qcBwZyGqQ/Um4FBN2WkFWluEJAko2KtI+4ersuaIrgCzB0buEMYsUPgOy9DIcVQdsKX+MkoLkuIBgsCRFNPP+MtBn82AXZ6gFS3QHmQLlRL0fbX/2fXrfDMMwIw0WesyIgCYdZIpC/ca6cgpMyGh2j0fAiCJnSojJIfxTPQHXUKRP82LhmiRGS0F4EEdK8qEpPBuTXO1QRk+FpKqiBYBjWVD8ZeiURyEp+1HlAOemFuOflZcIp0gjb0yHs2aUlcxkWvQPNHNwXv4/xLesxDs1QWRNBZJtIqtU4+2ubUgZORG5c7VsR/rh/8nXgckK0pIEb0sTIlOmYVdlLVZ1bEFzOgaXoUNevQRXdSXQEKqBHKqCe+bJUMZME2KolHGNOhaBBX9F+olfArIH8UwXfNEmyLaJQCIBMzMaLqSA6mZILsBIa4j7qoX7q6TYkEgg+2RSjYCUAyw571xoB+BkHSBbCYXSN2vqAIr6GUmR9in+aRG4xp4g+pkxzFAw2MUZSvmmFizq2Bn55uqygpgklZbxEsMwzGGEhR4zYiCjD+eM6/Bm6yhMW/cwgplWxKUA/hG6CKMrGjFn04uIpw3AH4aRORabR52Gidufhz/TAVe2A/aEBrh8AWgnXJh/rngX0s/djdG6g81tOaRzNsJOEm7oyNoa3IqMOWO8GF9VGhOWnemYSM3qSnfD17UJ82xTCDrqbi56uTk2cpaF3733NGKbl6Fsx0Ys2LlDpL4+PbYRMa8PFf4ITj76fHx/3UtYG2+HZBnwmwaW6Bn4cp34xLurhGjMvHA/lIZJ8F/6WRhjp+5h2lJKyF4/lHA97EQMY50WdEsW0p5KqI4FjVI6bVvU1cGi398FTU9DQgp2jvo0GnDSHsBtwFEUWNQp0rIhIQ5FqYTLexqcWBRyZQCOVAcbzYCRyDdnr7oIvjM+UrLjygyzliyU2n2gtX0MwzDMAcFCjxlRUJ3c6NQGbFZGIaPVwHRkTM5tQmjzVoTKslAdFcjEMHvnIiQcL9xGCoFMK/RgLdz+AIxUEtKbz8A7/3pIZeWQgxGgs0sESEj0pJQgdMktGleXUjCKInmF+hu6HZWB5wNuzOqKYnnAJ9II5Vg7tFA1YjvXwe7ciZgi46nafB/CmJWDmXXQAQcvvv0kOmyZOuTBY5IFg4M2zY0ORUU2l4JXUgBJxo7uVjzzr7uRTp81oGlLyRjZ6A60Y+dDX/wkXHYOFRUuoLIBaGsB0jVwUlE4ZgskleLQJhTHQNI1Ck5XGF7vchEFkfRRyOppyJ44JHdOmHhmdAvuoBdKXQO0k29C+vXvQ4YGqBpk+RgowXGQI6XVhJ4pjZYsvPjAMAwzNLDQKwF0Xcdzzz2Ld955B5lMBuFwGGeeeRbmzp3LX5j9oBqwScEs2ltkqC4XHMtBjdyNgJ5FY7YL5maqdXJjUk7HRm0SDMeBz0qj0mjGe9t9yJmA5spi7DEJ1FeXwTX3XKx86FHIZgZZVxkWqyfApcqYVu+BS5FgO6VhxEIpVjQRs7Mp0eCbfrGYkcVl25qAujq8G4kAyW5kyDTPAryWDVOS0a5posfWdr8POZcbHk8Ao40UVMOCopEg3k3I0OGxLAoRiujUovIQuqleTc8iKkkDmrYMZ3bFDOHIGktbCPtcuODoM+BL/w3Q14t2C47PB0maDps6IGRGwQm2QVZMKDrQZc2BHI6gIgpIqSxsqRuu+l1wXDrFCAFDgdtJwOxYCFftxyF56mAZJ8HlMiDRQgSNYaqbm6Uzh52RYLzEMAxzuGChN8yjAXfd9Vf86U9/RDQa7XPf3XffhYkTJ+KrX/06TjrpJIxUhKNgLlM0+KCf4apy1LXlYBiGsKpPu8oxNr4KLluHI0swMmlkYt3IVU2CpgKhoAfdCeqXlwUUDd1SGRauyuECl47Hlrnwkr0AQb+OUdVBpDsN6IYjBIzLyiIQLA0jFpFi5fKibetKwMhBCoQQ6u7AmFQKHtvB9EQCVLm4SnVhtScANeCnFuAo03UYioKcogCaD0lZwjIYlGAoQqC2JEG1bYxKZ3Hhzl1IKwp8lo20oqJNVSGrGlyqm+xFDqgv13A6Lwsij4ilTGx48y7M9kbhGKTyTMDTAcdZBYRTkFymSLd0usfAbQQwdVYdVFWF2S3BdpdDLtsFS5JpRIVVvWihoFNPyCzSm97ByqYkvLEmGMFqjBkVQUCThDkRN0tnjgRK3XiJYRjmcMFCbxhPFH/wg+/joYceFNs1NbU4//zzRTRv69atePrpRdi4cSM+/elP4vbbf4LzzluAkQY5Q+aWPg09HsXr2zrgmnQ0Zpx+CV5PTkRjdDECmTgsbxl2TbkSkVwbkNwOt2PAkFxQFB+q4+uh2Ca6HQuKkUKVtR5ZLYRl9Vcjmrbw2DvUiN2G5paRMDRs6TTQWOlGpq0Zx2x5HSEnicZx1bCjF4iavuE+Ebu0egr+b+Vr6DRyCCdiOKYrhj80NuKVqkpojoPGdBqNuokXfCoiiht+I4OqbA6bgwG4TAvZbBpxlwK/A0zL2dhIZjWGjpPa2nByZzsW1dWiw63Ba1tIKgpeK4/AcrtRs/UdHFUzEWPLR5VM7Q6laxZEHqEiDTPdjHYpBxshqIqDkKsTstMBydAAk9wyDcg1KUj6VBGNTlkqmj3j4U7vQtivQ5XDoPCfouiU+QpHsWBnckh2xqGXG3B8IfgSrdjc6sPsaXXCnIijJwzDMAxTurDQG6b87W+PCJFHroRf+9rX8dGPXiVW+At89atfww9/+AM8+eQT+MY3vo4pU6aisbFxj+dZuXIlHnjgfnF72rRpuPbafxvS9/ncc8/B5VJxxhnzDurxB/v+SAi3v7IQW7a2iRYJ/1qxCeGmFmwNnobRO5cjERoLKWhBUVWMSqxH3FsDXfHCsU10JB1MdTWJ6AihGinoWgit4SlwZBW1nSuRqpmOZNYGBQnHV2nY3J4Tr1NbpuJyZRk8uglV9kKyEqJZuPfc64f9pFqOGTj3vW1QE9vgsW08NKYGKdmBZlvIKSq2BIKY6i2HGz7IMqWyOtgUdMGGjZmJGOKqircqIkjIMrbKEibEOiDZCj66sxP3ja3GinAIOVlC1OUSkb6gYSLhcqHN1rG9bQs+f1TpCBNK5Q37lLzYcxw4BtCSq0Ct5oEqZWE5DrKGAp/mhuyuhZNKAJYFuboS3jk3wFz/Hrasb4M3m0DMNw6Sqw1lxg74PH44dlLUPUr01EYOXqsJY5WtMLxu6MEyvF1zNWbNOw2KRnFShmEYhmFKlRKyiyhNhJ19zu7T1Ni2bfzlL38Wtz//+f/Axz52bR+RRwSDQfzwhz/CCSecIFIU77//vgGfv7w8gg996ENiAr106RtD/v7XrFmNdevWHfTjD/b9kQtkQeQRpu2gK5pCJtoFjx4XaYOOpIixsRIxNNWdKKJ15PyWVX2I+uvREZ6M9vAkmJ4yRPwKNBeFSYCwFcWlM91iHxHwyJjZ4MUZ0wK4+WQvArkoVJn6wPW8lyT1iMpiOEPn3Iann0TcFYHXcpCVgA7VJRrMN2ayIqKXk2VEcmmE052Q7JyIhtqSDb9loDKXRbPXA9WGEHC65GCHz41y3YDlWD0iTwb5RVKaJwk8xQEimRzKHQmNpo1yMmkpEeh8vmBOCHVOJ2ZufATHbX4IlTE/opgOCx4Ykhdd5kRAbhTpq3KoEkp1A1xTz4C5eQ2MdBI5S0LKW4VIvAm+7RZcmTQc6qdn+IFkFZDWIAUScDVuhMe/HR6ri/KJMVF9Hh4rw43SGYZhGKbE4YjesDFrUPITw5CKf732BpqamuD3+3HNNdcUnfsoStA74qEoCm644UYsWbIEjz/+D3zpS1+G19u3Z1Z9/ShceullME0Lr7zy0j7fT1dXFx5++P+wY8cOMfH/6Ec/ilmzZuO1117DU08tFNHFUaNG4YorrkRVVRWamrbipZdeEj3ltm3bJqJ655xzzqDGYDDv75lnnoamaWhtbcW6DZtQFuvGnJrdLo267IZaFkHWXYZgugWhQqqmVoZ1ihvvTbxSNKu2FTfGbHsUSMagal6EQn64VQnTqySYLVsg2xLcyx7DBVPPwsKtXvH3IdF3wbgMcq88CXNHXtgqteMge/wlUQuVTqaFYNVdQaS0CGBGEdJ1pGRAkxXMSKQA2xR/J6uqEklVhc+RUWbmMDadwsU7d6FLc2NcKo0twSDSiltEss5r2QmfRRYuZMFCK08OVNuBLOcFOp3NXkdCteaH1xtEKUGf5cuVpdDrDKiyB+/tALrbj8aL9V/H1i4DPj2FqxPPYlJgMdweC+qYufCMugLZDYugSIDHlW/j4c1FkXVVQm5Xobg2Q5J0QPMDvjZIiguyY4ioquruhumbjenZN5F56jeQgzUifXO4pxUzDMMwDDMwLPSGi1lD2sIDi7tQ5lXw2tNviX1zjzsZMd2N+5Z27haDs8sQ8qlF0XfCCSeirKwM8XhcCLRJkyYd9Hv6+te/hrq6Ohx99NFC1JWXV4j9tbU1IupG4m/z5s248cZP4G9/exSBQBD19fUi2kj3NzSMwvvJ6tWr8eijj+Kiiy7EmIZ63LFwIawTT8LcmjBsSUY6Mg6XHhvBC7l5qF36S2iOgVDIB6dqFGa0v4qlYy5HoMwvBHX1CZchuXgRlGQHIE8XkT5r63uQZQlKzTjY3R0Ir30eN5x7HbLkm6EC2efuhpPqFgLPatkq/ikzTi6JWihfwCcEa3umEy+OCiENL3KSjSavhoyiIGQYaEiToyMQNA24HRsuWcVRiSTCuSzKDQsVuolut4QpKYriZVGVy2JSMopmr1ekFnSSCydFTA0dNVkbKhzYsoa57iCuOOai0muensvAScWEOysxvlrDptYktrbb0BU/GkaV4zXtRqx1X4/rTw9DdgXyj/M+Cbv7RUwoTyCaBJROG4oahsdXASluAoEdkFxqT+P0MCRvDi7K45QVjHXHIJkaALcQ7qWSVswwDMMwzJ6w0DvCzRooY9O0HCgysGJnVtj225YpjmlPy33E4I4uA999tAUTayitUC1GADWPF4jHRRuGQyEa7cJZZ50lInPl5eXF/Q0No0VrB0rRpPYO7e3tQlSOGzcOkydPFlE2isp9EJDD6H/+59fEbZe/Ag/fdw/O9ncjnG5BDXYUvl8AACElSURBVLpRFV2La86agHh6qmhITQKO5rhzHR3HnhbMCxpJgtUlQdVTMLevo2onSPUTIIWqIGk+WK1bAT0HuDW455wBX+24fMNwStGkqBRF8cZOB2wLnjM+Atnjw3CHRNbEk47Hc/+6GxlLh+SY2BQqg+TYmBXLO76uC5ZhRnc3GpMpbAkEkFNlBBUXLujugisYxgXROBZVVSBKhizJDE7vysFUffj7uLHIuT2QZQW2bSFgmPj+ylWi3YJVVovqE6bA6/aLMS66p5YC9LsEwsXzJqDJmD6pFhNsMmORi6m/nYYbOfjhk6R8umVlF5xkAqq1HZVhG5hkIRCtgmwF4GA0JM80+K7/EfR3fwRr5wo4ejccuROyPwSkNCjq7rYrxbRirW+kn2EYhmGY4Q8LvSMUisjJEvB2UwaGZYtVf8uGqP3yBvMia1fTeuyK6vC687VLBUMQ0waiKQv3vNoFVe9AR3u7uN9yhw7pPX3/+z/E7353B37xi58LY5f/+q8fYMKECfjRj36InTt34swzz4TP5xO1dMkkGUJ88IwePbp4e+aUsfhbdBsavB54qY+dkUHqid8j+NlfwB2KFCfYNHmWvH54fB5RD+mx0ki8/hSkzSvg5NKwujsAaitAuKleqgqylhdvuWUvQpn/8eKk3U7EhDC3HQdaoGzYp2wWoDFy71qOjkAYWtqCbCSQkanpeT69ktIt6T9qnO63LBHJC5oybomMh5WWIBlZ1OeSuMlfj3RXM7RYh0jdTAe8WF4WgCPLqDBtYR5CRiwU1aNaQMRaoL/1LMy3noVr8lwoVaNKJt2QxBb9LhRVo3ORzp/AsfNR9Z6rjyMnReqLLTrMFCBlIZXZkIwIPQkcD9Xb7YTTORlyIAzfBTfB5Q1DmfVZ6MH7YKdbIXmr4R5zGXJLluT75xXeQwmkFTMMwzAMMzAs9I5QmmMGVmzLiJ9EVUCG20XTagejp58MxaWhu2WziKSVNRyFMRVuIfI0l4SsbmNLu44dUQPSur/BcWzUNM7CGzs9mDnROeiIyNSpU/Hzn/9CTPpJ7N1zz9347ne/h+XLl+G2236MadOmi2geuX0WcLvd+X51HxDvvPN2XrhJEt589RWMCahALg0nFRfCwtyyEsayl+A+dj70t56B1bETdlcLsv5qLPvV/yCV0ZFJG2g0tsDvZFHmJIF0QkTnRNUYRe7MFkhjpkKtHScmzU4uI8RObPKZWPnE48i27ECF0QapvA7jzb+g6rTh316B0gzVRAw+U0KnJ4gOLxDVXKIHHok7svOnsrqNwYAY+9mpLOYp5VjZrsBwxsLyqziqMg1/pBz+RBfsQAipTEKYuUgiJZNcIk0xjoWzk1xPKZUTnbuE+DO3vAfJ4y+pdEM6L+h3EVE1t6fHpGXP2tzi76r6IbnKADMjRB4h+yogH30svBO+CCk8qpjiqgTGwHPU1wEzDaj5SLV0XKSPsCyFtGKGYRiGYQaGhd4RCNW6/d/SGNKGjXKfDIMcI1MWAhqwrjmHhnIfwpNOR+fqZ7Ht+Z8jcs4PkNWrEfYrqAu5sKVDR8awobesQPzdv4nnnHLipWLimDHypi0FyLiERNvWpia0tbbgW9/6JhYsWIBTTjl1j/f1/e//F7LZrEgBpajdt7/9/8R+OvaLX/wCZsw4CuvXrxc1gQVmzJiBb3/7Wz0Rv7OEScuSJYvxqU99WtxPhi0PPfSQaAcxEPT+fvnLXwjzmZaW5n2+PyKRSOCaa64S9YPLl72Lnx0ThNO+A7BIbEqAmcMbv78Ny/2N+NSXvw7n3edFLdP2rVHUty2BZRiIymGYkgNZSiJn5kT7gN2ep9TLOgfb1GFagCrJ6H7uQSAdw/pODS9nJ+I8/R14rBTMzm3Ytl5GmedpeOcPc2GieaGVleP01jR+HzaQc1TRI4/Y4vfDa9kYm0rDb1tIuDWsr65DsisKyd0F3V8G1YxjSTqJyym6FKnEk0ENMVcNKsrrMdnKYYOjI+Nk4DYNzI51w2OR/6YwOYVE6YoinbYFqmWUXLqhOC96/S71YRduPL1CfFYpktf7vKHb7gkfh9m+GE6uA5LqgxyaCsVTDTnSsMc5JrZd1Dh978KSYRiGYZjShIXeEei0+ehbMby0JoHWbhO0OG9YDlyKjOqQjMm1brhVGbXH/xvi25bBiO9C+8IvITn5fEyefwHciCC2awNiaxahe+0/hROiu+F4hCee3DcFrIduXUWmbDqCU6aiZqaMSWO8qK0dOPp0zDHHiOicx+MRbR0KaZJf+cp/4rTTTkMqlcKcOUdjxYoVaGhoEPedeupp+O1vf4fNmzcJMxYyaKHIX4G3334b6XR6r+NBLqFk5EL/Cuzt/RHnnjsf8+bNE6YwXzt9OvzvPQ+nI4pTKvLpraYjwWsbqOxuQexPt0JJdYqIZ30mk48oORYC6BYOkKbsETVjvUUe4UBGVyyDeKoJG+TRgN0F2bGQ1CXM05fCZadhKzJUS4c7tg16vBzeYS5MRJrhcedhZvQBTOtsgkVmK7YhonFZxxGtEFwUSVVc2Eb1eWYO9WYaaynC5yQwI5NCtyLhCTqwezu6NQ8kVwDd4UoEO3fhVFNGWyKBilQK83fshCW5ITs5qo7seQMyrYCIXnJSuKrk0w1pvHsvyPRGDY6F/8Q7oW+6C7bRDVmrgrvxmgMWbf2FJcMwDMMwpQkLvSPQaTOZtUStGDk86qYN2wFkycHYCreYpKV1G6qvAmMu/hG2PvldWPEdSK+4H/9YkW8s3hv3mJNQduIX0Npt4xOn+fd4vZc3OaifdW5xn+FTMGFC3k2zPxdccOFe3/txxx1fvH366af3uY+ievRvoDq6ceMaMX/+eXt9XooODtbIZcKEiRg/qh6pfyxHNks1TRImBRQh2Ei4jfK4ENbcsNqahPU83S87cv52TxSJPhiqnUYO1PBbErb/NI22ISMpB9AcnISulA0t1YoKKwqXYyAHBV47ixzccNORqgwNOly+QEkIEzlSg6qAFzVxF6LkDqTnhUW9pAiBF1MVmGYOOVUVffVoHMnY35Ek6JDgBtDhmIDmgZvGw7ZgNa2GHa7G1VubgEwKGkXrFA2IlImok6NnkZYAr2lC9gUgl+dbAoz0SJQSGAvPrP/XJy2TYRiGYRimNyz0jkCnTTJd8WsKTNuCLElQKG3NcbChNQevW8bs0R4cM86Ld1CPsvN+CnPHYpibFiHTulY8j6y44G44DhVHXSjq93TTwab2HL7zaAuObfTjo8eHEfYqSOm2MG3pPUccKL3z/YSihEMFRfNcLld+g8xRfCHA1OHIKhzhVErSw0FKKYMnF4VMPfN64nU0xv2hPZqQKhIsKFBgidskYRqaX8cEmyJONky40C6XQ5YUVDgxdEoh+KwsdNuNVqUKuTFnYWYpTMSpFjGXwYVZCwu9EqIuDeFMGhdaEtQps7CoIoK2pvcQMdKo1XVIsgZ3j0kLBfJMxYXaXBxwuRHXelwfjRyqKsfAt2EDJFkFKkZBrqgTrSlaq+vxeLoNMVlC2HLw4VOuRvnRZ7Oo2UtaJsMwDMMwTG9Y6B1BkLii9EoSX0GvDPJeURUFluUgmraLE1wyW7jq+DCCHhkvUSJh9dmom7cA725NwjR01Ff6YdlS3qIdDjqSpnisYTp4Y1MSy5rSom0DTcBJSDZWaQh48gYOA6V3Dhd6Rw1FLdPcs5F45TEYOTL5yJ/qQrQZuojW0e18QicNxu4EzUJtWGEPjaEBGUbP0R6b4nwiViX6v0kwUGl3IiEFkZApVdFB0ElBclLYqpfhoX9uwIyjxg3/PnCaF3IwgobKMbihZSsy5IzpCyJw1ZeFMc1nHQdd0QQ6k5143J3FBsfEpGw3dMUDyw2EdR3nd8WgBMvxlMcWUcGI4sZlM8+BFs/CjlPPQvo7ObCTUTwVLkMiEoBimUh6/Fjod+Ezh3sMGIZhGIZhhgks9I4g8o57IZG+Ob5KE46bVUEF27oMnDTKC80li/YKpmWLOj0ybDhrRhmeXxXHi2uSMBwZ4aAfpk09uJxilJAIefMipS1OvfksVAYVIfIkycaumI5JNR5E/P0c/oY5cs1Y/Mt3Ehoyy1BvtQgBl4QXG6QGfAjUWiGfXlhAV3yQbUOkYdKxZHBfqBGjxE2dEjIlBV4n07OH/nOgioROHbLTjbTlE1FASvU0JBc8Thanb/s/dCXOQGWIGlWXRjsA6ifo9gagnXAh1Iq64v2R486H782n8alEFK/rLuwKnoHazpWQjG54vQFMvOKj0F97FDd0diMbDKFiwXVwBytgHde7zUAEmP1xxNa9AIn6FXr9UGobETUyyFgGfColgTIMwzAMwzAjRuht375duDRSk+7ezo/DCXLcu+G0clH/FfFJIo3yrlejSOUs4fKYyFrY3qnjzhfaUR1yCWF25vQgXlyTEDV3sbSJkEeBqko4frJHRAVf35gW0Tz6Z1n52r+ClnMcCeMq3bjh9AqU+5WSEXlEV8rBc2Xn4KPdG2HYefmVlPwISxkYcIuETBJkBP1sc9WIfnveZBtcdlbcS6ShCTMQS3KhWwqgwcr2SMB83R5BP91CGtJ9eRQnn+pZ5iTg1ql3WTWGO/tzbex9/8y0gm3L41gZmYYKzcR5c6vhjbihzTkDSMYQCoR3twLo97xkFVJtJ9CVTVAucl5Eun3wKj2puQzDMAzDMEzpCz2y/P/Yxz6GRYsWYezYscKK//bbb8fnPvc5DEfXzUIPLRISliOhvdvA6l1ZWLaD9gTVmkFsN0TciGcsYd6ytd1A1rB7mqXbIK+MrOGgzCsjmbXRGjeEqQtFBD0uSuOk246o+asM5NNDC/3nSoUK6j1YFsYubQy8ZgoRK4YwEgg7KXS7IpCNHDTJgK1oSATrRR9CDzKIlY3FZtQJ0RE0Y+hQK2G7/bDIdCQTRxlS8Nsp+JxMT0xQAtw+2IYukjtNEojUs4/q+iRACYbhLx/Y4GY4sj/XxsL99RoGbBMgxF1Z+X6f97LRc/DojuWI6mkh8i5rmF1S5yfDMAzDMMz7SUkIve9973tYunQpNm3ahLq6Ojz22GO47LLLcNxxx+H443e7QQ4X100SeYmMhcUbUzAtR0TgfG6gPW6KqB7NdUkE7ojqeGtLPh2TUjXtnlIzag1AgmNn1EBLjCbWPSVokoRyv4y0QQ3ZdTH5rgio+OeqBJ5dmRQRvc+cU4U5Y3woBUhQ3HjOKLy+NUS2pYBD7pmADhVJNYSN3kbUBxwomgc5LYRVEy5HpZpGm+lH2K9i3kQFz6zW0dmdxoYuSQjBMkVHtDyLqTufx+j2t1GR3gFZdUFSVZi2g5ziw66ySaiMboAMG77ycpRf/kkoSj51dqSxrzYB+2OUL4zPTDpNpGtSJI9FHsMwDMMwzAgTen/5y1/w6U9/Wog84tJLL8VRRx0l9g8noVdw3STBt6lNF9s5wxYirTsNZPLu/8IlhJw5XeQgmbVFVI+ifXmDlTw6ZRGK6FJPsVnPA7d1WXDJEOYrEZ+MrZ26iAK6FAntCRk/W9SGv9w0Zvgbh/Qwqc6HJUedisCKFbBMCQlbxU61ATURF04eXYu29m50S0F0TDwTV59chbqQ2icC5QtShFWFx28ioCm4ZG5IpNem9Zlwd21D9sWHYKx6HbBMKLXj0KY1wnDcaK6ehDGnnIZpM48asSJvKBB/A67JYxiGYRiGGXlCb9euXaIub+7cuX32UzTv3Xff3evjcrmc+Fegu5tqqIBYLAabGjMfBkjgue2UcMlMJdLIpk0RpRPvV3dEpK7P8QbgjZDhh4VEzoZh9TGP3Cuk+3yShOYskMnm68wkBUjkJGzOydiy04+KYGnUQtGY5gIV2BCaIVoqOFDgc8kYN7EGnjOvQkTPIiNp8LnJoTSFntMAes/jKbZ55WwFGUPuEX/p4jGGNwJnwSfhzPs3QM/BFQxjEqgdXAZev1eI5UQicdh+d4ZhGIZhGGZ4QfPHYDA4JJlMw17odXV1iZ8VFX1roGi7cN9A3HbbbSLlsz9U4zecWP0+POfE72OE8NnD/QYYhmEYhmEYpg9tbW2oqqoCRrrQKzTIJkOW3mQyGbjde7dh/8Y3voEvfelLxW2K4pEwJIE4XGuB4vE4Ro8eLdxHh6vr6JEEjyeP55EMn588nkcyfH7yWB6p8LnJ4zkczs99aZgRJfRoMCjEuXPnzj77aXvMmDF7fZymaeJfb8LhMEoBEnks9Hg8j1T4/OTxPJLh85PH80iFz00ezyMZPj+HlqEKOg17xw2fz4eTTjoJjz/+eHFfKpXCP//5T5xzzjmH9b0xDMMwDMMwDMMcDoZ9RI/4wQ9+IEQdpWOeeOKJ+NWvfoXq6mrcfPPNh/utMQzDMAzDMAzDfOAM+4gecfrpp+PFF18UjdJ/8YtfYMaMGXj11VcRCAQwkqBU1FtvvXWPlFSGx/NIgM9PHs8jGT4/eTyPVPjc5PE8kuHz88geT8kh/3mGYRiGYRiGYRimZCiJiB7DMAzDMAzDMAyzGxZ6DMMwDMMwDMMwJQYLPYZhGIZhGIZhmBKjJFw3md29A7ds2YLZs2cjGAzysBwCuVwO69atQygUEv0Yh6qfyUhF13WsXbtWtENpbGyEoiiH+y2VBCtXrkQsFsMJJ5wAVeXL+WBJJBJYvnz5HvvnzJkz4sy8hppNmzYhm81i2rRpotctM3jefPNN8V3Un8rKSkydOpWH9CCwLAubN28Wn/1x48ahvLycx/EQoPNz48aN4jZ/1gdPZ2cn1qxZgylTpqCqqmrAY1paWrB9+3aMHz8eFRUVg38RMmNhhjdLlixxLrnkEqeyspKMdZzFixcf7rc0bInH487nP/95JxKJOLNmzXJqamqco446ynnnnXcO91sblhiG4Xzzm98U5+acOXOc+vp6Z+zYsc5zzz13uN/asOeNN95wNE0Tn/n29vbD/XaGJXStpPE78cQTnZNPPrn4b+3atYf7rQ1b3n33XWfmzJlOdXW1M3fuXGfGjBnOsmXLDvfbGpZcdtllfc5LOk/pfP30pz99uN/asOSVV15xxo0b5zQ0NDhHH3204/V6nU984hOOaZqH+60NS+6++26nvLzcmTp1qtPY2OhMmDCBP+sHCH3HXHfddU5dXZ34TN9zzz17HGNZlnPzzTeL7/np06eLnzSfGiy8zFYCvPfee7j++uvxr3/963C/lWFPe3s7JkyYIKKjtNJPqyhHHXUULr30UloUOdxvb1iu9tEq1bZt2/Duu+9ix44duPDCC/GRj3wEtm0f7rc3bOnu7sbHPvYxfO5znzvcb6UkePbZZ0VLnsI/Wl1lBk9rayvOPvtsnHLKKdi1axfeeust/OMf/0BzczMP50Hw97//vc95+f/+3/8T+z/+8Y/zeB4ENG6nnnqqaMX1zjvvYOnSpbj77rvxwAMP8HgOklWrVuETn/gEbr/9dhGRoijp1Vdfjcsuu0xk8DD7hsZs3rx5IvNhb9xxxx146KGHsGzZMjHe1Ebuv//7v8V1YTCw0CsBbrzxRvHh4tStQ4dC45///Ofh9XrFtsvlEuNLQoVEHzM4/H4/vvCFLxTHk1Jgqe8lpRumUikezoPk5ptvxpVXXinGkjl0NmzYIL5M+Zw8NKiPLaVl/+xnPyumZ9PC2Xnnncen6RDwpz/9CbNmzcJxxx3H43mQC7nHH398MZWYFnHD4bDYzwyOV155Rcw5b7jhhuK+W265RZQP/fOf/+Th3A8UPKCFh8LcaCD+/Oc/48Mf/nAxTfvEE0/EWWedJfYPBhZ6DHMAdRJUW1ZXV8djdZBQDj9FnO+77z58+9vfxje+8Q2uIz1I/vCHP4hVwP/6r//i83GIuOSSS3DVVVeJep0vfelLoo6HGTzPP/88zjnnHDGRpgg+Tfo4cj80kBh5/PHHcdNNN/GpeZD86Ec/wv/+7//i3nvvxXPPPScWzOh7/brrruMxHSR0raSMnY6OjuI+yoQi3n77bR7PQ4S+gyhbb+7cuX320yIPXVsHA1fvM8x+zC5++MMf4utf/7qI7jEHx9/+9jeRwkXpHQ0NDWKVihk8q1evxje/+U2RxsXn49BMVl544QWRQkMsWbJEpB5SujEtRjCDg9I1R40aJSIltFJNJgJkHnD//fcLkzDm4LnnnntElPTaa6/lYTxIqGzgsccew9e+9jXxGacsHRJ/B2VwMcKhsaRoPWWTffWrXxXGSzRXoiyerq6uw/32hj2JRAKGYexxbtL2YMeXI3oMsxcoakIpRxdddBG+9a1v8TgdAvTF+vrrr4sVP0o9OOOMM4TbFDM4KNWDUj5odZ/EHgk/4o033hB1J8zgmDx5clHkEeReSmP84IMP8lAeBLT4sHDhQhG5p1RYSnmnMaZoKXPoaZu0QEaphszgoegTfdZJnNB5SecnZZn853/+J/74xz/ykA4SEnSLFy/Gaaedht/97nfimvnLX/5SLJ7tKx2ROTAKC7kkoHuTyWTgdrsxGFjoMcwAUOSJvhTIVIBWUtkefGigFWlKjSMzEfqSYAYHpRlRETdFmOnfXXfdJfZ///vfx6JFi3g4h4CamppiChIzOMiu/thjjxX/CJqQkGEDtVbpneLFDA6KNNOiDqdtHlp2ztatW/GpT32qWD86ffp08T1PKbHM4KE2HxQRfeqpp4RBCLVXKBjYMYcupCl61/+7iLap5ddgYKHHMP2gLwO6+FPhK+Xyc8+3g2cgc4tCzx1Olxk8lP7a24WPHM+IJ598UkxgmEM/P6l2hycqB8f8+fOFw2bvujxy2iXBV1ZWxqfnQUIRJ3KCJcdI5uAo9Cij87E3tL23/mXMvqHoUn+XyEgkIrKgmEOH6p2feOKJPnV7lDFB+wcD1+iVAFQHQZPngvJfsWIFTNMUq6tUD8UMzh6cRB5NSshBilZSC3Aj+sHz9NNPC4coaqdAtTvUhJ7ECaXEUpocwxxOqLaEnGDPPPNMEbWn6D21BCCxxwweumaSWRCZW1AtGaXIUUuAL37xi4NON2J2L0aQxfp3v/tdHpJDgKIgZLr0mc98RpQN1NbW4pFHHhHzJUo9ZAbPNddcI+ZLFBklp82f//znIoUzGAzycO4Hymois5UC69evF4u3dF5OnDhR7KNrJ5mvfPKTnxQ1kfT9RLV7X/7ylzEYJGqmN6hHMEfkKj/11ujPpz/9adFrizlwyM1ob73Jfv/734sLGjM4qA6CehVRDRldxBYsWCCEH0dKDx2qeySxQqt8oVCIT81BQiuklP5KCxK0Ok2pR/T5Hz16NI/lQdLW1oaf/OQnogaKUrsKjqYkqJnBQ2ZBt956q0iN48jToUH93eh7/OWXX0Y8Hhf1ejRPmjlzJp+aBwGZgtx2223is97Y2CgWeubMmcNjeQDQgiK1nuoPRUPJ06AAicGf/vSnYtFs0qRJ4vue2oANBhZ6DMMwDMMwDMMwJQbX6DEMwzAMwzAMw5QYLPQYhmEYhmEYhmFKDBZ6DMMwDMMwDMMwJQYLPYZhGIZhGIZhmBKDhR7DMAzDMAzDMEyJwUKPYRiGYRiGYRimxGChxzAMwzAMwzAMU2Kw0GMYhmGYIWLLli14/PHHD3ibYRiGYd4vWOgxDMMwJcfatWvx5JNP4vXXX0c6nR704zdv3ownnnhi0I97+eWXccsttxzw9sG+DsMwDMPsDxZ6DMMwTMmQSCRwzjnn4KSTTsIdd9yBb3zjG5g2bRp+/vOfD+p5XnjhBXzuc58b8vfX2NiISy655H1/HYZhGIZReQgYhmGYUuF73/seNm7cKCJl4XBY7Ovu7u6TLtnS0oKXXnpJ3PZ6vZgyZQqmTp1avH/nzp148803kUql8OCDD4p9s2fPFoKRaGpqwrJly1BRUYFjjjkGPp/vgN/fmDFjMH/+/CF5nc7OTrz99ttQVRXHHnssysrKDnrcGIZhmNKDhR7DMAxTMqxcuRJz584tijwiFArh3/7t34rbra2teOyxx8RtElmvvfYaFixYgHvvvReSJKG5uRnvvvuuSPksHEcii8TgF77wBXHcCSecgI6ODnHs3/72N3zoQx86oPdHqZvf/va3cfHFFx/S69Dx1113nfhd3W43Nm3ahDvvvBNnnXXWkI4nwzAMM3xhoccwDMOUDCSMfvKTn4i0TUqRrK+v3+MYipoVImgECalZs2bh73//O6644goRHbv55pvxgx/8oM9xf/jDH7Bw4UKsX79eRNmIH/7wh0JwrVmzZtDv9VBeh7YpLZX+EV1dXXjvvfcG/R4YhmGY0oWFHsMwDFMykPDJZrO49dZbhelJQ0MDzjvvPHzrW9/CuHHjiscZhiHSHnft2gVd1zF69GgsXbpUCL298Ze//EUIwhdffBGO44h/gUBAGL9QxK2urm5IfocDeR1KOSUhSL+rx+NBeXk5Tj/99CF5fYZhGKY0YKHHMAzDlAyapuHHP/4xbrvtNqxatQqvvvoqfvrTn4pUx9WrV6OqqkpEvs4///xifZ7f7xfpnG1tbft87q1btwpR+Mgjj/TZ/9GPflTsHyoO5HV+9atf4aabbhK/DxnPUCrojTfeKH5/hmEYhiFY6DEMwzAlB9XaHXXUUeIfuXBOnDgRzz33HK655hoR3TvzzDNx1113FY+nqB9FzvYFmZ3Q4yg19P3kQF6H0k8pAkkRvueff16Y0FCt4f333/++vjeGYRhm+MDtFRiGYZiSgaJh/aH0RqJg0EKumxTJK0DbJJJ6Q6mShcf1FoP33XefaOHQG3LPPFgO9nUKtymN89prr8XnP/95LFmy5KDfB8MwDFN6cESPYRiGKRkoCka1d+SiSTV5FPEiN8oTTzyx6Eh56aWX4n//939FbRu1JqA0SPrZG2pn0N7eLoxSKBpIEbTvfOc7InpGzpeUNkkOmW+88YZo5fDKK68c1Ps92Ne5/PLLMWPGDBx//PHIZDIiPfXqq68eghFkGIZhSgUWegzDMEzJ8Nvf/lYIPXKtpFYGkUhE1OyRyYrL5RLHfP3rXxcmLXQ/1bT94he/wJYtWyDLu5NcJk+ejKeeekr036NaPxJb1N+O0iWp7QEJLxKKZ599Nq666qq9NkTf3/bBvg7VHlLUb/HixaK9Av0OvZ+XYRiGYSRnf0UJDMMwDMMwDMMwzLCCa/QYhmEYhmEYhmFKDBZ6DMMwDMMwDMMwJQYLPYZhGIZhGIZhmBKDhR7DMAzDMAzDMEyJwUKPYRiGYRiGYRimxGChxzAMwzAMwzAMU2Kw0GMYhmEYhmEYhikxWOgxDMMwDMMwDMOUGCz0GIZhGIZhGIZhSgwWegzDMAzDMAzDMCUGCz2GYRiGYRiGYZgSg4UewzAMwzAMwzAMSov/D4NpasP6kfX4AAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -528,7 +546,7 @@ "id": "e1f0a3b2", "metadata": {}, "source": [ - "Of the 1,096 feasible designs, six are Pareto-efficient (ringed in the figure). All of them fly at the highest altitude (800 km) with the wider field of regard (60 degrees), which observe the most points per satellite, so the trade is in the number of satellites and planes. One satellite samples only 4% of the points sufficiently (at least four times a day), and the share rises steeply with the number of satellites: two satellites in two planes (29%) sample twice as many points as two in one plane (14%), and six satellites in two inclined planes sample 98%. No design with more than six satellites is efficient, because six already sample nearly every point. Designs with the same number of satellites differ widely: their layout (inclination, planes, and phasing) matters as much as their number." + "Of the 1,096 feasible designs, seven are Pareto-efficient (ringed in the figure). All of them fly at the highest altitude (800 km) with the wider field of regard (60 degrees), which observe the most points per satellite, so the trade is in the number of satellites and planes. One satellite samples only 3% of the points sufficiently (at least four times a day), and the share rises steeply with the number of satellites: two satellites in two planes (30%) sample nearly twice as many points as two in one plane (17%), four satellites sample about two thirds of the points in one plane or two (68% and 70%), and six satellites in two inclined planes sample 98%. No design with more than six satellites is efficient, because six already sample nearly every point. Designs with the same number of satellites differ widely: their layout (inclination, planes, and phasing) matters as much as their number." ] }, { @@ -547,10 +565,10 @@ "id": "a2b3c4d5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T17:05:04.952090Z", - "iopub.status.busy": "2026-11-11T17:05:04.951864Z", - "iopub.status.idle": "2026-11-11T17:05:05.020207Z", - "shell.execute_reply": "2026-11-11T17:05:05.019457Z" + "iopub.execute_input": "2026-11-11T18:30:12.446118Z", + "iopub.status.busy": "2026-11-11T18:30:12.445846Z", + "iopub.status.idle": "2026-11-11T18:30:12.516654Z", + "shell.execute_reply": "2026-11-11T18:30:12.515674Z" } }, "outputs": [ @@ -585,21 +603,21 @@ " \n", " \n", " \n", - " 1046\n", - " 800 km, 60 deg FOR, SSO: 1 at 06:00\n", - " 1.0\n", + " 1050\n", + " 800 km, 60 deg FOR, SSO: 1 at 12:00\n", " 1.0\n", - " 3.4\n", - " 4.8\n", " 1.0\n", + " 3.0\n", + " 4.2\n", + " 0.6\n", " \n", " \n", - " 1049\n", - " 800 km, 60 deg FOR, SSO: 2 at 09:00\n", + " 1047\n", + " 800 km, 60 deg FOR, SSO: 2 at 06:00\n", " 2.0\n", " 1.0\n", " 11.6\n", - " 11.4\n", + " 10.4\n", " 0.9\n", " \n", " \n", @@ -607,62 +625,71 @@ " 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...\n", " 2.0\n", " 2.0\n", - " 28.6\n", - " 33.8\n", - " 1.7\n", + " 30.2\n", + " 34.2\n", + " 1.8\n", " \n", " \n", " 1019\n", " 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...\n", " 3.0\n", " 1.0\n", - " 24.6\n", - " 19.2\n", + " 26.2\n", + " 17.0\n", " 1.1\n", " \n", " \n", - " 1088\n", - " 800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00\n", + " 1075\n", + " 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00\n", " 3.0\n", " 2.0\n", - " 26.4\n", - " 58.0\n", - " 1.5\n", + " 28.8\n", + " 60.6\n", + " 1.3\n", " \n", " \n", - " 972\n", - " 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...\n", + " 1001\n", + " 800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac...\n", " 3.0\n", " 3.0\n", - " 36.0\n", - " 58.6\n", - " 1.3\n", + " 34.2\n", + " 61.0\n", + " 3.8\n", " \n", " \n", " 1020\n", " 800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac...\n", " 4.0\n", " 1.0\n", - " 47.2\n", - " 27.2\n", - " 1.2\n", + " 49.2\n", + " 28.6\n", + " 2.1\n", " \n", " \n", - " 1079\n", - " 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00\n", + " 1081\n", + " 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00\n", " 4.0\n", " 2.0\n", - " 52.2\n", - " 82.8\n", - " 1.3\n", + " 57.6\n", + " 85.4\n", + " 0.7\n", " \n", " \n", " 758\n", " 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...\n", " 6.0\n", " 3.0\n", - " 87.4\n", - " 97.0\n", + " 89.0\n", + " 96.4\n", + " 0.5\n", + " \n", + " \n", + " 1045\n", + " 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...\n", + " 8.0\n", + " 4.0\n", + " 97.8\n", + " 96.6\n", " 0.5\n", " \n", " \n", @@ -670,27 +697,27 @@ " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " 9.0\n", " 3.0\n", - " 98.0\n", - " 98.0\n", - " 0.5\n", + " 97.8\n", + " 97.8\n", + " 0.2\n", " \n", " \n", " 1036\n", " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " 9.0\n", " 3.0\n", - " 98.0\n", - " 98.0\n", - " 0.5\n", + " 97.8\n", + " 97.8\n", + " 0.2\n", " \n", " \n", " 1037\n", " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " 9.0\n", " 3.0\n", - " 98.0\n", - " 98.0\n", - " 0.5\n", + " 97.8\n", + " 97.8\n", + " 0.2\n", " \n", " \n", "\n", @@ -698,32 +725,34 @@ ], "text/plain": [ " description satellites planes \\\n", - "1046 800 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", - "1049 800 km, 60 deg FOR, SSO: 2 at 09:00 2.0 1.0 \n", + "1050 800 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", + "1047 800 km, 60 deg FOR, SSO: 2 at 06:00 2.0 1.0 \n", "963 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", "1019 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... 3.0 1.0 \n", - "1088 800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00 3.0 2.0 \n", - "972 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", + "1075 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3.0 2.0 \n", + "1001 800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac... 3.0 3.0 \n", "1020 800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac... 4.0 1.0 \n", - "1079 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00 4.0 2.0 \n", + "1081 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4.0 2.0 \n", "758 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... 6.0 3.0 \n", + "1045 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", "1035 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", "1036 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", "1037 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", "\n", " sufficient accurate accurate sem \n", - "1046 3.4 4.8 1.0 \n", - "1049 11.6 11.4 0.9 \n", - "963 28.6 33.8 1.7 \n", - "1019 24.6 19.2 1.1 \n", - "1088 26.4 58.0 1.5 \n", - "972 36.0 58.6 1.3 \n", - "1020 47.2 27.2 1.2 \n", - "1079 52.2 82.8 1.3 \n", - "758 87.4 97.0 0.5 \n", - "1035 98.0 98.0 0.5 \n", - "1036 98.0 98.0 0.5 \n", - "1037 98.0 98.0 0.5 " + "1050 3.0 4.2 0.6 \n", + "1047 11.6 10.4 0.9 \n", + "963 30.2 34.2 1.8 \n", + "1019 26.2 17.0 1.1 \n", + "1075 28.8 60.6 1.3 \n", + "1001 34.2 61.0 3.8 \n", + "1020 49.2 28.6 2.1 \n", + "1081 57.6 85.4 0.7 \n", + "758 89.0 96.4 0.5 \n", + "1045 97.8 96.6 0.5 \n", + "1035 97.8 97.8 0.2 \n", + "1036 97.8 97.8 0.2 \n", + "1037 97.8 97.8 0.2 " ] }, "execution_count": 6, @@ -747,16 +776,16 @@ "id": "b3c4d5e6", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T17:05:05.021810Z", - "iopub.status.busy": "2026-11-11T17:05:05.021636Z", - "iopub.status.idle": "2026-11-11T17:05:05.255447Z", - "shell.execute_reply": "2026-11-11T17:05:05.254691Z" + "iopub.execute_input": "2026-11-11T18:30:12.518605Z", + "iopub.status.busy": "2026-11-11T18:30:12.518320Z", + "iopub.status.idle": "2026-11-11T18:30:12.765306Z", + "shell.execute_reply": "2026-11-11T18:30:12.764493Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -791,7 +820,7 @@ "id": "c4d5e6f7", "metadata": {}, "source": [ - "The revisits of two designs of four satellites with similar shares of points sufficiently sampled show why they differ in accuracy: the times between their samples (`tatc.analysis.compute_revisit_statistics`), including the longest gap of the day, and the times of day they sample (`tatc.analysis.compute_local_time_coverage`, in eight 3-hour intervals of local time)." + "The revisits of two designs of four satellites, those in one plane that sample the most points sufficiently and those that sample the most points accurately, show why they differ in accuracy: the times between their samples (`tatc.analysis.compute_revisit_statistics`), including the longest gap of the day, and the times of day they sample (`tatc.analysis.compute_local_time_coverage`, in eight 3-hour intervals of local time)." ] }, { @@ -800,10 +829,10 @@ "id": "d5e6f7a8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T17:05:05.257129Z", - "iopub.status.busy": "2026-11-11T17:05:05.256869Z", - "iopub.status.idle": "2026-11-11T17:05:05.323474Z", - "shell.execute_reply": "2026-11-11T17:05:05.322669Z" + "iopub.execute_input": "2026-11-11T18:30:12.767151Z", + "iopub.status.busy": "2026-11-11T18:30:12.766884Z", + "iopub.status.idle": "2026-11-11T18:30:12.930298Z", + "shell.execute_reply": "2026-11-11T18:30:12.929620Z" } }, "outputs": [ @@ -846,19 +875,19 @@ " \n", " \n", " 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spacing 0)\n", - " 66.4\n", - " 25.0\n", + " 68.2\n", + " 26.8\n", " 0.4\n", - " 14.5\n", + " 13.8\n", " 2.0\n", " \n", " \n", - " 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00\n", - " 52.2\n", - " 82.8\n", - " 5.6\n", - " 10.4\n", - " 3.0\n", + " 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00\n", + " 57.6\n", + " 85.4\n", + " 5.9\n", + " 7.6\n", + " 4.0\n", " \n", " \n", "\n", @@ -867,28 +896,28 @@ "text/plain": [ " sufficient (%) \\\n", "design \n", - "800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spaci... 66.4 \n", - "800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00 52.2 \n", + "800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spaci... 68.2 \n", + "800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 57.6 \n", "\n", " accurate (%) \\\n", "design \n", - "800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spaci... 25.0 \n", - "800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00 82.8 \n", + "800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spaci... 26.8 \n", + "800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 85.4 \n", "\n", " median revisit (h) \\\n", "design \n", "800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spaci... 0.4 \n", - "800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00 5.6 \n", + "800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 5.9 \n", "\n", " median longest gap (h) \\\n", "design \n", - "800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spaci... 14.5 \n", - "800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00 10.4 \n", + "800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spaci... 13.8 \n", + "800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 7.6 \n", "\n", " median 3-h intervals sampled \n", "design \n", "800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spaci... 2.0 \n", - "800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00 3.0 " + "800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4.0 " ] }, "execution_count": 8, @@ -900,16 +929,16 @@ "from tatc.analysis import compute_local_time_coverage, compute_revisit_statistics\n", "\n", "four = accuracy[(accuracy.satellites == 4)].sort_values(\"sufficient\", ascending=False)\n", - "# the most sufficiently sampling design of four satellites, and the most accurately sampling one of another layout\n", - "first = four.iloc[0]\n", - "second = four[four.design != first.design].sort_values(\"accurate\", ascending=False).iloc[0]\n", + "# the most sufficiently sampling design of four satellites in one plane, and the most accurately sampling design of four\n", + "first = four[four.planes == 1].iloc[0]\n", + "second = four.sort_values(\"accurate\", ascending=False).iloc[0]\n", "by_key = {d.key: d for d in designs}\n", "rows = []\n", "for row in (first, second):\n", " d = by_key[row.design].realize(0)\n", " _, members = make_study().build(d)\n", " observations = get_cache(d.points_seed, DURATION)(members)\n", - " points = generate_points_random(N_POINTS, seed=d.points_seed)\n", + " points = generate_points_rotated_lattice(N_POINTS, seed=d.points_seed)\n", " revisits = compute_revisit_statistics(observations, START, START + DURATION, targets=points)\n", " local = compute_local_time_coverage(observations, targets=points)\n", " observed = revisits[revisits.samples > 0]\n", @@ -931,7 +960,7 @@ "id": "e6f7a8b9", "metadata": {}, "source": [ - "Counting samples and measuring their sampling error rank designs differently. Satellites in one plane (blue in the figure) sample many points four times a day, but in bursts: consecutive passes of satellites that follow each other in a plane, minutes apart, repeat each other for a field that decorrelates in hours. Four satellites in one Walker plane sample 66% of the points at least four times a day, but only 25% accurately: half of their revisits are 0.4 hours apart, and they leave a gap of 14.5 hours. Four satellites in two sun-synchronous planes sample fewer points four times (52%) but 83% accurately: their samples are 5.6 hours apart, in three of the eight 3-hour intervals of the day. Designs in a single plane remain efficient only as those that need the fewest launches, and sample at most 27% of the points accurately; six satellites in three planes sample 97% of the points accurately, as many as nine." + "Counting samples and measuring their sampling error rank designs differently. Satellites in one plane (blue in the figure) sample many points four times a day, but in bursts: consecutive passes of satellites that follow each other in a plane, minutes apart, repeat each other for a field that decorrelates in hours. Four satellites in one Walker plane sample 68% of the points at least four times a day, but only 27% accurately: half of their revisits are 0.4 hours apart, and they leave a gap of 13.8 hours. Four satellites in two sun-synchronous planes sample fewer points four times (58%) but 85% accurately: their samples are 5.9 hours apart, in four of the eight 3-hour intervals of the day. Designs in a single plane remain efficient only as those that need the fewest launches, and sample at most 29% of the points accurately; six satellites in three planes sample 96% of the points accurately, nearly as many as nine (98%)." ] }, { @@ -950,10 +979,10 @@ "id": "a8b9c0d1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T17:05:05.325140Z", - "iopub.status.busy": "2026-11-11T17:05:05.324947Z", - "iopub.status.idle": "2026-11-11T17:05:05.352759Z", - "shell.execute_reply": "2026-11-11T17:05:05.352015Z" + "iopub.execute_input": "2026-11-11T18:30:12.932076Z", + "iopub.status.busy": "2026-11-11T18:30:12.931821Z", + "iopub.status.idle": "2026-11-11T18:30:12.960626Z", + "shell.execute_reply": "2026-11-11T18:30:12.959820Z" } }, "outputs": [ @@ -1004,7 +1033,7 @@ " \n", " \n", " layout\n", - " 0.18\n", + " 0.19\n", " 0.12\n", " 1.00\n", " \n", @@ -1016,7 +1045,7 @@ " \n", " \n", " layout.sso.planes.count\n", - " 0.11\n", + " 0.10\n", " 0.19\n", " 0.36\n", " \n", @@ -1047,9 +1076,9 @@ "variable \n", "field_of_regard 0.25 0.25 1.00\n", "layout.walker.per_plane 0.22 0.18 0.64\n", - "layout 0.18 0.12 1.00\n", + "layout 0.19 0.12 1.00\n", "layout.walker.planes 0.12 0.29 0.64\n", - "layout.sso.planes.count 0.11 0.19 0.36\n", + "layout.sso.planes.count 0.10 0.19 0.36\n", "altitude 0.03 0.03 1.00\n", "layout.walker.relative_spacing 0.03 0.06 0.64\n", "layout.walker.inclination 0.00 0.00 0.64" @@ -1101,10 +1130,10 @@ "id": "a3b2c5d4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T17:05:05.354512Z", - "iopub.status.busy": "2026-11-11T17:05:05.354338Z", - "iopub.status.idle": "2026-11-11T17:05:06.927937Z", - "shell.execute_reply": "2026-11-11T17:05:06.927088Z" + "iopub.execute_input": "2026-11-11T18:30:12.962412Z", + "iopub.status.busy": "2026-11-11T18:30:12.962163Z", + "iopub.status.idle": "2026-11-11T18:30:14.503562Z", + "shell.execute_reply": "2026-11-11T18:30:14.502799Z" } }, "outputs": [ @@ -1139,56 +1168,74 @@ " \n", " \n", " \n", - " 1052\n", - " 800 km, 60 deg FOR, SSO: 1 at 15:00\n", + " 1017\n", + " 800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac...\n", " 1.0\n", " 1.0\n", - " 4.0\n", + " 2.8\n", " False\n", - " 0.25\n", + " 0.38\n", " \n", " \n", - " 1054\n", - " 800 km, 60 deg FOR, SSO: 1 at 18:00\n", + " 776\n", + " 700 km, 60 deg FOR, SSO: 1 at 12:00\n", " 1.0\n", " 1.0\n", - " 4.0\n", + " 3.0\n", " False\n", - " 0.42\n", + " 0.20\n", " \n", " \n", " 1048\n", " 800 km, 60 deg FOR, SSO: 1 at 09:00\n", " 1.0\n", " 1.0\n", - " 4.2\n", - " True\n", - " 0.74\n", + " 3.0\n", + " False\n", + " 0.12\n", " \n", " \n", - " 1051\n", - " 800 km, 60 deg FOR, SSO: 2 at 12:00\n", - " 2.0\n", + " 1050\n", + " 800 km, 60 deg FOR, SSO: 1 at 12:00\n", " 1.0\n", - " 12.2\n", + " 1.0\n", + " 3.0\n", " False\n", - " 0.22\n", + " 0.10\n", + " \n", + " \n", + " 1052\n", + " 800 km, 60 deg FOR, SSO: 1 at 15:00\n", + " 1.0\n", + " 1.0\n", + " 3.0\n", + " False\n", + " 0.12\n", + " \n", + " \n", + " 1054\n", + " 800 km, 60 deg FOR, SSO: 1 at 18:00\n", + " 1.0\n", + " 1.0\n", + " 3.2\n", + " True\n", + " 0.54\n", " \n", " \n", " 960\n", " 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...\n", " 2.0\n", " 1.0\n", - " 13.8\n", + " 16.6\n", " True\n", - " 0.78\n", + " 0.98\n", " \n", " \n", " 963\n", " 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...\n", " 2.0\n", " 2.0\n", - " 28.6\n", + " 30.2\n", " True\n", " 1.00\n", " \n", @@ -1197,34 +1244,34 @@ " 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...\n", " 3.0\n", " 1.0\n", - " 37.0\n", + " 38.0\n", " True\n", " 1.00\n", " \n", " \n", - " 1001\n", - " 800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac...\n", + " 972\n", + " 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...\n", " 3.0\n", " 3.0\n", - " 35.4\n", + " 37.6\n", " False\n", - " 0.29\n", + " 0.32\n", " \n", " \n", - " 698\n", - " 700 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...\n", + " 971\n", + " 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...\n", " 3.0\n", " 3.0\n", - " 35.8\n", + " 37.8\n", " False\n", - " 0.28\n", + " 0.29\n", " \n", " \n", " 962\n", " 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...\n", " 4.0\n", " 1.0\n", - " 66.4\n", + " 68.2\n", " True\n", " 1.00\n", " \n", @@ -1233,43 +1280,25 @@ " 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...\n", " 4.0\n", " 2.0\n", - " 66.2\n", - " False\n", - " 0.15\n", - " \n", - " \n", - " 966\n", - " 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...\n", - " 4.0\n", - " 2.0\n", - " 66.4\n", - " False\n", - " 0.32\n", - " \n", - " \n", - " 980\n", - " 800 km, 60 deg FOR, Walker 45 deg: 4 x 1 (spac...\n", - " 4.0\n", - " 4.0\n", - " 66.4\n", - " False\n", - " 0.40\n", + " 69.6\n", + " True\n", + " 0.92\n", " \n", " \n", - " 1025\n", + " 1026\n", " 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...\n", " 6.0\n", " 2.0\n", - " 97.8\n", + " 97.6\n", " False\n", " 0.32\n", " \n", " \n", - " 1026\n", + " 1025\n", " 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...\n", " 6.0\n", " 2.0\n", - " 98.0\n", + " 97.8\n", " True\n", " 1.00\n", " \n", @@ -1279,38 +1308,38 @@ ], "text/plain": [ " description satellites planes \\\n", + "1017 800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac... 1.0 1.0 \n", + "776 700 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", + "1048 800 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", + "1050 800 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", "1052 800 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", "1054 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", - "1048 800 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", - "1051 800 km, 60 deg FOR, SSO: 2 at 12:00 2.0 1.0 \n", "960 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 1.0 \n", "963 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", "961 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 1.0 \n", - "1001 800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac... 3.0 3.0 \n", - "698 700 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", + "972 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", + "971 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", "962 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", "965 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", - "966 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", - "980 800 km, 60 deg FOR, Walker 45 deg: 4 x 1 (spac... 4.0 4.0 \n", - "1025 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", "1026 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "1025 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", "\n", " sufficient pareto pareto_probability \n", - "1052 4.0 False 0.25 \n", - "1054 4.0 False 0.42 \n", - "1048 4.2 True 0.74 \n", - "1051 12.2 False 0.22 \n", - "960 13.8 True 0.78 \n", - "963 28.6 True 1.00 \n", - "961 37.0 True 1.00 \n", - "1001 35.4 False 0.29 \n", - "698 35.8 False 0.28 \n", - "962 66.4 True 1.00 \n", - "965 66.2 False 0.15 \n", - "966 66.4 False 0.32 \n", - "980 66.4 False 0.40 \n", - "1025 97.8 False 0.32 \n", - "1026 98.0 True 1.00 " + "1017 2.8 False 0.38 \n", + "776 3.0 False 0.20 \n", + "1048 3.0 False 0.12 \n", + "1050 3.0 False 0.10 \n", + "1052 3.0 False 0.12 \n", + "1054 3.2 True 0.54 \n", + "960 16.6 True 0.98 \n", + "963 30.2 True 1.00 \n", + "961 38.0 True 1.00 \n", + "972 37.6 False 0.32 \n", + "971 37.8 False 0.29 \n", + "962 68.2 True 1.00 \n", + "965 69.6 True 0.92 \n", + "1026 97.6 False 0.32 \n", + "1025 97.8 True 1.00 " ] }, "execution_count": 10, @@ -1332,7 +1361,7 @@ "id": "b4c3d6e5", "metadata": {}, "source": [ - "Four of the six efficient designs are efficient in every resample: two satellites in two planes, three or four satellites in one plane, and six in two planes. The others are not settled by five replicates. One satellite in a sun-synchronous orbit crossing the equator at 09:00 (efficient in 74% of the resamples) samples about as many points as one crossing at 15:00 or 18:00 (25% and 42%), and six satellites in two planes with another relative spacing (32%) sample about as many as the efficient design. Designs that are efficient with a probability between 0 and 1 are equally good candidates, given the uncertainty of the estimates: more replicates (samples of points) would separate them, or a tolerance of the share (see `pareto_front`) would treat them as ties." + "Four of the seven efficient designs are efficient in every resample: two satellites in two planes, three or four satellites in one plane, and six in two planes; two satellites in one plane (efficient in 98% of the resamples) and four in two planes (92%) nearly so. The single satellite is not settled by five replicates: one in a sun-synchronous orbit crossing the equator at 18:00 (efficient in 54% of the resamples) samples about as many points as one in a Walker orbit inclined 75 degrees (38%) or crossing at other times (10 to 20%). Likewise, three satellites in three planes (29% and 32%) sample about as many points as three in one plane, and six satellites in two planes with another relative spacing (32%) as many as the efficient design. Designs that are efficient with a probability between 0 and 1 are equally good candidates, given the uncertainty of the estimates: more replicates (samples of points) would separate them, or a tolerance of the share (see `pareto_front`) would treat them as ties." ] }, { @@ -1353,10 +1382,10 @@ "id": "b5d3f7a9", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T17:05:06.929733Z", - "iopub.status.busy": "2026-11-11T17:05:06.929476Z", - "iopub.status.idle": "2026-11-11T17:05:33.853639Z", - "shell.execute_reply": "2026-11-11T17:05:33.852946Z" + "iopub.execute_input": "2026-11-11T18:30:14.505542Z", + "iopub.status.busy": "2026-11-11T18:30:14.505342Z", + "iopub.status.idle": "2026-11-11T18:30:49.909930Z", + "shell.execute_reply": "2026-11-11T18:30:49.909243Z" } }, "outputs": [ @@ -1364,7 +1393,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "655 evaluations added, 1.7% of those of 40 replicates of every design\n" + "555 evaluations added, 1.4% of those of 40 replicates of every design\n" ] }, { @@ -1398,72 +1427,72 @@ " \n", " 0\n", " 0\n", - " 20\n", - " 20\n", - " 100\n", + " 31\n", + " 31\n", + " 155\n", " \n", " \n", " 1\n", " 1\n", - " 21\n", - " 21\n", - " 105\n", + " 16\n", + " 16\n", + " 80\n", " \n", " \n", " 2\n", " 2\n", - " 18\n", - " 18\n", - " 90\n", + " 13\n", + " 13\n", + " 65\n", " \n", " \n", " 3\n", " 3\n", - " 17\n", - " 17\n", - " 85\n", + " 12\n", + " 12\n", + " 60\n", " \n", " \n", " 4\n", " 4\n", - " 15\n", - " 15\n", - " 75\n", + " 9\n", + " 9\n", + " 45\n", " \n", " \n", " 5\n", " 5\n", - " 14\n", - " 14\n", - " 70\n", + " 11\n", + " 11\n", + " 55\n", " \n", " \n", " 6\n", " 6\n", - " 15\n", - " 15\n", - " 75\n", + " 11\n", + " 11\n", + " 55\n", " \n", " \n", " 7\n", " 7\n", - " 13\n", - " 6\n", - " 30\n", + " 12\n", + " 5\n", + " 25\n", " \n", " \n", " 8\n", " 8\n", " 12\n", - " 3\n", - " 15\n", + " 2\n", + " 10\n", " \n", " \n", " 9\n", " 9\n", " 12\n", - " 2\n", - " 10\n", + " 1\n", + " 5\n", " \n", " \n", "\n", @@ -1471,16 +1500,16 @@ ], "text/plain": [ " round uncertain refined evaluations\n", - "0 0 20 20 100\n", - "1 1 21 21 105\n", - "2 2 18 18 90\n", - "3 3 17 17 85\n", - "4 4 15 15 75\n", - "5 5 14 14 70\n", - "6 6 15 15 75\n", - "7 7 13 6 30\n", - "8 8 12 3 15\n", - "9 9 12 2 10" + "0 0 31 31 155\n", + "1 1 16 16 80\n", + "2 2 13 13 65\n", + "3 3 12 12 60\n", + "4 4 9 9 45\n", + "5 5 11 11 55\n", + "6 6 11 11 55\n", + "7 7 12 5 25\n", + "8 8 12 2 10\n", + "9 9 12 1 5" ] }, "execution_count": 11, @@ -1506,10 +1535,10 @@ "id": "c6e4a8b0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T17:05:33.855225Z", - "iopub.status.busy": "2026-11-11T17:05:33.854996Z", - "iopub.status.idle": "2026-11-11T17:05:33.918358Z", - "shell.execute_reply": "2026-11-11T17:05:33.917661Z" + "iopub.execute_input": "2026-11-11T18:30:49.911695Z", + "iopub.status.busy": "2026-11-11T18:30:49.911513Z", + "iopub.status.idle": "2026-11-11T18:30:49.972883Z", + "shell.execute_reply": "2026-11-11T18:30:49.972203Z" } }, "outputs": [ @@ -1545,102 +1574,142 @@ " \n", " \n", " \n", - " 772\n", - " 700 km, 60 deg FOR, SSO: 1 at 06:00\n", + " 498\n", + " 600 km, 60 deg FOR, SSO: 1 at 06:00\n", " 1.0\n", " 1.0\n", - " 2.68\n", + " 1.92\n", " 40\n", " False\n", - " 0.16\n", + " 0.14\n", " \n", " \n", - " 774\n", - " 700 km, 60 deg FOR, SSO: 1 at 09:00\n", + " 743\n", + " 700 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac...\n", " 1.0\n", " 1.0\n", - " 2.70\n", + " 1.92\n", " 40\n", " False\n", - " 0.19\n", + " 0.15\n", " \n", " \n", - " 778\n", - " 700 km, 60 deg FOR, SSO: 1 at 15:00\n", + " 502\n", + " 600 km, 60 deg FOR, SSO: 1 at 12:00\n", " 1.0\n", " 1.0\n", - " 2.70\n", + " 2.00\n", " 40\n", " False\n", - " 0.18\n", + " 0.20\n", " \n", " \n", " 780\n", " 700 km, 60 deg FOR, SSO: 1 at 18:00\n", " 1.0\n", " 1.0\n", - " 2.72\n", + " 2.45\n", " 40\n", - " False\n", - " 0.19\n", + " True\n", + " 0.62\n", " \n", " \n", - " 1017\n", - " 800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac...\n", + " 774\n", + " 700 km, 60 deg FOR, SSO: 1 at 09:00\n", " 1.0\n", " 1.0\n", - " 3.12\n", + " 2.52\n", " 40\n", - " False\n", - " 0.45\n", + " True\n", + " 0.70\n", " \n", " \n", - " 1046\n", - " 800 km, 60 deg FOR, SSO: 1 at 06:00\n", + " 778\n", + " 700 km, 60 deg FOR, SSO: 1 at 15:00\n", " 1.0\n", " 1.0\n", - " 3.40\n", + " 2.62\n", " 40\n", " True\n", - " 0.63\n", + " 0.78\n", " \n", " \n", - " 1050\n", - " 800 km, 60 deg FOR, SSO: 1 at 12:00\n", + " 776\n", + " 700 km, 60 deg FOR, SSO: 1 at 12:00\n", " 1.0\n", " 1.0\n", - " 3.40\n", + " 2.70\n", " 40\n", " True\n", - " 0.64\n", + " 0.83\n", " \n", " \n", - " 1054\n", - " 800 km, 60 deg FOR, SSO: 1 at 18:00\n", + " 1017\n", + " 800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac...\n", " 1.0\n", " 1.0\n", - " 3.42\n", + " 2.75\n", " 40\n", " True\n", - " 0.65\n", + " 0.80\n", + " \n", + " \n", + " 772\n", + " 700 km, 60 deg FOR, SSO: 1 at 06:00\n", + " 1.0\n", + " 1.0\n", + " 2.90\n", + " 10\n", + " True\n", + " 0.98\n", " \n", " \n", " 1052\n", " 800 km, 60 deg FOR, SSO: 1 at 15:00\n", " 1.0\n", " 1.0\n", - " 4.00\n", - " 5\n", + " 2.90\n", + " 10\n", + " True\n", + " 0.98\n", + " \n", + " \n", + " 1046\n", + " 800 km, 60 deg FOR, SSO: 1 at 06:00\n", + " 1.0\n", + " 1.0\n", + " 3.10\n", + " 10\n", " True\n", " 0.99\n", " \n", " \n", + " 1054\n", + " 800 km, 60 deg FOR, SSO: 1 at 18:00\n", + " 1.0\n", + " 1.0\n", + " 3.10\n", + " 10\n", + " True\n", + " 0.98\n", + " \n", + " \n", " 1048\n", " 800 km, 60 deg FOR, SSO: 1 at 09:00\n", " 1.0\n", " 1.0\n", - " 4.20\n", - " 5\n", + " 3.20\n", + " 10\n", + " True\n", + " 0.99\n", + " \n", + " \n", + " 1050\n", + " 800 km, 60 deg FOR, SSO: 1 at 12:00\n", + " 1.0\n", + " 1.0\n", + " 3.20\n", + " 10\n", " True\n", " 0.99\n", " \n", @@ -1649,17 +1718,17 @@ " 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...\n", " 2.0\n", " 1.0\n", - " 14.13\n", - " 15\n", + " 16.60\n", + " 5\n", " True\n", - " 0.99\n", + " 1.00\n", " \n", " \n", " 963\n", " 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...\n", " 2.0\n", " 2.0\n", - " 28.60\n", + " 30.20\n", " 5\n", " True\n", " 1.00\n", @@ -1669,27 +1738,47 @@ " 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...\n", " 3.0\n", " 1.0\n", - " 37.00\n", + " 38.00\n", " 5\n", " True\n", " 1.00\n", " \n", " \n", - " 973\n", + " 1001\n", + " 800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac...\n", + " 3.0\n", + " 3.0\n", + " 36.10\n", + " 30\n", + " False\n", + " 0.12\n", + " \n", + " \n", + " 972\n", " 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...\n", " 3.0\n", " 3.0\n", - " 37.40\n", + " 37.02\n", " 40\n", " True\n", - " 0.81\n", + " 0.35\n", + " \n", + " \n", + " 971\n", + " 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...\n", + " 3.0\n", + " 3.0\n", + " 37.83\n", + " 40\n", + " True\n", + " 0.73\n", " \n", " \n", " 962\n", " 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...\n", " 4.0\n", " 1.0\n", - " 66.40\n", + " 68.20\n", " 5\n", " True\n", " 1.00\n", @@ -1699,47 +1788,27 @@ " 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...\n", " 4.0\n", " 2.0\n", - " 66.20\n", + " 69.60\n", " 5\n", " True\n", " 0.97\n", " \n", " \n", - " 966\n", - " 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...\n", - " 4.0\n", - " 2.0\n", - " 66.40\n", - " 5\n", - " True\n", - " 0.99\n", - " \n", - " \n", - " 980\n", - " 800 km, 60 deg FOR, Walker 45 deg: 4 x 1 (spac...\n", - " 4.0\n", - " 4.0\n", - " 66.70\n", - " 40\n", - " True\n", - " 0.74\n", - " \n", - " \n", - " 1025\n", + " 1026\n", " 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...\n", " 6.0\n", " 2.0\n", - " 97.80\n", + " 97.60\n", " 5\n", " True\n", " 1.00\n", " \n", " \n", - " 1026\n", + " 1025\n", " 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...\n", " 6.0\n", " 2.0\n", - " 98.00\n", + " 97.80\n", " 5\n", " True\n", " 1.00\n", @@ -1749,47 +1818,47 @@ " 600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...\n", " 8.0\n", " 2.0\n", - " 97.80\n", + " 97.40\n", " 5\n", " True\n", - " 0.99\n", + " 0.97\n", " \n", " \n", " 480\n", " 600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...\n", " 8.0\n", " 2.0\n", - " 97.80\n", + " 97.40\n", " 5\n", " True\n", - " 0.99\n", + " 0.97\n", " \n", " \n", " 753\n", " 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...\n", " 8.0\n", " 2.0\n", - " 97.80\n", + " 97.60\n", " 5\n", " True\n", - " 0.99\n", + " 1.00\n", " \n", " \n", " 754\n", " 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...\n", " 8.0\n", " 2.0\n", - " 97.80\n", + " 97.60\n", " 5\n", " True\n", - " 0.99\n", + " 1.00\n", " \n", " \n", " 1027\n", " 800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...\n", " 8.0\n", " 2.0\n", - " 98.00\n", + " 97.80\n", " 5\n", " True\n", " 1.00\n", @@ -1799,7 +1868,7 @@ " 800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...\n", " 8.0\n", " 2.0\n", - " 98.00\n", + " 97.80\n", " 5\n", " True\n", " 1.00\n", @@ -1809,37 +1878,37 @@ " 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...\n", " 8.0\n", " 4.0\n", - " 97.80\n", + " 97.60\n", " 5\n", " True\n", - " 0.99\n", + " 1.00\n", " \n", " \n", " 769\n", " 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...\n", " 8.0\n", " 4.0\n", - " 97.80\n", + " 97.60\n", " 5\n", " True\n", - " 0.99\n", + " 1.00\n", " \n", " \n", " 770\n", " 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...\n", " 8.0\n", " 4.0\n", - " 97.80\n", + " 97.60\n", " 5\n", " True\n", - " 0.99\n", + " 1.00\n", " \n", " \n", " 1043\n", " 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...\n", " 8.0\n", " 4.0\n", - " 98.00\n", + " 97.80\n", " 5\n", " True\n", " 1.00\n", @@ -1849,7 +1918,7 @@ " 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...\n", " 8.0\n", " 4.0\n", - " 98.00\n", + " 97.80\n", " 5\n", " True\n", " 1.00\n", @@ -1859,7 +1928,7 @@ " 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...\n", " 8.0\n", " 4.0\n", - " 98.00\n", + " 97.80\n", " 5\n", " True\n", " 1.00\n", @@ -1869,70 +1938,70 @@ " 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " 9.0\n", " 3.0\n", - " 97.69\n", - " 35\n", + " 97.53\n", + " 15\n", " True\n", - " 0.92\n", + " 0.99\n", " \n", " \n", " 487\n", " 600 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " 9.0\n", " 3.0\n", - " 97.77\n", - " 35\n", + " 97.60\n", + " 10\n", " True\n", - " 0.94\n", + " 1.00\n", " \n", " \n", - " 763\n", + " 762\n", " 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " 9.0\n", " 3.0\n", - " 97.96\n", - " 25\n", + " 97.60\n", + " 5\n", " True\n", - " 0.97\n", + " 1.00\n", " \n", " \n", - " 762\n", + " 763\n", " 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " 9.0\n", " 3.0\n", - " 98.00\n", - " 25\n", + " 97.60\n", + " 5\n", " True\n", - " 0.97\n", + " 1.00\n", " \n", " \n", " 1035\n", " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " 9.0\n", " 3.0\n", - " 98.00\n", + " 97.80\n", " 5\n", " True\n", - " 0.96\n", + " 1.00\n", " \n", " \n", " 1036\n", " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " 9.0\n", " 3.0\n", - " 98.00\n", + " 97.80\n", " 5\n", " True\n", - " 0.96\n", + " 1.00\n", " \n", " \n", " 1037\n", " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " 9.0\n", " 3.0\n", - " 98.00\n", + " 97.80\n", " 5\n", " True\n", - " 0.96\n", + " 1.00\n", " \n", " \n", "\n", @@ -1940,26 +2009,30 @@ ], "text/plain": [ " description satellites planes \\\n", - "772 700 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", + "498 600 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", + "743 700 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac... 1.0 1.0 \n", + "502 600 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", + "780 700 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", "774 700 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", "778 700 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", - "780 700 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", + "776 700 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", "1017 800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac... 1.0 1.0 \n", + "772 700 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", + "1052 800 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", "1046 800 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", - "1050 800 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", "1054 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", - "1052 800 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", "1048 800 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", + "1050 800 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", "960 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 1.0 \n", "963 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", "961 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 1.0 \n", - "973 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", + "1001 800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac... 3.0 3.0 \n", + "972 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", + "971 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", "962 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", "965 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", - "966 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", - "980 800 km, 60 deg FOR, Walker 45 deg: 4 x 1 (spac... 4.0 4.0 \n", - "1025 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", "1026 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "1025 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", "479 600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", "480 600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", "753 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", @@ -1974,52 +2047,56 @@ "1045 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", "761 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", "487 600 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "763 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", "762 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "763 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", "1035 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", "1036 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", "1037 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", "\n", " sufficient replicates pareto pareto_probability \n", - "772 2.68 40 False 0.16 \n", - "774 2.70 40 False 0.19 \n", - "778 2.70 40 False 0.18 \n", - "780 2.72 40 False 0.19 \n", - "1017 3.12 40 False 0.45 \n", - "1046 3.40 40 True 0.63 \n", - "1050 3.40 40 True 0.64 \n", - "1054 3.42 40 True 0.65 \n", - "1052 4.00 5 True 0.99 \n", - "1048 4.20 5 True 0.99 \n", - "960 14.13 15 True 0.99 \n", - "963 28.60 5 True 1.00 \n", - "961 37.00 5 True 1.00 \n", - "973 37.40 40 True 0.81 \n", - "962 66.40 5 True 1.00 \n", - "965 66.20 5 True 0.97 \n", - "966 66.40 5 True 0.99 \n", - "980 66.70 40 True 0.74 \n", + "498 1.92 40 False 0.14 \n", + "743 1.92 40 False 0.15 \n", + "502 2.00 40 False 0.20 \n", + "780 2.45 40 True 0.62 \n", + "774 2.52 40 True 0.70 \n", + "778 2.62 40 True 0.78 \n", + "776 2.70 40 True 0.83 \n", + "1017 2.75 40 True 0.80 \n", + "772 2.90 10 True 0.98 \n", + "1052 2.90 10 True 0.98 \n", + "1046 3.10 10 True 0.99 \n", + "1054 3.10 10 True 0.98 \n", + "1048 3.20 10 True 0.99 \n", + "1050 3.20 10 True 0.99 \n", + "960 16.60 5 True 1.00 \n", + "963 30.20 5 True 1.00 \n", + "961 38.00 5 True 1.00 \n", + "1001 36.10 30 False 0.12 \n", + "972 37.02 40 True 0.35 \n", + "971 37.83 40 True 0.73 \n", + "962 68.20 5 True 1.00 \n", + "965 69.60 5 True 0.97 \n", + "1026 97.60 5 True 1.00 \n", "1025 97.80 5 True 1.00 \n", - "1026 98.00 5 True 1.00 \n", - "479 97.80 5 True 0.99 \n", - "480 97.80 5 True 0.99 \n", - "753 97.80 5 True 0.99 \n", - "754 97.80 5 True 0.99 \n", - "1027 98.00 5 True 1.00 \n", - "1028 98.00 5 True 1.00 \n", - "768 97.80 5 True 0.99 \n", - "769 97.80 5 True 0.99 \n", - "770 97.80 5 True 0.99 \n", - "1043 98.00 5 True 1.00 \n", - "1044 98.00 5 True 1.00 \n", - "1045 98.00 5 True 1.00 \n", - "761 97.69 35 True 0.92 \n", - "487 97.77 35 True 0.94 \n", - "763 97.96 25 True 0.97 \n", - "762 98.00 25 True 0.97 \n", - "1035 98.00 5 True 0.96 \n", - "1036 98.00 5 True 0.96 \n", - "1037 98.00 5 True 0.96 " + "479 97.40 5 True 0.97 \n", + "480 97.40 5 True 0.97 \n", + "753 97.60 5 True 1.00 \n", + "754 97.60 5 True 1.00 \n", + "1027 97.80 5 True 1.00 \n", + "1028 97.80 5 True 1.00 \n", + "768 97.60 5 True 1.00 \n", + "769 97.60 5 True 1.00 \n", + "770 97.60 5 True 1.00 \n", + "1043 97.80 5 True 1.00 \n", + "1044 97.80 5 True 1.00 \n", + "1045 97.80 5 True 1.00 \n", + "761 97.53 15 True 0.99 \n", + "487 97.60 10 True 1.00 \n", + "762 97.60 5 True 1.00 \n", + "763 97.60 5 True 1.00 \n", + "1035 97.80 5 True 1.00 \n", + "1036 97.80 5 True 1.00 \n", + "1037 97.80 5 True 1.00 " ] }, "execution_count": 12, @@ -2040,7 +2117,7 @@ "id": "d7f5b9c1", "metadata": {}, "source": [ - "Refinement adds 655 evaluations, 1.7% of those that 40 replicates of every design would take, to the few designs whose efficiency is uncertain. With the tolerance, the designs that sample nearly every point (six to nine satellites, about 98%) are all efficient candidates, with probabilities of 0.92 or more, rather than uncertain: they differ by less than matters. The designs that stay uncertain after ten rounds lie about one tolerance below the front, such as single satellites that sample about 3.4% of the points against the best single satellite's 4.2%: whether they are within the tolerance of the front is a question that more replicates settle only slowly, and one that does not change the trade. An absolute tolerance suits a share near saturation better than one near zero; a tolerance proportional to the objective would treat both alike." + "Refinement adds 555 evaluations, 1.4% of those that 40 replicates of every design would take, to the few designs whose efficiency is uncertain. With the tolerance, the designs that sample nearly every point (six to nine satellites, about 98%) are all efficient candidates, with probabilities of 0.97 or more, rather than uncertain: they differ by less than matters. The designs that stay uncertain with 40 replicates lie about one tolerance below the front, such as single satellites that sample 1.9 to 2.8% of the points against the best single satellite's 3.2%, and three satellites in three planes that sample 37.0 and 37.8% against 38.0% in one plane: whether they are within the tolerance of the front is a question that more replicates settle only slowly, and one that does not change the trade. An absolute tolerance suits a share near saturation better than one near zero; a tolerance proportional to the objective would treat both alike." ] }, { @@ -2059,10 +2136,10 @@ "id": "f2a3b4c5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T17:05:33.920005Z", - "iopub.status.busy": "2026-11-11T17:05:33.919778Z", - "iopub.status.idle": "2026-11-11T17:05:34.651641Z", - "shell.execute_reply": "2026-11-11T17:05:34.651024Z" + "iopub.execute_input": "2026-11-11T18:30:49.974634Z", + "iopub.status.busy": "2026-11-11T18:30:49.974389Z", + "iopub.status.idle": "2026-11-11T18:31:02.187962Z", + "shell.execute_reply": "2026-11-11T18:31:02.187044Z" } }, "outputs": [ @@ -2070,7 +2147,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "optimism of the selection: -0.35 percentage points\n" + "optimism of the selection: -0.02 percentage points\n" ] }, { @@ -2105,152 +2182,202 @@ " \n", " \n", " \n", - " 33\n", - " 800 km, 60 deg FOR, SSO: 1 at 18:00\n", + " 23\n", + " 800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac...\n", " 1.0\n", " 1.0\n", - " 3.42\n", - " 2.65\n", + " 2.75\n", + " 2.60\n", + " 20\n", + " False\n", + " \n", + " \n", + " 14\n", + " 700 km, 60 deg FOR, SSO: 1 at 15:00\n", + " 1.0\n", + " 1.0\n", + " 2.62\n", + " 2.85\n", " 20\n", " True\n", " \n", " \n", - " 29\n", - " 800 km, 60 deg FOR, SSO: 1 at 06:00\n", + " 15\n", + " 700 km, 60 deg FOR, SSO: 1 at 18:00\n", " 1.0\n", " 1.0\n", - " 3.40\n", - " 2.75\n", + " 2.45\n", + " 2.85\n", " 20\n", " True\n", " \n", " \n", - " 30\n", - " 800 km, 60 deg FOR, SSO: 1 at 09:00\n", + " 12\n", + " 700 km, 60 deg FOR, SSO: 1 at 09:00\n", " 1.0\n", " 1.0\n", - " 4.20\n", - " 2.80\n", + " 2.52\n", + " 2.90\n", " 20\n", " True\n", " \n", " \n", - " 31\n", - " 800 km, 60 deg FOR, SSO: 1 at 12:00\n", + " 13\n", + " 700 km, 60 deg FOR, SSO: 1 at 12:00\n", + " 1.0\n", + " 1.0\n", + " 2.70\n", + " 2.95\n", + " 20\n", + " True\n", + " \n", + " \n", + " 11\n", + " 700 km, 60 deg FOR, SSO: 1 at 06:00\n", " 1.0\n", " 1.0\n", - " 3.40\n", " 2.90\n", + " 3.45\n", " 20\n", " True\n", " \n", " \n", - " 32\n", + " 35\n", + " 800 km, 60 deg FOR, SSO: 1 at 09:00\n", + " 1.0\n", + " 1.0\n", + " 3.20\n", + " 3.50\n", + " 20\n", + " True\n", + " \n", + " \n", + " 38\n", + " 800 km, 60 deg FOR, SSO: 1 at 18:00\n", + " 1.0\n", + " 1.0\n", + " 3.10\n", + " 3.50\n", + " 20\n", + " True\n", + " \n", + " \n", + " 37\n", " 800 km, 60 deg FOR, SSO: 1 at 15:00\n", " 1.0\n", " 1.0\n", - " 4.00\n", " 2.90\n", + " 3.75\n", " 20\n", " True\n", " \n", " \n", - " 11\n", + " 34\n", + " 800 km, 60 deg FOR, SSO: 1 at 06:00\n", + " 1.0\n", + " 1.0\n", + " 3.10\n", + " 3.80\n", + " 20\n", + " True\n", + " \n", + " \n", + " 36\n", + " 800 km, 60 deg FOR, SSO: 1 at 12:00\n", + " 1.0\n", + " 1.0\n", + " 3.20\n", + " 3.85\n", + " 20\n", + " True\n", + " \n", + " \n", + " 16\n", " 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...\n", " 2.0\n", " 1.0\n", - " 14.13\n", - " 14.70\n", + " 16.60\n", + " 16.15\n", " 20\n", " True\n", " \n", " \n", - " 14\n", + " 19\n", " 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...\n", " 2.0\n", " 2.0\n", - " 28.60\n", - " 27.55\n", + " 30.20\n", + " 28.95\n", " 20\n", " True\n", " \n", " \n", - " 12\n", + " 17\n", " 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...\n", " 3.0\n", " 1.0\n", - " 37.00\n", - " 37.15\n", + " 38.00\n", + " 36.70\n", " 20\n", " True\n", " \n", " \n", - " 17\n", + " 21\n", " 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...\n", " 3.0\n", " 3.0\n", - " 37.40\n", - " 37.40\n", + " 37.83\n", + " 35.60\n", " 20\n", - " True\n", + " False\n", " \n", " \n", - " 13\n", - " 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...\n", - " 4.0\n", - " 1.0\n", - " 66.40\n", - " 66.85\n", + " 22\n", + " 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...\n", + " 3.0\n", + " 3.0\n", + " 37.02\n", + " 37.05\n", " 20\n", " True\n", " \n", " \n", - " 15\n", - " 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...\n", + " 18\n", + " 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...\n", " 4.0\n", - " 2.0\n", - " 66.20\n", - " 66.85\n", + " 1.0\n", + " 68.20\n", + " 66.50\n", " 20\n", " True\n", " \n", " \n", - " 16\n", + " 20\n", " 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...\n", " 4.0\n", " 2.0\n", + " 69.60\n", " 66.40\n", - " 67.15\n", - " 20\n", - " True\n", - " \n", - " \n", - " 18\n", - " 800 km, 60 deg FOR, Walker 45 deg: 4 x 1 (spac...\n", - " 4.0\n", - " 4.0\n", - " 66.70\n", - " 66.95\n", " 20\n", " True\n", " \n", " \n", - " 20\n", + " 25\n", " 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...\n", " 6.0\n", " 2.0\n", - " 98.00\n", - " 98.45\n", + " 97.60\n", + " 97.80\n", " 20\n", " True\n", " \n", " \n", - " 19\n", + " 24\n", " 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...\n", " 6.0\n", " 2.0\n", " 97.80\n", - " 98.55\n", + " 97.95\n", " 20\n", " True\n", " \n", @@ -2259,8 +2386,8 @@ " 600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...\n", " 8.0\n", " 2.0\n", - " 97.80\n", - " 98.45\n", + " 97.40\n", + " 97.75\n", " 20\n", " True\n", " \n", @@ -2269,8 +2396,8 @@ " 600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...\n", " 8.0\n", " 2.0\n", - " 97.80\n", - " 98.50\n", + " 97.40\n", + " 97.85\n", " 20\n", " True\n", " \n", @@ -2279,8 +2406,8 @@ " 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...\n", " 8.0\n", " 2.0\n", - " 97.80\n", - " 98.65\n", + " 97.60\n", + " 97.95\n", " 20\n", " True\n", " \n", @@ -2289,28 +2416,28 @@ " 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...\n", " 8.0\n", " 2.0\n", - " 97.80\n", - " 98.65\n", + " 97.60\n", + " 97.95\n", " 20\n", " True\n", " \n", " \n", - " 21\n", + " 26\n", " 800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...\n", " 8.0\n", " 2.0\n", - " 98.00\n", - " 98.70\n", + " 97.80\n", + " 98.10\n", " 20\n", " True\n", " \n", " \n", - " 22\n", + " 27\n", " 800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...\n", " 8.0\n", " 2.0\n", - " 98.00\n", - " 98.70\n", + " 97.80\n", + " 98.10\n", " 20\n", " True\n", " \n", @@ -2319,8 +2446,8 @@ " 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...\n", " 8.0\n", " 4.0\n", - " 97.80\n", - " 98.65\n", + " 97.60\n", + " 97.95\n", " 20\n", " True\n", " \n", @@ -2329,8 +2456,8 @@ " 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...\n", " 8.0\n", " 4.0\n", - " 97.80\n", - " 98.65\n", + " 97.60\n", + " 97.95\n", " 20\n", " True\n", " \n", @@ -2339,38 +2466,38 @@ " 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...\n", " 8.0\n", " 4.0\n", - " 97.80\n", - " 98.65\n", + " 97.60\n", + " 97.95\n", " 20\n", " True\n", " \n", " \n", - " 28\n", + " 31\n", " 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...\n", " 8.0\n", " 4.0\n", - " 98.00\n", - " 98.65\n", + " 97.80\n", + " 98.10\n", " 20\n", " True\n", " \n", " \n", - " 26\n", + " 32\n", " 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...\n", " 8.0\n", " 4.0\n", - " 98.00\n", - " 98.70\n", + " 97.80\n", + " 98.10\n", " 20\n", " True\n", " \n", " \n", - " 27\n", + " 33\n", " 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...\n", " 8.0\n", " 4.0\n", - " 98.00\n", - " 98.70\n", + " 97.80\n", + " 98.10\n", " 20\n", " True\n", " \n", @@ -2379,8 +2506,8 @@ " 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " 9.0\n", " 3.0\n", - " 97.69\n", - " 98.05\n", + " 97.53\n", + " 97.45\n", " 20\n", " True\n", " \n", @@ -2389,58 +2516,58 @@ " 600 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " 9.0\n", " 3.0\n", - " 97.77\n", - " 98.45\n", + " 97.60\n", + " 97.85\n", " 20\n", " True\n", " \n", " \n", - " 7\n", + " 6\n", " 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " 9.0\n", " 3.0\n", - " 97.96\n", - " 98.60\n", + " 97.60\n", + " 97.95\n", " 20\n", " True\n", " \n", " \n", - " 6\n", + " 7\n", " 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " 9.0\n", " 3.0\n", - " 98.00\n", - " 98.65\n", + " 97.60\n", + " 97.95\n", " 20\n", " True\n", " \n", " \n", - " 23\n", + " 28\n", " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " 9.0\n", " 3.0\n", - " 98.00\n", - " 98.70\n", + " 97.80\n", + " 98.10\n", " 20\n", " True\n", " \n", " \n", - " 24\n", + " 29\n", " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " 9.0\n", " 3.0\n", - " 98.00\n", - " 98.70\n", + " 97.80\n", + " 98.10\n", " 20\n", " True\n", " \n", " \n", - " 25\n", + " 30\n", " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " 9.0\n", " 3.0\n", - " 98.00\n", - " 98.70\n", + " 97.80\n", + " 98.10\n", " 20\n", " True\n", " \n", @@ -2450,76 +2577,86 @@ ], "text/plain": [ " description satellites planes \\\n", - "33 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", - "29 800 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", - "30 800 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", - "31 800 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", - "32 800 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", - "11 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 1.0 \n", - "14 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", - "12 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 1.0 \n", - "17 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", - "13 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", - "15 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", - "16 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", - "18 800 km, 60 deg FOR, Walker 45 deg: 4 x 1 (spac... 4.0 4.0 \n", - "20 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", - "19 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "23 800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac... 1.0 1.0 \n", + "14 700 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", + "15 700 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", + "12 700 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", + "13 700 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", + "11 700 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", + "35 800 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", + "38 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", + "37 800 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", + "34 800 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", + "36 800 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", + "16 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 1.0 \n", + "19 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", + "17 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 1.0 \n", + "21 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", + "22 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", + "18 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", + "20 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", + "25 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "24 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", "0 600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", "1 600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", "3 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", "4 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "21 800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "22 800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", + "26 800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", + "27 800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", "8 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", "9 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", "10 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "28 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "26 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "27 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "31 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "32 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "33 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", "5 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", "2 600 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "7 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", "6 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "23 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "24 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "25 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "7 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "28 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "29 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "30 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", "\n", " sufficient selected sufficient replicates pareto \n", - "33 3.42 2.65 20 True \n", - "29 3.40 2.75 20 True \n", - "30 4.20 2.80 20 True \n", - "31 3.40 2.90 20 True \n", - "32 4.00 2.90 20 True \n", - "11 14.13 14.70 20 True \n", - "14 28.60 27.55 20 True \n", - "12 37.00 37.15 20 True \n", - "17 37.40 37.40 20 True \n", - "13 66.40 66.85 20 True \n", - "15 66.20 66.85 20 True \n", - "16 66.40 67.15 20 True \n", - "18 66.70 66.95 20 True \n", - "20 98.00 98.45 20 True \n", - "19 97.80 98.55 20 True \n", - "0 97.80 98.45 20 True \n", - "1 97.80 98.50 20 True \n", - "3 97.80 98.65 20 True \n", - "4 97.80 98.65 20 True \n", - "21 98.00 98.70 20 True \n", - "22 98.00 98.70 20 True \n", - "8 97.80 98.65 20 True \n", - "9 97.80 98.65 20 True \n", - "10 97.80 98.65 20 True \n", - "28 98.00 98.65 20 True \n", - "26 98.00 98.70 20 True \n", - "27 98.00 98.70 20 True \n", - "5 97.69 98.05 20 True \n", - "2 97.77 98.45 20 True \n", - "7 97.96 98.60 20 True \n", - "6 98.00 98.65 20 True \n", - "23 98.00 98.70 20 True \n", - "24 98.00 98.70 20 True \n", - "25 98.00 98.70 20 True " + "23 2.75 2.60 20 False \n", + "14 2.62 2.85 20 True \n", + "15 2.45 2.85 20 True \n", + "12 2.52 2.90 20 True \n", + "13 2.70 2.95 20 True \n", + "11 2.90 3.45 20 True \n", + "35 3.20 3.50 20 True \n", + "38 3.10 3.50 20 True \n", + "37 2.90 3.75 20 True \n", + "34 3.10 3.80 20 True \n", + "36 3.20 3.85 20 True \n", + "16 16.60 16.15 20 True \n", + "19 30.20 28.95 20 True \n", + "17 38.00 36.70 20 True \n", + "21 37.83 35.60 20 False \n", + "22 37.02 37.05 20 True \n", + "18 68.20 66.50 20 True \n", + "20 69.60 66.40 20 True \n", + "25 97.60 97.80 20 True \n", + "24 97.80 97.95 20 True \n", + "0 97.40 97.75 20 True \n", + "1 97.40 97.85 20 True \n", + "3 97.60 97.95 20 True \n", + "4 97.60 97.95 20 True \n", + "26 97.80 98.10 20 True \n", + "27 97.80 98.10 20 True \n", + "8 97.60 97.95 20 True \n", + "9 97.60 97.95 20 True \n", + "10 97.60 97.95 20 True \n", + "31 97.80 98.10 20 True \n", + "32 97.80 98.10 20 True \n", + "33 97.80 98.10 20 True \n", + "5 97.53 97.45 20 True \n", + "2 97.60 97.85 20 True \n", + "6 97.60 97.95 20 True \n", + "7 97.60 97.95 20 True \n", + "28 97.80 98.10 20 True \n", + "29 97.80 98.10 20 True \n", + "30 97.80 98.10 20 True " ] }, "execution_count": 13, @@ -2545,7 +2682,7 @@ "id": "a3b4c5d6", "metadata": {}, "source": [ - "The selection is optimistic where it chose among many nearly equal designs. The single satellites, the best of dozens of single-satellite designs that sample 3 to 4% of the points, sample 2.7 to 2.9% with the new replicates, 0.5 to 1.4 percentage points fewer, and the one that looked best (crossing the equator at 09:00, with 4.2%) is no better than the others. The designs of two to nine satellites confirm their shares within about a percentage point. Most sample slightly more points with the new replicates (by 0.2 to 0.9 points), as the new samples of points happen to be sampled more easily by every design: common random numbers share this difference between samples among the designs, and it is not an effect of the selection. The mean optimism over the designs (-0.35 points) mixes the two, so compare the designs one by one. Every confirmed design remains efficient within the tolerance: the shape of the front is confirmed, but its single-satellite end is less good than it looked." + "The selection is optimistic where it chose the best of nearly equal designs. The designs of two to four satellites sample 0.5 to 3.2 percentage points fewer with the new replicates: four satellites in two planes 66.4% rather than 69.6%, and in one plane 66.5% rather than 68.2%. Of the two designs of three satellites in three planes that refinement left nearly as good as three in one plane, one samples 35.6% with the new replicates (rather than 37.8%) and is no longer efficient. The single satellites (but one) and the designs of six to nine satellites instead sample slightly more points with the new replicates (by up to 0.9 and 0.5 points), as the new samples of points happen to be sampled more easily at both ends of the front: common random numbers share this difference between samples among the designs, and it is not an effect of the selection. The mean optimism over the designs (-0.02 points) mixes the two, so compare the designs one by one. All but two of the confirmed designs remain efficient within the tolerance: the shape of the front is confirmed, but its middle is up to 3 points less good than it looked." ] }, { @@ -2564,10 +2701,10 @@ "id": "f9b7d1e3", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T17:05:34.653508Z", - "iopub.status.busy": "2026-11-11T17:05:34.653338Z", - "iopub.status.idle": "2026-11-11T17:05:35.969870Z", - "shell.execute_reply": "2026-11-11T17:05:35.969159Z" + "iopub.execute_input": "2026-11-11T18:31:02.189661Z", + "iopub.status.busy": "2026-11-11T18:31:02.189466Z", + "iopub.status.idle": "2026-11-11T18:31:03.586608Z", + "shell.execute_reply": "2026-11-11T18:31:03.585817Z" } }, "outputs": [ @@ -2575,7 +2712,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "194 of 1096 designs meet the requirement\n" + "209 of 1096 designs meet the requirement\n" ] }, { @@ -2615,7 +2752,7 @@ " 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...\n", " 4.0\n", " 1.0\n", - " 61.8\n", + " 65.0\n", " 1.0\n", " 5\n", " 1.00\n", @@ -2626,32 +2763,10 @@ " 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...\n", " 4.0\n", " 2.0\n", - " 61.8\n", - " 1.0\n", - " 5\n", - " 0.24\n", - " 1.0\n", - " \n", - " \n", - " 966\n", - " 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...\n", - " 4.0\n", - " 2.0\n", - " 62.4\n", + " 68.0\n", " 1.0\n", " 5\n", - " 0.38\n", - " 1.0\n", - " \n", - " \n", - " 980\n", - " 800 km, 60 deg FOR, Walker 45 deg: 4 x 1 (spac...\n", - " 4.0\n", - " 4.0\n", - " 63.8\n", - " 1.0\n", - " 40\n", - " 0.45\n", + " 0.94\n", " 1.0\n", " \n", " \n", @@ -2659,10 +2774,10 @@ " 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...\n", " 6.0\n", " 2.0\n", - " 97.4\n", + " 97.8\n", " 1.0\n", " 5\n", - " 0.47\n", + " 1.00\n", " 1.0\n", " \n", " \n", @@ -2670,43 +2785,10 @@ " 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...\n", " 6.0\n", " 2.0\n", - " 97.6\n", + " 97.0\n", " 1.0\n", " 5\n", - " 1.00\n", - " 1.0\n", - " \n", - " \n", - " 487\n", - " 600 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", - " 9.0\n", - " 3.0\n", - " 96.8\n", - " 1.0\n", - " 35\n", - " 0.12\n", - " 1.0\n", - " \n", - " \n", - " 762\n", - " 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", - " 9.0\n", - " 3.0\n", - " 96.8\n", - " 1.0\n", - " 25\n", - " 0.12\n", - " 1.0\n", - " \n", - " \n", - " 763\n", - " 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", - " 9.0\n", - " 3.0\n", - " 96.8\n", - " 1.0\n", - " 25\n", - " 0.11\n", + " 0.50\n", " 1.0\n", " \n", " \n", @@ -2717,35 +2799,20 @@ " description satellites planes \\\n", "962 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", "965 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", - "966 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", - "980 800 km, 60 deg FOR, Walker 45 deg: 4 x 1 (spac... 4.0 4.0 \n", "1025 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", "1026 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", - "487 600 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "762 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "763 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", "\n", " sufficient p20 reliability replicates pareto_probability \\\n", - "962 61.8 1.0 5 1.00 \n", - "965 61.8 1.0 5 0.24 \n", - "966 62.4 1.0 5 0.38 \n", - "980 63.8 1.0 40 0.45 \n", - "1025 97.4 1.0 5 0.47 \n", - "1026 97.6 1.0 5 1.00 \n", - "487 96.8 1.0 35 0.12 \n", - "762 96.8 1.0 25 0.12 \n", - "763 96.8 1.0 25 0.11 \n", + "962 65.0 1.0 5 1.00 \n", + "965 68.0 1.0 5 0.94 \n", + "1025 97.8 1.0 5 1.00 \n", + "1026 97.0 1.0 5 0.50 \n", "\n", " requirements_probability \n", "962 1.0 \n", "965 1.0 \n", - "966 1.0 \n", - "980 1.0 \n", "1025 1.0 \n", - "1026 1.0 \n", - "487 1.0 \n", - "762 1.0 \n", - "763 1.0 " + "1026 1.0 " ] }, "execution_count": 14, @@ -2778,7 +2845,7 @@ "id": "a0c8e2f4", "metadata": {}, "source": [ - "194 of the 1,096 designs meet the requirement of sampling half of the points sufficiently in at least 80% of the samples, and none of them has fewer than four satellites: the best three satellites sample 37% of the points on average. Among those that meet it, four satellites in one plane (inclined 45 degrees) are efficient for sure, sampling at least 62% of the points in 80% of the samples, and so are six satellites in two planes inclined 75 degrees (at least 97%). Four satellites in two or four planes are nearly as good, with probabilities of 0.24 to 0.45, which are the alternatives to weigh with other criteria, such as the cost of launching more planes." + "209 of the 1,096 designs meet the requirement of sampling half of the points sufficiently in at least 80% of the samples, and none of them has fewer than four satellites: the best three satellites sample 38% of the points on average. Among those that meet it, four satellites in one plane (inclined 45 degrees) are efficient for sure, sampling at least 65% of the points in 80% of the samples, and so are six satellites in two planes inclined 75 degrees (at least 98%). Four satellites in two planes sample more (at least 68%) and are efficient in 94% of the resamples, and six satellites in two planes with another relative spacing in 50%: these are the alternatives to weigh with other criteria, such as the cost of launching more planes." ] }, { @@ -2797,7 +2864,7 @@ "\n", "The policy is a decision of each design: a fragment of the design space (`policy_space`) decides whether to restore failed satellites, and the spares in orbit (in each plane) and on the ground (here, none or one of each, and none without restoration, which would never use them), and configures the policy of each design (`configure`, from a base policy of half a year of procurement and spares that are produced again). The efficient designs by accuracy, each with each of the five policies, form a design space of both, in which each history gives both the cost of what is produced and launched (the restorations and spares, and the launches that fail) and the phases in which its satellites operate, evaluated as in the previous section: the share of points accurately sampled on average over the mission, and in the worst 10% of the histories, and the cost at 70% confidence.\n", "\n", - "The failures are cheap to simulate, but each phase's share is expensive to evaluate, and most phases repeat the same sets of operating satellites. Each replicate (a sample of points, the expensive part) therefore simulates 20 histories of the failures of its mission (`Deployment.simulate_many`, stratified: a Latin hypercube over the histories in which each satellite's life and each launch draws from its own stratum of its distribution, which estimates means several times more precisely than independent histories), evaluates them together (`evaluate_missions`) with a cache that evaluates each set of satellites once (`PhaseCache`, shared by the histories, policies, and designs of a replicate), and summarizes them (`summarize_missions`): their mean share, and their worst 10% (the risk of the mission), and their cost at 70% confidence. Five replicates of 20 histories measure the risk of each mission with 100 histories, at a fraction of the cost of 100 replicates." + "The failures are cheap to simulate, but each phase's share is expensive to evaluate, and most phases repeat the same sets of operating satellites. Each replicate (a sample of points, the expensive part) therefore simulates 20 histories of the failures of its mission (`Deployment.simulate_many`, stratified: a Latin hypercube over the histories in which each satellite's life and each launch draws from its own stratum of its distribution, which estimates means several times more precisely than independent histories), evaluates them together (`evaluate_missions`) with a cache that evaluates each set of satellites once (`PhaseCache`, shared by the histories, policies, and designs of a replicate), and summarizes them (`summarize_missions`): their mean share, and their worst 10% (the risk of the mission), and their cost at 70% confidence. Five replicates of 20 histories measure the risk of each mission with 100 histories, at a fraction of the cost of 100 replicates. Without restoration (degrading), the satellites fail independently, so that the mean share over the failures is computed exactly (`expected_missions`, from the probability that each set of satellites operates), without sampling error; its worst 10% and cost still come from the histories." ] }, { @@ -2806,10 +2873,10 @@ "id": "d1e2f3a4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T17:05:35.971530Z", - "iopub.status.busy": "2026-11-11T17:05:35.971301Z", - "iopub.status.idle": "2026-11-11T17:05:38.964364Z", - "shell.execute_reply": "2026-11-11T17:05:38.963613Z" + "iopub.execute_input": "2026-11-11T18:31:03.588212Z", + "iopub.status.busy": "2026-11-11T18:31:03.588046Z", + "iopub.status.idle": "2026-11-11T18:31:12.120885Z", + "shell.execute_reply": "2026-11-11T18:31:12.120121Z" } }, "outputs": [ @@ -2824,7 +2891,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "60 designs x 5 replicates x 20 histories in 3 s\n" + "65 designs x 5 replicates x 20 histories in 5 s\n" ] }, { @@ -2901,19 +2968,19 @@ " \n", " \n", " \n", - " de5bf5d3c148\n", - " 800 km, 60 deg FOR, SSO: 1 at 06:00\n", + " 9b3481aea973\n", + " 800 km, 60 deg FOR, SSO: 1 at 12:00\n", + " 3.4\n", + " 3.2\n", " 3.9\n", - " 3.5\n", - " 4.4\n", - " 4.6\n", - " 4.6\n", - " 4.6\n", - " 0.5\n", " 4.0\n", - " 4.3\n", - " 4.2\n", - " 4.3\n", + " 4.1\n", + " 4.0\n", + " 0.4\n", + " 3.5\n", + " 3.7\n", + " 3.7\n", + " 3.7\n", " 110.2\n", " 130.6\n", " 147.6\n", @@ -2921,19 +2988,19 @@ " 162.2\n", " \n", " \n", - " 7274d007018f\n", - " 800 km, 60 deg FOR, SSO: 2 at 09:00\n", + " fac5d43a19c7\n", + " 800 km, 60 deg FOR, SSO: 2 at 06:00\n", + " 10.0\n", + " 7.0\n", + " 9.2\n", " 9.6\n", - " 8.2\n", - " 10.3\n", - " 10.7\n", - " 10.9\n", - " 10.8\n", - " 3.7\n", - " 8.6\n", - " 9.5\n", + " 9.8\n", " 9.7\n", - " 9.9\n", + " 2.1\n", + " 7.3\n", + " 8.3\n", + " 8.6\n", + " 8.7\n", " 128.9\n", " 153.4\n", " 170.3\n", @@ -2944,16 +3011,16 @@ " b85daf65c3a4\n", " 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...\n", " 16.7\n", + " 10.9\n", + " 14.8\n", + " 14.7\n", + " 16.0\n", + " 14.9\n", + " 4.6\n", " 12.2\n", - " 16.7\n", - " 16.5\n", - " 18.1\n", - " 16.7\n", - " 5.0\n", - " 14.0\n", + " 12.9\n", " 14.3\n", - " 16.1\n", - " 14.8\n", + " 13.3\n", " 146.2\n", " 188.2\n", " 211.1\n", @@ -2963,17 +3030,17 @@ " \n", " 104e33a3c842\n", " 800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac...\n", - " 28.6\n", - " 15.6\n", - " 21.5\n", - " 23.4\n", - " 23.3\n", - " 23.9\n", - " 6.2\n", - " 17.8\n", - " 19.7\n", + " 29.3\n", + " 16.1\n", + " 22.3\n", + " 24.4\n", + " 24.4\n", + " 24.9\n", + " 6.1\n", + " 18.0\n", " 20.4\n", - " 21.1\n", + " 21.0\n", + " 21.9\n", " 170.2\n", " 218.9\n", " 237.7\n", @@ -2983,17 +3050,17 @@ " \n", " 33b006848799\n", " 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...\n", - " 31.7\n", - " 16.3\n", - " 25.7\n", - " 27.8\n", - " 28.6\n", - " 28.1\n", + " 33.0\n", + " 17.7\n", + " 26.1\n", + " 28.2\n", + " 28.9\n", + " 28.5\n", " 0.6\n", - " 19.1\n", - " 24.7\n", - " 25.2\n", - " 25.2\n", + " 19.5\n", + " 25.1\n", + " 25.6\n", + " 25.6\n", " 136.5\n", " 159.4\n", " 192.7\n", @@ -3001,19 +3068,19 @@ " 206.4\n", " \n", " \n", - " ceabaa8327b8\n", - " 800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00\n", - " 54.8\n", - " 31.9\n", - " 45.9\n", - " 48.9\n", - " 49.9\n", - " 49.4\n", - " 8.7\n", - " 37.7\n", - " 43.3\n", - " 44.2\n", - " 45.2\n", + " c576e2e2dbd1\n", + " 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00\n", + " 57.0\n", + " 33.1\n", + " 47.3\n", + " 50.7\n", + " 51.7\n", + " 51.2\n", + " 7.1\n", + " 38.5\n", + " 44.7\n", + " 44.9\n", + " 46.8\n", " 153.9\n", " 198.1\n", " 229.3\n", @@ -3021,19 +3088,19 @@ " 240.1\n", " \n", " \n", - " 92ff9cd17e00\n", - " 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...\n", - " 57.8\n", - " 32.6\n", - " 44.2\n", - " 46.9\n", - " 46.9\n", - " 47.1\n", - " 11.2\n", + " f216ec70e160\n", + " 800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac...\n", + " 60.4\n", + " 32.9\n", + " 44.9\n", + " 48.0\n", + " 48.1\n", + " 48.3\n", + " 9.5\n", " 37.7\n", - " 42.7\n", - " 41.8\n", - " 43.1\n", + " 43.0\n", + " 42.4\n", + " 43.5\n", " 161.2\n", " 201.0\n", " 247.9\n", @@ -3041,19 +3108,19 @@ " 260.4\n", " \n", " \n", - " 25d7b27dab28\n", - " 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00\n", - " 82.2\n", - " 49.0\n", - " 66.4\n", - " 66.8\n", - " 70.4\n", - " 67.3\n", - " 12.8\n", - " 54.2\n", - " 59.0\n", - " 60.1\n", - " 61.4\n", + " 3690f1194419\n", + " 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00\n", + " 82.8\n", + " 50.7\n", + " 68.5\n", + " 68.8\n", + " 72.5\n", + " 69.3\n", + " 10.8\n", + " 56.2\n", + " 61.3\n", + " 62.2\n", + " 63.1\n", " 170.4\n", " 218.3\n", " 246.8\n", @@ -3061,19 +3128,39 @@ " 260.7\n", " \n", " \n", + " cb6bd361b577\n", + " 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...\n", + " 96.0\n", + " 75.8\n", + " 81.2\n", + " 76.3\n", + " 81.5\n", + " 76.2\n", + " 60.4\n", + " 73.8\n", + " 69.8\n", + " 73.9\n", + " 69.6\n", + " 246.8\n", + " 326.4\n", + " 376.7\n", + " 347.0\n", + " 389.6\n", + " \n", + " \n", " 716cb479efda\n", " 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...\n", - " 97.2\n", - " 63.8\n", - " 77.8\n", - " 73.9\n", - " 79.5\n", - " 74.0\n", - " 39.3\n", + " 97.0\n", + " 64.2\n", + " 78.0\n", + " 74.2\n", + " 79.6\n", + " 74.3\n", + " 38.9\n", " 70.1\n", - " 67.9\n", - " 71.4\n", - " 67.6\n", + " 67.3\n", + " 71.5\n", + " 66.9\n", " 209.5\n", " 278.8\n", " 316.7\n", @@ -3081,19 +3168,19 @@ " 329.0\n", " \n", " \n", - " 5529c21520be\n", + " 679ca275c8fc\n", " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", - " 98.0\n", - " 80.1\n", - " 83.3\n", - " 77.1\n", - " 83.4\n", - " 77.1\n", - " 66.1\n", - " 78.5\n", - " 71.7\n", - " 78.5\n", - " 71.7\n", + " 98.3\n", + " 79.5\n", + " 83.0\n", + " 76.8\n", + " 83.0\n", + " 76.8\n", + " 69.0\n", + " 78.7\n", + " 72.1\n", + " 78.6\n", + " 72.1\n", " 253.5\n", " 340.0\n", " 394.6\n", @@ -3101,19 +3188,19 @@ " 405.7\n", " \n", " \n", - " 679ca275c8fc\n", + " 5529c21520be\n", " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", - " 98.0\n", - " 80.3\n", - " 83.4\n", - " 77.1\n", - " 83.4\n", - " 77.1\n", - " 67.6\n", - " 78.6\n", - " 72.0\n", - " 78.4\n", - " 72.0\n", + " 98.3\n", + " 79.3\n", + " 82.8\n", + " 76.8\n", + " 82.8\n", + " 76.9\n", + " 66.4\n", + " 78.1\n", + " 71.6\n", + " 78.2\n", + " 71.6\n", " 253.5\n", " 340.0\n", " 394.6\n", @@ -3123,17 +3210,17 @@ " \n", " de505bc89299\n", " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", - " 98.0\n", - " 80.2\n", - " 83.3\n", - " 77.0\n", - " 83.3\n", - " 77.0\n", - " 66.9\n", - " 78.5\n", - " 71.8\n", - " 78.3\n", - " 71.8\n", + " 98.3\n", + " 79.5\n", + " 82.9\n", + " 76.9\n", + " 83.0\n", + " 76.9\n", + " 68.0\n", + " 78.7\n", + " 71.7\n", + " 78.4\n", + " 71.7\n", " 253.5\n", " 340.0\n", " 394.6\n", @@ -3148,97 +3235,103 @@ " description \\\n", "policy \n", "base \n", - "de5bf5d3c148 800 km, 60 deg FOR, SSO: 1 at 06:00 \n", - "7274d007018f 800 km, 60 deg FOR, SSO: 2 at 09:00 \n", + "9b3481aea973 800 km, 60 deg FOR, SSO: 1 at 12:00 \n", + "fac5d43a19c7 800 km, 60 deg FOR, SSO: 2 at 06:00 \n", "b85daf65c3a4 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... \n", "104e33a3c842 800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac... \n", "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", - "ceabaa8327b8 800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00 \n", - "92ff9cd17e00 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... \n", - "25d7b27dab28 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00 \n", + "c576e2e2dbd1 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 \n", + "f216ec70e160 800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac... \n", + "3690f1194419 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 \n", + "cb6bd361b577 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... \n", "716cb479efda 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", - "5529c21520be 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", "679ca275c8fc 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", + "5529c21520be 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", "de505bc89299 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", "\n", " full constellation accurate \\\n", "policy degrade produce spare in orbit \n", "base \n", - "de5bf5d3c148 3.9 3.5 4.4 4.6 \n", - "7274d007018f 9.6 8.2 10.3 10.7 \n", - "b85daf65c3a4 16.7 12.2 16.7 16.5 \n", - "104e33a3c842 28.6 15.6 21.5 23.4 \n", - "33b006848799 31.7 16.3 25.7 27.8 \n", - "ceabaa8327b8 54.8 31.9 45.9 48.9 \n", - "92ff9cd17e00 57.8 32.6 44.2 46.9 \n", - "25d7b27dab28 82.2 49.0 66.4 66.8 \n", - "716cb479efda 97.2 63.8 77.8 73.9 \n", - "5529c21520be 98.0 80.1 83.3 77.1 \n", - "679ca275c8fc 98.0 80.3 83.4 77.1 \n", - "de505bc89299 98.0 80.2 83.3 77.0 \n", + "9b3481aea973 3.4 3.2 3.9 4.0 \n", + "fac5d43a19c7 10.0 7.0 9.2 9.6 \n", + "b85daf65c3a4 16.7 10.9 14.8 14.7 \n", + "104e33a3c842 29.3 16.1 22.3 24.4 \n", + "33b006848799 33.0 17.7 26.1 28.2 \n", + "c576e2e2dbd1 57.0 33.1 47.3 50.7 \n", + "f216ec70e160 60.4 32.9 44.9 48.0 \n", + "3690f1194419 82.8 50.7 68.5 68.8 \n", + "cb6bd361b577 96.0 75.8 81.2 76.3 \n", + "716cb479efda 97.0 64.2 78.0 74.2 \n", + "679ca275c8fc 98.3 79.5 83.0 76.8 \n", + "5529c21520be 98.3 79.3 82.8 76.8 \n", + "de505bc89299 98.3 79.5 82.9 76.9 \n", "\n", " accurate p10 \\\n", "policy spare on ground spares in orbit and on ground degrade \n", "base \n", - "de5bf5d3c148 4.6 4.6 0.5 \n", - "7274d007018f 10.9 10.8 3.7 \n", - "b85daf65c3a4 18.1 16.7 5.0 \n", - "104e33a3c842 23.3 23.9 6.2 \n", - "33b006848799 28.6 28.1 0.6 \n", - "ceabaa8327b8 49.9 49.4 8.7 \n", - "92ff9cd17e00 46.9 47.1 11.2 \n", - "25d7b27dab28 70.4 67.3 12.8 \n", - "716cb479efda 79.5 74.0 39.3 \n", - "5529c21520be 83.4 77.1 66.1 \n", - "679ca275c8fc 83.4 77.1 67.6 \n", - "de505bc89299 83.3 77.0 66.9 \n", + "9b3481aea973 4.1 4.0 0.4 \n", + "fac5d43a19c7 9.8 9.7 2.1 \n", + "b85daf65c3a4 16.0 14.9 4.6 \n", + "104e33a3c842 24.4 24.9 6.1 \n", + "33b006848799 28.9 28.5 0.6 \n", + "c576e2e2dbd1 51.7 51.2 7.1 \n", + "f216ec70e160 48.1 48.3 9.5 \n", + "3690f1194419 72.5 69.3 10.8 \n", + "cb6bd361b577 81.5 76.2 60.4 \n", + "716cb479efda 79.6 74.3 38.9 \n", + "679ca275c8fc 83.0 76.8 69.0 \n", + "5529c21520be 82.8 76.9 66.4 \n", + "de505bc89299 83.0 76.9 68.0 \n", "\n", " \\\n", "policy produce spare in orbit spare on ground \n", "base \n", - "de5bf5d3c148 4.0 4.3 4.2 \n", - "7274d007018f 8.6 9.5 9.7 \n", - "b85daf65c3a4 14.0 14.3 16.1 \n", - "104e33a3c842 17.8 19.7 20.4 \n", - "33b006848799 19.1 24.7 25.2 \n", - "ceabaa8327b8 37.7 43.3 44.2 \n", - "92ff9cd17e00 37.7 42.7 41.8 \n", - "25d7b27dab28 54.2 59.0 60.1 \n", - "716cb479efda 70.1 67.9 71.4 \n", - "5529c21520be 78.5 71.7 78.5 \n", - "679ca275c8fc 78.6 72.0 78.4 \n", - "de505bc89299 78.5 71.8 78.3 \n", + "9b3481aea973 3.5 3.7 3.7 \n", + "fac5d43a19c7 7.3 8.3 8.6 \n", + "b85daf65c3a4 12.2 12.9 14.3 \n", + "104e33a3c842 18.0 20.4 21.0 \n", + "33b006848799 19.5 25.1 25.6 \n", + "c576e2e2dbd1 38.5 44.7 44.9 \n", + "f216ec70e160 37.7 43.0 42.4 \n", + "3690f1194419 56.2 61.3 62.2 \n", + "cb6bd361b577 73.8 69.8 73.9 \n", + "716cb479efda 70.1 67.3 71.5 \n", + "679ca275c8fc 78.7 72.1 78.6 \n", + "5529c21520be 78.1 71.6 78.2 \n", + "de505bc89299 78.7 71.7 78.4 \n", "\n", " cost p70 \\\n", "policy spares in orbit and on ground degrade produce spare in orbit \n", "base \n", - "de5bf5d3c148 4.3 110.2 130.6 147.6 \n", - "7274d007018f 9.9 128.9 153.4 170.3 \n", - "b85daf65c3a4 14.8 146.2 188.2 211.1 \n", - "104e33a3c842 21.1 170.2 218.9 237.7 \n", - "33b006848799 25.2 136.5 159.4 192.7 \n", - "ceabaa8327b8 45.2 153.9 198.1 229.3 \n", - "92ff9cd17e00 43.1 161.2 201.0 247.9 \n", - "25d7b27dab28 61.4 170.4 218.3 246.8 \n", - "716cb479efda 67.6 209.5 278.8 316.7 \n", - "5529c21520be 71.7 253.5 340.0 394.6 \n", - "679ca275c8fc 72.0 253.5 340.0 394.6 \n", - "de505bc89299 71.8 253.5 340.0 394.6 \n", + "9b3481aea973 3.7 110.2 130.6 147.6 \n", + "fac5d43a19c7 8.7 128.9 153.4 170.3 \n", + "b85daf65c3a4 13.3 146.2 188.2 211.1 \n", + "104e33a3c842 21.9 170.2 218.9 237.7 \n", + "33b006848799 25.6 136.5 159.4 192.7 \n", + "c576e2e2dbd1 46.8 153.9 198.1 229.3 \n", + "f216ec70e160 43.5 161.2 201.0 247.9 \n", + "3690f1194419 63.1 170.4 218.3 246.8 \n", + "cb6bd361b577 69.6 246.8 326.4 376.7 \n", + "716cb479efda 66.9 209.5 278.8 316.7 \n", + "679ca275c8fc 72.1 253.5 340.0 394.6 \n", + "5529c21520be 71.6 253.5 340.0 394.6 \n", + "de505bc89299 71.7 253.5 340.0 394.6 \n", "\n", " \n", "policy spare on ground spares in orbit and on ground \n", "base \n", - "de5bf5d3c148 146.3 162.2 \n", - "7274d007018f 170.0 184.3 \n", + "9b3481aea973 146.3 162.2 \n", + "fac5d43a19c7 170.0 184.3 \n", "b85daf65c3a4 204.4 223.3 \n", "104e33a3c842 235.8 249.8 \n", "33b006848799 175.2 206.4 \n", - "ceabaa8327b8 212.4 240.1 \n", - "92ff9cd17e00 216.8 260.4 \n", - "25d7b27dab28 235.4 260.7 \n", + "c576e2e2dbd1 212.4 240.1 \n", + "f216ec70e160 216.8 260.4 \n", + "3690f1194419 235.4 260.7 \n", + "cb6bd361b577 347.0 389.6 \n", "716cb479efda 294.4 329.0 \n", - "5529c21520be 355.7 405.7 \n", "679ca275c8fc 355.7 405.7 \n", + "5529c21520be 355.7 405.7 \n", "de505bc89299 355.7 405.7 " ] }, @@ -3311,12 +3404,12 @@ "id": "e2f3a4b5", "metadata": {}, "source": [ - "The 6,000 histories (100 of each of the 60 designs and policies) take a few seconds here, against about as long for 1,200 histories of one per replicate without the cache. The shares accurately sampled over the mission fall short of those of the full constellation under every policy, by the phases of deployment and the failures of launches as well as of satellites (37% of which fail within five years). The response to failures matters most for the designs of several satellites in several planes, and in their worst histories:\n", + "The 6,500 histories (100 of each of the 65 designs and policies) take a few seconds here. The shares accurately sampled over the mission fall short of those of the full constellation under every policy, by the phases of deployment and the failures of launches as well as of satellites (37% of which fail within five years), but for the single satellite, whose shares differ by less than the sampling error of five replicates (the full constellation's are of 20). The response to failures matters most for the designs of several satellites in several planes, and in their worst histories:\n", "\n", - "* **Degrading** is cheapest, but loses 12 to 17 points of the mean against producing replacements for the designs of three to six satellites in two or three planes, and more in their worst 10% of histories (39% against 70% for six satellites in three Walker planes; 1% against 19% for two satellites in two planes, which can lose both). Nine satellites in three planes lose only 3 points: a failure leaves eight.\n", + "* **Degrading** is cheapest, but loses 12 to 18 points of the mean against producing replacements for the designs of three to six satellites in two or three planes, and more in their worst 10% of histories (39% against 70% for six satellites in three Walker planes; 1% against 20% for two satellites in two planes, which can lose both). Nine satellites in three planes lose only 3.5 points: a failure leaves eight. The means of degrading are exact (`expected_missions`); those of the other policies are estimates from 100 histories.\n", "* **Producing replacements** restores most of it, at 17 to 34% more cost at 70% confidence than degrading.\n", - "* **Spares** cost 28 to 56% more than degrading, and pay off in the worst histories of the small designs of several planes: two satellites in two planes keep about 25% in their worst histories with a spare, against 19% by producing replacements. A spare on the ground costs less than a spare in each plane for the designs of several planes, and restores about as well.\n", - "* **A spare in orbit can hurt**: for six or nine satellites in three planes, the spares delay the deployment (each plane's spare takes longer to produce, and a fourth satellite in a plane takes a second launch of up to three), so that they sample less on average (74% against 78% for six satellites, 77% against 83% for nine) at a higher cost. Spares in orbit and on the ground together cost the most, and sample about as much as a spare on the ground alone, or less." + "* **Spares** cost 28 to 56% more than degrading (up to 62% for spares both in orbit and on the ground), and pay off in the worst histories of the small designs of several planes: two satellites in two planes keep about 25% in their worst histories with a spare, against 20% by producing replacements. A spare on the ground costs less than a spare in each plane for the designs of several planes, and restores as well or better.\n", + "* **A spare in orbit can hurt**: for six to nine satellites in three or four planes, the spares delay the deployment (each plane waits for its spare to be produced, and a fourth satellite in a plane of three takes a second launch), so that they sample less on average (74% against 78% for six satellites, 76% against 81% for eight, 77% against 83% for nine) at a higher cost. Spares in orbit and on the ground together cost the most, and sample about as much as a spare on the ground alone, or less." ] }, { @@ -3325,10 +3418,10 @@ "id": "b8c9d0e1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T17:05:38.965953Z", - "iopub.status.busy": "2026-11-11T17:05:38.965737Z", - "iopub.status.idle": "2026-11-11T17:05:38.974167Z", - "shell.execute_reply": "2026-11-11T17:05:38.973472Z" + "iopub.execute_input": "2026-11-11T18:31:12.122682Z", + "iopub.status.busy": "2026-11-11T18:31:12.122431Z", + "iopub.status.idle": "2026-11-11T18:31:12.131848Z", + "shell.execute_reply": "2026-11-11T18:31:12.131188Z" } }, "outputs": [ @@ -3370,130 +3463,114 @@ " \n", " \n", " \n", - " 56ce6ae8edc1\n", - " 800 km, 60 deg FOR, SSO: 1 at 06:00\n", + " 2a310c00151b\n", + " 800 km, 60 deg FOR, SSO: 1 at 12:00\n", " degrade\n", - " 3.5\n", - " 0.5\n", + " 3.2\n", + " 0.4\n", " 110.2\n", " \n", " \n", - " 21919a7c8e69\n", - " 800 km, 60 deg FOR, SSO: 2 at 09:00\n", + " bc2076a0d3d8\n", + " 800 km, 60 deg FOR, SSO: 2 at 06:00\n", " degrade\n", - " 8.2\n", - " 3.7\n", + " 7.0\n", + " 2.1\n", " 128.9\n", " \n", " \n", - " 098de5b3e423\n", - " 800 km, 60 deg FOR, SSO: 1 at 06:00\n", + " bb6574900ac3\n", + " 800 km, 60 deg FOR, SSO: 1 at 12:00\n", " produce\n", - " 4.4\n", - " 4.0\n", + " 3.9\n", + " 3.5\n", " 130.6\n", " \n", " \n", " 638697713902\n", " 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...\n", " degrade\n", - " 12.2\n", - " 5.0\n", + " 10.9\n", + " 4.6\n", " 146.2\n", " \n", " \n", - " dcfeee8eff41\n", - " 800 km, 60 deg FOR, SSO: 2 at 09:00\n", + " 43f50c8bc38a\n", + " 800 km, 60 deg FOR, SSO: 2 at 06:00\n", " produce\n", - " 10.3\n", - " 8.6\n", + " 9.2\n", + " 7.3\n", " 153.4\n", " \n", " \n", - " dbca2b91551b\n", - " 800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00\n", - " degrade\n", - " 31.9\n", - " 8.7\n", - " 153.9\n", - " \n", - " \n", " ad99c42082ab\n", " 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...\n", " produce\n", - " 25.7\n", - " 19.1\n", + " 26.1\n", + " 19.5\n", " 159.4\n", " \n", " \n", " cc2e14e787ff\n", " 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...\n", " spare on ground\n", - " 28.6\n", - " 25.2\n", + " 28.9\n", + " 25.6\n", " 175.2\n", " \n", " \n", - " 2f843d5c75f6\n", - " 800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00\n", + " eeb7c70a720b\n", + " 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00\n", " produce\n", - " 45.9\n", - " 37.7\n", + " 47.3\n", + " 38.5\n", " 198.1\n", " \n", " \n", - " 13421e38f465\n", - " 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...\n", - " produce\n", - " 44.2\n", - " 37.7\n", - " 201.0\n", - " \n", - " \n", " 3a902b976460\n", " 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...\n", " degrade\n", - " 63.8\n", - " 39.3\n", + " 64.2\n", + " 38.9\n", " 209.5\n", " \n", " \n", - " 1b5495ba11a7\n", - " 800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00\n", + " 6d54bdbf4648\n", + " 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00\n", " spare on ground\n", - " 49.9\n", - " 44.2\n", + " 51.7\n", + " 44.9\n", " 212.4\n", " \n", " \n", - " 13c5120fa410\n", - " 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00\n", + " 1afde0569e34\n", + " 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00\n", " produce\n", - " 66.4\n", - " 54.2\n", + " 68.5\n", + " 56.2\n", " 218.3\n", " \n", " \n", - " fb6667b89846\n", - " 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00\n", + " e7721a705c31\n", + " 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00\n", " spare on ground\n", - " 70.4\n", - " 60.1\n", + " 72.5\n", + " 62.2\n", " 235.4\n", " \n", " \n", " 46932f795a5a\n", " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " degrade\n", - " 80.3\n", - " 67.6\n", + " 79.5\n", + " 69.0\n", " 253.5\n", " \n", " \n", " 6e4564d2ae2c\n", " 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...\n", " produce\n", - " 77.8\n", + " 78.0\n", " 70.1\n", " 278.8\n", " \n", @@ -3501,16 +3578,24 @@ " 570a452fdb8f\n", " 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...\n", " spare on ground\n", - " 79.5\n", - " 71.4\n", + " 79.6\n", + " 71.5\n", " 294.4\n", " \n", " \n", + " 2b499d154a98\n", + " 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...\n", + " produce\n", + " 81.2\n", + " 73.8\n", + " 326.4\n", + " \n", + " \n", " a37619256b26\n", " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " produce\n", - " 83.4\n", - " 78.6\n", + " 83.0\n", + " 78.7\n", " 340.0\n", " \n", " \n", @@ -3520,45 +3605,43 @@ "text/plain": [ " description \\\n", "design \n", - "56ce6ae8edc1 800 km, 60 deg FOR, SSO: 1 at 06:00 \n", - "21919a7c8e69 800 km, 60 deg FOR, SSO: 2 at 09:00 \n", - "098de5b3e423 800 km, 60 deg FOR, SSO: 1 at 06:00 \n", + "2a310c00151b 800 km, 60 deg FOR, SSO: 1 at 12:00 \n", + "bc2076a0d3d8 800 km, 60 deg FOR, SSO: 2 at 06:00 \n", + "bb6574900ac3 800 km, 60 deg FOR, SSO: 1 at 12:00 \n", "638697713902 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... \n", - "dcfeee8eff41 800 km, 60 deg FOR, SSO: 2 at 09:00 \n", - "dbca2b91551b 800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00 \n", + "43f50c8bc38a 800 km, 60 deg FOR, SSO: 2 at 06:00 \n", "ad99c42082ab 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", "cc2e14e787ff 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", - "2f843d5c75f6 800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00 \n", - "13421e38f465 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... \n", + "eeb7c70a720b 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 \n", "3a902b976460 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", - "1b5495ba11a7 800 km, 60 deg FOR, SSO: 2 at 12:00, 1 at 15:00 \n", - "13c5120fa410 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00 \n", - "fb6667b89846 800 km, 60 deg FOR, SSO: 2 at 12:00, 2 at 09:00 \n", + "6d54bdbf4648 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 \n", + "1afde0569e34 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 \n", + "e7721a705c31 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 \n", "46932f795a5a 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", "6e4564d2ae2c 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", "570a452fdb8f 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", + "2b499d154a98 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... \n", "a37619256b26 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", "\n", " policy accurate accurate p10 cost p70 \n", "design \n", - "56ce6ae8edc1 degrade 3.5 0.5 110.2 \n", - "21919a7c8e69 degrade 8.2 3.7 128.9 \n", - "098de5b3e423 produce 4.4 4.0 130.6 \n", - "638697713902 degrade 12.2 5.0 146.2 \n", - "dcfeee8eff41 produce 10.3 8.6 153.4 \n", - "dbca2b91551b degrade 31.9 8.7 153.9 \n", - "ad99c42082ab produce 25.7 19.1 159.4 \n", - "cc2e14e787ff spare on ground 28.6 25.2 175.2 \n", - "2f843d5c75f6 produce 45.9 37.7 198.1 \n", - "13421e38f465 produce 44.2 37.7 201.0 \n", - "3a902b976460 degrade 63.8 39.3 209.5 \n", - "1b5495ba11a7 spare on ground 49.9 44.2 212.4 \n", - "13c5120fa410 produce 66.4 54.2 218.3 \n", - "fb6667b89846 spare on ground 70.4 60.1 235.4 \n", - "46932f795a5a degrade 80.3 67.6 253.5 \n", - "6e4564d2ae2c produce 77.8 70.1 278.8 \n", - "570a452fdb8f spare on ground 79.5 71.4 294.4 \n", - "a37619256b26 produce 83.4 78.6 340.0 " + "2a310c00151b degrade 3.2 0.4 110.2 \n", + "bc2076a0d3d8 degrade 7.0 2.1 128.9 \n", + "bb6574900ac3 produce 3.9 3.5 130.6 \n", + "638697713902 degrade 10.9 4.6 146.2 \n", + "43f50c8bc38a produce 9.2 7.3 153.4 \n", + "ad99c42082ab produce 26.1 19.5 159.4 \n", + "cc2e14e787ff spare on ground 28.9 25.6 175.2 \n", + "eeb7c70a720b produce 47.3 38.5 198.1 \n", + "3a902b976460 degrade 64.2 38.9 209.5 \n", + "6d54bdbf4648 spare on ground 51.7 44.9 212.4 \n", + "1afde0569e34 produce 68.5 56.2 218.3 \n", + "e7721a705c31 spare on ground 72.5 62.2 235.4 \n", + "46932f795a5a degrade 79.5 69.0 253.5 \n", + "6e4564d2ae2c produce 78.0 70.1 278.8 \n", + "570a452fdb8f spare on ground 79.6 71.5 294.4 \n", + "2b499d154a98 produce 81.2 73.8 326.4 \n", + "a37619256b26 produce 83.0 78.7 340.0 " ] }, "execution_count": 16, @@ -3579,7 +3662,7 @@ "id": "c9d0e1f2", "metadata": {}, "source": [ - "The front of cost at 70% confidence against the share accurately sampled in the worst 10% of the histories chooses designs and policies together. Along it, degrading is the cheapest policy of a design and restoring buys robustness: three satellites in two sun-synchronous planes keep 9% of the points accurately sampled in their worst histories if they degrade (154 million), 38% if they produce replacements (198 million), and 44% with a spare on the ground (212 million); six satellites in three Walker planes keep 39%, 70%, and 71% for 210, 279, and 294 million. Nine satellites in three planes degrade gracefully (68% in their worst histories for 254 million), and producing replacements raises them to 79% for 340 million. A spare on the ground is efficient for designs of two to six satellites, but a spare in orbit is not efficient for any design here, as it delays the deployment. The policy that a design deserves depends on the design, which is why the policy is a decision of the design rather than of the study." + "The front of cost at 70% confidence against the share accurately sampled in the worst 10% of the histories chooses designs and policies together. Along it, degrading is the cheapest policy of a design and restoring buys robustness: two satellites in two Walker planes keep 20% of the points accurately sampled in their worst histories if they produce replacements (159 million) and 26% with a spare on the ground (175 million); six satellites in three Walker planes keep 39%, 70%, and 72% if they degrade, produce replacements, or keep a spare on the ground, for 210, 279, and 294 million. Nine satellites in three planes degrade gracefully (69% in their worst histories for 254 million), and producing replacements raises them to 79% for 340 million. A spare on the ground is efficient for designs of two to six satellites, but a spare in orbit is not efficient for any design here, as it delays the deployment. The policy that a design deserves depends on the design, which is why the policy is a decision of the design rather than of the study." ] }, { @@ -3600,10 +3683,10 @@ "id": "c2d3e4f5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T17:05:38.975667Z", - "iopub.status.busy": "2026-11-11T17:05:38.975443Z", - "iopub.status.idle": "2026-11-11T17:05:40.636839Z", - "shell.execute_reply": "2026-11-11T17:05:40.636169Z" + "iopub.execute_input": "2026-11-11T18:31:12.133600Z", + "iopub.status.busy": "2026-11-11T18:31:12.133359Z", + "iopub.status.idle": "2026-11-11T18:31:13.861367Z", + "shell.execute_reply": "2026-11-11T18:31:13.860657Z" } }, "outputs": [ @@ -3611,7 +3694,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "520 of 1096 designs cost at most 150 at 70% confidence, of which 34 are efficient in at least half of the resamples\n" + "520 of 1096 designs cost at most 150 at 70% confidence, of which 46 are efficient in at least half of the resamples\n" ] }, { @@ -3652,8 +3735,8 @@ " \n", " \n", " \n", - " 913\n", - " 800 km, 30 deg FOR, SSO: 1 at 12:00\n", + " 635\n", + " 700 km, 30 deg FOR, SSO: 1 at 06:00\n", " 1\n", " 1\n", " 3.2\n", @@ -3668,8 +3751,8 @@ " 1.0\n", " \n", " \n", - " 912\n", - " 800 km, 30 deg FOR, SSO: 2 at 09:00\n", + " 910\n", + " 800 km, 30 deg FOR, SSO: 2 at 06:00\n", " 2\n", " 1\n", " 3.5\n", @@ -3680,7 +3763,7 @@ " 20.0\n", " 87.2\n", " 30.8\n", - " 3.2\n", + " 2.6\n", " 0.9\n", " \n", " \n", @@ -3696,24 +3779,24 @@ " 19.8\n", " 94.3\n", " 42.3\n", - " 7.8\n", - " 1.0\n", + " 6.2\n", + " 0.9\n", " \n", " \n", - " 922\n", - " 800 km, 30 deg FOR, SSO: 2 at 12:00, 1 at 06:00\n", + " 824\n", + " 800 km, 30 deg FOR, Walker 45 deg: 1 x 3 (spac...\n", " 3\n", - " 2\n", - " 4.0\n", - " 117.3\n", + " 1\n", + " 3.8\n", + " 109.6\n", " 44.4\n", " 33.0\n", - " 16.0\n", - " 22.2\n", - " 105.3\n", + " 8.0\n", + " 22.5\n", + " 98.2\n", " 41.0\n", " 7.8\n", - " 0.7\n", + " 1.0\n", " \n", " \n", " 835\n", @@ -3728,8 +3811,8 @@ " 21.8\n", " 112.2\n", " 52.5\n", - " 12.0\n", - " 0.8\n", + " 11.2\n", + " 1.0\n", " \n", " \n", " 828\n", @@ -3744,8 +3827,8 @@ " 24.5\n", " 115.9\n", " 50.7\n", - " 20.0\n", - " 0.9\n", + " 22.2\n", + " 1.0\n", " \n", " \n", " 963\n", @@ -3760,7 +3843,7 @@ " 19.8\n", " 126.0\n", " 53.7\n", - " 28.6\n", + " 30.2\n", " 1.0\n", " \n", " \n", @@ -3776,8 +3859,8 @@ " 23.5\n", " 129.2\n", " 62.2\n", - " 29.0\n", - " 0.8\n", + " 31.0\n", + " 0.7\n", " \n", " \n", " 961\n", @@ -3792,7 +3875,7 @@ " 22.5\n", " 134.4\n", " 57.4\n", - " 37.0\n", + " 38.0\n", " 0.6\n", " \n", " \n", @@ -3801,10 +3884,10 @@ ], "text/plain": [ " description satellites planes \\\n", - "913 800 km, 30 deg FOR, SSO: 1 at 12:00 1 1 \n", - "912 800 km, 30 deg FOR, SSO: 2 at 09:00 2 1 \n", + "635 700 km, 30 deg FOR, SSO: 1 at 06:00 1 1 \n", + "910 800 km, 30 deg FOR, SSO: 2 at 06:00 2 1 \n", "826 800 km, 30 deg FOR, Walker 45 deg: 2 x 1 (spac... 2 2 \n", - "922 800 km, 30 deg FOR, SSO: 2 at 12:00, 1 at 06:00 3 2 \n", + "824 800 km, 30 deg FOR, Walker 45 deg: 1 x 3 (spac... 3 1 \n", "835 800 km, 30 deg FOR, Walker 45 deg: 3 x 1 (spac... 3 3 \n", "828 800 km, 30 deg FOR, Walker 45 deg: 2 x 2 (spac... 4 2 \n", "963 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2 2 \n", @@ -3812,10 +3895,10 @@ "961 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3 1 \n", "\n", " deployed cost p70 cost development cost production cost launch \\\n", - "913 3.2 83.6 44.4 12.0 8.0 \n", - "912 3.5 96.9 44.4 22.8 8.0 \n", + "635 3.2 83.6 44.4 12.0 8.0 \n", + "910 3.5 96.9 44.4 22.8 8.0 \n", "826 3.8 104.7 44.4 22.8 16.0 \n", - "922 4.0 117.3 44.4 33.0 16.0 \n", + "824 3.8 109.6 44.4 33.0 8.0 \n", "835 4.2 124.8 44.4 33.0 24.0 \n", "828 4.0 129.3 44.4 42.7 16.0 \n", "963 3.8 139.2 66.7 34.2 16.0 \n", @@ -3823,25 +3906,25 @@ "961 3.8 149.1 66.7 49.4 8.0 \n", "\n", " cost operations cost present cost peak annual sufficient \\\n", - "913 17.5 75.5 23.5 1.0 \n", - "912 20.0 87.2 30.8 3.2 \n", - "826 19.8 94.3 42.3 7.8 \n", - "922 22.2 105.3 41.0 7.8 \n", - "835 21.8 112.2 52.5 12.0 \n", - "828 24.5 115.9 50.7 20.0 \n", - "963 19.8 126.0 53.7 28.6 \n", - "845 23.5 129.2 62.2 29.0 \n", - "961 22.5 134.4 57.4 37.0 \n", + "635 17.5 75.5 23.5 1.0 \n", + "910 20.0 87.2 30.8 2.6 \n", + "826 19.8 94.3 42.3 6.2 \n", + "824 22.5 98.2 41.0 7.8 \n", + "835 21.8 112.2 52.5 11.2 \n", + "828 24.5 115.9 50.7 22.2 \n", + "963 19.8 126.0 53.7 30.2 \n", + "845 23.5 129.2 62.2 31.0 \n", + "961 22.5 134.4 57.4 38.0 \n", "\n", " pareto_probability \n", - "913 1.0 \n", - "912 0.9 \n", - "826 1.0 \n", - "922 0.7 \n", - "835 0.8 \n", - "828 0.9 \n", + "635 1.0 \n", + "910 0.9 \n", + "826 0.9 \n", + "824 1.0 \n", + "835 1.0 \n", + "828 1.0 \n", "963 1.0 \n", - "845 0.8 \n", + "845 0.7 \n", "961 0.6 " ] }, @@ -3888,7 +3971,7 @@ "id": "d3e4f5a6", "metadata": {}, "source": [ - "520 of the 1,096 designs cost at most 150 million dollars at 70% confidence. Along the front, money buys sufficiency in steps: one satellite (84 million at 70% confidence, of which 44 million on average develops it) samples 1% of the points sufficiently; a second satellite in its plane, 3%, and in a second plane, 8%; four satellites in two Walker planes (129 million), 20%. The planes now have a price: four satellites in four planes sample more points sufficiently than in two (29% against 20%, as more planes spread the samples in time), at twice the cost of launches (32 million against 16). The wider field of regard joins the front only near the budget, where its development (67 million against 44) is worth its swath: two satellites with the wider imager sample 29% of the points for 139 million, as many as four with the narrower one, and three of them 37% for 149 million, the most within the budget. The designs that sample nearly every point (six to nine satellites) cost more than the budget.\n", + "520 of the 1,096 designs cost at most 150 million dollars at 70% confidence. Along the front, money buys sufficiency in steps: one satellite (84 million at 70% confidence, of which 44 million on average develops it) samples 1% of the points sufficiently; a second satellite in its plane, 3%, and in a second plane, 6%; four satellites in two Walker planes (129 million), 22%. The planes now have a price: four satellites in four planes sample more points sufficiently than in two (31% against 22%, as more planes spread the samples in time), at twice the cost of launches (32 million against 16). The wider field of regard joins the front only near the budget, where its development (67 million against 44) is worth its swath: two satellites with the wider imager sample 30% of the points for 139 million, about as many as four with the narrower one in four planes, and three of them 38% for 149 million, the most within the budget. The designs that sample nearly every point (six to nine satellites) cost more than the budget.\n", "\n", "Each design's schedule follows from its satellites and planes (`deployed`, years from the start of development to the launch of its last plane): one satellite is launched 3.2 years after development starts; four satellites in two planes take a year to produce, and are deployed after 4.0 years; and four satellites in four planes, after 4.8 years, as each plane takes a launch and launches are half a year apart. Dated, the costs are worth 8 to 9% less at present (at 3% a year), as most are incurred three or more years from now. The most expensive year is the one after development, in which the satellites are produced and the first are launched: four satellites in four planes need 62 million in that year, and one satellite 24 million. A budget of annual funding would limit the satellites produced in a year, which a slower production rate would spread over more years, at the cost of deploying later.\n", "\n", @@ -3913,10 +3996,10 @@ "id": "f5a6b7c8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T17:05:40.638413Z", - "iopub.status.busy": "2026-11-11T17:05:40.638183Z", - "iopub.status.idle": "2026-11-11T17:05:40.824879Z", - "shell.execute_reply": "2026-11-11T17:05:40.824101Z" + "iopub.execute_input": "2026-11-11T18:31:13.863068Z", + "iopub.status.busy": "2026-11-11T18:31:13.862822Z", + "iopub.status.idle": "2026-11-11T18:31:14.085781Z", + "shell.execute_reply": "2026-11-11T18:31:14.085149Z" } }, "outputs": [ @@ -3964,13 +4047,13 @@ " \n", " \n", " \n", - " bc0fd0c644ee\n", - " 800 km, 60 deg FOR, SSO: 1 at 09:00\n", + " 163120bf9590\n", + " 800 km, 60 deg FOR, SSO: 1 at 18:00\n", " 1.0\n", " 1.0\n", " 3.2\n", - " 4.2\n", - " 4.2\n", + " 3.2\n", + " 3.2\n", " 0.0\n", " inf\n", " \n", @@ -3980,8 +4063,8 @@ " 2.0\n", " 1.0\n", " 3.5\n", - " 13.8\n", - " 13.8\n", + " 16.6\n", + " 16.6\n", " 0.0\n", " inf\n", " \n", @@ -3991,9 +4074,9 @@ " 2.0\n", " 2.0\n", " 3.8\n", - " 28.6\n", - " 25.8\n", - " 2.8\n", + " 30.2\n", + " 27.3\n", + " 2.9\n", " inf\n", " \n", " \n", @@ -4002,8 +4085,8 @@ " 3.0\n", " 1.0\n", " 3.8\n", - " 37.0\n", - " 37.0\n", + " 38.0\n", + " 38.0\n", " 0.0\n", " inf\n", " \n", @@ -4013,20 +4096,31 @@ " 4.0\n", " 1.0\n", " 4.5\n", - " 66.4\n", - " 61.4\n", - " 5.0\n", + " 68.2\n", + " 63.5\n", + " 4.7\n", " 4.5\n", " \n", " \n", - " 400cf2b03fa8\n", + " 6ba50f2632cd\n", + " 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...\n", + " 4.0\n", + " 2.0\n", + " 4.0\n", + " 69.6\n", + " 64.3\n", + " 5.3\n", + " 4.0\n", + " \n", + " \n", + " 6bef11e40977\n", " 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...\n", " 6.0\n", " 2.0\n", " 4.5\n", - " 98.0\n", - " 87.0\n", - " 11.0\n", + " 97.8\n", + " 87.1\n", + " 10.7\n", " 4.5\n", " \n", " \n", @@ -4036,30 +4130,33 @@ "text/plain": [ " description satellites \\\n", "design \n", - "bc0fd0c644ee 800 km, 60 deg FOR, SSO: 1 at 09:00 1.0 \n", + "163120bf9590 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 \n", "f7413b1f8466 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 \n", "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 \n", "d5d3fa915ca7 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 \n", "1af5f2707be3 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 \n", - "400cf2b03fa8 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 \n", + "6ba50f2632cd 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 \n", + "6bef11e40977 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 \n", "\n", " planes deployed sufficient sufficient mean lost \\\n", "design \n", - "bc0fd0c644ee 1.0 3.2 4.2 4.2 0.0 \n", - "f7413b1f8466 1.0 3.5 13.8 13.8 0.0 \n", - "33b006848799 2.0 3.8 28.6 25.8 2.8 \n", - "d5d3fa915ca7 1.0 3.8 37.0 37.0 0.0 \n", - "1af5f2707be3 1.0 4.5 66.4 61.4 5.0 \n", - "400cf2b03fa8 2.0 4.5 98.0 87.0 11.0 \n", + "163120bf9590 1.0 3.2 3.2 3.2 0.0 \n", + "f7413b1f8466 1.0 3.5 16.6 16.6 0.0 \n", + "33b006848799 2.0 3.8 30.2 27.3 2.9 \n", + "d5d3fa915ca7 1.0 3.8 38.0 38.0 0.0 \n", + "1af5f2707be3 1.0 4.5 68.2 63.5 4.7 \n", + "6ba50f2632cd 2.0 4.0 69.6 64.3 5.3 \n", + "6bef11e40977 2.0 4.5 97.8 87.1 10.7 \n", "\n", " sufficient time \n", "design \n", - "bc0fd0c644ee inf \n", + "163120bf9590 inf \n", "f7413b1f8466 inf \n", "33b006848799 inf \n", "d5d3fa915ca7 inf \n", "1af5f2707be3 4.5 \n", - "400cf2b03fa8 4.5 " + "6ba50f2632cd 4.0 \n", + "6bef11e40977 4.5 " ] }, "execution_count": 18, @@ -4085,7 +4182,7 @@ "id": "a6b7c8d9", "metadata": {}, "source": [ - "Deployment costs the designs of several planes or launches. Six satellites in two planes sample 98% of the points once deployed, but 87% on average over the mission, as the first plane flies alone for three quarters of a year while the second is produced, and they sample half of the points only 4.5 years after development starts, when the second plane is launched. Four satellites in one plane need two launches (of up to three satellites) half a year apart, and lose 5 points of their 66%; two satellites in two planes lose 3 points of their 29%. The designs launched at once lose nothing. Over a five-year mission, the loss is the share of the mission before full deployment times the shortfall of the partial constellation: a shorter mission, slower production, or fewer launches a year would weigh deployment more, and could reorder the front." + "Deployment costs the designs of several planes or launches. Six satellites in two planes sample 98% of the points once deployed, but 87% on average over the mission, as the first plane flies alone for three quarters of a year while the second is produced, and they sample half of the points only 4.5 years after development starts, when the second plane is launched. Four satellites in one plane need two launches (of up to three satellites) half a year apart, and lose 5 points of their 68%; four satellites in two planes lose 5 points of their 70%, and two satellites in two planes 3 points of their 30%. The designs launched at once lose nothing. Over a five-year mission, the loss is the share of the mission before full deployment times the shortfall of the partial constellation: a shorter mission, slower production, or fewer launches a year would weigh deployment more, and could reorder the front." ] }, { @@ -4106,10 +4203,10 @@ "id": "d6e5f8a7", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T17:05:40.826446Z", - "iopub.status.busy": "2026-11-11T17:05:40.826232Z", - "iopub.status.idle": "2026-11-11T17:05:42.841203Z", - "shell.execute_reply": "2026-11-11T17:05:42.840413Z" + "iopub.execute_input": "2026-11-11T18:31:14.087444Z", + "iopub.status.busy": "2026-11-11T18:31:14.087223Z", + "iopub.status.idle": "2026-11-11T18:31:26.158358Z", + "shell.execute_reply": "2026-11-11T18:31:26.157668Z" } }, "outputs": [ @@ -4149,40 +4246,40 @@ " 12 h, 1 replicate\n", " 5.0\n", " NaN\n", - " 68\n", - " 5 of 6\n", - " 100.0\n", - " 16.0\n", + " 74\n", + " 4 of 7\n", + " 98.8\n", + " 16.9\n", " \n", " \n", " 1\n", " 12 h, 1 replicate\n", " 10.0\n", " 5.0\n", - " 212\n", - " 6 of 6\n", + " 248\n", + " 7 of 7\n", " 100.0\n", - " 23.7\n", + " 29.2\n", " \n", " \n", " 2\n", " 6 h, 1 replicate\n", " 5.0\n", " NaN\n", - " 55\n", - " 1 of 6\n", - " 79.0\n", - " 10.2\n", + " 62\n", + " 1 of 7\n", + " 83.0\n", + " 10.6\n", " \n", " \n", " 3\n", " 6 h, 1 replicate\n", " 20.0\n", " NaN\n", - " 241\n", - " 6 of 6\n", - " 100.0\n", - " 24.8\n", + " 231\n", + " 5 of 7\n", + " 96.6\n", + " 25.1\n", " \n", " \n", "\n", @@ -4190,22 +4287,22 @@ ], "text/plain": [ " screening study keep (%) tolerance (%) designs kept \\\n", - "0 12 h, 1 replicate 5.0 NaN 68 \n", - "1 12 h, 1 replicate 10.0 5.0 212 \n", - "2 6 h, 1 replicate 5.0 NaN 55 \n", - "3 6 h, 1 replicate 20.0 NaN 241 \n", + "0 12 h, 1 replicate 5.0 NaN 74 \n", + "1 12 h, 1 replicate 10.0 5.0 248 \n", + "2 6 h, 1 replicate 5.0 NaN 62 \n", + "3 6 h, 1 replicate 20.0 NaN 231 \n", "\n", " efficient designs kept hypervolume (% of true front) \\\n", - "0 5 of 6 100.0 \n", - "1 6 of 6 100.0 \n", - "2 1 of 6 79.0 \n", - "3 6 of 6 100.0 \n", + "0 4 of 7 98.8 \n", + "1 7 of 7 100.0 \n", + "2 1 of 7 83.0 \n", + "3 5 of 7 96.6 \n", "\n", " cost (% of every design) \n", - "0 16.0 \n", - "1 23.7 \n", - "2 10.2 \n", - "3 24.8 " + "0 16.9 \n", + "1 29.2 \n", + "2 10.6 \n", + "3 25.1 " ] }, "execution_count": 19, @@ -4246,9 +4343,9 @@ "id": "e7f6a9b8", "metadata": {}, "source": [ - "The 12-hour screening study ranks designs nearly as the full study does. Keeping the best 5% of the designs finds a front with the hypervolume of the true front at 16% of the cost of evaluating every design, although it misses one efficient design, whose place a design with nearly the same objectives takes. Keeping 10%, with a tolerance of 5 percentage points, keeps every efficient design at 24% of the cost.\n", + "The 12-hour screening study ranks designs nearly as the full study does. Keeping the best 5% of the designs finds a front with 99% of the hypervolume of the true front at 17% of the cost of evaluating every design, although it misses three of the seven efficient designs, whose places designs with nearly the same objectives take. Keeping 10%, with a tolerance of 5 percentage points, keeps every efficient design at 29% of the cost.\n", "\n", - "The 6-hour screening study is cheaper, but ranks designs differently: one observation of a point in 6 hours separates designs less than four observations in a day do. Keeping 5% of the designs keeps only one of the six efficient ones (79% of the hypervolume), and it must keep 20% to keep them all, which costs as much as the 12-hour study. How many designs to keep depends on how well the cheap study ranks designs, which is worth checking on a sample of designs evaluated with both studies before screening a larger space." + "The 6-hour screening study is cheaper, but ranks designs differently: one observation of a point in 6 hours separates designs less than four observations in a day do. Keeping 5% of the designs keeps only one of the seven efficient ones (83% of the hypervolume), and keeping 20% still misses two of them (97% of the hypervolume) at 25% of the cost, nearly as much as the 12-hour study that keeps them all. How many designs to keep depends on how well the cheap study ranks designs, which is worth checking on a sample of designs evaluated with both studies before screening a larger space." ] }, { @@ -4269,10 +4366,10 @@ "id": "a9b8c1d0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T17:05:42.842829Z", - "iopub.status.busy": "2026-11-11T17:05:42.842601Z", - "iopub.status.idle": "2026-11-11T17:05:43.982198Z", - "shell.execute_reply": "2026-11-11T17:05:43.981451Z" + "iopub.execute_input": "2026-11-11T18:31:26.160062Z", + "iopub.status.busy": "2026-11-11T18:31:26.159842Z", + "iopub.status.idle": "2026-11-11T18:31:27.178938Z", + "shell.execute_reply": "2026-11-11T18:31:27.178266Z" } }, "outputs": [ @@ -4304,18 +4401,18 @@ " \n", " \n", " Optuna (NSGA-II)\n", - " 140.0\n", - " 95.3\n", + " 143.0\n", + " 92.1\n", " \n", " \n", " pymoo (NSGA-II)\n", - " 87.0\n", - " 89.6\n", + " 81.0\n", + " 84.3\n", " \n", " \n", " Latin hypercube sample\n", " 176.0\n", - " 80.3\n", + " 79.3\n", " \n", " \n", "\n", @@ -4323,9 +4420,9 @@ ], "text/plain": [ " designs evaluated hypervolume (% of true front)\n", - "Optuna (NSGA-II) 140.0 95.3\n", - "pymoo (NSGA-II) 87.0 89.6\n", - "Latin hypercube sample 176.0 80.3" + "Optuna (NSGA-II) 143.0 92.1\n", + "pymoo (NSGA-II) 81.0 84.3\n", + "Latin hypercube sample 176.0 79.3" ] }, "execution_count": 20, @@ -4383,16 +4480,16 @@ "id": "b0c9d2e1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T17:05:43.983687Z", - "iopub.status.busy": "2026-11-11T17:05:43.983462Z", - "iopub.status.idle": "2026-11-11T17:05:44.111120Z", - "shell.execute_reply": "2026-11-11T17:05:44.110357Z" + "iopub.execute_input": "2026-11-11T18:31:27.180650Z", + "iopub.status.busy": "2026-11-11T18:31:27.180366Z", + "iopub.status.idle": "2026-11-11T18:31:27.307537Z", + "shell.execute_reply": "2026-11-11T18:31:27.306838Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -4424,7 +4521,7 @@ "id": "c1d0e3f2", "metadata": {}, "source": [ - "Both optimizers find more of the hypervolume than a Latin hypercube sample of as many designs. Optuna (NSGA-II, searching the hierarchical space directly) finds 95% of the hypervolume of the true front with 140 designs, 13% of the space. pymoo (NSGA-II, searching the encoded space) finds 90% with 87 designs: its 200 proposals include many that encode the same design or that violate the constraints, which are not evaluated. The sample finds 80% with 176 designs. The searches stop at their budget of proposals, not at convergence: a larger budget, or screening, would bring them closer to the true front. Their results also depend on their seeds, so compare several seeds before relying on one." + "Both optimizers find more of the hypervolume than a Latin hypercube sample of as many designs. Optuna (NSGA-II, searching the hierarchical space directly) finds 92% of the hypervolume of the true front with 143 designs, 13% of the space. pymoo (NSGA-II, searching the encoded space) finds 84% with 81 designs: its 200 proposals include many that encode the same design or that violate the constraints, which are not evaluated. The sample finds 79% with 176 designs. The searches stop at their budget of proposals, not at convergence: a larger budget, or screening, would bring them closer to the true front. Their results also depend on their seeds, so compare several seeds before relying on one." ] }, { @@ -4435,10 +4532,10 @@ "## Summary\n", "\n", "* A `DesignSpace` declares a hierarchical trade space, with choices between alternatives (`Choice`), repeated elements such as orbit planes (`Repeat`), bounds that depend on other variables, constraints that measure their violation, and uncertain parameters (`Uncertain`) drawn for each replicate. Building blocks declare common constellation layouts (`walker_space` and `sso_planes_space`) and build their satellites with instruments or entries of the instrument catalog (`build_constellation`).\n", - "* A `Study` evaluates designs in replicates, in parallel, with a `SatelliteCache` that analyzes each distinct satellite once and a `ResultStore` that keeps its evaluations (by the fingerprint of the study, so that a changed study evaluates its designs again). Every design of a space of about a thousand designs can be evaluated in minutes.\n", + "* A `Study` evaluates designs in replicates (here, of points of a randomly oriented lattice, `generate_points_rotated_lattice`, which vary less between replicates than random points), in parallel, with a `SatelliteCache` that analyzes each distinct satellite once and a `ResultStore` that keeps its evaluations (by the fingerprint of the study, so that a changed study evaluates its designs again). Every design of a space of about a thousand designs can be evaluated in minutes.\n", "* Statistical sufficiency is measured by the sampling error of the statistic that observations estimate (`tatc.analysis.estimate_sampling_error`), which counts of samples overstate when samples cluster in time, as they do in a single plane; revisit statistics and local time coverage explain it.\n", "* The front of the means of the replicates is uncertain: `pareto_probability` finds the designs whose efficiency the replicates settle, and those that are equally good candidates, and `refine` adds replicates only to the latter, with a tolerance of differences that do not matter. `confirm` evaluates the selected designs with new replicates, which removes the optimism of selecting the best of many nearly equal designs.\n", - "* Statistics other than means (such as a `Quantile` or the `Probability` of meeting a threshold) state how reliably a design performs, and `Requirement`s on them are output constraints. Simulated missions (`Deployment.simulate`) draw the failures of satellites and launches from lives whose failure rates vary over the lifecycle (`FailureModel`), and restore them or not (`RestorationPolicy`, by spares in orbit or on the ground, or by producing new ones), for both the cost and the capability of each policy; the policy is a decision of each design (`policy_space`, configured by `configure`), on the front with the design. `sensitivity` finds the design variables that drive each objective.\n", + "* Statistics other than means (such as a `Quantile` or the `Probability` of meeting a threshold) state how reliably a design performs, and `Requirement`s on them are output constraints. Simulated missions (`Deployment.simulate`) draw the failures of satellites and launches from lives whose failure rates vary over the lifecycle (`FailureModel`), and restore them or not (`RestorationPolicy`, by spares in orbit or on the ground, or by producing new ones), for both the cost and the capability of each policy (exactly, without sampling, for missions that do not restore failed satellites: `expected_missions`); the policy is a decision of each design (`policy_space`, configured by `configure`), on the front with the design. `sensitivity` finds the design variables that drive each objective.\n", "* `screen` evaluates every design with a cheap study and the best with the full one, which finds the front at a fraction of the cost if the cheap study ranks designs as the full one does.\n", "* A `DeploymentSchedule` plans each design's deployment from rates of production and launch, which dates its costs and divides its mission into phases of the satellites that fly, evaluated with the observations of the full constellation for the mean capability over the mission and the time until a requirement is met.\n", "* A `CostModel` estimates the life-cycle cost of each deployment from the costs of its satellites, launches, and operations (given by the study), with uncertain growth whose quantiles give the cost at a confidence level, as an objective or a requirement in place of the numbers of satellites and planes.\n", diff --git a/src/tatc/generation/points.py b/src/tatc/generation/points.py index 8b7e101c..b4a3e987 100644 --- a/src/tatc/generation/points.py +++ b/src/tatc/generation/points.py @@ -133,7 +133,9 @@ def generate_points_rotated_lattice( `generate_points_random`, but the points cover the sphere evenly rather than clustering by chance, so that statistics of samples of points (such as the share of points sampled sufficiently, over the replicates of a - trade study) vary several times less between samples of the same size. + trade study) vary less between samples of the same size (with about 1.5 + to 4 times less variance for the shares of points that constellations + sample). With a mask, the lattice covers the sphere with about `count` points inside the mask (from the mask's share of the sphere's area), and the From f83aff6107968bbe1bf0575013af049ad5107179 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Wed, 11 Nov 2026 21:57:43 -0700 Subject: [PATCH 25/52] judge designs by criteria, and key stores of results by the definitions of studies - Designs are infeasible only if their functions raise Infeasible or fail the validation of TAT-C's schemas; other errors are raised (or recorded as failed with errors="record") and are not stored. - Criteria (objectives, statistics, requirements, tolerances, and by) replace the keyword arguments of every function that judges designs; summarize wraps aggregate, and statistics name the columns they need. - Fingerprints hash the definitions of studies, with the source of the TAT-C modules they use and data frames by content; stores keep the definitions and explain changes, records are JSON, and workers store each evaluation as it completes. Satellite caches keep each definition apart and warn once. - refine stops refining designs whose objectives are known within a precision of their tolerances, within a budget of evaluations, and pareto_probability gives standard errors; searches return a Search to refine and confirm. - Replicates may draw named parameters as in other replicates (shift) or be evaluated in scenarios that set values of the design space, each kept apart in stores. - pymoo searches eliminate the proposals of designs proposed or evaluated before. --- src/tatc/tradespace/__init__.py | 31 +- src/tatc/tradespace/cache.py | 162 ++++-- src/tatc/tradespace/confirmation.py | 72 +-- src/tatc/tradespace/criteria.py | 468 +++++++++++++--- src/tatc/tradespace/fingerprint.py | 759 ++++++++++++++++++++------ src/tatc/tradespace/nodes.py | 4 +- src/tatc/tradespace/optimization.py | 261 ++++++--- src/tatc/tradespace/pareto.py | 361 ++++++------ src/tatc/tradespace/refinement.py | 219 +++++--- src/tatc/tradespace/screening.py | 92 ++-- src/tatc/tradespace/space.py | 196 ++++++- src/tatc/tradespace/store.py | 254 +++++++-- src/tatc/tradespace/study.py | 592 ++++++++++++++------ tests/tradespace/test_cache.py | 76 ++- tests/tradespace/test_confirmation.py | 11 +- tests/tradespace/test_criteria.py | 155 +++++- tests/tradespace/test_fingerprint.py | 183 ++++++- tests/tradespace/test_optimization.py | 136 +++-- tests/tradespace/test_pareto.py | 111 +++- tests/tradespace/test_refinement.py | 105 +++- tests/tradespace/test_screening.py | 18 + tests/tradespace/test_space.py | 67 +++ tests/tradespace/test_store.py | 182 +++++- tests/tradespace/test_study.py | 190 ++++++- 24 files changed, 3667 insertions(+), 1038 deletions(-) diff --git a/src/tatc/tradespace/__init__.py b/src/tatc/tradespace/__init__.py index 41425443..67df6e66 100644 --- a/src/tatc/tradespace/__init__.py +++ b/src/tatc/tradespace/__init__.py @@ -63,6 +63,7 @@ policy_space, ) from .criteria import ( + Criteria, Maximum, Mean, Minimum, @@ -70,17 +71,26 @@ Quantile, Requirement, StandardDeviation, + StandardError, Statistic, aggregate, + summarize, ) from .optimization import ( Evaluations, + Search, make_pymoo_problem, optimize_optuna, optimize_pymoo, ) -from .fingerprint import get_fingerprint, get_source_hash -from .pareto import hypervolume, pareto_front, pareto_probability, pareto_ranks +from .fingerprint import compare_definitions, get_definition, get_fingerprint +from .pareto import ( + hypervolume, + hypervolume_progress, + pareto_front, + pareto_probability, + pareto_ranks, +) from .refinement import Refinement, refine from .screening import Screening, screen from .sensitivity import main_effects, sensitivity @@ -98,8 +108,14 @@ ) from .space import Design, DesignSpace from .store import ResultStore -from .study import Study, summarize -from .values import ChoiceValues, RepeatValues, Scope, Values, configure +from .study import Study +from .values import ( + ChoiceValues, + RepeatValues, + Scope, + Values, + configure, +) __all__ = [ "Bathtub", @@ -109,6 +125,7 @@ "Confirmation", "CostEstimate", "CostModel", + "Criteria", "Deployment", "DeploymentSchedule", "Derived", @@ -145,7 +162,9 @@ "SatelliteCost", "Scope", "Screening", + "Search", "StandardDeviation", + "StandardError", "Statistic", "Study", "Uncertain", @@ -155,6 +174,7 @@ "aggregate", "allocate_histories", "build_constellation", + "compare_definitions", "configure", "confirm", "count_planes", @@ -162,11 +182,12 @@ "evaluate_missions", "evaluate_phases", "expected_missions", + "get_definition", "get_fingerprint", "get_satellite_key", - "get_source_hash", "hours_to_time", "hypervolume", + "hypervolume_progress", "main_effects", "make_pymoo_problem", "optimize_optuna", diff --git a/src/tatc/tradespace/cache.py b/src/tatc/tradespace/cache.py index d5b400c1..f146170a 100644 --- a/src/tatc/tradespace/cache.py +++ b/src/tatc/tradespace/cache.py @@ -17,8 +17,10 @@ import json import os import pickle +import shutil import tempfile import time +import warnings from collections.abc import Callable, Iterable from pathlib import Path from typing import Any @@ -26,7 +28,28 @@ import pandas as pd from ..schemas import Satellite -from .fingerprint import get_fingerprint +from .fingerprint import _fingerprint_of, compare_definitions, get_definition + + +def _write(path: Path, data: bytes, replace: bool = False) -> None: + """ + Writes a file (if it does not exist, or to `replace` it) through a + temporary file that is renamed, so that a parallel worker never reads a + partial file. + """ + if path.exists() and not replace: + return + descriptor, temporary = tempfile.mkstemp(dir=path.parent, suffix=".tmp") + with os.fdopen(descriptor, "wb") as file: + file.write(data) + try: + os.replace(temporary, path) + except PermissionError: + # on Windows, another worker is replacing or reading the file, which + # then holds the same content + os.remove(temporary) + if not path.exists(): + raise def get_satellite_key(satellite: Satellite) -> str: @@ -62,57 +85,134 @@ class SatelliteCache: A cache on disk (`directory`) persists between sessions and is shared by the parallel workers of a trade study (see `Study`), each of which otherwise has its own cache in memory. Results in the directory are keyed - by the satellite, the fingerprint of the function (its code, the plain - values it closes over or refers to, and the version and source of TAT-C, see - `Study.fingerprint`), and the `namespace`, which must identify what the - fingerprint cannot see: the data the function uses (such as its targets) - and the code of other modules it calls. Change it whenever these change. + by the fingerprint of the function (its code, the values it closes over + or refers to, such as data frames of targets, by their content, and the + source of the modules of TAT-C it depends on, see `get_definition`), by + a `namespace`, which must identify what the fingerprint cannot see (data + the function reads, such as from files, and the code of other modules it + calls, other than TAT-C's: change it whenever these change), and by the + satellite, in a folder of + each namespace (by a hash of it, with the namespace in `namespace.txt`), + and in it a folder of each fingerprint (with the definition in + `definition.json`). A cache warns if its namespace has results only of + other definitions of its function, which it does not reuse, with the + differences from the latest (see `compare_definitions`), and removes + them with `prune`. A result that cannot be read (such as one written + with other versions of the libraries of its data) is computed again. Args: function (Callable): The analysis of one satellite. directory (str | os.PathLike | None): A directory in which to store results, or `None` to keep them in memory only. - namespace (str | None): An identifier of the analysis, required with - a `directory`. + namespace (str): An identifier of the analysis (of what the + fingerprint of the function cannot see). """ def __init__( self, function: Callable[[Satellite], Any], directory: str | os.PathLike | None = None, - namespace: str | None = None, + namespace: str = "", ): - if directory is not None and not namespace: - raise ValueError("a cache on disk requires a namespace") self.function = function self.directory = None if directory is None else Path(directory) self.namespace = namespace - self.fingerprint = get_fingerprint(function) if directory is not None else "" + self.fingerprint = "" """str: The fingerprint of the function, which keys results on disk.""" self.hits = 0 """int: The number of results retrieved from the cache.""" self.misses = 0 """int: The number of results computed.""" self._memory: dict[str, Any] = {} + self._unreadable: set[str] = set() + self._folder: Path | None = None if self.directory is not None: - self.directory.mkdir(parents=True, exist_ok=True) + definition = get_definition(function=function) + self.fingerprint = _fingerprint_of(definition) + space = hashlib.sha1(namespace.encode()).hexdigest()[:16] + self._folder = self.directory / space / self.fingerprint + self._folder.mkdir(parents=True, exist_ok=True) + _write(self._folder.parent / "namespace.txt", namespace.encode()) + text = json.dumps(definition, sort_keys=True, default=str) + _write(self._folder / "definition.json", text.encode()) + self._warn_other_definitions(definition) def __getstate__(self) -> dict: # copies sent to parallel workers start with empty memories state = self.__dict__.copy() - state["_memory"] = {} + state["_memory"], state["_unreadable"] = {}, set() return state + def _others(self) -> list[Path]: + """ + Gets the folders of the results of the namespace by other definitions + of the function (that hold results), the latest last. + """ + folders = [ + folder + for folder in self._folder.parent.iterdir() + if folder.is_dir() + and folder != self._folder + and next(folder.glob("*.pkl"), None) is not None + ] + return sorted(folders, key=lambda folder: folder.stat().st_mtime) + + def _warn_other_definitions(self, definition: dict) -> None: + """ + Warns if the namespace has results only of other definitions of the + function, with the differences from the latest, once (of the caches + of the definition, such as those of parallel workers). + """ + if next(self._folder.glob("*.pkl"), None) is not None: + return + others = self._others() + if not others: + return + try: + # the first cache of the definition to warn marks its folder + with open(self._folder / "warned", "x", encoding="utf-8"): + pass + except FileExistsError: + return + count = sum(1 for folder in others for _ in folder.glob("*.pkl")) + message = ( + f"the cache has {count} results of namespace {self.namespace!r} by " + + "other definitions of its function, which are not reused (remove " + + "them with SatelliteCache.prune)" + ) + try: + before = json.loads((others[-1] / "definition.json").read_text()) + except (OSError, ValueError): + before = None + if before is not None: + differences = compare_definitions(before, definition) + message += "; the latest differs in: " + "; ".join(differences) + warnings.warn(message, stacklevel=3) + + def prune(self) -> int: + """ + Removes the results on disk of the namespace by other definitions of + the function (see `SatelliteCache`). + + Returns: + int: the number of results removed + """ + if self._folder is None: + return 0 + removed = 0 + for folder in self._folder.parent.iterdir(): + if folder.is_dir() and folder != self._folder: + removed += sum(1 for _ in folder.glob("*.pkl")) + shutil.rmtree(folder, ignore_errors=True) + return removed + def _path(self, key: str) -> Path: - name = hashlib.sha1( - f"{self.namespace}/{self.fingerprint}/{key}".encode() - ).hexdigest() - return self.directory / f"{name}.pkl" + return self._folder / f"{key}.pkl" def _load(self, key: str) -> Any: if key in self._memory: return self._memory[key] - if self.directory is not None: + if self._folder is not None: path = self._path(key) for attempt in range(5): if not path.exists(): @@ -125,31 +225,25 @@ def _load(self, key: str) -> Any: # try again, then compute the result instead time.sleep(0.02 * (attempt + 1)) continue + except Exception: # pylint: disable=broad-exception-caught + # written with other versions of the libraries of its data + break self._memory[key] = result return result + if path.exists(): + self._unreadable.add(key) raise KeyError(key) def _store(self, key: str, result: Any) -> None: self._memory[key] = result - if self.directory is None: + if self._folder is None: return path = self._path(key) - if path.exists(): + if path.exists() and key not in self._unreadable: # another worker stored the (same) result return - # write to a temporary file, then rename it, so that a parallel - # worker never reads a partial file - descriptor, temporary = tempfile.mkstemp(dir=self.directory, suffix=".tmp") - with os.fdopen(descriptor, "wb") as file: - pickle.dump(result, file) - try: - os.replace(temporary, path) - except PermissionError: - # on Windows, another worker is replacing or reading the file, - # which then holds the same result - os.remove(temporary) - if not path.exists(): - raise + self._unreadable.discard(key) + _write(path, pickle.dumps(result), replace=True) def get(self, satellite: Satellite) -> Any: """ diff --git a/src/tatc/tradespace/confirmation.py b/src/tatc/tradespace/confirmation.py index 3ecc4e28..e10c6826 100644 --- a/src/tatc/tradespace/confirmation.py +++ b/src/tatc/tradespace/confirmation.py @@ -13,8 +13,8 @@ import numpy as np import pandas as pd -from .criteria import Requirement, Statistic, _get_statistics, aggregate -from .pareto import Tolerance, pareto_front +from .criteria import Criteria, _as_criteria, aggregate +from .pareto import pareto_front from .space import Design from .study import Study @@ -29,21 +29,19 @@ class Confirmation: """pandas.DataFrame: The results of the new replicates (see `Study.run`).""" summary: pd.DataFrame """pandas.DataFrame: A row per design (and group): the statistics of - the new replicates, those of the replicates that selected the design - (` selected`), the number of new `replicates`, and whether - the design meets the requirements (`meets_requirements`) and is - efficient among the confirmed designs that do (`pareto`), by the new - replicates.""" - - def optimism(self, objectives: Mapping[str, str]) -> pd.Series: + the criteria by the new replicates, those of the replicates that + selected the design (` selected`), the number of new + `replicates`, and whether the design meets the requirements + (`meets_requirements`) and is efficient among the confirmed designs that + do (`pareto`), by the new replicates.""" + criteria: Criteria + """Criteria: The criteria of the confirmation.""" + + def optimism(self) -> pd.Series: """ Gets the optimism of selection: the mean amount by which the selecting replicates made the designs look better than the new replicates do, - in each objective (positive if they looked better). - - Args: - objectives (Mapping[str, str]): The objectives and their - directions (`"min"` or `"max"`). + in each objective of the criteria (positive if they looked better). Returns: pandas.Series: the optimism of each objective, in its units @@ -56,7 +54,7 @@ def optimism(self, objectives: Mapping[str, str]) -> pd.Series: * (1.0 if direction == "max" else -1.0) ) ) - for name, direction in objectives.items() + for name, direction in self.criteria.objectives.items() } ) @@ -65,12 +63,8 @@ def confirm( study: Study, designs: Sequence[Design], results: pd.DataFrame, - objectives: Mapping[str, str], + criteria: Criteria | Mapping[str, str], replicates: int | None = None, - statistics: Mapping[str, Statistic | str] | None = None, - requirements: Sequence[Requirement] = (), - by: Sequence[str] = (), - tolerance: Mapping[str, Tolerance] | None = None, ) -> Confirmation: """ Confirms selected designs (such as a Pareto front, or the best designs @@ -93,21 +87,16 @@ def confirm( results (pandas.DataFrame): Every result that informed the selection (see `Study.run`), such as those of an enumeration, refinement, or search. - objectives (Mapping[str, str]): The objectives: statistics (or - metrics) and their directions (`"min"` or `"max"`). + criteria (Criteria | Mapping[str, str]): The criteria (see + `Criteria`), or the objectives (metrics whose means they are) + and their directions (`"min"` or `"max"`). replicates (int | None): The number of new replicates, or `None` for the study's number. - statistics (Mapping[str, Statistic | str] | None): Statistics, by - name, of objectives and requirements that are not means. - requirements (Sequence[Requirement]): Requirements on statistics. - by (Sequence[str]): Columns that group records of an evaluation (such - as a sensor), whose fronts are found separately. - tolerance (Mapping[str, float | str] | None): The tolerances of - objectives (see `pareto_front`). Returns: Confirmation: the new results and the summary of each design """ + criteria = _as_criteria(criteria) count = study.replicates if replicates is None else replicates if count < 1: raise ValueError("replicates must be at least 1") @@ -115,18 +104,12 @@ def confirm( keys = {design.key for design in designs} start = int(results["replicate"].max()) + 1 if len(results) > 0 else 0 fresh = study.run(designs, replicates=range(start, start + count)) - names = list(dict.fromkeys([*objectives, *(r.name for r in requirements)])) - resolved = _get_statistics(names, statistics) - resolved = {name: resolved[name] for name in names} - columns = ["design", *by] + names = criteria.names + columns = ["design", *criteria.by] selected = aggregate( - results[results["design"].isin(keys)], - resolved, - requirements, - by=by, - design_columns=[], + results[results["design"].isin(keys)], criteria, design_columns=[] ) - confirmed = aggregate(fresh, resolved, requirements, by=by, design_columns=[]) + confirmed = aggregate(fresh, criteria, design_columns=[]) summary = confirmed[[*columns, *names, "replicates", "meets_requirements"]] summary = summary.merge( selected[[*columns, *names]].rename( @@ -143,11 +126,8 @@ def confirm( "meets_requirements", ] ] + # the front of the designs whose objectives are known, by the new replicates + known = summary.dropna(subset=list(criteria.objectives)) summary["pareto"] = False - groups = summary.groupby(list(by), sort=False) if by else [((), summary)] - for _, group in groups: - candidates = group[group["meets_requirements"]].dropna(subset=list(objectives)) - if len(candidates) > 0: - efficient = pareto_front(candidates, objectives, tolerance) - summary.loc[efficient.index, "pareto"] = efficient - return Confirmation(results=fresh, summary=summary) + summary.loc[known.index, "pareto"] = pareto_front(known, criteria).to_numpy() + return Confirmation(results=fresh, summary=summary, criteria=criteria) diff --git a/src/tatc/tradespace/criteria.py b/src/tatc/tradespace/criteria.py index c8fbd967..8a7bafc1 100644 --- a/src/tatc/tradespace/criteria.py +++ b/src/tatc/tradespace/criteria.py @@ -1,7 +1,8 @@ """ Criteria of designs over their replicates: statistics of the metrics of their evaluations (such as a mean, a quantile, or the probability of meeting -a threshold), and requirements on these statistics. +a threshold), requirements on these statistics, and the criteria by which +designs are judged (objectives, requirements, and tolerances). The outcomes of a design are uncertain if its replicates differ (see `Uncertain`), and a statistic over the replicates states how a design is @@ -16,27 +17,72 @@ from __future__ import annotations import operator as op -from collections.abc import Mapping, Sequence -from dataclasses import dataclass +from collections.abc import Iterator, Mapping, Sequence +from dataclasses import dataclass, field +from typing import Any import numpy as np import pandas as pd +from .study import _STATUS_COLUMNS + _OPERATORS = {">=": op.ge, ">": op.gt, "<=": op.le, "<": op.lt} +_DIRECTIONS = ("min", "max") + + +def _is_derived(metric: Any) -> bool: + """ + Whether a metric is computed from others in each replicate (such as a + `Utility`): an object with the `columns` it needs and an `evaluate` + method of their values. + """ + return ( + not isinstance(metric, (str, Statistic)) + and hasattr(metric, "columns") + and callable(getattr(metric, "evaluate", None)) + ) + class Statistic: """ - Base class of statistics of a metric (a column of the results of a study) - over the replicates of each design. + Base class of statistics of a metric over the replicates of each design: + a column of the results of a study, or a metric computed from others in + each replicate (such as a `Utility`, whose mean is the expected utility). Args: - column (str): The metric. + column (str | Utility): The metric. """ - def __init__(self, column: str): + def __init__(self, column: Any): self.column = column + @property + def columns(self) -> tuple[str, ...]: + """tuple[str, ...]: The columns of the results that the statistic + needs: its metric, or those its metric is computed from.""" + if _is_derived(self.column): + return tuple(self.column.columns) + return (self.column,) + + def values_of(self, matrices: Mapping[str, np.ndarray]) -> np.ndarray: + """ + Gets the values of the statistic's metric in each replicate of each + design, from those of the columns of the results. + + Args: + matrices (Mapping[str, numpy.ndarray]): The values of each column + (shape (designs, replicates)). + + Returns: + numpy.ndarray: the values of the metric (shape (designs, + replicates)) + """ + if _is_derived(self.column): + values = {name: matrices[name] for name in self.columns} + return np.asarray(self.column.evaluate(values), dtype=float) + return matrices[self.column] + def reduce(self, values: np.ndarray) -> np.ndarray: """ Computes the statistic of each design (row) from its values in its @@ -50,6 +96,12 @@ def reduce(self, values: np.ndarray) -> np.ndarray: """ raise NotImplementedError + def __eq__(self, other: object) -> bool: + return type(self) is type(other) and vars(self) == vars(other) + + def __hash__(self) -> int: + return hash((type(self), tuple(sorted(vars(self).items())))) + def __repr__(self) -> str: return f"{type(self).__name__}({self.column!r})" @@ -95,6 +147,20 @@ def reduce(self, values: np.ndarray) -> np.ndarray: return result +class StandardError(Statistic): + """ + The standard error of the mean of a metric over the replicates: its + standard deviation over the square root of the number of replicates, a + measure of the uncertainty of the mean (`NaN` with fewer than two + replicates). + """ + + def reduce(self, values: np.ndarray) -> np.ndarray: + counts = np.sum(~np.isnan(values), axis=1) + deviation = StandardDeviation(self.column).reduce(values) + return deviation / np.sqrt(np.maximum(counts, 1)) + + class Minimum(Statistic): """ The least value of a metric over the replicates (the worst case of a @@ -186,31 +252,43 @@ def __repr__(self) -> str: @dataclass(frozen=True) class Requirement: """ - A requirement on a statistic of a design (by its name in the statistics, - see `aggregate`, or a metric, whose mean it then is): for example, - `Requirement("sufficient p10", ">=", 80)`. A design that does not meet - it violates it by the difference between the statistic and the value. + A requirement on a statistic of a design (by its name in the statistics + of criteria, see `Criteria`, or a metric, whose mean it then is): for + example, `Requirement("sufficient p10", ">=", 80)`. + + A design that does not meet it violates it by the difference between the + statistic and the value, relative to a `scale`: by default the magnitude + of the value (or 1 if the value is 0), so that the violations of + requirements in different units are comparable, as they are added (see + `aggregate`, `screen`, and the constraint-aware optimizers of + `optimize_optuna` and `optimize_pymoo`). Args: name (str): The statistic (or metric). operator (str): The comparison: `">="`, `">"`, `"<="`, or `"<"`. value (float): The required value. + scale (float | None): The scale of violations, in the units of the + statistic, or `None` for the magnitude of the value (or 1 if it + is 0). """ name: str operator: str value: float + scale: float | None = None def __post_init__(self): if self.operator not in _OPERATORS: raise ValueError(f"operator must be one of {list(_OPERATORS)}") + if self.scale is not None and not self.scale > 0: + raise ValueError("scale must be positive") def violation(self, statistic: np.ndarray) -> np.ndarray: """ Computes the violations of the requirement: 0 where the statistic - meets it, and otherwise how far it misses the value (`NaN` where the - statistic is). A strict comparison that the statistic misses by - equality is violated by a small amount. + meets it, and otherwise how far it misses the value, relative to the + scale (`NaN` where the statistic is). A strict comparison that the + statistic misses by equality is violated by a small amount. Args: statistic (numpy.ndarray): The statistic of each design. @@ -223,29 +301,202 @@ def violation(self, statistic: np.ndarray) -> np.ndarray: gap = self.value - statistic else: gap = statistic - self.value + scale = self.scale if self.scale is not None else (abs(self.value) or 1.0) with np.errstate(invalid="ignore"): met = _OPERATORS[self.operator](statistic, self.value) - violation = np.where(met, 0.0, np.maximum(gap, 1e-9)) + violation = np.where(met, 0.0, np.maximum(gap / scale, 1e-9)) return np.where(np.isnan(statistic), np.nan, violation) -def _get_statistics( - names: Sequence[str], - statistics: Mapping[str, Statistic | str] | None, -) -> dict[str, Statistic]: +Tolerance = float | str +"""A tolerance of an objective: a value in its units, or a share of its value +(a string of a percentage, such as `"5%"`).""" + + +def _get_tolerances( + objectives: Mapping[str, str], tolerance: Mapping[str, Tolerance] +) -> np.ndarray: + """ + Gets the tolerances of the objectives (zero if not given): their absolute + values (first row) and their shares of the values of the objectives + (second row). + """ + unknown = set(tolerance) - set(objectives) + if unknown: + raise ValueError(f"tolerances of names that are not objectives: {unknown}") + values = np.zeros((2, len(objectives))) + for i, name in enumerate(objectives): + value = tolerance.get(name, 0.0) + if isinstance(value, str): + if not value.strip().endswith("%"): + raise ValueError( + f"a tolerance string must be a percentage, not {value!r}" + ) + values[1, i] = float(value.strip()[:-1]) / 100 + else: + values[0, i] = float(value) + if np.any(values < 0): + raise ValueError("tolerances must not be negative") + return values + + +@dataclass(frozen=True) +class Criteria: """ - Gets the statistics of names: those given (a metric given as a string is - its mean), and the means of the metrics of names not given. + The criteria by which designs are judged from the results of their + replicates: objectives to minimize or maximize and requirements to + meet, the statistics over the replicates that they name (see + `Statistic`), the tolerances of the objectives within which differences + do not matter, and the columns that group the records of an evaluation + (such as a sensor), in each group of which designs are judged + separately. + + Objectives and requirements name statistics: those of `statistics`, or + otherwise the means of the metrics of their names. A design is + efficient if it meets the requirements and no other design that meets + them is as good in every objective and better in at least one, by more + than the tolerances (see `pareto_front`). + + The functions that judge designs (`aggregate`, `pareto_front`, + `pareto_ranks`, `hypervolume`, `pareto_probability`, `refine`, + `confirm`, `screen`, and the searches of `optimize_optuna` and + `optimize_pymoo`) take criteria, or a mapping of objectives to their + directions, which are criteria of the means of metrics alone. + + Args: + objectives (Mapping[str, str]): The objectives: statistics (or + metrics) and their directions (`"min"` or `"max"`). + statistics (Mapping[str, Statistic | str]): Statistics, by name, of + objectives and requirements that are not means of the metrics of + their names (a metric given as a string, or a `Utility`, is its + mean), and others to compute with them (see `aggregate`). + requirements (Sequence[Requirement]): Requirements on statistics. + tolerance (Mapping[str, float | str]): The tolerances of objectives + (by name, zero if not given): values in their units, or + percentages of their values (such as `"5%"`). + by (Sequence[str] | str): The columns that group the records of an + evaluation (such as a sensor), in each group of which designs are + judged separately. """ - statistics = dict(statistics or {}) - resolved = { - name: Mean(value) if isinstance(value, str) else value - for name, value in statistics.items() - } - for name in names: - if name not in resolved: - resolved[name] = Mean(name) - return resolved + + objectives: Mapping[str, str] + statistics: Mapping[str, Statistic | str] = field(default_factory=dict) + requirements: Sequence[Requirement] = () + tolerance: Mapping[str, Tolerance] = field(default_factory=dict) + by: Sequence[str] | str = () + + def __post_init__(self): + if not isinstance(self.objectives, Mapping): + raise TypeError("objectives must be a mapping of names to directions") + objectives = dict(self.objectives) + if len(objectives) == 0: + raise ValueError("at least one objective is required") + for name, direction in objectives.items(): + if direction not in _DIRECTIONS: + raise ValueError( + f"direction of {name!r} must be 'min' or 'max', not {direction!r}" + ) + statistics = { + name: Mean(value) if isinstance(value, str) or _is_derived(value) else value + for name, value in dict(self.statistics).items() + } + for name, statistic in statistics.items(): + if not isinstance(statistic, Statistic): + raise TypeError(f"statistic {name!r} is not a Statistic") + requirements = tuple(self.requirements) + for requirement in requirements: + if not isinstance(requirement, Requirement): + raise TypeError(f"{requirement!r} is not a Requirement") + tolerance = dict(self.tolerance) + _get_tolerances(objectives, tolerance) # checks the tolerances + by = (self.by,) if isinstance(self.by, str) else tuple(self.by) + object.__setattr__(self, "objectives", objectives) + object.__setattr__(self, "statistics", statistics) + object.__setattr__(self, "requirements", requirements) + object.__setattr__(self, "tolerance", tolerance) + object.__setattr__(self, "by", by) + + @property + def names(self) -> list[str]: + """list[str]: The names of the statistics: of the objectives, of the + requirements, and the others of `statistics`, in that order.""" + return list( + dict.fromkeys( + [ + *self.objectives, + *(requirement.name for requirement in self.requirements), + *self.statistics, + ] + ) + ) + + def statistic(self, name: str) -> Statistic: + """ + Gets the statistic of a name: that of `statistics`, or the mean of + the metric of the name. + + Args: + name (str): The name. + + Returns: + Statistic: the statistic + """ + return self.statistics[name] if name in self.statistics else Mean(name) + + @property + def metrics(self) -> list[str]: + """list[str]: The metrics (columns of the results of a study) of + the statistics.""" + return sorted( + {column for name in self.names for column in self.statistic(name).columns} + ) + + +def _as_criteria(criteria: Criteria | Mapping[str, str]) -> Criteria: + """ + Gets criteria, or the criteria of the means of objectives. + """ + if isinstance(criteria, Criteria): + return criteria + if isinstance(criteria, Mapping): + return Criteria(criteria) + raise TypeError( + "criteria must be Criteria or a mapping of objectives to their directions" + ) + + +def _resolve(criteria: Criteria) -> dict[str, Statistic]: + """ + Gets the statistic of each name of criteria. + """ + return {name: criteria.statistic(name) for name in criteria.names} + + +def _signs(criteria: Criteria) -> np.ndarray: + """ + Gets the signs that make the objectives of criteria costs (to minimize). + """ + return np.array( + [ + 1.0 if direction == "min" else -1.0 + for direction in criteria.objectives.values() + ] + ) + + +def _groups(frame: pd.DataFrame, by: Sequence[str]) -> Iterator[tuple[tuple, Any]]: + """ + Iterates over the groups of a data frame by columns (or the frame, if + none): the values of the columns, and the positions of the group's rows. + """ + if not by: + yield (), np.arange(len(frame)) + return + missing = [column for column in by if column not in frame.columns] + if missing: + raise ValueError(f"no columns {missing} to group by") + for key, positions in frame.groupby(list(by), sort=False).indices.items(): + yield (key if isinstance(key, tuple) else (key,)), positions def _get_matrices( @@ -253,18 +504,32 @@ def _get_matrices( ) -> tuple[pd.Index, pd.Index, dict[str, np.ndarray]]: """ Gets the values of metrics of each design (rows) in each replicate - (columns) of the results of a group. + (columns) of the results of a group, which must have one record per + evaluation (a design in a replicate). """ missing = [column for column in columns if column not in group.columns] if missing: raise ValueError(f"metrics that are not in the results: {missing}") + keys = ["design", "replicate"] + if group.duplicated(keys).any(): + candidates = [ + column + for column in group.columns + if column not in (*_STATUS_COLUMNS, *columns) + ] + counts = group.groupby(keys)[candidates].nunique(dropna=False).max() + varying = list(counts.index[counts > 1]) + raise ValueError( + "the results have several records of an evaluation (a design in a " + + "replicate): give the columns that separate them as `by` (of the " + + "criteria)" + + (f", such as {varying}" if varying else "") + ) designs = pd.Index(group["design"].drop_duplicates()) replicates = pd.Index(sorted(group["replicate"].unique())) matrices = {} for column in columns: - table = group.pivot_table( - index="design", columns="replicate", values=column, dropna=False - ) + table = group.pivot(index="design", columns="replicate", values=column) matrices[column] = table.reindex(index=designs, columns=replicates).to_numpy( dtype=float ) @@ -283,7 +548,7 @@ def _evaluate( """ values = {} for name, statistic in statistics.items(): - matrix = matrices[statistic.column] + matrix = statistic.values_of(matrices) values[name] = statistic.reduce( matrix if columns is None else matrix[:, columns] ) @@ -294,38 +559,46 @@ def _evaluate( return values, violation -def _check_names( - statistics: Mapping[str, Statistic], requirements: Sequence[Requirement] -) -> None: - for requirement in requirements: - if requirement.name not in statistics: - raise ValueError(f"no statistic named {requirement.name!r}") +def _design_columns(results: pd.DataFrame, excluded: set[str]) -> list[str]: + """ + Gets the columns of the values of designs: those (other than `excluded`) + that are the same in every record of each design. + """ + candidates = [column for column in results.columns if column not in excluded] + if not candidates or len(results) == 0: + return [] + constant = results.groupby("design")[candidates].nunique(dropna=False) + return [column for column in candidates if (constant[column] <= 1).all()] def aggregate( results: pd.DataFrame, - statistics: Mapping[str, Statistic | str] | Sequence[str], - requirements: Sequence[Requirement] = (), - by: Sequence[str] = (), + statistics: Criteria | Mapping[str, Statistic | str] | Sequence[str], + by: Sequence[str] | str = (), design_columns: Sequence[str] | None = None, ) -> pd.DataFrame: """ Aggregates the feasible results of a study (see `Study.run`) over the replicates of each design (and each group of the columns `by`, such as a sensor): the statistics, by name (a metric given as a string, or in a - list of names, is its mean), the number of `replicates`, the `violation` - of the requirements (their sum, 0 if the design meets them all), and - whether the design meets them (`meets_requirements`), with the values of the - design. + list of names, is its mean), the number of `replicates`, and the values + of the design. + + With criteria (see `Criteria`), the statistics that they name, in each + group of their `by`, and the `violation` of their requirements (the sum + of the violations, see `Requirement`, 0 if the design meets them all) + and whether the design meets them (`meets_requirements`). + + The results must have one record per evaluation (a design in a + replicate) in each group. Args: results (pandas.DataFrame): The results. - statistics (Mapping[str, Statistic | str] | Sequence[str]): The - statistics, by name, or the metrics whose means to compute. - requirements (Sequence[Requirement]): Requirements on the statistics - (or on the means of metrics, which are added to the statistics). - by (Sequence[str]): Other columns that group records of an - evaluation. + statistics (Criteria | Mapping[str, Statistic | str] | Sequence[str]): + Criteria, the statistics by name, or the metrics whose means to + compute. + by (Sequence[str] | str): Other columns that group records of an + evaluation (those of the criteria, with criteria). design_columns (Sequence[str] | None): The columns of the values of designs, or `None` for those that are the same in every replicate of a design (except the metrics). @@ -333,33 +606,38 @@ def aggregate( Returns: pandas.DataFrame: a row per design (and group) """ - if not isinstance(statistics, Mapping): - statistics = {name: Mean(name) for name in statistics} - resolved = _get_statistics([r.name for r in requirements], statistics) - _check_names(resolved, requirements) + criteria = statistics if isinstance(statistics, Criteria) else None + if criteria is not None: + if by: + raise ValueError("criteria group records by their own `by`") + resolved, requirements, by = ( + _resolve(criteria), + criteria.requirements, + criteria.by, + ) + else: + if not isinstance(statistics, Mapping): + statistics = {name: name for name in statistics} + resolved = { + name: Mean(value) if isinstance(value, str) or _is_derived(value) else value + for name, value in statistics.items() + } + requirements = () + by = (by,) if isinstance(by, str) else tuple(by) feasible = results[results["feasible"]] if "feasible" in results else results - metrics = sorted({statistic.column for statistic in resolved.values()}) + metrics = sorted( + {column for statistic in resolved.values() for column in statistic.columns} + ) if design_columns is None: - excluded = { - "design", - "replicate", - "feasible", - "error", - "seconds", - *metrics, - *by, - } - candidates = [c for c in feasible.columns if c not in excluded] - constant = feasible.groupby("design")[candidates].nunique(dropna=False) - design_columns = [c for c in candidates if (constant[c] <= 1).all()] + design_columns = _design_columns(feasible, {*_STATUS_COLUMNS, *metrics, *by}) design_columns = [c for c in design_columns if c not in resolved and c not in by] frames = [] - groups = feasible.groupby(list(by), sort=False) if by else [((), feasible)] - for key, group in groups: + for key, positions in _groups(feasible, by): + group = feasible.iloc[positions] designs, _, matrices = _get_matrices(group, metrics) values, violation = _evaluate(resolved, requirements, matrices) frame = pd.DataFrame({"design": designs}) - for name, value in zip(by, key if isinstance(key, tuple) else (key,)): + for name, value in zip(by, key): frame[name] = value first = group.drop_duplicates("design").set_index("design") for column in design_columns: @@ -369,9 +647,45 @@ def aggregate( frame["replicates"] = ( group.groupby("design")["replicate"].nunique().reindex(designs).to_numpy() ) - frame["violation"] = violation - frame["meets_requirements"] = violation == 0 + if criteria is not None: + frame["violation"] = violation + frame["meets_requirements"] = violation == 0 frames.append(frame) if not frames: - return pd.DataFrame(columns=["design", *by, *resolved, "replicates"]) + judged = ["violation", "meets_requirements"] if criteria is not None else [] + return pd.DataFrame(columns=["design", *by, *resolved, "replicates", *judged]) return pd.concat(frames, ignore_index=True) + + +def summarize( + results: pd.DataFrame, + metrics: Sequence[str], + by: Sequence[str] | str = (), + design_columns: Sequence[str] | None = None, +) -> pd.DataFrame: + """ + Summarizes the metrics of the feasible results of a study over their + replicates (see `aggregate`): for each design (and each group of the + columns `by`, such as a sensor), the mean of each metric, its standard + deviation (` std`) and standard error (` sem`) between + replicates, and the number of replicates (`replicates`), with the values + of the design. + + Args: + results (pandas.DataFrame): The results (see `Study.run`). + metrics (Sequence[str]): The columns of the metrics. + by (Sequence[str] | str): Other columns that group records of an + evaluation. + design_columns (Sequence[str] | None): The columns of the values of + designs, or `None` for those that are the same in every + replicate of a design (except the metrics). + + Returns: + pandas.DataFrame: the summary, a row per design (and group) + """ + statistics: dict[str, Statistic] = {} + for metric in metrics: + statistics[metric] = Mean(metric) + statistics[f"{metric} std"] = StandardDeviation(metric) + statistics[f"{metric} sem"] = StandardError(metric) + return aggregate(results, statistics, by=by, design_columns=design_columns) diff --git a/src/tatc/tradespace/fingerprint.py b/src/tatc/tradespace/fingerprint.py index 54dc4567..854fd9a9 100644 --- a/src/tatc/tradespace/fingerprint.py +++ b/src/tatc/tradespace/fingerprint.py @@ -3,37 +3,56 @@ and settings), which key persistent results so that results computed with other definitions are not reused. -A fingerprint describes values by their content where it can: plain values -(numbers, strings, dates and times, and their containers), pydantic models -(such as satellites and instruments), small arrays, the nodes of design -spaces, dataclasses (such as cost models) by their fields, and functions, by -their code, the values they close over and their defaults, and the -constants (numbers, strings, dates and times, and tuples of them), -dataclasses, and functions of the same module that they refer to as globals -(not mutable containers, which are often state, such as caches). Other -objects (such as data frames) are described by their type only: identify -them by a namespace (see `ResultStore` and `SatelliteCache`). Functions of -other modules (such as TAT-C's) are described by their names, as the version -of TAT-C and a hash of its source (its code and resources, such as the -instrument catalog) are part of a fingerprint, so that results computed with -other code of TAT-C (another version, or a change in development) are not -reused. +A definition (see `get_definition`) describes values by their content where +it can: plain values (numbers, strings, dates and times, and their +containers), pydantic models (such as satellites and instruments), arrays +and data frames (by a hash of their data, with geometries by their +well-known binary), the nodes of design spaces, dataclasses (such as cost +models) by their fields (but those whose metadata has `"fingerprint": +False`, such as directories of caches, which do not change results), and +functions, by their compiled code (which ties a definition to the version of +Python, which it records), the values they close over and their defaults, +and the constants (numbers, strings, dates and times, and tuples of them), +data (arrays and data frames), dataclasses, and functions of the same module +that they refer to as globals (not mutable containers, which are often +state, such as caches). Functions and classes of other modules are described +by their names, and other objects by their type only. Data that functions +read (such as from files) and the code of other modules they call (other +than TAT-C's) are not described: identify them by a namespace (see +`ResultStore` and `SatelliteCache`). + +TAT-C is described by the source of the modules that the values depend on: +the modules that define the functions, classes, and objects of TAT-C they +refer to, the modules of TAT-C that those import (anywhere in their code, +including imports within functions), and so on, with the resource files +these modules name (such as the instrument catalog). A name imported from a +package depends on the module that defines it, not on every module of the +package, so that `from tatc.analysis import collect_observations` depends +on the module of point sampling (and those it imports), not on the other +analyses. Results computed by a study are then reused after changes to TAT-C +that cannot change them (such as to modules the study does not use), and +not after changes that can. @author: Paul T. Grogan """ from __future__ import annotations +import ast import dataclasses +import dis import functools import hashlib import json +import sys import types +from collections.abc import Iterable from datetime import date, datetime, time, timedelta from pathlib import Path from typing import Any import numpy as np +import pandas as pd from pydantic import BaseModel _MAX_DEPTH = 24 @@ -42,68 +61,82 @@ _MAX_ITEMS = 1000 """The most items of a container (or array) described one by one.""" +_PACKAGE = "tatc" +"""The name of the package whose modules a definition describes by source.""" + +_ROOT = Path(__file__).resolve().parents[1] +"""The directory of the package.""" + +_RESOURCES = "resources" +"""The directory of the package's resource files (data, not modules).""" + def _type(value: Any) -> dict: kind = type(value) return {"type": f"{kind.__module__}.{kind.__qualname__}"} +def _name(value: Any) -> str: + return f"{getattr(value, '__module__', None)}.{value.__qualname__}" + + def _sort_key(value: Any) -> str: return json.dumps(value, sort_keys=True, default=str) -def _code(code: types.CodeType, depth: int, seen: set) -> dict: +def _is_package_module(module: Any) -> bool: + """Whether a module name is of the package (TAT-C).""" + return isinstance(module, str) and ( + module == _PACKAGE or module.startswith(_PACKAGE + ".") + ) + + +def _is_dataclass(value: Any) -> bool: + """Whether a value is an instance of a dataclass (such as a cost model).""" + return dataclasses.is_dataclass(value) and not isinstance(value, type) + + +def _is_data(value: Any) -> bool: + """Whether a value is data (an array or a data frame or series).""" + return isinstance(value, (np.ndarray, pd.DataFrame, pd.Series)) + + +def _hash_column(column: pd.Series) -> bytes: """ - Describes compiled code by its instructions, constants, and names (not - its file or line numbers, which change as code moves). + Gets the hashes of the values of a column (geometries by their + well-known binary, which is exact). """ - return { - "code": code.co_code.hex(), - "constants": [_describe(c, depth + 1, seen) for c in code.co_consts], - "names": list(code.co_names), - } + if str(column.dtype) == "geometry": + return b"".join( + hashlib.sha1(b"" if wkb is None else wkb).digest() + for wkb in column.to_wkb() + ) + try: + return pd.util.hash_pandas_object(column, index=False).to_numpy().tobytes() + except TypeError: # such as of unhashable objects + return "\x1f".join(repr(item) for item in column.tolist()).encode() -def _function(function: types.FunctionType, depth: int, seen: set) -> dict: +def _frame(value: pd.DataFrame | pd.Series) -> dict: """ - Describes a function: its code, the values it closes over, its defaults, - and the constants, dataclasses, and functions of its module it refers to - as globals. + Describes a data frame (or series) by its columns, types, and shape, and + a hash of its index and values. """ - if id(function) in seen: - return {"function": function.__qualname__, "recursive": True} - seen = seen | {id(function)} - closure = [ - _describe(cell.cell_contents, depth + 1, seen) - for cell in (function.__closure__ or ()) - if _has_contents(cell) - ] - referenced = {} - module = function.__module__ - for name in _global_names(function.__code__): - if name not in function.__globals__: - continue - value = function.__globals__[name] - if isinstance(value, types.FunctionType): - if value.__module__ == module: - referenced[name] = _function(value, depth + 1, seen) - elif _is_constant(value) or _is_dataclass(value): - referenced[name] = _describe(value, depth + 1, seen) + frame = value.to_frame() if isinstance(value, pd.Series) else value + digest = hashlib.sha1() + digest.update(pd.util.hash_pandas_object(frame.index).to_numpy().tobytes()) + for i in range(frame.shape[1]): + digest.update(_hash_column(frame.iloc[:, i])) return { - "function": function.__qualname__, - **_code(function.__code__, depth, seen), - "closure": closure, - "defaults": _describe(function.__defaults__, depth + 1, seen), - "keyword defaults": _describe(function.__kwdefaults__, depth + 1, seen), - "globals": referenced, + **_type(value), + "columns": [str(column) for column in frame.columns], + "types": [str(dtype) for dtype in frame.dtypes], + "index": str(frame.index.dtype), + "shape": list(value.shape), + "data": digest.hexdigest(), } -def _is_dataclass(value: Any) -> bool: - """Whether a value is an instance of a dataclass (such as a cost model).""" - return dataclasses.is_dataclass(value) and not isinstance(value, type) - - def _has_contents(cell: Any) -> bool: try: cell.cell_contents # pylint: disable=pointless-statement @@ -112,11 +145,22 @@ def _has_contents(cell: Any) -> bool: return True +_GLOBAL_LOADS = ("LOAD_GLOBAL", "LOAD_NAME") +"""The instructions that load a global (rather than an attribute, whose names +code also lists).""" + + def _global_names(code: types.CodeType) -> list[str]: """ - Gets the names a code (and its nested code) refers to. + Gets the global names a code (and its nested code) loads (not the names of + attributes, such as `values` of `design.values`, which may be the names + of unrelated globals). """ - names = list(code.co_names) + names = [ + instruction.argval + for instruction in dis.get_instructions(code) + if instruction.opname in _GLOBAL_LOADS + ] for constant in code.co_consts: if isinstance(constant, types.CodeType): names.extend(_global_names(constant)) @@ -145,141 +189,514 @@ def _is_constant(value: Any, depth: int = 0) -> bool: return False -def _describe(value: Any, depth: int = 0, seen: set | None = None) -> Any: +class _Describer: """ - Describes a value as plain data (see the module). + Describes values as plain data (see the module), noting the modules of + the package that they depend on. """ - # pylint: disable=too-many-return-statements,too-many-branches,import-outside-toplevel - seen = set() if seen is None else seen - if depth > _MAX_DEPTH: - return _type(value) - if value is None or isinstance(value, (bool, int, str)): - return value - if isinstance(value, float): - return repr(value) - if isinstance(value, np.generic): - return _describe(value.item(), depth, seen) - if isinstance(value, bytes): - return hashlib.sha1(value).hexdigest() - if isinstance(value, (datetime, date, time)): - return value.isoformat() - if isinstance(value, timedelta): - return {"timedelta": value.total_seconds()} - if _is_dataclass(value): - return { - **_type(value), - **{ - item.name: _describe(getattr(value, item.name), depth + 1, seen) - for item in dataclasses.fields(value) - }, - } - if isinstance(value, BaseModel): - return {**_type(value), **value.model_dump(mode="json")} - if isinstance(value, np.ndarray): - if value.dtype == object: - return {**_type(value), "shape": list(value.shape)} + + def __init__(self): + self.modules: set[str] = set() + """The modules of the package that the described values refer to.""" + + def note(self, module: Any) -> None: + """Notes a module that a value refers to (if it is of the package).""" + if _is_package_module(module): + self.modules.add(module) + + def code(self, code: types.CodeType, depth: int, seen: set) -> dict: + """ + Describes compiled code by its instructions, constants, and names (not + its file or line numbers, which change as code moves). + """ return { - "array": str(value.dtype), - "shape": list(value.shape), - "data": hashlib.sha1(np.ascontiguousarray(value).tobytes()).hexdigest(), + "code": code.co_code.hex(), + "constants": [self.describe(c, depth + 1, seen) for c in code.co_consts], + "names": list(code.co_names), } - if isinstance(value, (list, tuple)): - if len(value) > _MAX_ITEMS: - return {**_type(value), "length": len(value)} - return [_describe(v, depth + 1, seen) for v in value] - if isinstance(value, (set, frozenset)): - if len(value) > _MAX_ITEMS: - return {**_type(value), "length": len(value)} - return sorted((_describe(v, depth + 1, seen) for v in value), key=_sort_key) - if isinstance(value, dict): - if len(value) > _MAX_ITEMS: - return {**_type(value), "length": len(value)} - return sorted( - ( - [_describe(k, depth + 1, seen), _describe(v, depth + 1, seen)] - for k, v in value.items() - ), - key=_sort_key, - ) - if isinstance(value, types.CodeType): - return _code(value, depth, seen) - if isinstance(value, types.FunctionType): - return _function(value, depth, seen) - if isinstance(value, types.MethodType): - return { - "method": _describe(value.__func__, depth + 1, seen), - "self": _describe(value.__self__, depth + 1, seen), + + def function(self, function: types.FunctionType, depth: int, seen: set) -> dict: + """ + Describes a function: its code, the values it closes over, its + defaults, the constants, dataclasses, and functions of its module it + refers to as globals, and the names of the functions, classes, and + modules of other modules it refers to as globals. + """ + self.note(function.__module__) + if id(function) in seen: + return {"function": function.__qualname__, "recursive": True} + seen = seen | {id(function)} + closure = { + name: self.describe(cell.cell_contents, depth + 1, seen) + for name, cell in zip( + function.__code__.co_freevars, function.__closure__ or () + ) + if _has_contents(cell) } - if isinstance(value, functools.partial): + referenced: dict[str, Any] = {} + module = function.__module__ + for name in _global_names(function.__code__): + if name not in function.__globals__: + continue + value = function.__globals__[name] + if isinstance(value, types.FunctionType): + if value.__module__ == module: + referenced[name] = self.function(value, depth + 1, seen) + else: + self.note(value.__module__) + referenced[name] = {"name": _name(value)} + elif ( + isinstance(value, (type, types.BuiltinFunctionType, types.ModuleType)) + or _is_constant(value) + or _is_data(value) + or _is_dataclass(value) + ): + referenced[name] = self.describe(value, depth + 1, seen) + else: + # state (such as a cache), whose code may be of the package + self.note(type(value).__module__) return { - "partial": _describe(value.func, depth + 1, seen), - "arguments": _describe(value.args, depth + 1, seen), - "keywords": _describe(value.keywords, depth + 1, seen), + "function": function.__qualname__, + **self.code(function.__code__, depth, seen), + "closure": closure, + "defaults": self.describe(function.__defaults__, depth + 1, seen), + "keyword defaults": self.describe(function.__kwdefaults__, depth + 1, seen), + "globals": referenced, } - if isinstance(value, (types.BuiltinFunctionType, type)): - return {"name": f"{value.__module__}.{value.__qualname__}"} - from .nodes import Node - if isinstance(value, Node): - if id(value) in seen: - return {**_type(value), "recursive": True} - return { - **_type(value), - **{ - name: _describe(attribute, depth + 1, seen | {id(value)}) - for name, attribute in sorted(vars(value).items()) - }, - } - return _type(value) + def describe(self, value: Any, depth: int = 0, seen: set | None = None) -> Any: + """ + Describes a value as plain data (see the module). + """ + # pylint: disable=too-many-return-statements,too-many-branches,import-outside-toplevel + seen = set() if seen is None else seen + if depth > _MAX_DEPTH: + self.note(type(value).__module__) + return _type(value) + if value is None or isinstance(value, (bool, int, str)): + return value + if isinstance(value, float): + return repr(value) + if isinstance(value, np.generic): + return self.describe(value.item(), depth, seen) + if isinstance(value, bytes): + return hashlib.sha1(value).hexdigest() + if isinstance(value, (datetime, date, time)): + return value.isoformat() + if isinstance(value, timedelta): + return {"timedelta": value.total_seconds()} + if _is_dataclass(value): + self.note(type(value).__module__) + return { + **_type(value), + **{ + item.name: self.describe(getattr(value, item.name), depth + 1, seen) + for item in dataclasses.fields(value) + if item.metadata.get("fingerprint", True) + }, + } + if isinstance(value, BaseModel): + self.note(type(value).__module__) + return {**_type(value), **value.model_dump(mode="json")} + if isinstance(value, np.ndarray): + if value.dtype == object: + return {**_type(value), "shape": list(value.shape)} + return { + "array": str(value.dtype), + "shape": list(value.shape), + "data": hashlib.sha1(np.ascontiguousarray(value).tobytes()).hexdigest(), + } + if isinstance(value, (pd.DataFrame, pd.Series)): + return _frame(value) + if isinstance(value, (list, tuple)): + if len(value) > _MAX_ITEMS: + return {**_type(value), "length": len(value)} + return [self.describe(v, depth + 1, seen) for v in value] + if isinstance(value, (set, frozenset)): + if len(value) > _MAX_ITEMS: + return {**_type(value), "length": len(value)} + return sorted( + (self.describe(v, depth + 1, seen) for v in value), key=_sort_key + ) + if isinstance(value, dict): + if len(value) > _MAX_ITEMS: + return {**_type(value), "length": len(value)} + if all(isinstance(key, str) for key in value): + return { + key: self.describe(item, depth + 1, seen) + for key, item in value.items() + } + return sorted( + ( + [ + self.describe(k, depth + 1, seen), + self.describe(v, depth + 1, seen), + ] + for k, v in value.items() + ), + key=_sort_key, + ) + if isinstance(value, types.CodeType): + return self.code(value, depth, seen) + if isinstance(value, types.FunctionType): + return self.function(value, depth, seen) + if isinstance(value, types.MethodType): + return { + "method": self.describe(value.__func__, depth + 1, seen), + "self": self.describe(value.__self__, depth + 1, seen), + } + if isinstance(value, functools.partial): + return { + "partial": self.describe(value.func, depth + 1, seen), + "arguments": self.describe(value.args, depth + 1, seen), + "keywords": self.describe(value.keywords, depth + 1, seen), + } + if isinstance(value, (types.BuiltinFunctionType, type)): + self.note(getattr(value, "__module__", None)) + return {"name": _name(value)} + if isinstance(value, types.ModuleType): + self.note(value.__name__) + return {"module": value.__name__} + self.note(type(value).__module__) + from .nodes import Node + + if isinstance(value, Node): + if id(value) in seen: + return {**_type(value), "recursive": True} + return { + **_type(value), + **{ + name: self.describe(attribute, depth + 1, seen | {id(value)}) + for name, attribute in sorted(vars(value).items()) + }, + } + return _type(value) -_SOURCE_SUFFIXES = (".py", ".yml", ".yaml", ".json") -"""The files of TAT-C whose content is part of a fingerprint.""" +@functools.lru_cache(maxsize=1) +def _module_files() -> dict[str, Path]: + """ + Gets the source files of the modules of the package, by module name + (packages by their `__init__.py`). + """ + found = {} + for path in sorted(_ROOT.rglob("*.py")): + if "__pycache__" in path.parts: + continue + parts = path.relative_to(_ROOT).with_suffix("").parts + if parts[-1] == "__init__": + parts = parts[:-1] + found[".".join((_PACKAGE, *parts))] = path + return found -@functools.lru_cache(maxsize=1) -def get_source_hash() -> str: +def _is_package(module: str) -> bool: + """Whether a module of the package is a package (an `__init__.py`).""" + path = _module_files().get(module) + return path is not None and path.name == "__init__.py" + + +@functools.lru_cache(maxsize=None) +def _tree(module: str) -> ast.Module: + """Gets the syntax tree of a module of the package.""" + return ast.parse(_module_files()[module].read_bytes()) + + +def _absolute(module: str, node: ast.ImportFrom) -> str: + """Gets the absolute name of the module of an import from a module.""" + if node.level == 0: + return node.module or "" + package = module if _is_package(module) else module.rpartition(".")[0] + parts = package.split(".") + parts = parts[: len(parts) - (node.level - 1)] + return ".".join(parts + ([node.module] if node.module else [])) + + +def _is_constant_node(node: ast.AST) -> bool: + """Whether an expression is a constant (or a tuple or list of them).""" + if isinstance(node, ast.Constant): + return True + return isinstance(node, (ast.Tuple, ast.List)) and all( + _is_constant_node(item) for item in node.elts + ) + + +def _assigned(node: ast.stmt) -> tuple[list[str], ast.AST | None]: + """Gets the names a statement assigns, and the value it assigns them.""" + if isinstance(node, ast.Assign): + return [t.id for t in node.targets if isinstance(t, ast.Name)], node.value + if isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name): + return [node.target.id], node.value + return [], None + + +@functools.lru_cache(maxsize=None) +def _resolve(module: str, name: str) -> frozenset[tuple[str, str]]: """ - Gets a hash of the source of TAT-C: its code and resources (such as the - instrument catalog), the files of the package with the suffixes of - `_SOURCE_SUFFIXES` (by their paths in the package and their content), - computed once in a process. + Gets what a name imported from a module of the package depends on: a + submodule of that name, or (from a package) the module that defines it, + following the package's imports. Items are `("module", m)`, for a module + and those it imports, or `("file", m)`, for the source of a module only + (a package through which a name is imported, or that defines it as a + constant). + """ + files = _module_files() + if f"{module}.{name}" in files: + return frozenset({("module", f"{module}.{name}")}) + if module not in files: + return frozenset() + if not _is_package(module): + return frozenset({("module", module)}) + for node in _tree(module).body: + if isinstance(node, ast.ImportFrom): + for alias in node.names: + if (alias.asname or alias.name) == name: + source = _absolute(module, node) + if not _is_package_module(source) or source == module: + return frozenset({("file", module)}) + return frozenset({("file", module)}) | _resolve(source, alias.name) + elif isinstance(node, ast.Import): + for alias in node.names: + if alias.asname == name and _is_package_module(alias.name): + return frozenset({("file", module), ("module", alias.name)}) + elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)): + if node.name == name: + return frozenset({("module", module)}) + else: + names, value = _assigned(node) + if name in names: + if value is not None and _is_constant_node(value): + return frozenset({("file", module)}) + return frozenset({("module", module)}) + return frozenset({("module", module)}) + + +@functools.lru_cache(maxsize=None) +def _imports(module: str) -> frozenset[tuple[str, str]]: + """ + Gets what the imports of a module of the package (anywhere in its code) + depend on (see `_resolve`). + """ + found: set[tuple[str, str]] = set() + for node in ast.walk(_tree(module)): + if isinstance(node, ast.Import): + found.update( + ("module", alias.name) + for alias in node.names + if _is_package_module(alias.name) + ) + elif isinstance(node, ast.ImportFrom): + source = _absolute(module, node) + if not _is_package_module(source): + continue + for alias in node.names: + if alias.name == "*": + found.add(("module", source)) + else: + found.update(_resolve(source, alias.name)) + return frozenset(found) + + +@functools.lru_cache(maxsize=None) +def _resources_of(module: str) -> frozenset[str]: + """ + Gets the resource files a module of the package names: if it refers to + the directory of resources, those whose names, or the names of whose + directories (within it), are strings of its code. + """ + strings = { + node.value + for node in ast.walk(_tree(module)) + if isinstance(node, ast.Constant) and isinstance(node.value, str) + } + if _RESOURCES not in strings: + return frozenset() + directory = _ROOT / _RESOURCES + found = set() + for path in directory.rglob("*"): + if not path.is_file() or "__pycache__" in path.parts: + continue + folders = path.relative_to(directory).parts[:-1] + if path.name in strings or any(folder in strings for folder in folders): + found.add(path.relative_to(_ROOT).as_posix()) + return frozenset(found) + + +def _get_dependencies(modules: Iterable[str]) -> tuple[list[str], list[str]]: + """ + Gets the modules of TAT-C (and resource files) that modules depend on: + the modules and the modules of TAT-C they import (anywhere in their + code), and so on, where a name imported from a package depends on the + module that defines it (and the source of the package's `__init__.py`), + not on every module of the package, and the resource files that these + modules name. + + Args: + modules (Iterable[str]): The names of the modules (others than of + TAT-C are ignored). Returns: - str: the hash + tuple[list[str], list[str]]: the names of the modules, and the paths + of the resource files (within the package) """ - root = Path(__file__).resolve().parents[1] - digest = hashlib.sha1() - for path in sorted(root.rglob("*")): - if path.suffix in _SOURCE_SUFFIXES and "__pycache__" not in path.parts: - digest.update(path.relative_to(root).as_posix().encode()) - digest.update(path.read_bytes()) - return digest.hexdigest()[:16] + files = _module_files() + whole: set[str] = set() + sources: set[str] = set() + pending = [module for module in modules if _is_package_module(module)] + while pending: + module = pending.pop() + if module in whole or module not in files: + continue + whole.add(module) + for kind, other in _imports(module): + if kind == "module": + pending.append(other) + else: + sources.add(other) + resources = set().union(*(_resources_of(module) for module in whole)) + # the trees are no longer needed: what they give is kept + _tree.cache_clear() + return sorted(whole | sources), sorted(resources) + + +@functools.lru_cache(maxsize=None) +def _hash_file(path: Path, modified: int, size: int) -> str: + del modified, size # keys of the cache, so that a changed file is hashed again + return hashlib.sha1(path.read_bytes()).hexdigest()[:16] + + +def _hash(path: Path) -> str: + """Gets a hash of the content of a file (computed again if it changes).""" + status = path.stat() + return _hash_file(path, status.st_mtime_ns, status.st_size) + + +def get_definition(*values: Any, **named: Any) -> dict: + """ + Gets the definition of values (such as a design space and the functions + of a study) that their fingerprint hashes (see `get_fingerprint`): a + description of each value (see the module), the version of Python (as + functions are described by their compiled code), and a hash of the + source of each module of TAT-C (and of each resource file) that the + values depend on (see the module). + + Args: + *values (Any): The values, described by their positions. + **named (Any): The values, described by their names. + + Returns: + dict: the definition, as plain data (`python`, `values`, `modules`, + and `resources`), which `compare_definitions` compares + """ + describer = _Describer() + described = {str(i): describer.describe(value) for i, value in enumerate(values)} + described.update({name: describer.describe(value) for name, value in named.items()}) + modules, resources = _get_dependencies(describer.modules) + files = _module_files() + return { + "python": f"{sys.implementation.name} {sys.version_info[0]}.{sys.version_info[1]}", + "values": described, + "modules": {module: _hash(files[module]) for module in modules}, + "resources": {path: _hash(_ROOT / path) for path in resources}, + } + + +def _fingerprint_of(definition: dict) -> str: + """Gets the fingerprint of a definition (see `get_definition`).""" + text = json.dumps(definition, sort_keys=True, default=str) + return hashlib.sha1(text.encode()).hexdigest()[:16] -def get_fingerprint(*values: Any) -> str: +def get_fingerprint(*values: Any, **named: Any) -> str: """ Gets a fingerprint of values (such as a design space and the functions - of a study) and of the version and source of TAT-C (see - `get_source_hash`): a key that changes if their definitions do (see the - module for what it describes). + of a study): a hash of their definition (see `get_definition`), which + changes if they do, or if the source of TAT-C that they depend on does. Args: - *values (Any): The values. + *values (Any): The values, described by their positions. + **named (Any): The values, described by their names. Returns: str: the fingerprint """ - # pylint: disable=import-outside-toplevel - from .. import __version__ - - text = json.dumps( - { - "tatc": __version__, - "source": get_source_hash(), - "values": [_describe(value) for value in values], - }, - sort_keys=True, - default=str, - ) - return hashlib.sha1(text.encode()).hexdigest()[:16] + return _fingerprint_of(get_definition(*values, **named)) + + +_SHORT = 40 +"""The longest value shown in a difference between definitions.""" + + +def _show(value: Any) -> str: + return value if isinstance(value, str) else json.dumps(value, default=str) + + +def _differences(before: Any, after: Any, path: str) -> list[str]: + """ + Gets the differences between descriptions, by the path to each value + that differs (and the values, if they are short). + """ + if before == after: + return [] + if isinstance(before, dict) and isinstance(after, dict): + found = [] + for key in sorted(set(before) | set(after), key=str): + inner = f"{path}.{key}" if path else str(key) + if key not in before: + found.append(f"{inner} (added)") + elif key not in after: + found.append(f"{inner} (removed)") + else: + found.extend(_differences(before[key], after[key], inner)) + return found + if ( + isinstance(before, list) + and isinstance(after, list) + and len(before) == len(after) + ): + found = [] + for i, (old, new) in enumerate(zip(before, after)): + found.extend(_differences(old, new, f"{path}[{i}]")) + return found + path = path or "values" + if all( + not isinstance(v, (dict, list)) and len(_show(v)) <= _SHORT + for v in (before, after) + ): + return [f"{path}: {_show(before)} -> {_show(after)}"] + return [path] + + +def compare_definitions(before: dict, after: dict, limit: int = 5) -> list[str]: + """ + Compares definitions (see `get_definition`), as to explain why results + of one are not reused by the other: the version of Python, the values + that differ (by their path in the description, such as + `evaluate.closure.offset: 0.0 -> 1.0`, or `evaluate.code` for a change + to the code of a function), and the modules of TAT-C (and resource + files) whose source differs, or that only one depends on. + + Args: + before (dict): A definition. + after (dict): Another definition. + limit (int): The most differences listed (and a count of others). + + Returns: + list[str]: the differences (none if the definitions are the same) + """ + found = [] + if before.get("python") != after.get("python"): + found.append(f"python: {before.get('python')} -> {after.get('python')}") + found.extend(_differences(before.get("values", {}), after.get("values", {}), "")) + for kind, label in (("modules", "module"), ("resources", "resource")): + old, new = before.get(kind, {}), after.get(kind, {}) + for name in sorted(set(old) | set(new)): + if name not in old: + found.append(f"{label} {name} (added)") + elif name not in new: + found.append(f"{label} {name} (removed)") + elif old[name] != new[name]: + found.append(f"{label} {name}") + if len(found) > limit: + return found[:limit] + [f"{len(found) - limit} more"] + return found diff --git a/src/tatc/tradespace/nodes.py b/src/tatc/tradespace/nodes.py index 6c6d9cd3..38726c60 100644 --- a/src/tatc/tradespace/nodes.py +++ b/src/tatc/tradespace/nodes.py @@ -22,7 +22,9 @@ class Infeasible(Exception): """ Raised while deciding a design that violates a constraint of its design - space or has a variable without feasible values. + space or has a variable without feasible values, and by the build or + evaluation functions of a study to reject a design, which is then + recorded as infeasible (see `Study`). Args: message (str): The reason. diff --git a/src/tatc/tradespace/optimization.py b/src/tatc/tradespace/optimization.py index 369deae7..5e94d064 100644 --- a/src/tatc/tradespace/optimization.py +++ b/src/tatc/tradespace/optimization.py @@ -4,40 +4,67 @@ `DesignSpace.suggest`) and pymoo (which searches the unit hypercube that encodes it, see `DesignSpace.decode`). Both are optional dependencies. -The objectives of a design are statistics over its replicates of the -metrics of its evaluations (see `Study.run`, which must give one record per -evaluation): their means, or other statistics (see `aggregate`), such as a -quantile or the probability of meeting a threshold. Requirements on -statistics (see `Requirement`) are output constraints, whose violations the -optimizers minimize along with those of the constraints of the design space. +Designs are judged by criteria (see `Criteria`, without `by`): their +objectives are statistics over their replicates of the metrics of their +evaluations (see `Study.run`, which must give one record per evaluation): +their means, or other statistics, such as a quantile or the probability of +meeting a threshold. Requirements on statistics (see `Requirement`) are +output constraints, whose violations the optimizers minimize along with +those of the constraints of the design space. The tolerances of the +criteria do not apply to searches. Each design is evaluated once, however often an optimizer proposes it, and designs proposed together are evaluated together, in parallel if the study is (see `Study`). +A search chooses its front from one evaluation of each design (with the +study's replicates), which favors the designs whose replicates were lucky: +refine the designs it evaluated (see `refine`) and confirm its front (see +`confirm`) with the designs of the search (see `Search`), as for any study. + @author: Paul T. Grogan """ from __future__ import annotations -from collections.abc import Mapping, Sequence +from collections.abc import Mapping +from dataclasses import dataclass from typing import Any import numpy as np import pandas as pd from .criteria import ( - Requirement, - Statistic, - _check_names, + Criteria, + _as_criteria, _evaluate, _get_matrices, - _get_statistics, + _resolve, + _signs, ) -from .pareto import _check_directions from .space import Design, Infeasible from .study import Study +@dataclass +class Search: + """ + The outcome of a search with an optimizer (see `optimize_optuna` and + `optimize_pymoo`), whose designs and results refine and confirm its + front as for any study (see `refine` and `confirm`):: + + search = optimize_optuna(study, criteria, n_trials=200) + refined = refine(study, search.designs, search.results, criteria) + """ + + results: pd.DataFrame + """pandas.DataFrame: The results of every evaluation (see `Study.run`).""" + designs: list[Design] + """list[Design]: The designs evaluated, in the order of their evaluation.""" + state: Any + """Any: The optimizer's own outcome: the Optuna study (`optuna.Study`) or + the result of pymoo (`pymoo.core.result.Result`).""" + + class Evaluations: """ The evaluations of designs for a search: the objectives of each design @@ -46,27 +73,18 @@ class Evaluations: Args: study (Study): The study that evaluates designs. - objectives (Mapping[str, str]): The objectives: statistics (or - metrics, whose means they are) and their directions (`"min"` or - `"max"`). - statistics (Mapping[str, Statistic | str] | None): Statistics, by - name, of objectives and requirements that are not means. - requirements (Sequence[Requirement]): Requirements on statistics. + criteria (Criteria | Mapping[str, str]): The criteria, without `by` + (see `Criteria`), or the objectives (metrics whose means they + are) and their directions (`"min"` or `"max"`). """ - def __init__( - self, - study: Study, - objectives: Mapping[str, str], - statistics: Mapping[str, Statistic | str] | None = None, - requirements: Sequence[Requirement] = (), - ): - _check_directions(objectives) - self.study, self.objectives = study, dict(objectives) - self.requirements = list(requirements) - names = list(objectives) + [r.name for r in self.requirements] - self.statistics = _get_statistics(names, statistics) - _check_names(self.statistics, self.requirements) + def __init__(self, study: Study, criteria: Criteria | Mapping[str, str]): + self.study, self.criteria = study, _as_criteria(criteria) + if self.criteria.by: + raise ValueError( + "searches need one record per evaluation: give criteria without `by`" + ) + self._statistics = _resolve(self.criteria) self.values: dict[str, tuple[float, ...] | None] = {} """dict: The objectives of each evaluated design (by key), or `None` if it is infeasible.""" @@ -77,6 +95,9 @@ def __init__( """dict: The share of the replicates of each evaluated design (by key) that are infeasible (0 for a feasible design), the violation of its feasibility for constraint-aware optimizers.""" + self.designs: dict[str, Design] = {} + """dict: The evaluated designs (by key), in the order of their + evaluation.""" self._records: list[pd.DataFrame] = [] self._checked = False @@ -115,6 +136,7 @@ def _run(self, designs: list[Design]) -> None: """ Evaluates designs, recording their objectives and violations. """ + self.designs.update((design.key, design) for design in designs) records = self.study.run(designs) self._records.append(records) if records.groupby(["design", "replicate"]).size().max() > 1: @@ -130,16 +152,15 @@ def _run(self, designs: list[Design]) -> None: self.values[key] = self.violations[key] = None feasible = records[~records["design"].isin(infeasible)] if len(feasible) > 0: - metrics = sorted({s.column for s in self.statistics.values()}) - keys, _, matrices = _get_matrices(feasible, metrics) - values, _ = _evaluate(self.statistics, [], matrices) + keys, _, matrices = _get_matrices(feasible, self.criteria.metrics) + values, _ = _evaluate(self._statistics, [], matrices) for i, key in enumerate(keys): self.values[key] = tuple( - float(values[name][i]) for name in self.objectives + float(values[name][i]) for name in self.criteria.objectives ) self.violations[key] = tuple( float(requirement.violation(values[requirement.name][i])) - for requirement in self.requirements + for requirement in self.criteria.requirements ) def worst(self) -> list[float]: @@ -156,30 +177,28 @@ def worst(self) -> list[float]: if values is not None and not np.isnan(values).any() ] if not feasible: - return [0.0] * len(self.objectives) + return [0.0] * len(self.criteria.objectives) table = np.array(feasible) return [ float(table[:, i].max() if direction == "min" else table[:, i].min()) - for i, direction in enumerate(self.objectives.values()) + for i, direction in enumerate(self.criteria.objectives.values()) ] def optimize_optuna( study: Study, - objectives: Mapping[str, str], + criteria: Criteria | Mapping[str, str], n_trials: int, sampler: Any = None, optuna_study: Any = None, batch_size: int | None = None, constraints: bool = True, - statistics: Mapping[str, Statistic | str] | None = None, - requirements: Sequence[Requirement] = (), max_designs: int | None = None, -) -> tuple[Any, pd.DataFrame]: +) -> Search: """ Searches a study's design space with Optuna: each trial suggests a design - (see `DesignSpace.suggest`) and is told the means of its objectives over - its replicates (or other statistics, see `statistics`). + (see `DesignSpace.suggest`) and is told the objectives of the criteria: + statistics (such as means) of its metrics over its replicates. With `constraints`, each trial records the violation of the constraints of its design (`trial.set_constraint`, under the name `"feasibility"`): @@ -192,9 +211,10 @@ def optimize_optuna( rank it. Without `constraints` (or with a version of Optuna before 5, which lacks `set_constraint`), an infeasible design prunes its trial. - Each requirement is a constraint of the trials (named by its statement, - such as `"sufficient p10 >= 80"`), whose value is its violation (see - `Requirement.violation`), and which requires `constraints`. + Each requirement of the criteria is a constraint of the trials (named by + its statement, such as `"sufficient p10 >= 80"`), whose value is its + violation (see `Requirement.violation`), and which requires + `constraints`. Trials are asked in batches, whose designs are evaluated together (in parallel, if the study is) before they are told. A batch defaults to one @@ -212,8 +232,9 @@ def optimize_optuna( Args: study (Study): The study that evaluates designs. - objectives (Mapping[str, str]): The objectives: columns of the - results and their directions (`"min"` or `"max"`). + criteria (Criteria | Mapping[str, str]): The criteria, without `by` + (see `Criteria`), or the objectives (metrics whose means they + are) and their directions (`"min"` or `"max"`). n_trials (int): The number of trials. sampler (optuna.samplers.BaseSampler | None): The sampler, or `None` for TPE (with a constant liar in batches); ignored with an @@ -223,14 +244,10 @@ def optimize_optuna( batch_size (int | None): The number of trials evaluated together. constraints (bool): `True` to record the violations of constraints, `False` to prune infeasible trials. - statistics (Mapping[str, Statistic | str] | None): Statistics, by - name, of objectives and requirements that are not means. - requirements (Sequence[Requirement]): Requirements on statistics. max_designs (int | None): The most designs to evaluate, if limited. Returns: - tuple[optuna.Study, pandas.DataFrame]: the Optuna study, and the - results of every evaluation (see `Study.run`) + Search: the results and designs of the search, and the Optuna study """ # pylint: disable=import-outside-toplevel try: @@ -239,10 +256,11 @@ def optimize_optuna( raise ImportError( "optimize_optuna requires optuna (pip install optuna)" ) from error - evaluations = Evaluations(study, objectives, statistics, requirements) + evaluations = Evaluations(study, criteria) + requirements = evaluations.criteria.requirements directions = [ "minimize" if direction == "min" else "maximize" - for direction in evaluations.objectives.values() + for direction in evaluations.criteria.objectives.values() ] batch_size = batch_size or study.workers if optuna_study is None: @@ -252,7 +270,7 @@ def optimize_optuna( constrained = constraints and hasattr(optuna.trial.Trial, "set_constraint") if requirements and not constrained: raise ValueError("requirements need constraints (and Optuna 5 or later)") - names = [f"{r.name} {r.operator} {r.value}" for r in evaluations.requirements] + names = [f"{r.name} {r.operator} {r.value}" for r in requirements] def set_constraints(trial: Any, feasibility: float, violations) -> None: trial.set_constraint("feasibility", feasibility) @@ -298,15 +316,10 @@ def infeasible(trial: Any, violation: float) -> None: optuna_study.tell( trial, list(np.where(np.isnan(values), evaluations.worst(), values)) ) - return optuna_study, evaluations.results + return Search(evaluations.results, list(evaluations.designs.values()), optuna_study) -def make_pymoo_problem( - study: Study, - objectives: Mapping[str, str], - statistics: Mapping[str, Statistic | str] | None = None, - requirements: Sequence[Requirement] = (), -) -> Any: +def make_pymoo_problem(study: Study, criteria: Criteria | Mapping[str, str]) -> Any: """ Makes a pymoo problem of a study's design space: its variables are the unit hypercube that encodes the design space (see `DesignSpace.decode` @@ -314,39 +327,74 @@ def make_pymoo_problem( objectives are negated), and its constraint (`G <= 0`) is violated by designs that violate a constraint of the design space (by the amount of the violation, see `DesignSpace`) or that the study finds infeasible (by - the share of their infeasible replicates). Each requirement is a further - constraint, whose value is its violation (see `Requirement.violation`). + the share of their infeasible replicates). Each requirement of the + criteria is a further constraint, whose value is its violation (see + `Requirement.violation`). The designs of a population are evaluated together. The problem keeps its evaluations (`evaluations`, see `Evaluations`), - whose `results` are those of every evaluation (see `Study.run`). + whose `results` are those of every evaluation (see `Study.run`), and an + elimination of duplicates by design (`duplicates`, a pymoo + `DuplicateElimination` for the `eliminate_duplicates` of an algorithm): + many points of the unit hypercube decode to the same design (those in the + same level of each variable, or that differ only in the variables of the + branches the design does not choose), which pymoo's elimination of equal + points does not see. A proposal is a duplicate if it decodes to the same + design (by key) as another proposal, a member of the population, or a + design evaluated before; proposals that violate a constraint of the + design space are not duplicates. Args: study (Study): The study that evaluates designs. - objectives (Mapping[str, str]): The objectives: statistics (or - metrics) and their directions (`"min"` or `"max"`). - statistics (Mapping[str, Statistic | str] | None): Statistics, by - name, of objectives and requirements that are not means. - requirements (Sequence[Requirement]): Requirements on statistics. + criteria (Criteria | Mapping[str, str]): The criteria, without `by` + (see `Criteria`), or the objectives (metrics whose means they + are) and their directions (`"min"` or `"max"`). Returns: pymoo.core.problem.Problem: the problem """ # pylint: disable=import-outside-toplevel try: + from pymoo.core.duplicate import DuplicateElimination from pymoo.core.problem import Problem except ImportError as error: raise ImportError( "make_pymoo_problem requires pymoo (pip install pymoo)" ) from error - evaluations = Evaluations(study, objectives, statistics, requirements) - n_requirements = len(evaluations.requirements) - signs = np.array( - [1.0 if direction == "min" else -1.0 for direction in objectives.values()] - ) + evaluations = Evaluations(study, criteria) + n_requirements = len(evaluations.criteria.requirements) + signs = _signs(evaluations.criteria) n_var = len(study.space.unit_paths()) + def key_of(individual: Any) -> str | None: + """The key of the design of a proposal, or `None` if it violates a + constraint of the design space.""" + try: + return study.space.decode(individual.X).key + except Infeasible: + return None + + class DesignDuplicates(DuplicateElimination): + """ + An elimination of the proposals of designs proposed or evaluated + before (see `make_pymoo_problem`). + """ + + def _do(self, pop: Any, other: Any, is_duplicate: np.ndarray) -> np.ndarray: + seen = set(evaluations.designs) + if other is not None: + seen.update(key for key in map(key_of, other) if key is not None) + for i, individual in enumerate(pop): + key = key_of(individual) + if key is None: + continue + if key in seen: + is_duplicate[i] = True + else: + seen.add(key) + return is_duplicate + class DesignSpaceProblem(Problem): """ A pymoo problem of a design space (see `make_pymoo_problem`). @@ -361,6 +409,7 @@ def __init__(self): xu=1.0, ) self.evaluations = evaluations + self.duplicates = DesignDuplicates() def _evaluate(self, x, out, *args, **kwargs): designs: list[Design | None] = [] @@ -392,36 +441,63 @@ def _evaluate(self, x, out, *args, **kwargs): return DesignSpaceProblem() +def _eliminate_duplicates(algorithm: Any, duplicates: Any) -> None: + """ + Makes a pymoo algorithm eliminate duplicates by design: pymoo's genetic + algorithms eliminate duplicates in their initialization and mating. + """ + parts = [ + algorithm, + getattr(algorithm, "initialization", None), + getattr(algorithm, "mating", None), + ] + if any(part is None or not hasattr(part, "eliminate_duplicates") for part in parts): + raise ValueError( + "distinct searches need an algorithm that eliminates duplicates in its " + + "initialization and mating (as pymoo's genetic algorithms do): " + + "pass distinct=False for others" + ) + for part in parts: + part.eliminate_duplicates = duplicates + + def optimize_pymoo( study: Study, - objectives: Mapping[str, str], + criteria: Criteria | Mapping[str, str], algorithm: Any = None, termination: Any = ("n_gen", 10), seed: int | None = None, - statistics: Mapping[str, Statistic | str] | None = None, - requirements: Sequence[Requirement] = (), + distinct: bool = True, **kwargs: Any, -) -> tuple[Any, pd.DataFrame]: +) -> Search: """ Searches a study's design space with a pymoo algorithm (see - `make_pymoo_problem`). + `make_pymoo_problem`). The algorithm eliminates proposals of designs + proposed or evaluated before (its initialization and mating, see + `make_pymoo_problem`'s `duplicates`), unless `distinct` is `False`, so + that each generation proposes as many new designs as it can: as many + generations then evaluate more designs, and find more of the front. Args: study (Study): The study that evaluates designs. - objectives (Mapping[str, str]): The objectives: columns of the - results and their directions (`"min"` or `"max"`). + criteria (Criteria | Mapping[str, str]): The criteria, without `by` + (see `Criteria`), or the objectives (metrics whose means they + are) and their directions (`"min"` or `"max"`). algorithm (pymoo.core.algorithm.Algorithm | None): The algorithm, or `None` for NSGA-II with populations of 20. termination (Any): The termination criterion of `pymoo.optimize.minimize`. seed (int | None): The seed of the algorithm. - statistics (Mapping[str, Statistic | str] | None): Statistics, by - name, of objectives and requirements that are not means. - requirements (Sequence[Requirement]): Requirements on statistics. + distinct (bool): `True` to eliminate the proposals of designs proposed + or evaluated before, `False` for the algorithm's own elimination + of duplicates (of equal points). **kwargs (Any): Other arguments of `pymoo.optimize.minimize`. Returns: - tuple[pymoo.core.result.Result, pandas.DataFrame]: the result of the - search, and the results of every evaluation (see `Study.run`) + Search: the results and designs of the search, and the result of pymoo + + Raises: + ValueError: if the search is distinct but the algorithm does not + eliminate duplicates as pymoo's genetic algorithms do. """ # pylint: disable=import-outside-toplevel from pymoo.optimize import minimize @@ -430,6 +506,9 @@ def optimize_pymoo( from pymoo.algorithms.moo.nsga2 import NSGA2 algorithm = NSGA2(pop_size=20) - problem = make_pymoo_problem(study, objectives, statistics, requirements) + problem = make_pymoo_problem(study, criteria) + if distinct: + _eliminate_duplicates(algorithm, problem.duplicates) result = minimize(problem, algorithm, termination, seed=seed, **kwargs) - return result, problem.evaluations.results + evaluations = problem.evaluations + return Search(evaluations.results, list(evaluations.designs.values()), result) diff --git a/src/tatc/tradespace/pareto.py b/src/tatc/tradespace/pareto.py index 87f37d86..a071685f 100644 --- a/src/tatc/tradespace/pareto.py +++ b/src/tatc/tradespace/pareto.py @@ -1,10 +1,14 @@ """ Pareto efficiency of designs with several objectives: non-dominated -designs, Pareto ranks, and the hypervolume of a set of designs. +designs, Pareto ranks, and the hypervolume of a set of designs (and of the +designs of a search as it proceeds). -Objectives are given as a mapping of the columns of a data frame (such as a -summary of a study, see `summarize`) to their directions, `"min"` or -`"max"`. +Designs are judged by criteria (see `Criteria`): objectives (columns of a +data frame, such as the statistics of a summary of a study, see `aggregate`) +to minimize or maximize, requirements that efficient designs meet, the +tolerances of the objectives, and the groups in which designs are judged +separately. A mapping of objectives to their directions (`"min"` or +`"max"`) is the criteria of these objectives alone. @author: Paul T. Grogan """ @@ -17,84 +21,56 @@ import pandas as pd from .criteria import ( + Criteria, Requirement, - Statistic, - _check_names, + _as_criteria, + aggregate, _evaluate, _get_matrices, - _get_statistics, + _get_tolerances, + _groups, + _resolve, + _signs, ) -Objectives = Mapping[str, str] -"""Objectives: columns and their directions (`"min"` or `"max"`).""" - -def _check_directions(objectives: Objectives) -> list[str]: - """ - Checks the directions of objectives, returning them. - """ - if len(objectives) == 0: - raise ValueError("at least one objective is required") - for column, direction in objectives.items(): - if direction not in ("min", "max"): - raise ValueError( - f"direction of {column!r} must be 'min' or 'max', not {direction!r}" - ) - return list(objectives.values()) - - -def _get_costs(frame: pd.DataFrame, objectives: Objectives) -> np.ndarray: +def _get_costs(frame: pd.DataFrame, objectives: Mapping[str, str]) -> np.ndarray: """ Gets the objectives of a data frame as costs (to minimize): maximized objectives are negated. """ - if len(objectives) == 0: - raise ValueError("at least one objective is required") + missing = [column for column in objectives if column not in frame.columns] + if missing: + raise ValueError(f"no columns of the objectives {missing}") columns = [] for column, direction in objectives.items(): - if direction not in ("min", "max"): - raise ValueError( - f"direction of {column!r} must be 'min' or 'max', not {direction!r}" - ) values = frame[column].to_numpy(dtype=float) columns.append(values if direction == "min" else -values) - costs = np.column_stack(columns) + costs = np.column_stack(columns) if len(frame) > 0 else np.empty((0, len(columns))) if np.isnan(costs).any(): raise ValueError("objectives must not be NaN") return costs -Tolerance = float | str -"""A tolerance of an objective: a value in its units, or a share of its value -(a string of a percentage, such as `"5%"`).""" - - -def _get_tolerances( - objectives: Objectives, tolerance: Mapping[str, Tolerance] | None +def _get_violation( + frame: pd.DataFrame, requirements: Sequence[Requirement] ) -> np.ndarray: """ - Gets the tolerances of the objectives (zero if not given): their absolute - values (first row) and their shares of the values of the objectives - (second row). + Gets the total violation of requirements by the rows of a data frame, + from the columns of their statistics (infinite where a statistic is + missing). """ - tolerance = tolerance or {} - unknown = set(tolerance) - set(objectives) - if unknown: - raise ValueError(f"tolerances of columns that are not objectives: {unknown}") - values = np.zeros((2, len(objectives))) - for i, column in enumerate(objectives): - value = tolerance.get(column, 0.0) - if isinstance(value, str): - if not value.strip().endswith("%"): - raise ValueError( - f"a tolerance string must be a percentage, not {value!r}" - ) - values[1, i] = float(value.strip()[:-1]) / 100 - else: - values[0, i] = float(value) - if np.any(values < 0): - raise ValueError("tolerances must not be negative") - return values + violation = np.zeros(len(frame)) + for requirement in requirements: + if requirement.name not in frame.columns: + raise ValueError( + f"no column of the statistic {requirement.name!r} of a requirement: " + + "aggregate the results with the criteria (see aggregate)" + ) + violation = violation + requirement.violation( + frame[requirement.name].to_numpy(dtype=float) + ) + return np.where(np.isnan(violation), np.inf, violation) _BLOCK_ELEMENTS = 2_000_000 @@ -179,76 +155,84 @@ def _dominated(costs: np.ndarray, tolerances: np.ndarray | None = None) -> np.nd def pareto_front( - frame: pd.DataFrame, - objectives: Objectives, - tolerance: Mapping[str, Tolerance] | None = None, + frame: pd.DataFrame, criteria: Criteria | Mapping[str, str] ) -> pd.Series: """ - Finds the Pareto-efficient (non-dominated) rows of a data frame: those - that no other row dominates, being no worse in every objective and - better in at least one. Rows with the same objectives are all efficient - if any is. - - With a `tolerance` of an objective, a row dominates another only if it - would still dominate it if it were worse by the tolerance in that - objective: a value in the objective's units, or a share of the other - row's value (a percentage, such as `"5%"`), which suits objectives that - range over orders of magnitude. Rows within the tolerances of the front (that no other row is - clearly better than) are then efficient as well, which suits objectives - estimated with an uncertainty (such as a few standard errors of their - means, see `summarize`), or by a cheaper analysis (see `screen`). + Finds the Pareto-efficient (non-dominated) rows of a data frame (such as + the designs of a summary of a study, see `aggregate`): those that meet + the requirements of the criteria (by the columns of their statistics) + and that no other row that meets them dominates, being no worse in every + objective and better in at least one, in each group of the criteria's + `by`. Rows with the same objectives are all efficient if any is. + + With a tolerance of an objective (see `Criteria`), a row dominates + another only if it would still dominate it if it were worse by the + tolerance in that objective: a value in the objective's units, or a + share of the other row's value (a percentage, such as `"5%"`), which + suits objectives that range over orders of magnitude. Rows within the + tolerances of the front (that no other row is clearly better than) are + then efficient as well, which suits objectives estimated with an + uncertainty (such as a few standard errors of their means, see + `summarize`), or by a cheaper analysis (see `screen`). Args: frame (pandas.DataFrame): The rows (such as designs). - objectives (Mapping[str, str]): The objectives: columns and their - directions (`"min"` or `"max"`). - tolerance (Mapping[str, float | str] | None): The tolerances of - objectives (by column, zero if not given): values, or - percentages of values (such as `"5%"`). + criteria (Criteria | Mapping[str, str]): The criteria, or the + objectives (columns) and their directions (`"min"` or `"max"`). Returns: pandas.Series: whether each row is efficient (boolean, with the frame's index) """ - if len(frame) == 0: - return pd.Series([], index=frame.index, dtype=bool) - costs = _get_costs(frame, objectives) - tolerances = _get_tolerances(objectives, tolerance) - return pd.Series(~_dominated(costs, tolerances), index=frame.index, name="pareto") + criteria = _as_criteria(criteria) + tolerances = _get_tolerances(criteria.objectives, criteria.tolerance) + efficient = np.zeros(len(frame), dtype=bool) + for _, positions in _groups(frame, criteria.by): + group = frame.iloc[positions] + meets = _get_violation(group, criteria.requirements) == 0 + if meets.any(): + costs = _get_costs(group[meets], criteria.objectives) + efficient[positions[meets]] = ~_dominated(costs, tolerances) + return pd.Series(efficient, index=frame.index, name="pareto") def pareto_ranks( - frame: pd.DataFrame, - objectives: Objectives, - tolerance: Mapping[str, Tolerance] | None = None, + frame: pd.DataFrame, criteria: Criteria | Mapping[str, str] ) -> pd.Series: """ - Ranks the rows of a data frame by non-dominated sorting: rank 0 is the - Pareto front, rank 1 the front of the others, and so on, optionally with - tolerances of the objectives (see `pareto_front`). + Ranks the rows of a data frame by non-dominated sorting, in each group + of the criteria's `by`: rank 0 is the Pareto front (see `pareto_front`), + rank 1 the front of the others, and so on, with the tolerances of the + criteria. Rows that miss the requirements of the criteria are ranked + after those that meet them, in order of their violation (the sum of the + violations of the requirements, see `Requirement`). Args: frame (pandas.DataFrame): The rows (such as designs). - objectives (Mapping[str, str]): The objectives: columns and their - directions (`"min"` or `"max"`). - tolerance (Mapping[str, float | str] | None): The tolerances of - objectives (by column, zero if not given): values, or - percentages of values (such as `"5%"`). + criteria (Criteria | Mapping[str, str]): The criteria, or the + objectives (columns) and their directions (`"min"` or `"max"`). Returns: pandas.Series: the rank of each row (with the frame's index) """ + criteria = _as_criteria(criteria) + tolerances = _get_tolerances(criteria.objectives, criteria.tolerance) ranks = np.full(len(frame), -1, dtype=int) - if len(frame) > 0: - costs = _get_costs(frame, objectives) - tolerances = _get_tolerances(objectives, tolerance) - remaining = np.arange(len(frame)) + for _, positions in _groups(frame, criteria.by): + group = frame.iloc[positions] + violation = _get_violation(group, criteria.requirements) + meets = violation == 0 + costs = _get_costs(group[meets], criteria.objectives) + remaining = positions[meets] rank = 0 while len(remaining) > 0: - front = ~_dominated(costs[remaining], tolerances) + front = ~_dominated(costs, tolerances) ranks[remaining[front]] = rank - remaining = remaining[~front] + remaining, costs = remaining[~front], costs[~front] rank += 1 + if (~meets).any(): + order = pd.Series(violation[~meets]).rank(method="dense").to_numpy() + ranks[positions[~meets]] = rank + order.astype(int) - 1 return pd.Series(ranks, index=frame.index, name="pareto_rank") @@ -281,125 +265,162 @@ def _hypervolume(points: np.ndarray, reference: np.ndarray) -> float: def hypervolume( frame: pd.DataFrame, - objectives: Objectives, + criteria: Criteria | Mapping[str, str], reference: Mapping[str, float] | Sequence[float], ) -> float: """ Computes the hypervolume of the rows of a data frame: the volume of the objective space that they dominate, up to a reference point that is worse than every row of interest in every objective. Rows that are not - better than the reference in every objective add nothing. A larger - hypervolume is a better set of designs, which makes it a measure of the - progress of a search, or of how close a search comes to the true Pareto - front. + better than the reference in every objective, or that miss the + requirements of the criteria, add nothing (the tolerances of the + criteria do not apply). A larger hypervolume is a better set of designs, + which makes it a measure of the progress of a search, or of how close a + search comes to the true Pareto front. The hypervolume is exact. Its computation slices the objectives in turn, which takes long with many objectives and many efficient rows. Args: - frame (pandas.DataFrame): The rows (such as designs). - objectives (Mapping[str, str]): The objectives: columns and their - directions (`"min"` or `"max"`). + frame (pandas.DataFrame): The rows (such as designs), of one group + (criteria with `by` are not accepted). + criteria (Criteria | Mapping[str, str]): The criteria, or the + objectives (columns) and their directions (`"min"` or `"max"`). reference (Mapping[str, float] | Sequence[float]): The reference point: the value of each objective (by column, or in order). Returns: float: the hypervolume, in the product of the units of the objectives """ + criteria = _as_criteria(criteria) + if criteria.by: + raise ValueError( + "a hypervolume is of the rows of one group: give criteria without `by`" + ) + objectives = criteria.objectives if isinstance(reference, Mapping): reference = [reference[column] for column in objectives] if len(reference) != len(objectives): raise ValueError("the reference point needs a value for each objective") - signs = np.array([1.0 if d == "min" else -1.0 for d in objectives.values()]) - bound = signs * np.asarray(reference, dtype=float) + bound = _signs(criteria) * np.asarray(reference, dtype=float) if len(frame) == 0: return 0.0 + frame = frame[_get_violation(frame, criteria.requirements) == 0] costs = _get_costs(frame, objectives) costs = costs[np.all(costs < bound, axis=1)] return _hypervolume(costs, bound) +def hypervolume_progress( + results: pd.DataFrame, + criteria: Criteria | Mapping[str, str], + reference: Mapping[str, float] | Sequence[float], + step: int = 10, +) -> pd.Series: + """ + Gets the hypervolume of the designs evaluated by a search (such as an + optimizer, see `optimize_optuna`) as it proceeds: of the first designs + evaluated (in the order of their first records in the results of the + search), judged by their statistics over their replicates (see + `aggregate`), in steps of `step` designs (and of all of them). + + Args: + results (pandas.DataFrame): The results of the search (see + `Study.run`). + criteria (Criteria | Mapping[str, str]): The criteria, or the + objectives (columns) and their directions (`"min"` or `"max"`). + reference (Mapping[str, float] | Sequence[float]): The reference + point (see `hypervolume`). + step (int): The number of designs of each step. + + Returns: + pandas.Series: the hypervolume, by the number of designs evaluated + """ + if step < 1: + raise ValueError("step must be at least 1") + criteria = _as_criteria(criteria) + summary = aggregate(results, criteria).set_index("design") + order = results["design"].drop_duplicates().tolist() + counts = list(range(step, len(order) + 1, step)) + if order and (not counts or counts[-1] != len(order)): + counts.append(len(order)) + return pd.Series( + [ + hypervolume(summary[summary.index.isin(order[:n])], criteria, reference) + for n in counts + ], + index=pd.Index(counts, name="designs"), + name="hypervolume", + dtype=float, + ) + + def pareto_probability( results: pd.DataFrame, - objectives: Objectives, - by: Sequence[str] = (), + criteria: Criteria | Mapping[str, str], n_resamples: int = 500, seed: int = 0, - statistics: Mapping[str, Statistic | str] | None = None, - requirements: Sequence[Requirement] = (), - tolerance: Mapping[str, Tolerance] | None = None, ) -> pd.DataFrame: """ - Estimates the probability that each design is Pareto-efficient (and - meets the requirements, if any), given the uncertainty of its replicates, - by a bootstrap: each resample draws replicates with replacement, the - same replicates for every design (which keeps the correlation between - designs of common random numbers, see `Design.realize`), computes the - statistics of each design over the drawn replicates, and finds the front - of the designs that meet the requirements. The probability is the share - of resamples in which a design is on that front. - - Objectives and requirements name statistics (see `aggregate`): the - means of metrics, unless `statistics` define them otherwise (such as a - quantile or the probability of meeting a threshold). + Estimates the probability that each design is Pareto-efficient by + criteria (and meets their requirements, if any), given the uncertainty + of its replicates, by a bootstrap: each resample draws replicates with + replacement, the same replicates for every design (which keeps the + correlation between designs of common random numbers, see + `Design.realize`), computes the statistics of each design over the drawn + replicates, and finds the front of the designs that meet the + requirements (in each group of the criteria's `by`). The probability is + the share of resamples in which a design is on that front. Designs that are efficient with a probability between 0 and 1 are those whose efficiency the replicates do not settle: more replicates (see `refine`) would settle it, unless designs differ by less than matters (as - near saturation), which a `tolerance` of the objectives settles: designs - within the tolerances of the front are efficient (see `pareto_front`). With - few replicates, the bootstrap has few distinct resamples and understates - the uncertainty. Designs may have different replicates (as after - `refine`): replicates are drawn from all of them, and each design's + near saturation), which a tolerance of the objectives settles: designs + within the tolerances of the front are efficient (see `pareto_front`). + With few replicates, the bootstrap has few distinct resamples and + understates the uncertainty. Designs may have different replicates (as + after `refine`): replicates are drawn from all of them, and each design's statistics are those of its drawn replicates (or of all of its replicates, if none is drawn). Args: results (pandas.DataFrame): The results of a study (see `Study.run`), with a record per replicate of each design (and - group of `by`). Infeasible results are ignored. - objectives (Mapping[str, str]): The objectives: statistics (or - metrics) and their directions (`"min"` or `"max"`). - by (Sequence[str]): Columns that group records of an evaluation (such - as a sensor), whose fronts are found separately. + group of the criteria's `by`). Infeasible results are ignored. + criteria (Criteria | Mapping[str, str]): The criteria, or the + objectives (metrics whose means they are) and their directions + (`"min"` or `"max"`). n_resamples (int): The number of resamples. seed (int): The seed of the resamples. - statistics (Mapping[str, Statistic | str] | None): Statistics, by - name, of objectives and requirements that are not means. - requirements (Sequence[Requirement]): Requirements on statistics. - tolerance (Mapping[str, float | str] | None): The tolerances of - objectives (by name, zero if not given): values, or percentages of - values (such as `"5%"`). Returns: pandas.DataFrame: a row per design (and group): the statistics of - the objectives (and requirements) over every replicate, the - number of `replicates`, whether the design meets the - requirements (`meets_requirements`) and is efficient among those - that do (`pareto`) by these statistics, the probability that it - is efficient (`pareto_probability`), and the probability that it - meets the requirements (`requirements_probability`) + the criteria over every replicate, the standard error of each + objective (` se`, its standard deviation over the + resamples), the number of `replicates`, + whether the design meets the requirements (`meets_requirements`) + and is efficient among those that do (`pareto`) by these + statistics, the probability that it is efficient + (`pareto_probability`), and the probability that it meets the + requirements (`requirements_probability`) """ - names = list(objectives) + [requirement.name for requirement in requirements] - resolved = _get_statistics(names, statistics) - resolved = {name: resolved[name] for name in dict.fromkeys(names)} - _check_names(resolved, requirements) - signs = np.array( - [1.0 if d == "min" else -1.0 for d in _check_directions(objectives)] - ) - tolerances = _get_tolerances(objectives, tolerance) + criteria = _as_criteria(criteria) + resolved = _resolve(criteria) + requirements = criteria.requirements + signs = _signs(criteria) + tolerances = _get_tolerances(criteria.objectives, criteria.tolerance) feasible = results[results["feasible"]] if "feasible" in results else results - metrics = sorted({statistic.column for statistic in resolved.values()}) + metrics = criteria.metrics rng = np.random.default_rng(seed) frames = [] - groups = feasible.groupby(list(by), sort=False) if by else [((), feasible)] - for key, group in groups: + for key, positions in _groups(feasible, criteria.by): + group = feasible.iloc[positions] designs, replicates, matrices = _get_matrices(group, metrics) values, violation = _evaluate(resolved, requirements, matrices) def front(values, violation): costs = np.column_stack( - [s * values[name] for s, name in zip(signs, objectives)] + [s * values[name] for s, name in zip(signs, criteria.objectives)] ) ok = (violation == 0) & ~np.isnan(costs).any(axis=1) efficient = np.zeros(len(costs), dtype=bool) @@ -409,6 +430,9 @@ def front(values, violation): efficient, meets = front(values, violation) counts = np.zeros(len(designs)) met = np.zeros(len(designs)) + # the sums of the objectives (and of their squares) over the resamples + sums = {name: np.zeros(len(designs)) for name in criteria.objectives} + squares = {name: np.zeros(len(designs)) for name in criteria.objectives} for _ in range(n_resamples): drawn = rng.integers(0, len(replicates), len(replicates)) sample, sample_violation = _evaluate( @@ -423,11 +447,18 @@ def front(values, violation): sample_front, sample_meets = front(sample, sample_violation) counts += sample_front met += sample_meets + for name in criteria.objectives: + sums[name] += sample[name] + squares[name] += sample[name] ** 2 frame = pd.DataFrame({"design": designs}) - for name, value in zip(by, key if isinstance(key, tuple) else (key,)): + for name, value in zip(criteria.by, key): frame[name] = value for name, value in values.items(): frame[name] = value + for name in criteria.objectives: + mean = sums[name] / n_resamples + variance = np.maximum(squares[name] / n_resamples - mean**2, 0.0) + frame[f"{name} se"] = np.sqrt(variance) frame["replicates"] = ( group.groupby("design")["replicate"].nunique().reindex(designs).to_numpy() ) diff --git a/src/tatc/tradespace/refinement.py b/src/tatc/tradespace/refinement.py index b2ec70da..2ee467d3 100644 --- a/src/tatc/tradespace/refinement.py +++ b/src/tatc/tradespace/refinement.py @@ -1,6 +1,6 @@ """ Adaptive replication: replicates added only to the designs whose Pareto -efficiency their replicates do not settle. +efficiency their replicates do not settle, within a budget of evaluations. @author: Paul T. Grogan """ @@ -11,9 +11,10 @@ from collections.abc import Mapping, Sequence from dataclasses import dataclass, field +import numpy as np import pandas as pd -from .criteria import Requirement, Statistic +from .criteria import Criteria, _as_criteria, _get_tolerances from .pareto import pareto_probability from .space import Design from .study import Study @@ -30,45 +31,84 @@ class Refinement: those added (see `Study.run`).""" probability: pd.DataFrame """pandas.DataFrame: The probability that each design is efficient after - the last round (see `pareto_probability`).""" + the last round (see `pareto_probability`), and whether its efficiency is + `uncertain` (by the bounds of `refine`, or with fewer than its least + replicates) and, if so, whether it is `indifferent` (its objectives are + known to within the precision of their tolerances).""" history: pd.DataFrame = field(default_factory=pd.DataFrame) """pandas.DataFrame: For each round, the number of designs whose - efficiency is uncertain (`uncertain`), the number to which replicates - were added (`refined`), and the evaluations added (`evaluations`).""" + efficiency is uncertain (`uncertain`), of these, those that are + indifferent (`indifferent`), the number to which replicates were added + (`refined`), and the evaluations added (`evaluations`).""" @property def uncertain(self) -> pd.DataFrame: """pandas.DataFrame: The rows of `probability` whose efficiency is - still uncertain (as of the bounds of `refine`, or with fewer than - its least replicates).""" - return self.probability[self.probability["uncertain"]] + still uncertain, and that more replicates would settle (those that are + not indifferent).""" + probability = self.probability + return probability[probability["uncertain"] & ~probability["indifferent"]] + + @property + def indifferent(self) -> pd.DataFrame: + """pandas.DataFrame: The rows of `probability` whose efficiency is + uncertain, but whose objectives are known to within the precision of + their tolerances, so that whether they are within the tolerances of + the front does not matter.""" + return self.probability[self.probability["indifferent"]] + + +def _precise( + probability: pd.DataFrame, criteria: Criteria, precision: float | None +) -> np.ndarray: + """ + Gets whether each design's objectives are known to within the precision + of their tolerances: the standard error of each objective that varies + between replicates is less than `precision` times its tolerance (at the + design's value). Designs whose varying objectives lack a tolerance are + not precise. + """ + precise = np.zeros(len(probability), dtype=bool) + if precision is None or not criteria.tolerance: + return precise + tolerances = _get_tolerances(criteria.objectives, criteria.tolerance) + precise[:] = True + for i, name in enumerate(criteria.objectives): + error = probability[f"{name} se"].to_numpy(dtype=float) + value = np.abs(probability[name].to_numpy(dtype=float)) + tolerance = tolerances[0, i] + tolerances[1, i] * value + varies = np.nan_to_num(error) > 0 + precise &= ~varies | (error < precision * tolerance) + return precise def refine( study: Study, designs: Sequence[Design], results: pd.DataFrame, - objectives: Mapping[str, str], - statistics: Mapping[str, Statistic | str] | None = None, - requirements: Sequence[Requirement] = (), - by: Sequence[str] = (), + criteria: Criteria | Mapping[str, str], bounds: tuple[float, float] = (0.05, 0.95), step: int | None = None, max_replicates: int | None = None, min_replicates: int = 5, max_rounds: int = 10, + precision: float | None = 0.5, + budget: int | None = None, n_resamples: int = 500, seed: int = 0, - tolerance: Mapping[str, float | str] | None = None, ) -> Refinement: """ - Adds replicates to the designs whose Pareto efficiency is uncertain, - until it is settled: in each round, the probability that each design is - efficient (and meets the requirements) is estimated by a bootstrap (see + Adds replicates to the designs whose Pareto efficiency (by criteria, see + `Criteria`) is uncertain, until it is settled: in each round, the + probability that each design is efficient (and meets the requirements) + is estimated by a bootstrap (see `pareto_probability`), and each design whose probability is strictly between the `bounds` gets `step` more replicates, up to `max_replicates`. Rounds end when no design is uncertain (or can be - refined), or after `max_rounds`. + refined), when the `budget` of evaluations is spent, or after + `max_rounds`. If a round would spend more than is left of the budget, the + designs with the fewest replicates (below `min_replicates`) are refined + first, and then those whose probability is nearest 0.5. A bootstrap of few replicates has few distinct resamples, and can find a design surely inefficient (or efficient) by the luck of its replicates: @@ -83,23 +123,29 @@ def refine( saves the evaluations that uniform replication would spend on them. Designs that differ by less than any number of replicates could - separate (such as designs near saturation) stay uncertain: give a - `tolerance` of the objectives within which differences do not matter, - so that such designs are all efficient (see `pareto_probability`). A - warning is given if designs remain uncertain without a tolerance. + separate (such as designs near saturation) stay uncertain: give the + criteria a tolerance of the objectives within which differences do not + matter, so that such designs are all efficient (see + `pareto_probability`). A design whose distance from the front is about + its tolerance stays uncertain too, and more replicates settle which side + of the tolerance it falls on only slowly, though it does not matter: a + design is `indifferent`, and not refined, once the standard error of each + objective that varies between its replicates (see `pareto_probability`) + is less than `precision` times the objective's tolerance (at the + design's value), which saves the evaluations that would otherwise go to + such designs until `max_replicates`. A design whose varying objectives + lack a tolerance is never indifferent. A warning is given if designs + remain uncertain (but not indifferent) without a tolerance. Args: study (Study): The study that evaluates designs. designs (Sequence[Design]): The designs (those of the results). results (pandas.DataFrame): The results of the designs (see `Study.run`). - objectives (Mapping[str, str]): The objectives: statistics (or - metrics) and their directions (`"min"` or `"max"`). - statistics (Mapping[str, Statistic | str] | None): Statistics, by - name, of objectives and requirements that are not means. - requirements (Sequence[Requirement]): Requirements on statistics. - by (Sequence[str]): Columns that group records of an evaluation (such - as a sensor); a design is uncertain if it is in any group. + criteria (Criteria | Mapping[str, str]): The criteria, or the + objectives (metrics whose means they are) and their directions + (`"min"` or `"max"`). A design is uncertain if it is in any + group of the criteria's `by`. bounds (tuple[float, float]): The probabilities between which a design is uncertain. step (int | None): The replicates added to an uncertain design in a @@ -109,15 +155,19 @@ def refine( min_replicates (int): The fewest replicates with which a design's efficiency can be settled. max_rounds (int): The most rounds. + precision (float | None): The standard error of an objective, as a + share of its tolerance, below which an uncertain design is + indifferent, or `None` to refine uncertain designs until + `max_replicates`. + budget (int | None): The most evaluations to add (a design in a + replicate), if limited. n_resamples (int): The number of resamples of each bootstrap. seed (int): The seed of the bootstraps. - tolerance (Mapping[str, float | str] | None): The tolerances of - objectives (by name, zero if not given): values, or percentages of - values (such as `"5%"`, see `pareto_front`). Returns: Refinement: the results, the final probabilities, and the history """ + criteria = _as_criteria(criteria) low, high = bounds if not 0 <= low < high <= 1: raise ValueError("bounds must satisfy 0 <= low < high <= 1") @@ -126,63 +176,94 @@ def refine( raise ValueError("step must be at least 1") if max_replicates is not None and max_replicates < min_replicates: raise ValueError("max_replicates must be at least min_replicates") + if precision is not None and precision <= 0: + raise ValueError("precision must be positive (or None)") + if budget is not None and budget < 0: + raise ValueError("budget must not be negative") by_key = {design.key: design for design in designs} frames = [results] history = [] + spent = 0 def estimate(round_: int) -> pd.DataFrame: probability = pareto_probability( pd.concat(frames, ignore_index=True), - objectives, - by=by, + criteria, n_resamples=n_resamples, seed=seed + round_, - statistics=statistics, - requirements=requirements, - tolerance=tolerance, ) + few = probability["replicates"] < min_replicates probability["uncertain"] = ( (probability["pareto_probability"] > low) & (probability["pareto_probability"] < high) - ) | (probability["replicates"] < min_replicates) + ) | few + probability["indifferent"] = ( + probability["uncertain"] & ~few & _precise(probability, criteria, precision) + ) return probability for round_ in range(max_rounds): probability = estimate(round_) - uncertain = probability.groupby("design")["uncertain"].any() - uncertain = list(uncertain[uncertain].index) + grouped = probability.groupby("design") + uncertain = grouped["uncertain"].any() + # a design is indifferent if it is in every group in which it is uncertain + settling = ( + (probability["uncertain"] & ~probability["indifferent"]) + .groupby(probability["design"]) + .any() + ) + indifferent = uncertain & ~settling combined = pd.concat(frames, ignore_index=True) - # the next replicate of each uncertain design following = combined.groupby("design")["replicate"].max() + 1 - # the replicates added to each uncertain design (fewer at the limit) - added_to = { - key: ( + # the designs to refine, the fewest replicates and the least settled first + distance = (probability["pareto_probability"] - 0.5).abs() + priority = pd.DataFrame( + { + "few": grouped["replicates"].min() < min_replicates, + "distance": distance.groupby(probability["design"]).min(), + "replicates": grouped["replicates"].min(), + } + ) + candidates = priority[settling.reindex(priority.index, fill_value=False)] + candidates = candidates.sort_values( + ["few", "distance", "replicates"], ascending=[False, True, True] + ) + left = None if budget is None else budget - spent + added_to = {} + for key in candidates.index: + if key not in by_key: + continue + count = ( step if max_replicates is None else min(step, max_replicates - int(following[key])) ) - for key in uncertain - if key in by_key + if left is not None: + count = min(count, left) + if count <= 0: + continue + added_to[key] = count + if left is not None: + left -= count + if left == 0: + break + record = { + "round": round_, + "uncertain": int(uncertain.sum()), + "indifferent": int(indifferent.sum()), + "refined": len(added_to), + "evaluations": 0, } - refined = [key for key, count in added_to.items() if count > 0] - if not refined: - history.append( - { - "round": round_, - "uncertain": len(uncertain), - "refined": 0, - "evaluations": 0, - } - ) + if not added_to: + history.append(record) break - added = 0 # designs with the same next replicates are evaluated together plan = pd.DataFrame( { - "start": following[refined].astype(int), - "count": [added_to[key] for key in refined], + "start": following[list(added_to)].astype(int), + "count": list(added_to.values()), }, - index=refined, + index=list(added_to), ) for (start, count), keys in plan.groupby(["start", "count"]): new = study.run( @@ -190,23 +271,19 @@ def estimate(round_: int) -> pd.DataFrame: replicates=range(int(start), int(start) + int(count)), ) frames.append(new) - added += new.groupby(["design", "replicate"]).ngroups - history.append( - { - "round": round_, - "uncertain": len(uncertain), - "refined": len(refined), - "evaluations": added, - } - ) + record["evaluations"] += new.groupby(["design", "replicate"]).ngroups + spent += record["evaluations"] + history.append(record) else: probability = estimate(max_rounds) - remaining = probability.loc[probability["uncertain"], "design"].nunique() - if remaining > 0 and not tolerance: + remaining = probability.loc[ + probability["uncertain"] & ~probability["indifferent"], "design" + ].nunique() + if remaining > 0 and not criteria.tolerance: warnings.warn( f"{remaining} designs remain uncertain: designs that differ by less " + "than replicates separate stay uncertain without a tolerance of " - + "the objectives (see pareto_front)", + + "the objectives (see Criteria)", stacklevel=2, ) return Refinement( diff --git a/src/tatc/tradespace/screening.py b/src/tatc/tradespace/screening.py index 54d078c9..661d87d8 100644 --- a/src/tatc/tradespace/screening.py +++ b/src/tatc/tradespace/screening.py @@ -10,37 +10,16 @@ import math from collections.abc import Mapping, Sequence -from dataclasses import dataclass, field +from dataclasses import dataclass, field, replace -import numpy as np import pandas as pd -from .criteria import Requirement, Statistic, _get_statistics, aggregate +from .criteria import Criteria, Tolerance, _as_criteria, aggregate from .pareto import pareto_ranks from .space import Design from .study import Study -def _rank( - summary: pd.DataFrame, - objectives: Mapping[str, str], - tolerance: Mapping[str, float] | None, -) -> pd.Series: - """ - Ranks designs: those that meet the requirements by non-dominated sorting - of their objectives, then the others by their violations. - """ - ranks = pd.Series(-1, index=summary.index, name="pareto_rank") - meets = summary["meets_requirements"] - if meets.any(): - ranks[meets] = pareto_ranks(summary[meets], objectives, tolerance) - if (~meets).any(): - start = int(ranks[meets].max()) + 1 if meets.any() else 0 - violation = summary.loc[~meets, "violation"].fillna(np.inf) - ranks[~meets] = start + violation.rank(method="dense").astype(int) - 1 - return ranks - - @dataclass class Screening: """ @@ -52,8 +31,8 @@ class Screening: the `stage` (0 for the first).""" summaries: list[pd.DataFrame] = field(default_factory=list) """list[pandas.DataFrame]: For each stage, the summary of its designs - (see `summarize`), with their Pareto rank (`pareto_rank`, -1 if - infeasible) and whether they were `kept` for the next stage.""" + (see `aggregate`), with their Pareto rank (`pareto_rank`, see + `pareto_ranks`) and whether they were `kept` for the next stage.""" designs: list[Design] = field(default_factory=list) """list[Design]: The designs analyzed in the last stage.""" @@ -77,31 +56,35 @@ def _per_stage(value, count: int, name: str) -> list: def screen( designs: Sequence[Design], studies: Sequence[Study], - objectives: Mapping[str, str], + criteria: Criteria | Mapping[str, str], keep: float | int | Sequence[float | int] = 0.25, - tolerance: Mapping[str, float] | Sequence[Mapping[str, float] | None] | None = None, - statistics: Mapping[str, Statistic | str] | None = None, - requirements: Sequence[Requirement] = (), + tolerance: ( + Mapping[str, Tolerance] | Sequence[Mapping[str, Tolerance] | None] | None + ) = None, ) -> Screening: """ Screens designs with studies of increasing fidelity (and cost): each study (stage) evaluates the designs kept by the one before, ranks them by - non-dominated sorting of their objectives (see `pareto_ranks`): the means - of metrics, or other statistics over their replicates (see `aggregate`), - and keeps whole fronts, best first, until it keeps at least `keep` - designs (a number, or a share of the feasible designs). + non-dominated sorting of the objectives of the criteria (see + `pareto_ranks`): the means of metrics, or other statistics over their + replicates (see `Criteria`), and keeps whole fronts, best first, until + it keeps at least `keep` designs (a number, or a share of the feasible + designs). Designs that miss a requirement are ranked after those that meet them - all, in order of their violation (see `aggregate`), rather than dropped: + all, in order of their violation (see `pareto_ranks`), rather than + dropped: a cheap analysis may miss a requirement that the full analysis meets, so designs that nearly meet the requirements are kept if `keep` reaches them. A cheap analysis ranks designs less exactly than an expensive one, so a design it ranks just behind another may be better: keep enough designs, - or give a `tolerance` of each objective (in the units of the stage's - analysis), within which differences do not separate fronts (see - `pareto_front`), so that nearly efficient designs are kept. Compare the + or give a `tolerance` of each objective for the stages of cheap analyses + (in the units of the stage's analysis, in place of the criteria's), + within which differences do not separate fronts (see `pareto_front`), + so that nearly efficient designs are kept. The last stage ranks designs + with the tolerances of the criteria. Compare the final front with one found without screening on a sample of designs to check that screening does not lose efficient designs. @@ -109,21 +92,26 @@ def screen( designs (Sequence[Design]): The designs to screen. studies (Sequence[Study]): The studies of each stage, in order of increasing fidelity. - objectives (Mapping[str, str]): The objectives: statistics (or - metrics) and their directions (`"min"` or `"max"`). + criteria (Criteria | Mapping[str, str]): The criteria, without + `by` (see `Criteria`), or the objectives (metrics whose means they + are) and their directions (`"min"` or `"max"`). keep (float | int | Sequence): The designs kept by each stage but the last: a number (int), or a share of its feasible designs (float), or a value for each stage. tolerance (Mapping | Sequence | None): The tolerances of objectives - in each stage but the last (see `pareto_front`), or the same for - each stage. - statistics (Mapping[str, Statistic | str] | None): Statistics, by - name, of objectives and requirements that are not means. - requirements (Sequence[Requirement]): Requirements on statistics. + in each stage but the last, in place of those of the criteria + (see `Criteria`): the same for each stage, or one for each (`None` + for the criteria's). Returns: Screening: the results and summaries of each stage """ + criteria = _as_criteria(criteria) + if criteria.by: + raise ValueError( + "screening ranks designs by one record per evaluation: " + + "give criteria without `by`" + ) if len(studies) == 0: raise ValueError("at least one study is required") transitions = len(studies) - 1 @@ -132,19 +120,21 @@ def screen( tolerances = [tolerance] * transitions else: tolerances = _per_stage(tolerance, transitions, "tolerance") - names = list(objectives) + [requirement.name for requirement in requirements] - resolved = _get_statistics(names, statistics) + # the criteria of each stage: with the tolerance of a cheap stage, if any + stages = [ + criteria if value is None else replace(criteria, tolerance=value) + for value in tolerances + ] + [criteria] current = list({design.key: design for design in designs}.values()) screening = Screening(results=pd.DataFrame()) frames = [] for stage, study in enumerate(studies): results = study.run(current).assign(stage=stage) frames.append(results) - summary = aggregate(results, resolved, requirements, design_columns=[]) - summary = summary.dropna(subset=list(objectives)).reset_index(drop=True) - summary["pareto_rank"] = _rank( - summary, objectives, tolerances[stage] if stage < transitions else None - ) + summary = aggregate(results, criteria, design_columns=[]) + summary = summary.dropna(subset=list(criteria.objectives)) + summary = summary.reset_index(drop=True) + summary["pareto_rank"] = pareto_ranks(summary, stages[stage]) if stage < transitions: amount = keeps[stage] count = ( diff --git a/src/tatc/tradespace/space.py b/src/tatc/tradespace/space.py index fb425f31..b41708b9 100644 --- a/src/tatc/tradespace/space.py +++ b/src/tatc/tradespace/space.py @@ -24,13 +24,15 @@ import hashlib import json +import re import zlib -from collections.abc import Callable, Iterator, Sequence +from collections.abc import Callable, Iterable, Iterator, Mapping, Sequence from functools import partial from typing import Any import numpy as np +from .fingerprint import _Describer from .nodes import ( Choice, Derived, @@ -81,7 +83,8 @@ class _Context: """ How a walk of a design space decides its nodes: `choose(path, domain)` decides a variable, `draw(path, node)` draws an uncertain parameter (or - `None` for nominal values), and `check` enables constraints. If given, + `None` for nominal values), `fix(path, node)` gives a fixed value (or + `None` for its value), and `check` enables constraints. If given, `record(path, domain, value)` is called with every decision, chosen or prescribed. With an `odometer` (of an enumeration), the items of unordered repetitions are only walked in the order of their levels. @@ -94,8 +97,10 @@ def __init__( check: bool = True, record: Callable[[str, _Domain, Any], None] | None = None, odometer: _Odometer | None = None, + fix: Callable[[str, Fixed], Any] | None = None, ): self.choose, self.draw, self.check = choose, draw, check + self.fix = fix self.record, self.odometer = record, odometer def decide(self, path: str, domain: _Domain, prescribed: Any) -> Any: @@ -122,6 +127,17 @@ def _join(path: str, name: str) -> str: return f"{path}.{name}" if path else name +_ITEM_INDEX = re.compile(r"\[\d+\]") + + +def _generic(path: str) -> str: + """ + Gets the path of a node with `[*]` for the index of any item of a + repetition (as of `DesignSpace.uncertain_paths`). + """ + return _ITEM_INDEX.sub("[*]", path) + + def _walk( node: Node, path: str, @@ -143,7 +159,7 @@ def _walk( value = ctx.decide(path, node.domain(scope), prescribed) return value, value if isinstance(node, Fixed): - return node.value, _ABSENT + return (node.value if ctx.fix is None else ctx.fix(path, node)), _ABSENT if isinstance(node, Derived): return node.function(scope), _ABSENT if isinstance(node, Uncertain): @@ -373,6 +389,9 @@ def __init__( ): self.space, self.decisions, self.replicate = space, decisions, replicate self._values = values + self._scenario = "" + """str: A description of the values of the scenario of a realized + design (see `realize`), `""` without one.""" self.key = hashlib.sha1(_decision_key(decisions).encode()).hexdigest()[:12] """str: An identifier of the design, from its decisions only (not from its derived values or uncertain parameters).""" @@ -415,7 +434,14 @@ def flat(self) -> dict[str, Any]: _flatten(self.space, self._values, "", out) return out - def realize(self, replicate: int, seed: int = 0, common: bool = True) -> Design: + def realize( + self, + replicate: int, + seed: int = 0, + common: bool = True, + shift: Mapping[str, int] | None = None, + scenario: Mapping[str, Any] | None = None, + ) -> Design: """ Realizes a replicate of the design: draws its uncertain parameters (and computes the values derived from them). @@ -430,25 +456,65 @@ def realize(self, replicate: int, seed: int = 0, common: bool = True) -> Design: is also seeded by the design's key, so that draws are independent between designs. + A `shift` draws some parameters as in other replicates: a parameter + named in it (by its path, with `[*]` for the index of any item of a + repetition, see `DesignSpace.uncertain_paths`) is drawn as in + replicate `replicate + shift[name]`, and the others as in + `replicate`. Such a mixed replicate differs from `replicate` in the + named parameters only, which measures their effects on the outcomes + of a design (see `attribute_variance`). + + A `scenario` gives fixed values and uncertain parameters other values + (by their paths, with `[*]` for the index of any item of a + repetition, as of `DesignSpace.uncertain_paths`): a condition under + which designs are compared, such as a requirement, rather than + averaged over (see `Study`). Values derived from them are derived + from the scenario's, and an uncertain parameter that it gives is not + drawn. + Args: replicate (int): The replicate. seed (int): The seed of the trade study. common (bool): `True` to use common random numbers between designs. + shift (Mapping[str, int] | None): The offsets of the replicates + as in which the named uncertain parameters are drawn, if any. + scenario (Mapping[str, Any] | None): The values of fixed values + and uncertain parameters of a scenario (by path), if any. Returns: Design: the realized design + + Raises: + ValueError: if `shift` names a path that is not of an uncertain + parameter of the design space, or `scenario` one that is not + of a fixed value or an uncertain parameter. """ - stream = [seed, replicate] + ([] if common else [int(self.key, 16)]) + shift = dict(shift or {}) + _check_uncertain(self.space, shift) + scenario = dict(scenario or {}) + _check_scenario(self.space, scenario) + tail = [] if common else [int(self.key, 16)] def draw(path: str, node: Uncertain) -> Any: - rng = np.random.default_rng(stream + [zlib.crc32(path.encode())]) + name = _generic(path) + if name in scenario: + return scenario[name] + drawn_in = replicate + int(shift.get(name, 0)) + rng = np.random.default_rng( + [seed, drawn_in, *tail, zlib.crc32(path.encode())] + ) return node.sampler(rng) - values, _ = _walk( - self.space, "", Scope(), _Context(draw=draw, check=False), self.decisions - ) - return Design(self.space, self.decisions, values, replicate) + def fix(path: str, node: Fixed) -> Any: + return scenario.get(_generic(path), node.value) + + ctx = _Context(draw=draw, check=False, fix=fix if scenario else None) + values, _ = _walk(self.space, "", Scope(), ctx, self.decisions) + realized = Design(self.space, self.decisions, values, replicate) + # pylint: disable-next=protected-access + realized._scenario = _describe_scenario(scenario) + return realized def __repr__(self) -> str: replicate = "" if self.replicate is None else f", replicate={self.replicate}" @@ -693,6 +759,20 @@ def unit_paths(self) -> list[str]: """ return _unit_paths(self, "") + def uncertain_paths(self) -> list[str]: + """ + Gets the paths of the uncertain parameters of the design space (see + `Uncertain`), in the order they are drawn, with `[*]` for the index + of any item of a repetition (so that the phases of every plane of a + constellation are one path, such as `planes[*].phase`), and with + the branches of choices (such as `layout.walker.phase_fraction`), + whether a design chooses them or not. + + Returns: + list[str]: the paths + """ + return _uncertain_paths(self, "") + def decode(self, unit: Sequence[float]) -> Design: """ Decodes a design from a point of the unit hypercube (a value in @@ -793,3 +873,99 @@ def _unit_paths(node: Node, path: str) -> list[str]: p for k in range(largest) for p in _unit_paths(node.item, f"{path}[{k}]") ] return [] + + +def _fixed_paths(node: Node, path: str) -> list[str]: + """ + Gets the paths of the fixed values of a node, with `[*]` for the index of + any item of a repetition (as `_uncertain_paths`). + """ + if isinstance(node, Fixed): + return [path] + if isinstance(node, DesignSpace): + return [ + p + for name, child in node.children.items() + for p in _fixed_paths(child, _join(path, name)) + ] + if isinstance(node, Choice): + return [ + p + for name, branch in node.branches.items() + for p in _fixed_paths(branch, _join(path, name)) + ] + if isinstance(node, Repeat): + return _fixed_paths(node.item, f"{path}[*]") + return [] + + +def _check_scenario(space: DesignSpace, values: Mapping[str, Any]) -> None: + """ + Checks that the values of a scenario are of fixed values or uncertain + parameters of a design space (by path), raising a `ValueError` if not. + """ + if not values: + return + known = [*_fixed_paths(space, ""), *space.uncertain_paths()] + unknown = sorted(set(values) - set(known)) + if unknown: + raise ValueError( + "not fixed values or uncertain parameters of the design space: " + + f"{unknown} (it has {known})" + ) + + +def _describe_scenario(values: Mapping[str, Any]) -> str: + """ + Gets a description of the values of a scenario (`""` without values), + which identifies them (by their content, see `get_definition`). + """ + if not values: + return "" + described = _Describer().describe(dict(values)) + return json.dumps(described, sort_keys=True, default=str) + + +def _scenario_of(design: Design) -> str: + """ + Gets the description of the values of the scenario of a realized design + (see `Design.realize`), `""` without one. + """ + return getattr(design, "_scenario", "") + + +def _check_uncertain(space: DesignSpace, paths: Iterable[str]) -> None: + """ + Checks that paths are of uncertain parameters of a design space (see + `DesignSpace.uncertain_paths`), raising a `ValueError` if not. + """ + known = space.uncertain_paths() + unknown = sorted(set(paths) - set(known)) + if unknown: + raise ValueError( + f"not uncertain parameters of the design space: {unknown} (it has {known})" + ) + + +def _uncertain_paths(node: Node, path: str) -> list[str]: + """ + Gets the paths of the uncertain parameters of a node (see + `DesignSpace.uncertain_paths`). + """ + if isinstance(node, Uncertain): + return [path] + if isinstance(node, DesignSpace): + return [ + p + for name, child in node.children.items() + for p in _uncertain_paths(child, _join(path, name)) + ] + if isinstance(node, Choice): + return [ + p + for name, branch in node.branches.items() + for p in _uncertain_paths(branch, _join(path, name)) + ] + if isinstance(node, Repeat): + return _uncertain_paths(node.item, f"{path}[*]") + return [] diff --git a/src/tatc/tradespace/store.py b/src/tatc/tradespace/store.py index f8f226f3..bb830bec 100644 --- a/src/tatc/tradespace/store.py +++ b/src/tatc/tradespace/store.py @@ -8,53 +8,162 @@ from __future__ import annotations +import base64 +import json +import math import os import pickle import sqlite3 -from collections.abc import Iterable +from collections.abc import Callable, Iterable from contextlib import closing +from datetime import date, datetime, time, timedelta, timezone from pathlib import Path +from typing import Any + +import numpy as np + +_RESULTS_TABLE = ( + "CREATE TABLE IF NOT EXISTS results (namespace TEXT, context TEXT, " + + "design TEXT, replicate INTEGER, variant TEXT, records TEXT, " + + "PRIMARY KEY (namespace, context, design, replicate, variant))" +) +"""The table of the records of evaluations.""" + +_JSON = (bool, int, str) +"""Types whose values are kept as they are in JSON (exactly these types).""" + + +def _encode(value: Any) -> Any: + """ + Encodes a value as JSON data: plain values as they are, and others + tagged (as `{"$tag": data}`), so that they are decoded exactly (numpy + scalars as Python's), or pickled if JSON cannot hold them. + """ + # pylint: disable=too-many-return-statements + kind = type(value) + if value is None or kind in _JSON: + return value + if kind is float: + return value if math.isfinite(value) else {"$float": repr(value)} + if isinstance(value, np.generic): + item = value.item() + if type(item) in (*_JSON, float): + return _encode(item) + elif kind is list: + return [_encode(item) for item in value] + elif kind is tuple: + return {"$tuple": [_encode(item) for item in value]} + elif kind is dict: + if all(type(key) is str and not key.startswith("$") for key in value): + return {key: _encode(item) for key, item in value.items()} + return {"$dict": [[_encode(k), _encode(v)] for k, v in value.items()]} + elif kind is datetime and value.tzinfo in (None, timezone.utc): + return {"$datetime": value.isoformat()} + elif kind is date: + return {"$date": value.isoformat()} + elif kind is time and value.tzinfo is None: + return {"$time": value.isoformat()} + elif kind is timedelta: + return {"$timedelta": [value.days, value.seconds, value.microseconds]} + return {"$pickle": base64.b64encode(pickle.dumps(value)).decode("ascii")} + + +_DECODERS: dict[str, Callable[[Any], Any]] = { + "$float": float, + "$tuple": lambda items: tuple(_decode(item) for item in items), + "$dict": lambda pairs: {_decode(k): _decode(v) for k, v in pairs}, + "$datetime": datetime.fromisoformat, + "$date": date.fromisoformat, + "$time": time.fromisoformat, + "$timedelta": lambda parts: timedelta(*parts), + "$pickle": lambda text: pickle.loads(base64.b64decode(text)), +} + + +def _decode(value: Any) -> Any: + """Decodes a value from JSON data (see `_encode`).""" + if isinstance(value, list): + return [_decode(item) for item in value] + if isinstance(value, dict): + if len(value) == 1: + tag, data = next(iter(value.items())) + if tag in _DECODERS: + return _DECODERS[tag](data) + return {key: _decode(item) for key, item in value.items()} + return value class ResultStore: """ A store of the records of the evaluations of a study (see `Study.run`), - by the key of each design and its replicate, in a SQLite database file. + by the key of each design, its replicate, and the variant of the + replicate (`""`, or the parameters drawn as in other replicates, see + `Study.run`), in a SQLite database file. Records are also keyed by a `context`: a study gives its fingerprint (see `Study.fingerprint`), which changes with its seed, its use of common random numbers, the definitions of its design space and its build and evaluation functions (their code, and the plain values they refer - to), and the version and source of TAT-C, so that records computed with other - definitions are not reused. The `namespace` identifies what a - fingerprint cannot see: the data the functions use (such as the targets - of the analysis) and the code of other modules they call. Change it - whenever these change. Several studies may share a file, in their own - namespaces. + to), and the source of the modules of TAT-C they depend on, so that + records computed with other definitions are not reused. The store keeps + the definition of each context (see `define`), from which a study + explains why it does not reuse records (see `compare_definitions`). A + fingerprint describes the data that the functions are given (such as + data frames of targets they close over or refer to, by their content), + but not data that they read (such as from files) nor the code of other + modules they call (other than TAT-C's): a `namespace` identifies these, + and must change whenever they do. Several studies may share a file, in + their own namespaces. + + Records are kept as JSON (in the column `records` of the table `results`, + a list of records per evaluation), which other tools can read: numbers + (numpy's as Python's), strings, and booleans as they are, and other + values (such as infinite numbers, dates and times, and tuples) tagged, + as `{"$tag": data}`, so that they are read exactly as they were written + (or pickled, as `{"$pickle": data}`, if JSON cannot hold them). Args: path (str | os.PathLike): The database file (created if needed). - namespace (str): An identifier of the study. + namespace (str): An identifier of the study (and of what its + fingerprint cannot see). """ - def __init__(self, path: str | os.PathLike, namespace: str): - if not namespace: - raise ValueError("a store requires a namespace") + def __init__(self, path: str | os.PathLike, namespace: str = ""): self.path, self.namespace = Path(path), namespace self.path.parent.mkdir(parents=True, exist_ok=True) with closing(self._connect()) as connection: - with connection: + connection.isolation_level = None + connection.execute("BEGIN IMMEDIATE") + try: + columns = { + row[1] for row in connection.execute("PRAGMA table_info(results)") + } + if columns and "variant" not in columns: + # evaluations stored before replicates had variants are of + # plain replicates + connection.execute("ALTER TABLE results RENAME TO _invariant") + connection.execute(_RESULTS_TABLE) + connection.execute( + "INSERT INTO results SELECT namespace, context, design, " + + "replicate, '', records FROM _invariant" + ) + connection.execute("DROP TABLE _invariant") + connection.execute(_RESULTS_TABLE) connection.execute( - "CREATE TABLE IF NOT EXISTS evaluations (namespace TEXT, " - + "context TEXT, design TEXT, replicate INTEGER, records BLOB, " - + "PRIMARY KEY (namespace, context, design, replicate))" + "CREATE TABLE IF NOT EXISTS definitions (namespace TEXT, " + + "context TEXT, definition TEXT, defined TEXT, " + + "PRIMARY KEY (namespace, context))" ) + connection.execute("COMMIT") + except BaseException: + connection.execute("ROLLBACK") + raise def _connect(self) -> sqlite3.Connection: return sqlite3.connect(self.path, timeout=60) def get( - self, keys: Iterable[tuple[str, int]], context: str = "" + self, keys: Iterable[tuple[str, int]], context: str = "", variant: str = "" ) -> dict[tuple[str, int], list[dict]]: """ Gets the stored records of evaluations. @@ -64,6 +173,8 @@ def get( design and its replicate. context (str): The context of the evaluations (such as the fingerprint of a study). + variant (str): The variant of the replicates (`""` for plain + replicates). Returns: dict: the records of each stored evaluation (others are omitted) @@ -76,18 +187,22 @@ def get( designs = sorted({design for design, _ in part}) marks = ",".join("?" * len(designs)) rows = connection.execute( - "SELECT design, replicate, records FROM evaluations " - + f"WHERE namespace = ? AND context = ? AND design IN ({marks})", - [self.namespace, context, *designs], + "SELECT design, replicate, records FROM results WHERE " + + "namespace = ? AND context = ? AND variant = ? " + + f"AND design IN ({marks})", + [self.namespace, context, variant, *designs], ).fetchall() wanted = set(part) - for design, replicate, blob in rows: + for design, replicate, text in rows: if (design, replicate) in wanted: - found[design, replicate] = pickle.loads(blob) + found[design, replicate] = _decode(json.loads(text)) return found def put( - self, items: Iterable[tuple[str, int, list[dict]]], context: str = "" + self, + items: Iterable[tuple[str, int, list[dict]]], + context: str = "", + variant: str = "", ) -> None: """ Stores the records of evaluations, replacing any stored before. @@ -97,30 +212,81 @@ def put( key of a design, its replicate, and its records. context (str): The context of the evaluations (such as the fingerprint of a study). + variant (str): The variant of the replicates (`""` for plain + replicates). """ rows = [ - (self.namespace, context, design, int(replicate), pickle.dumps(records)) + ( + self.namespace, + context, + design, + int(replicate), + variant, + json.dumps(_encode(records), allow_nan=False), + ) for design, replicate, records in items ] if rows: with closing(self._connect()) as connection: with connection: connection.executemany( - "INSERT OR REPLACE INTO evaluations VALUES (?, ?, ?, ?, ?)", + "INSERT OR REPLACE INTO results VALUES (?, ?, ?, ?, ?, ?)", rows, ) + def define(self, context: str, definition: dict) -> None: + """ + Keeps the definition of a context (such as that of a study, see + `Study.definition`), if it is not kept already. + + Args: + context (str): The context (such as the fingerprint of a study). + definition (dict): Its definition (see `get_definition`). + """ + defined = datetime.now(timezone.utc).isoformat(timespec="seconds") + with closing(self._connect()) as connection: + with connection: + connection.execute( + "INSERT OR IGNORE INTO definitions VALUES (?, ?, ?, ?)", + [ + self.namespace, + context, + json.dumps(definition, sort_keys=True, default=str), + defined, + ], + ) + + def definition(self, context: str) -> dict | None: + """ + Gets the definition of a context (see `define`). + + Args: + context (str): The context. + + Returns: + dict | None: the definition, or `None` if it is not kept + """ + with closing(self._connect()) as connection: + row = connection.execute( + "SELECT definition FROM definitions WHERE namespace = ? AND context = ?", + [self.namespace, context], + ).fetchone() + return None if row is None else json.loads(row[0]) + def contexts(self) -> dict[str, int]: """ - Gets the contexts of the namespace's stored evaluations. + Gets the contexts of the namespace's stored evaluations, in the order + they were defined (see `define`; those not defined first). Returns: dict[str, int]: the number of evaluations of each context """ with closing(self._connect()) as connection: rows = connection.execute( - "SELECT context, COUNT(*) FROM evaluations WHERE namespace = ? " - + "GROUP BY context", + "SELECT r.context, COUNT(*) FROM results AS r LEFT JOIN definitions " + + "AS d ON d.namespace = r.namespace AND d.context = r.context " + + "WHERE r.namespace = ? GROUP BY r.context " + + "ORDER BY MIN(d.defined), MIN(d.rowid), r.context", [self.namespace], ).fetchall() return dict(rows) @@ -128,15 +294,41 @@ def contexts(self) -> dict[str, int]: def __len__(self) -> int: return sum(self.contexts().values()) - def clear(self) -> None: + def prune(self, keep: str) -> int: """ - Removes the stored records of the namespace (of every context). + Removes the stored records (and definitions) of the namespace's other + contexts, such as those of earlier definitions of a study (keeping + those of its fingerprint, see `Study.fingerprint`). + + Args: + keep (str): The context to keep. + + Returns: + int: the number of evaluations removed """ with closing(self._connect()) as connection: with connection: + removed = connection.execute( + "DELETE FROM results WHERE namespace = ? AND context != ?", + [self.namespace, keep], + ).rowcount connection.execute( - "DELETE FROM evaluations WHERE namespace = ?", [self.namespace] + "DELETE FROM definitions WHERE namespace = ? AND context != ?", + [self.namespace, keep], ) + return removed + + def clear(self) -> None: + """ + Removes the stored records (and definitions) of the namespace (of + every context). + """ + with closing(self._connect()) as connection: + with connection: + for table in ("results", "definitions"): + connection.execute( + f"DELETE FROM {table} WHERE namespace = ?", [self.namespace] + ) def __repr__(self) -> str: return f"ResultStore({str(self.path)!r}, {self.namespace!r}: {len(self)} evaluations)" diff --git a/src/tatc/tradespace/study.py b/src/tatc/tradespace/study.py index 6d26c5c6..1e25ae10 100644 --- a/src/tatc/tradespace/study.py +++ b/src/tatc/tradespace/study.py @@ -7,27 +7,45 @@ from __future__ import annotations +import hashlib +import inspect +import json import math import os import time import warnings -from collections.abc import Callable, Iterable, Sequence +from collections.abc import Callable, Iterable, Mapping, Sequence from concurrent.futures import Executor, as_completed -from typing import Any +from typing import Any, NamedTuple -import numpy as np import pandas as pd +from pydantic import ValidationError -from .fingerprint import get_fingerprint -from .space import Design, DesignSpace +from .fingerprint import _fingerprint_of, compare_definitions, get_definition +from .nodes import Infeasible +from .space import ( + Design, + DesignSpace, + _check_scenario, + _check_uncertain, + _describe_scenario, +) from .store import ResultStore _STATUS_COLUMNS = ["design", "replicate", "feasible", "error", "seconds"] """Columns of the results of a study that are neither design values nor metrics.""" -_FAILED = "_failed" -"""A key of the records of evaluations that failed (with `errors="record"`), which -are not stored.""" +_UNSTORED = "_unstored" +"""A key of the records of evaluations that are not stored: those that failed +(with `errors="record"`) and designs that failed validation, which may be +mistakes in a study's functions that its fingerprint cannot see.""" + + +_WORKER_TIMEOUT = 120 +"""The seconds that an idle worker process waits for evaluations before it +exits: long enough to outlast the pauses of a study between its runs (such +as the bootstrap of each round of `refine`), which would otherwise start new +workers (with a warning of loky's, if evaluations arrive as a worker exits).""" def _get_executor(n_jobs: int) -> Executor: @@ -55,7 +73,9 @@ def _get_executor(n_jobs: int) -> Executor: "NUMBA_NUM_THREADS", ) } - return get_reusable_executor(max_workers=n_jobs, env=threads) + return get_reusable_executor( + max_workers=n_jobs, env=threads, timeout=_WORKER_TIMEOUT + ) class Study: @@ -67,15 +87,55 @@ class Study: `build`, and evaluates the result with `evaluate`, which returns its outcomes: a mapping (or `pandas.Series`) of metrics, or a `pandas.DataFrame` of several records of metrics (such as one per - sensor), whose named index is kept as columns. + sensor), whose named index is kept as columns. An `evaluate` function + with a parameter named `design` is also given the realized design (with + the uncertain parameters of the replicate), as for an evaluation that + depends on values of the design other than those it builds:: + + def build(d): + return build_constellation(d.layout, payload, epoch=START) + + def evaluate(satellites, design): + deployment = SCHEDULE.plan(design.layout) + ... + + A design is recorded as infeasible, with the error, rather than raised, + if `build` or `evaluate` rejects it by raising `Infeasible`, or if + `build` fails the validation of TAT-C's schemas (a pydantic + `ValidationError`, such as of an orbit too high to be sun-synchronous). + Other errors (including other `ValueError`s, which are as likely + mistakes in the functions as properties of designs) are raised, which + stops the study, unless `errors` is `"record"`: then the evaluation is + recorded as infeasible, with the type of the error and its message. + Evaluations that fail and designs that fail validation are not kept in + the study's store, so that a later run evaluates them again (as after + fixing a mistake in code that the study's fingerprint cannot see, see + `fingerprint`). A warning is given if no design of a run (of several) + is feasible. - A design that `build` rejects with a `ValueError` (which includes the - validation errors of TAT-C's schemas) is recorded as infeasible, with - the error, rather than raised. Other errors of `build` or `evaluate` - are raised, which stops the study, unless `errors` is `"record"`: then - the evaluation is recorded as infeasible, with the type of the error and - its message, and is not kept in the study's store, so that a later run - evaluates it again. + The metrics must not be named as the columns of the results that + identify an evaluation (`design`, `replicate`, `feasible`, `error`, and + `seconds`), and a metric named as a value of the design (see + `Design.flat`) must equal it (restating it, as a design variable that is + also an objective): metrics that would replace these columns raise a + `ValueError`, whatever `errors` is. + + A study may evaluate designs in `scenarios`: conditions under which + designs are compared rather than averaged over (as uncertain parameters + are), such as the requirements of a mission or the field it must sample. + A scenario gives fixed values or uncertain parameters of the design space + other values (by path, see `Design.realize`), which the functions read + from the design as any other value (so that they need not change), and + each design is evaluated in each scenario in each replicate (with the + same uncertain parameters in every scenario), recorded with the name of + its scenario (`scenario`, so that the design space may not have a value + of that name). Judge designs in each scenario with criteria `by` the + scenario (see `Criteria`), and across them with `robustness`. Scenarios + are not part of the study's fingerprint: the evaluations of each are + stored by its values (as a variant of the replicates, see + `ResultStore`), so that a scenario added later is evaluated alone, and + one without values shares the evaluations of the study without + scenarios. Evaluations run in parallel with `n_jobs` worker processes (or an `executor` with the interface of `concurrent.futures.Executor`). They are @@ -85,13 +145,18 @@ class Study: parameters (with common random numbers). The functions, and the objects they refer to, are copied to each worker for each chunk, so keep large inputs out of them (for example, load them from files in the workers) if - copying them takes long. + copying them takes long. Each evaluation is added to the study's store + (if any) as it completes, by the worker that evaluates it, so that a run + that is interrupted loses only the evaluations in progress; chunks that + have not begun are then cancelled. Args: space (DesignSpace): The design space. build (Callable): A function of a realized design that builds the object to evaluate (for example, a list of satellites). - evaluate (Callable): A function of a built object that evaluates it. + evaluate (Callable): A function of a built object that evaluates it + (and of the realized design, if it has a parameter named + `design`). replicates (int): The number of replicates of each design. seed (int): The seed of the uncertain parameters. common_random_numbers (bool): `True` to draw the same uncertain @@ -110,7 +175,11 @@ class Study: which evaluations stored before (by a study of the same fingerprint, see `fingerprint`) are taken rather than evaluated again, and to which new ones are added as they complete (see - `ResultStore`). + `ResultStore`), by the workers that evaluate them (so its file + must be reachable from them). + scenarios (Mapping[str, Mapping[str, Any]] | None): The scenarios + in which to evaluate designs, if any: the values of fixed values + and uncertain parameters of each (by path), by name. """ def __init__( @@ -126,6 +195,7 @@ def __init__( chunks_per_job: int = 2, store: ResultStore | None = None, errors: str = "raise", + scenarios: Mapping[str, Mapping[str, Any]] | None = None, ): if errors not in ("raise", "record"): raise ValueError(f"errors must be 'raise' or 'record', not {errors!r}") @@ -142,30 +212,55 @@ def __init__( self.chunks_per_job = chunks_per_job self.store = store self.errors = errors + self.scenarios = _check_scenarios(space, scenarios) def __getstate__(self) -> dict: - # an executor and a store are not sent to workers + # an executor is not sent to workers (which add evaluations to the store) state = self.__dict__.copy() - state["executor"] = state["store"] = None + state["executor"] = None return state - def _evaluate(self, design: Design, replicate: int) -> list[dict]: + def _evaluate( + self, + design: Design, + replicate: int, + shift: Mapping[str, int] | None = None, + case: _Case | None = None, + ) -> list[dict]: """ - Evaluates a replicate of a design, returning its records. + Evaluates a replicate of a design (with parameters drawn as in other + replicates, if shifted, and in a scenario, if any), returning its + records. """ - realized = design.realize(replicate, self.seed, self.common_random_numbers) - base = {"design": design.key, "replicate": replicate, **realized.flat()} + realized = design.realize( + replicate, + self.seed, + self.common_random_numbers, + shift, + None if case is None else case.values, + ) + base: dict = {"design": design.key, "replicate": replicate} + if case is not None and case.name is not None: + base["scenario"] = case.name + base.update(realized.flat()) began = time.perf_counter() try: built = self.build(realized) - except ValueError as error: + except Infeasible as error: return [{**base, "feasible": False, "error": str(error)}] + except ValidationError as error: + return [{**base, "feasible": False, "error": str(error), _UNSTORED: True}] except Exception as error: # pylint: disable=broad-exception-caught if self.errors == "raise": raise return [self._failure(base, error)] try: - outcome = self.evaluate(built) + if _takes_design(self.evaluate): + outcome = self.evaluate(built, design=realized) + else: + outcome = self.evaluate(built) + except Infeasible as error: + return [{**base, "feasible": False, "error": str(error)}] except Exception as error: # pylint: disable=broad-exception-caught if self.errors == "raise": raise @@ -174,8 +269,12 @@ def _evaluate(self, design: Design, replicate: int) -> list[dict]: if isinstance(outcome, pd.DataFrame): named = any(name is not None for name in outcome.index.names) frame = outcome.reset_index() if named else outcome - return [{**base, **record} for record in frame.to_dict("records")] - return [{**base, **dict(outcome)}] + records = frame.to_dict("records") + else: + records = [dict(outcome)] + for record in records: + _check_metrics(record, base) + return [{**base, **record} for record in records] @staticmethod def _failure(base: dict, error: Exception) -> dict: @@ -183,32 +282,89 @@ def _failure(base: dict, error: Exception) -> dict: Gets the record of an evaluation that failed. """ message = f"{type(error).__name__}: {error}" - return {**base, "feasible": False, "error": message, _FAILED: True} + return {**base, "feasible": False, "error": message, _UNSTORED: True} + + def _evaluate_and_store( + self, + design: Design, + replicate: int, + context: str, + shift: Mapping[str, int] | None = None, + case: _Case | None = None, + ) -> list[dict]: + """ + Evaluates a replicate of a design (shifted, if given, and in a + scenario, if any), adding its records to the store (if any, and if + they are stored, see `_UNSTORED`) in a context. + """ + records = self._evaluate(design, replicate, shift, case) + if self.store is not None and not _unstored(records): + variant = _variant_of(shift) if case is None else case.variant + if case is not None and case.name is not None: + # the evaluations of a scenario are stored by its values, not + # its name (which the results give, see `_in_scenario`) + kept = [ + {k: v for k, v in r.items() if k != "scenario"} for r in records + ] + else: + kept = records + self.store.put([(design.key, replicate, kept)], context, variant) + return records + + def _run_chunk( + self, + tasks: list[tuple[int, Design, int, int]], + context: str, + shift: Mapping[str, int] | None, + cases: Sequence[_Case], + ) -> list[list[dict]]: + """ + Evaluates a chunk of tasks (index, design, replicate, and case) in + turn (shifted, if given), adding each to the store (if any) in a + context. + """ + return [ + self._evaluate_and_store(design, replicate, context, shift, cases[case]) + for _, design, replicate, case in tasks + ] - def _run_chunk(self, tasks: list[tuple[int, Design, int]]) -> list[list[dict]]: + def _cases(self, shift: Mapping[str, int]) -> list[_Case]: """ - Evaluates a chunk of tasks (index, design, replicate) in turn. + Gets the cases of a run: its scenarios (or none), and the variants of + their evaluations in a store. """ - return [self._evaluate(design, replicate) for _, design, replicate in tasks] + if not self.scenarios: + return [_Case(None, {}, _variant_of(shift))] + return [ + _Case(name, values, _variant_of(shift, _describe_scenario(values))) + for name, values in self.scenarios.items() + ] + + @property + def definition(self) -> dict: + """dict: The definition of the study (see `get_definition`), which + its fingerprint hashes: its seed, its use of common random numbers, + its design space (including fixed values and the distributions of + uncertain parameters), its build and evaluation functions (their + code, the values they close over, and the plain values and functions + of their module they refer to), and the source of the modules of + TAT-C that these, and studies, depend on.""" + return get_definition( + study=Study, + seed=self.seed, + common_random_numbers=self.common_random_numbers, + space=self.space, + build=self.build, + evaluate=self.evaluate, + ) @property def fingerprint(self) -> str: - """str: A key of the definition of the study, which changes with its - seed, its use of common random numbers, its design space (including - fixed values and the distributions of uncertain parameters), its - build and evaluation functions (their code, the values they close - over, and the plain values and functions of their module they refer - to), and the version and source of TAT-C (see `get_source_hash`). It - keys the records of a store (see + """str: A key of the definition of the study (see `definition`), which + changes if it does. It keys the records of a store (see `ResultStore`); data that it cannot describe (such as data frames) must be identified by the store's namespace.""" - return get_fingerprint( - self.seed, - self.common_random_numbers, - self.space, - self.build, - self.evaluate, - ) + return _fingerprint_of(self.definition) @property def workers(self) -> int: @@ -224,12 +380,24 @@ def run( designs: Iterable[Design] | None = None, progress: Callable[[int, int], None] | None = None, replicates: Iterable[int] | None = None, + shift: Mapping[str, int] | None = None, ) -> pd.DataFrame: """ Evaluates designs in every replicate (or in given replicates, such as additional ones, see `refine`). Repeated designs (with the same key) are evaluated once. + With a `shift`, each replicate draws the named uncertain parameters + as in another replicate (see `Design.realize`): for example, with a + shift of `{"points_seed": 10}`, replicate 3 draws `points_seed` as + replicate 13 does, and its other parameters as replicate 3 does. + Such mixed replicates are kept apart from plain ones in the store + (by their variant, see `ResultStore`), and are recorded with the + replicate they shift (and the values they draw, see `Design.flat`). + + With scenarios (see `Study`), each design is evaluated in each + scenario in each replicate. + Args: designs (Iterable[Design] | None): The designs, or `None` for every design of the design space (see @@ -240,62 +408,68 @@ def run( replicates (Iterable[int] | None): The replicates (their indices, which seed their uncertain parameters), or `None` for the study's (`range(replicates)`). + shift (Mapping[str, int] | None): The offsets of the replicates as + in which the named uncertain parameters are drawn (by their + paths, see `DesignSpace.uncertain_paths`), if any. Returns: pandas.DataFrame: The outcomes, a record per evaluation (or per - record of an evaluation), in the order of the designs and - replicates, with the design's key (`design`), the - `replicate`, the values of the design by path (see - `Design.flat`), whether it is `feasible` (and the `error` if - not), the time to build and evaluate it (`seconds`), and the - metrics. + record of an evaluation), in the order of the designs (and + scenarios) and replicates, with the design's key (`design`), + the `replicate` (and the `scenario`, with scenarios), the + values of the design by path (see `Design.flat`), whether it + is `feasible` (and the `error` if not), the time to build and + evaluate it (`seconds`), and the metrics. """ + shift = {name: int(offset) for name, offset in (shift or {}).items() if offset} + _check_uncertain(self.space, shift) + cases = self._cases(shift) designs = self.space.enumerate() if designs is None else designs unique = list({design.key: design for design in designs}.values()) - # tasks in the order of replicates, whose designs share uncertain values + # tasks in the order of replicates (and scenarios), whose designs share + # uncertain values tasks = [ - (i, design, replicate) + (i, design, replicate, case) for replicate in ( range(self.replicates) if replicates is None else sorted(set(replicates)) ) + for case in range(len(cases)) for i, design in enumerate(unique) ] - results: list[tuple[int, int, list[dict]]] = [] + results: list[tuple[int, int, int, list[dict]]] = [] context = "" if self.store is not None: # evaluations stored before (by an interrupted or earlier run) - context = self.fingerprint - stored = self.store.get( - ((d.key, replicate) for _, d, replicate in tasks), context - ) - others = { - other: count - for other, count in self.store.contexts().items() - if other != context - } - if tasks and not stored and others: - warnings.warn( - f"the store has {sum(others.values())} evaluations of namespace " - + f"{self.store.namespace!r} by studies of other definitions " - + "(seed, design space, functions, or version or source of TAT-C), " - + "which are not reused (see Study.fingerprint)", - stacklevel=2, + definition = self.definition + context = _fingerprint_of(definition) + stored = {} + for k, case in enumerate(cases): + found = self.store.get( + ((d.key, r) for _, d, r, c in tasks if c == k), + context, + case.variant, + ) + stored.update( + {(key, r, k): records for (key, r), records in found.items()} ) + if tasks and not stored: + _warn_other_definitions(self.store, context, definition) + self.store.define(context, definition) results.extend( - (i, replicate, stored[design.key, replicate]) - for i, design, replicate in tasks - if (design.key, replicate) in stored + (i, case, replicate, stored[design.key, replicate, case]) + for i, design, replicate, case in tasks + if (design.key, replicate, case) in stored ) - tasks = [t for t in tasks if (t[1].key, t[2]) not in stored] + tasks = [t for t in tasks if (t[1].key, t[2], t[3]) not in stored] total = len(tasks) if self.executor is None and self.n_jobs == 1: - for done, (i, design, replicate) in enumerate(tasks, 1): - records = self._evaluate(design, replicate) - results.append((i, replicate, records)) - if self.store is not None and not _failed(records): - self.store.put([(design.key, replicate, records)], context) + for done, (i, design, replicate, case) in enumerate(tasks, 1): + records = self._evaluate_and_store( + design, replicate, context, shift, cases[case] + ) + results.append((i, case, replicate, records)) if progress is not None: progress(done, total) elif tasks: @@ -304,94 +478,198 @@ def run( size = math.ceil(total / max(n_chunks, 1)) chunks = [tasks[k : k + size] for k in range(0, total, size)] futures = { - executor.submit(self._run_chunk, chunk): chunk for chunk in chunks + executor.submit(self._run_chunk, chunk, context, shift, cases): chunk + for chunk in chunks } done = 0 - for future in as_completed(futures): - chunk = futures[future] - evaluated = future.result() - for (i, _, replicate), records in zip(chunk, evaluated): - results.append((i, replicate, records)) - if self.store is not None: - self.store.put( - ( - (design.key, replicate, records) - for (_, design, replicate), records in zip(chunk, evaluated) - if not _failed(records) - ), - context, - ) - done += len(chunk) - if progress is not None: - progress(done, total) - results.sort(key=lambda result: (result[0], result[1])) - return pd.DataFrame.from_records( + try: + for future in as_completed(futures): + chunk = futures[future] + evaluated = future.result() + for (i, _, replicate, case), records in zip(chunk, evaluated): + results.append((i, case, replicate, records)) + done += len(chunk) + if progress is not None: + progress(done, total) + except BaseException: + # interrupted (or an error): chunks that have not begun are + # cancelled, and those in progress add their evaluations to + # the store as they complete + for future in futures: + future.cancel() + raise + results.sort(key=lambda result: result[:3]) + frame = pd.DataFrame.from_records( [ - {k: v for k, v in record.items() if k != _FAILED} - for _, _, records in results + _in_scenario(record, cases[case].name) + for _, case, _, records in results for record in records ] ) + _check_feasible(frame) + return frame -def _failed(records: list[dict]) -> bool: +def _in_scenario(record: dict, name: str | None) -> dict: """ - Whether the records are of an evaluation that failed. + Gets a record of an evaluation for the results of a run: without the + marker of unstored records (see `_UNSTORED`), and with the name of its + scenario (if any) after its replicate (as records of a scenario are + stored without it). """ - return any(record.get(_FAILED, False) for record in records) + items = [(k, v) for k, v in record.items() if k != _UNSTORED] + if name is None: + return dict(items) + items = [(k, v) for k, v in items if k != "scenario"] + return dict([*items[:2], ("scenario", name), *items[2:]]) -def summarize( - results: pd.DataFrame, - metrics: Sequence[str], - by: Sequence[str] = (), - design_columns: Sequence[str] | None = None, -) -> pd.DataFrame: +class _Case(NamedTuple): + """ + A scenario of a run (or none, without scenarios): its name, its values, + and the variant of its evaluations in a store (see `_variant_of`). """ - Summarizes the metrics of the feasible results of a study over their - replicates: for each design (and each group of the columns `by`, such as - a sensor), the mean of each metric, its standard deviation (` - std`) and standard error (` sem`) between replicates, and the - number of replicates (`replicates`), with the values of the design. - Args: - results (pandas.DataFrame): The results (see `Study.run`). - metrics (Sequence[str]): The columns of the metrics. - by (Sequence[str]): Other columns that group records of an - evaluation. - design_columns (Sequence[str] | None): The columns of the values of - designs, or `None` for those that are the same in every - replicate of a design (except the metrics). - - Returns: - pandas.DataFrame: the summary, a row per design (and group) + name: str | None + values: Mapping[str, Any] + variant: str + + +def _check_scenarios( + space: DesignSpace, scenarios: Mapping[str, Mapping[str, Any]] | None +) -> dict[str, dict[str, Any]] | None: """ - feasible = results[results["feasible"]] if "feasible" in results else results - keys = ["design", *by] - if design_columns is None: - excluded = set(_STATUS_COLUMNS) | set(metrics) | set(by) - candidates = [column for column in feasible.columns if column not in excluded] - constant = feasible.groupby("design")[candidates].nunique(dropna=False) - design_columns = [ - column for column in candidates if (constant[column] <= 1).all() - ] - # metrics (such as a number of satellites) may also be values of designs - design_columns = [ - column - for column in design_columns - if column not in metrics and column not in by + Checks the scenarios of a study (see `Study`), returning them as plain + mappings (or `None` without scenarios). + """ + if not scenarios: + return None + if not isinstance(scenarios, Mapping): + raise TypeError("scenarios must be a mapping of names to values") + if "scenario" in space.children: + raise ValueError( + "a design space with a value named 'scenario' cannot have scenarios, " + + "whose names the results give as `scenario`" + ) + checked = {} + for name, values in scenarios.items(): + if not isinstance(name, str): + raise TypeError(f"the name of a scenario must be a string, not {name!r}") + if not isinstance(values, Mapping): + raise TypeError(f"the values of scenario {name!r} must be a mapping") + _check_scenario(space, values) + checked[name] = dict(values) + return checked + + +def _variant_of(shift: Mapping[str, int] | None, scenario: str = "") -> str: + """ + Gets the variant of replicates in a store (see `ResultStore`): `""` for + plain replicates, or (as JSON) a hash of the description of the values of + a scenario (see `_describe_scenario`) and the shift of each parameter. + """ + shift = {name: int(offset) for name, offset in (shift or {}).items() if offset} + parts: dict[str, Any] = {} + if scenario: + parts["scenario"] = hashlib.sha1(scenario.encode()).hexdigest()[:16] + if shift: + parts["shift"] = shift + return json.dumps(parts, sort_keys=True) if parts else "" + + +def _takes_design(function: Callable) -> bool: + """ + Whether a function has a parameter named `design`, which a study gives + the realized design (see `Study`). + """ + try: + parameter = inspect.signature(function).parameters.get("design") + except (TypeError, ValueError): # such as of some built-in functions + return False + return parameter is not None and parameter.kind in ( + inspect.Parameter.POSITIONAL_OR_KEYWORD, + inspect.Parameter.KEYWORD_ONLY, + ) + + +def _warn_other_definitions(store: ResultStore, context: str, definition: dict) -> None: + """ + Warns if a store has evaluations of its namespace by studies of other + definitions (which a study does not reuse), with the differences from + the definition of the latest (see `compare_definitions`). + """ + others = { + other: count for other, count in store.contexts().items() if other != context + } + if not others: + return + message = ( + f"the store has {sum(others.values())} evaluations of namespace " + + f"{store.namespace!r} by studies of other definitions, which are not " + + "reused (see Study.fingerprint)" + ) + for other in reversed(list(others)): + before = store.definition(other) + if before is not None: + differences = compare_definitions(before, definition) + message += "; the latest differs in: " + "; ".join(differences) + break + warnings.warn(message, stacklevel=3) + + +def _unstored(records: list[dict]) -> bool: + """ + Whether the records are of an evaluation that is not stored (see + `_UNSTORED`). + """ + return any(record.get(_UNSTORED, False) for record in records) + + +def _same(value: Any, other: Any) -> bool: + """ + Whether two values are equal (`NaN` equal to `NaN`). + """ + try: + # pylint: disable-next=comparison-with-itself + return bool(value == other) or bool(value != value and other != other) + except (TypeError, ValueError): # such as arrays + return False + + +def _check_metrics(metrics: dict, base: dict) -> None: + """ + Checks that the metrics of a record do not replace the columns of the + results of a study: they must not be named as its status columns, and + a metric named as a value of the design (a key of `base`) must equal it. + """ + clashes = [ + str(name) + for name, value in metrics.items() + if name in _STATUS_COLUMNS or (name in base and not _same(value, base[name])) ] - grouped = feasible.groupby(keys, sort=False) - summary = grouped[list(design_columns)].first() if design_columns else None - statistics = grouped[list(metrics)].agg(["mean", "std", "count"]) - columns = {} - for metric in metrics: - count = statistics[(metric, "count")] - columns[metric] = statistics[(metric, "mean")] - columns[f"{metric} std"] = statistics[(metric, "std")] - columns[f"{metric} sem"] = statistics[(metric, "std")] / np.sqrt(count) - columns["replicates"] = grouped["replicate"].nunique() - frame = pd.DataFrame(columns) - if summary is not None: - frame = summary.join(frame) - return frame.reset_index() + if clashes: + raise ValueError( + f"metrics named as columns of the results of a study: {sorted(clashes)}; " + + f"rename them (the results have the columns {_STATUS_COLUMNS}, and " + + "the values of each design, see Design.flat, which a metric of the " + + "same name must equal)" + ) + + +def _check_feasible(results: pd.DataFrame) -> None: + """ + Warns if none of several designs of the results of a study is feasible, + which is as likely a mistake in the study's functions as a property of + its designs. + """ + if len(results) == 0 or results["feasible"].any(): + return + designs = results["design"].nunique() + if designs < 2: + return + errors = results["error"].value_counts() + warnings.warn( + f"none of the {designs} designs is feasible; the most common error " + + f"({errors.iloc[0]} of {len(results)} evaluations): {errors.index[0]}", + stacklevel=3, + ) diff --git a/tests/tradespace/test_cache.py b/tests/tradespace/test_cache.py index d3849937..431dc632 100644 --- a/tests/tradespace/test_cache.py +++ b/tests/tradespace/test_cache.py @@ -7,6 +7,7 @@ import pickle import tempfile import unittest +import warnings from datetime import datetime, timedelta, timezone from pathlib import Path @@ -100,8 +101,6 @@ def test_hits_and_relabeling(self): def test_disk_cache(self): """Results on disk are shared by caches of the same namespace.""" with tempfile.TemporaryDirectory() as directory: - with self.assertRaises(ValueError): - SatelliteCache(self.analysis, directory=directory) SatelliteCache(self.analysis, directory, namespace="x")(_satellite("a")) again = SatelliteCache(self.analysis, directory, namespace="x") self.assertEqual(list(again(_satellite("b")).satellite), ["b", "b"]) @@ -113,28 +112,73 @@ def test_disk_cache(self): def test_disk_cache_of_other_functions(self): """Results on disk are not shared by functions of other definitions.""" + + def make(rows): + return SatelliteCache( + lambda satellite, rows=rows: pd.DataFrame( + {"satellite": [satellite.name] * rows} + ), + directory, + namespace="x", + ) + with tempfile.TemporaryDirectory() as directory: - for rows in (1, 1, 2): - cache = SatelliteCache( - lambda satellite, rows=rows: pd.DataFrame( - {"satellite": [satellite.name] * rows} - ), - directory, - namespace="x", - ) - self.assertEqual(len(cache(_satellite("a"))), rows) - self.assertEqual(len(list(Path(directory).iterdir())), 2) + for rows in (1, 1): + self.assertEqual(len(make(rows)(_satellite("a"))), rows) + # a namespace with results only of other definitions warns + with self.assertWarnsRegex( + UserWarning, r"1 results.*defaults\[0\]: 1 -> 2" + ): + cache = make(2) + # once, of the caches of the definition (such as of parallel workers) + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always") + make(2) + self.assertEqual(caught, []) + self.assertEqual(len(cache(_satellite("a"))), 2) + namespaces = list(Path(directory).iterdir()) + self.assertEqual(len(namespaces), 1) + self.assertEqual((namespaces[0] / "namespace.txt").read_text(), "x") + folders = [p for p in namespaces[0].iterdir() if p.is_dir()] + self.assertEqual(len(folders), 2) + self.assertTrue(all((p / "definition.json").exists() for p in folders)) + # results of other definitions are removed + self.assertEqual(cache.prune(), 1) + self.assertEqual(len([p for p in namespaces[0].iterdir() if p.is_dir()]), 1) + self.assertEqual(SatelliteCache(_name).prune(), 0) # in memory + + def test_disk_cache_of_other_data(self): + """Results on disk are keyed by the data the function closes over.""" + + def make(frame): + return SatelliteCache( + lambda satellite: frame.assign(satellite=satellite.name), directory + ) + + with tempfile.TemporaryDirectory() as directory: + make(pd.DataFrame({"value": [1.0]}))(_satellite("a")) + same = make(pd.DataFrame({"value": [1.0]})) + same(_satellite("b")) + self.assertEqual((same.hits, same.misses), (1, 0)) + with self.assertWarns(UserWarning): + other = make(pd.DataFrame({"value": [2.0]})) + self.assertEqual(list(other(_satellite("c")).value), [2.0]) + self.assertEqual(other.misses, 1) def test_unreadable_file(self): - """A result that cannot be read from disk is computed again.""" + """A result that cannot be read from disk is computed again and replaced.""" with tempfile.TemporaryDirectory() as directory: cache = SatelliteCache(self.analysis, directory, namespace="x") cache(_satellite("a")) - for path in Path(directory).iterdir(): + for path in Path(directory).rglob("*.pkl"): path.write_bytes(b"not a pickle") again = SatelliteCache(self.analysis, directory, namespace="x") self.assertEqual(list(again(_satellite("b")).satellite), ["b", "b"]) self.assertEqual(again.misses, 1) + # the file is replaced + third = SatelliteCache(self.analysis, directory, namespace="x") + third(_satellite("c")) + self.assertEqual((third.hits, third.misses), (1, 0)) def test_disk_cache_in_parallel(self): """Workers of a study share a cache on disk, storing each result once.""" @@ -150,8 +194,8 @@ def test_disk_cache_in_parallel(self): ) results = study.run() self.assertTrue((results.rows == 2).all()) - files = sorted(p.suffix for p in Path(directory).iterdir()) - self.assertEqual(files, [".pkl"] * 4) + files = sorted(p.suffix for p in Path(directory).rglob("*.*")) + self.assertEqual(files, [".json"] + [".pkl"] * 4 + [".txt"]) def test_pickled_cache_is_empty(self): """Copies of a cache (as sent to workers) start without results.""" diff --git a/tests/tradespace/test_confirmation.py b/tests/tradespace/test_confirmation.py index 81ec2cf0..16a6dd65 100644 --- a/tests/tradespace/test_confirmation.py +++ b/tests/tradespace/test_confirmation.py @@ -9,6 +9,7 @@ import numpy as np from tatc.tradespace import ( + Criteria, DesignSpace, Integer, Probability, @@ -63,7 +64,7 @@ def test_removes_optimism(self): self.assertTrue((confirmation.summary.replicates == 20).all()) # the new replicates follow every replicate of the results self.assertEqual(set(confirmation.results.replicate), set(range(3, 23))) - optimism = confirmation.optimism(OBJECTIVES) + optimism = confirmation.optimism() self.assertAlmostEqual(optimism["cost"], 0) # the 5 best of 50 designs of 3 replicates look better by about a # standard deviation of their means (0.58), which the new ones remove @@ -88,9 +89,11 @@ def test_requirements(self): self.study, self.selected, self.results, - OBJECTIVES, - statistics={"reliability": Probability("value", ">=", 1.5)}, - requirements=[Requirement("reliability", ">=", 0.5)], + Criteria( + OBJECTIVES, + statistics={"reliability": Probability("value", ">=", 1.5)}, + requirements=[Requirement("reliability", ">=", 0.5)], + ), ) summary = confirmation.summary self.assertIn("reliability selected", summary.columns) diff --git a/tests/tradespace/test_criteria.py b/tests/tradespace/test_criteria.py index 43ff82c1..b8427628 100644 --- a/tests/tradespace/test_criteria.py +++ b/tests/tradespace/test_criteria.py @@ -11,6 +11,7 @@ import pandas as pd from tatc.tradespace import ( + Criteria, DesignSpace, Integer, Maximum, @@ -20,11 +21,14 @@ Quantile, Requirement, StandardDeviation, + StandardError, Study, Uncertain, aggregate, + pareto_front, pareto_probability, screen, + summarize, ) VALUES = np.array( @@ -46,6 +50,9 @@ def test_reductions(self): np.testing.assert_allclose( StandardDeviation("x").reduce(VALUES), [1, np.nan, np.nan] ) + np.testing.assert_allclose( + StandardError("x").reduce(VALUES), [1 / np.sqrt(3), np.nan, np.nan] + ) np.testing.assert_allclose( Probability("x", ">=", 2).reduce(VALUES), [2 / 3, 1, np.nan] ) @@ -74,6 +81,15 @@ def test_invalid(self): Probability("x", "==", 1) with self.assertRaises(ValueError): Requirement("x", "!=", 1) + with self.assertRaises(ValueError): + Requirement("x", ">=", 1, scale=0) + + def test_equality(self): + """Statistics of the same kind and parameters are equal.""" + self.assertEqual(Quantile("x", 0.2), Quantile("x", 0.2)) + self.assertNotEqual(Quantile("x", 0.2), Quantile("x", 0.3)) + self.assertNotEqual(Mean("x"), Maximum("x")) + self.assertEqual(len({Mean("x"), Mean("x"), Mean("y")}), 2) class TestRequirement(unittest.TestCase): @@ -82,18 +98,31 @@ class TestRequirement(unittest.TestCase): """ def test_violation(self): - """Violations are the gaps to the required values.""" + """Violations are the gaps to the required values, relative to them.""" statistic = np.array([5.0, 10.0, 12.0, np.nan]) np.testing.assert_allclose( - Requirement("x", ">=", 10).violation(statistic), [5, 0, 0, np.nan] + Requirement("x", ">=", 10).violation(statistic), [0.5, 0, 0, np.nan] ) np.testing.assert_allclose( - Requirement("x", "<=", 10).violation(statistic), [0, 0, 2, np.nan] + Requirement("x", "<=", 10).violation(statistic), [0, 0, 0.2, np.nan] ) strict = Requirement("x", ">", 10).violation(statistic) self.assertGreater(strict[1], 0) self.assertEqual(strict[2], 0) + def test_scale(self): + """Violations are relative to a scale: given, or 1 for a value of 0.""" + statistic = np.array([5.0, 12.0]) + np.testing.assert_allclose( + Requirement("x", ">=", 10, scale=1).violation(statistic), [5, 0] + ) + np.testing.assert_allclose( + Requirement("x", "<=", 0).violation(statistic), [5, 12] + ) + np.testing.assert_allclose( + Requirement("x", "<=", -10).violation(statistic), [1.5, 2.2] + ) + def _results(): """Results of three designs in four replicates.""" @@ -119,29 +148,109 @@ class TestAggregate(unittest.TestCase): Unit tests for aggregating results. """ - def test_statistics_and_requirements(self): - """Statistics, violations, and design values are aggregated.""" + def test_statistics(self): + """Statistics and design values are aggregated, without violations.""" frame = aggregate( _results(), {"value": "value", "value p25": Quantile("value", 0.25), "cost": "cost"}, - [Requirement("value p25", ">=", 5), Requirement("cost", "<=", 1.5)], ).set_index("design") self.assertEqual(frame.loc["a", "value"], 13) self.assertAlmostEqual(frame.loc["b", "value p25"], 5) - self.assertEqual(frame.loc["a", "violation"], 0.5) - self.assertEqual(frame.loc["c", "violation"], 4) - self.assertEqual(list(frame.meets_requirements), [False, False, False]) self.assertEqual(frame.loc["c", "size"], "large") self.assertTrue((frame.replicates == 4).all()) + self.assertNotIn("violation", frame.columns) + self.assertEqual(list(aggregate(_results(), ["value"]).value), [13, 17.5, 1]) + + def test_criteria(self): + """Criteria add the violations of their requirements, relative to them.""" + criteria = Criteria( + {"cost": "min", "value": "max"}, + statistics={"value p25": Quantile("value", 0.25)}, + requirements=[ + Requirement("value p25", ">=", 5), + Requirement("cost", "<=", 1.5), + ], + ) + frame = aggregate(_results(), criteria).set_index("design") + self.assertEqual( + list(frame.columns[-6:-2]), ["cost", "value", "value p25", "replicates"] + ) + self.assertAlmostEqual(frame.loc["a", "violation"], 0.5 / 1.5) + self.assertAlmostEqual(frame.loc["c", "violation"], 4 / 5) + self.assertEqual(list(frame.meets_requirements), [False, False, False]) + with self.assertRaises(ValueError): + aggregate(_results(), criteria, by=["size"]) - def test_metric_names(self): - """Metrics given as names are their means, and requirements add theirs.""" - frame = aggregate(_results(), ["value"], [Requirement("cost", "<=", 1)]) + def test_requirement_on_metric(self): + """A requirement on a metric is on its mean.""" + criteria = Criteria( + {"value": "max"}, requirements=[Requirement("cost", "<=", 1)] + ) + frame = aggregate(_results(), criteria) self.assertIn("cost", frame.columns) self.assertEqual(list(frame.meets_requirements), [False, False, True]) # a requirement on a metric that the results do not have + missing = Criteria({"value": "max"}, requirements=[Requirement("w", ">=", 1)]) with self.assertRaises(ValueError): - aggregate(_results(), {"v": Mean("value")}, [Requirement("w", ">=", 1)]) + aggregate(_results(), missing) + + +class TestCriteria(unittest.TestCase): + """ + Unit tests for criteria. + """ + + def test_names(self): + """Names are those of objectives, requirements, and other statistics.""" + criteria = Criteria( + {"a": "min", "b": "max"}, + statistics={"c": Mean("x"), "b": "y"}, + requirements=[Requirement("c", ">=", 1), Requirement("a", "<=", 2)], + by="sensor", + ) + self.assertEqual(criteria.names, ["a", "b", "c"]) + self.assertEqual(criteria.metrics, ["a", "x", "y"]) + self.assertEqual(criteria.statistic("a"), Mean("a")) + self.assertEqual(criteria.statistic("b"), Mean("y")) + self.assertEqual(criteria.by, ("sensor",)) + + def test_invalid(self): + """Objectives, statistics, requirements, and tolerances are checked.""" + with self.assertRaises(ValueError): + Criteria({}) + with self.assertRaises(ValueError): + Criteria({"a": "lowest"}) + with self.assertRaises(ValueError): + Criteria({"a": "min"}, tolerance={"b": 1}) + with self.assertRaises(ValueError): + Criteria({"a": "min"}, tolerance={"a": "5"}) + with self.assertRaises(ValueError): + Criteria({"a": "min"}, tolerance={"a": -1}) + with self.assertRaises(TypeError): + Criteria({"a": "min"}, statistics={"b": 1}) + with self.assertRaises(TypeError): + Criteria({"a": "min"}, requirements=[("a", "<=", 1)]) + with self.assertRaises(TypeError): + pareto_front(pd.DataFrame({"a": [1]}), ["a"]) + + def test_shorthand(self): + """A mapping of objectives is the criteria of their means.""" + frame = pd.DataFrame({"cost": [1, 2, 3], "value": [1, 3, 2]}) + objectives = {"cost": "min", "value": "max"} + pd.testing.assert_series_equal( + pareto_front(frame, objectives), pareto_front(frame, Criteria(objectives)) + ) + + def test_records_of_groups(self): + """Several records of an evaluation need the columns that separate them.""" + results = pd.concat([_results().assign(sensor=s) for s in ("x", "y")]) + with self.assertRaisesRegex(ValueError, r"by.*\['sensor'\]"): + aggregate(results, ["value"]) + with self.assertRaisesRegex(ValueError, "sensor"): + pareto_probability(results, {"value": "max"}) + frame = aggregate(results, Criteria({"value": "max"}, by="sensor")) + self.assertEqual(len(frame), 6) + self.assertEqual(len(summarize(results, ["value"], by="sensor")), 6) class TestParetoProbabilityRequirements(unittest.TestCase): @@ -156,8 +265,10 @@ def test_quantile_objective(self): self.assertTrue(by_mean.loc["b", "pareto"]) # b has the larger mean pessimistic = pareto_probability( _results(), - {"cost": "min", "value q": "max"}, - statistics={"value q": Quantile("value", 0.25)}, + Criteria( + {"cost": "min", "value q": "max"}, + statistics={"value q": Quantile("value", 0.25)}, + ), ).set_index("design") self.assertTrue(pessimistic.loc["a", "pareto"]) self.assertFalse(pessimistic.loc["b", "pareto"]) @@ -166,9 +277,11 @@ def test_requirements(self): """Designs that miss a requirement are not efficient.""" probability = pareto_probability( _results(), - {"cost": "min", "value": "max"}, - requirements=[Requirement("reliable", ">=", 0.75)], - statistics={"reliable": Probability("value", ">=", 10)}, + Criteria( + {"cost": "min", "value": "max"}, + requirements=[Requirement("reliable", ">=", 0.75)], + statistics={"reliable": Probability("value", ">=", 10)}, + ), ).set_index("design") self.assertEqual(list(probability.meets_requirements), [True, False, False]) # a is efficient unless b meets the requirement (and dominates it) @@ -210,9 +323,11 @@ def test_misses_ranked_last(self): screening = screen( space.enumerate(), [study, study], - {"cost": "min", "value": "max"}, + Criteria( + {"cost": "min", "value": "max"}, + requirements=[Requirement("cost", "<=", 3)], + ), keep=4, - requirements=[Requirement("cost", "<=", 3)], ) first = screening.summaries[0].set_index("design") meets = first[first.meets_requirements] diff --git a/tests/tradespace/test_fingerprint.py b/tests/tradespace/test_fingerprint.py index d31f01d4..6cfb9f42 100644 --- a/tests/tradespace/test_fingerprint.py +++ b/tests/tradespace/test_fingerprint.py @@ -4,6 +4,7 @@ @author Paul T. Grogan """ +import ast import os import subprocess import sys @@ -15,7 +16,12 @@ import numpy as np import pandas as pd +from shapely.geometry import Point + +from tatc.analysis import collect_observations +from tatc.generation import generate_points_rotated_lattice from tatc.schemas import Instrument +from tatc.tradespace import fingerprint from tatc.tradespace import ( CostModel, DesignSpace, @@ -24,8 +30,9 @@ SatelliteCost, Study, Uncertain, + compare_definitions, + get_definition, get_fingerprint, - get_source_hash, ) THRESHOLD = 4 @@ -40,6 +47,28 @@ def _uses_helper(d): MODEL = None +TABLE = pd.DataFrame({"a": [1.0]}) + + +class _Opaque: + """An object described by its type only.""" + + def __init__(self, value): + self.value = value + + +def _uses_table(d): + return {"value": TABLE.a.sum() * d.a} + + +def _uses_attribute(d): + # an attribute named as the global `values`, which the function does not use + return {"value": d.values} + + +values = pd.DataFrame({"a": [1.0]}) # pylint: disable=invalid-name + + CACHES = {} @@ -53,6 +82,13 @@ def _uses_model(d): return {"cost": MODEL.estimate(d.layout).total} +START = datetime(2026, 1, 1, tzinfo=timezone.utc) + + +def _observe(satellite): + return collect_observations([], satellite, START, START + timedelta(days=1)) + + def _space(high=4, fixed=1.0, spread=1.0): return DesignSpace( a=Integer(1, high), @@ -122,11 +158,49 @@ def test_values(self): get_fingerprint(np.arange(3)), get_fingerprint(np.arange(3) + 1) ) self.assertEqual(get_fingerprint({1, 2, 3}), get_fingerprint({3, 2, 1})) - # other objects are described by their type only + # data frames and series by their content (and geometries by theirs) self.assertEqual( + get_fingerprint(pd.DataFrame({"a": [1]})), + get_fingerprint(pd.DataFrame({"a": [1]})), + ) + self.assertNotEqual( get_fingerprint(pd.DataFrame({"a": [1]})), get_fingerprint(pd.DataFrame({"a": [2]})), ) + self.assertNotEqual( + get_fingerprint(pd.Series([1.0], name="a")), + get_fingerprint(pd.Series([1.0], name="b")), + ) + points = generate_points_rotated_lattice(5, seed=1) + moved = points.copy() + moved.loc[0, "geometry"] = Point(0, 1e-9) + self.assertEqual( + get_fingerprint(points), + get_fingerprint(generate_points_rotated_lattice(5, seed=1)), + ) + self.assertNotEqual(get_fingerprint(points), get_fingerprint(moved)) + # other objects are described by their type only + self.assertEqual(get_fingerprint(_Opaque(1)), get_fingerprint(_Opaque(2))) + + def test_attributes_are_not_globals(self): + """Attributes named as globals do not refer to the globals.""" + global values # pylint: disable=global-statement,invalid-name + before = get_fingerprint(_uses_attribute) + values = pd.DataFrame({"a": [2.0]}) + try: + self.assertEqual(before, get_fingerprint(_uses_attribute)) + finally: + values = pd.DataFrame({"a": [1.0]}) + + def test_data_globals(self): + """Data that functions refer to as globals is described by content.""" + global TABLE # pylint: disable=global-statement + before = get_fingerprint(_uses_table) + TABLE = pd.DataFrame({"a": [2.0]}) + try: + self.assertNotEqual(before, get_fingerprint(_uses_table)) + finally: + TABLE = pd.DataFrame({"a": [1.0]}) def test_global_state(self): """Mutable globals (such as caches) do not change the fingerprint.""" @@ -161,16 +235,103 @@ def study(**kwargs): # but not with the settings of its execution self.assertEqual(study().fingerprint, study(n_jobs=2).fingerprint) + def test_modules(self): + """A definition has the modules of TAT-C (and resources) values depend on.""" + modules = get_definition(_observe)["modules"] + # the module that defines a function imported from a package, not + # the package, and the modules that it imports + self.assertIn("tatc.analysis.point_sampling", modules) + self.assertIn("tatc.schemas.space.satellite", modules) + self.assertNotIn("tatc.analysis", modules) + self.assertNotIn("tatc.analysis.ro_sampling", modules) + self.assertFalse(any(m.startswith("tatc.tradespace") for m in modules)) + self.assertIn("resources/defaults.yml", get_definition(_observe)["resources"]) + # studies depend on the modules of studies and their design spaces + study = Study(_space(), lambda d: d, lambda d: {"value": d.a}).definition + self.assertIn("tatc.tradespace.study", study["modules"]) + self.assertIn("tatc.tradespace.nodes", study["modules"]) + self.assertNotIn("tatc.tradespace.pareto", study["modules"]) + # plain values depend on no modules + self.assertEqual(get_definition(1, a="x")["modules"], {}) + def test_source(self): - """The source of TAT-C (its code and resources) changes the fingerprint.""" - self.assertEqual(len(get_source_hash()), 16) - self.assertIs(get_source_hash(), get_source_hash()) # computed once - before = get_fingerprint(_space()) - with mock.patch( - "tatc.tradespace.fingerprint.get_source_hash", return_value="changed" - ): - self.assertNotEqual(before, get_fingerprint(_space())) - self.assertEqual(before, get_fingerprint(_space())) + """The source of the modules values depend on changes the fingerprint.""" + original = fingerprint._hash # pylint: disable=protected-access + + def edited(name): + return lambda path: "edited" if path.name == name else original(path) + + before = get_fingerprint(_observe) + with mock.patch.object(fingerprint, "_hash", edited("point_sampling.py")): + self.assertNotEqual(before, get_fingerprint(_observe)) + with mock.patch.object(fingerprint, "_hash", edited("pareto.py")): + self.assertEqual(before, get_fingerprint(_observe)) + self.assertEqual(before, get_fingerprint(_observe)) + + def test_imports_resolve(self): + """Every import of a module of TAT-C resolves to modules of TAT-C.""" + # pylint: disable=protected-access + files = fingerprint._module_files() + self.assertIn("tatc.tradespace.fingerprint", files) + for module in files: + for _, other in fingerprint._imports(module): + self.assertIn(other, files, f"{other} (imported by {module})") + modules, resources = fingerprint._get_dependencies(files) + self.assertEqual(set(modules), set(files)) + self.assertTrue(resources) + # a constant of a package depends on its source only + self.assertEqual( + fingerprint._resolve("tatc", "__version__"), {("file", "tatc")} + ) + + def test_static_imports(self): + """Modules of TAT-C import modules by statements only (not by name).""" + # pylint: disable=protected-access + for module, path in fingerprint._module_files().items(): + tree = ast.parse(path.read_bytes()) + for node in ast.walk(tree): + if isinstance(node, ast.Call): + name = getattr(node.func, "id", getattr(node.func, "attr", None)) + self.assertNotIn(name, ("import_module", "__import__"), module) + + def test_compare(self): + """Comparisons of definitions name what differs.""" + + def study(high=4, offset=0.0, seed=0): + return Study( + _space(high=high), + lambda d: d, + lambda d, offset=offset: {"value": d.a + offset}, + seed=seed, + ).definition + + base = study() + self.assertEqual(compare_definitions(base, study()), []) + self.assertEqual( + compare_definitions(base, study(high=5)), + ["space.children.a.high: 4 -> 5"], + ) + self.assertEqual( + compare_definitions(base, study(offset=1.0)), + ["evaluate.defaults[0]: 0.0 -> 1.0"], + ) + self.assertEqual( + compare_definitions(base, study(high=5, seed=1), limit=1), + ["seed: 0 -> 1", "1 more"], + ) + other = { + **base, + "python": "cpython 0.0", + "modules": {**base["modules"], "tatc.tradespace.nodes": "edited"}, + } + self.assertEqual( + compare_definitions(base, other), + [ + f"python: {base['python']} -> cpython 0.0", + "module tatc.tradespace.nodes", + ], + ) + self.assertTrue(base["python"].endswith(f"{sys.version_info[1]}")) def test_stable_between_sessions(self): """Fingerprints do not change between sessions (with other hash seeds).""" diff --git a/tests/tradespace/test_optimization.py b/tests/tradespace/test_optimization.py index bdfccf30..58971dfb 100644 --- a/tests/tradespace/test_optimization.py +++ b/tests/tradespace/test_optimization.py @@ -13,6 +13,7 @@ from tatc.tradespace import ( Categorical, Choice, + Criteria, DesignSpace, Evaluations, Infeasible, @@ -67,7 +68,7 @@ def _build(design): if design.layout.choice == "single": return {"cost": 2.0 * design.layout.quality, "value": design.layout.quality} if any(p.size == 2 and p.satellites == 4 for p in design.layout.planes): - raise ValueError("too heavy") + raise Infeasible("too heavy") cost = sum(p.satellites * p.size + 1 for p in design.layout.planes) value = sum(np.sqrt(p.satellites) * p.size for p in design.layout.planes) return {"cost": cost, "value": value + design.noise} @@ -192,12 +193,13 @@ def test_optimize(self): optuna.logging.set_verbosity(optuna.logging.WARNING) summary, exact = _exact_hypervolume() - optuna_study, results = optimize_optuna( + search = optimize_optuna( _study(), OBJECTIVES, n_trials=150, sampler=optuna.samplers.NSGAIISampler(seed=1, population_size=20), ) + optuna_study, results = search.state, search.results self.assertEqual(len(optuna_study.trials), 150) found = summarize(results, list(OBJECTIVES)) self.assertLessEqual(found.design.nunique(), 150) @@ -218,14 +220,61 @@ def test_optimize(self): ) # pylint: disable=import-outside-toplevel _, exact = _exact_hypervolume() - result, results = optimize_pymoo( - _study(), OBJECTIVES, termination=("n_gen", 15), seed=1 - ) + search = optimize_pymoo(_study(), OBJECTIVES, termination=("n_gen", 15), seed=1) + result, results = search.state, search.results self.assertEqual(result.F.shape[1], 2) + self.assertEqual({d.key for d in search.designs}, set(results.design)) found = summarize(results, list(OBJECTIVES)) self.assertGreater(hypervolume(found, OBJECTIVES, REFERENCE), 0.9 * exact) self.assertFalse(results.feasible.all()) # some designs were too heavy + def test_duplicates(self): + """Proposals of the same design, or of designs evaluated before, are + duplicates; proposals that violate a constraint are not.""" + from pymoo.core.population import ( # pylint: disable=import-outside-toplevel + Population, + ) + + study = _study() + problem = make_pymoo_problem(study, OBJECTIVES) + single = study.space.design({"layout": ["single", {"quality": 2}]}) + x = study.space.encode(single) + # the same level of each variable, and other values of the branch not chosen + same = x.copy() + same[study.space.unit_paths().index("layout.single.quality")] += 0.1 + other = x.copy() + other[study.space.unit_paths().index("layout.planes.planes.count")] = 0.9 + too_many = study.space.encode( + study.space.design( + {"layout": ["planes", {"planes": [{"satellites": 4, "size": 0.5}] * 2}]} + ) + ) + too_many[study.space.unit_paths().index("layout.planes.planes.count")] = 0.99 + for k in range(3): + too_many[ + study.space.unit_paths().index(f"layout.planes.planes[{k}].satellites") + ] = 0.99 + with self.assertRaises(Infeasible): + study.space.decode(too_many) + pop = Population.new("X", np.array([x, same, other, too_many, too_many])) + kept = problem.duplicates.do(pop) + self.assertEqual(len(kept), 3) # one of the same design, and both infeasible + # designs evaluated before are duplicates + problem.evaluations.evaluate([single]) + self.assertEqual(len(problem.duplicates.do(pop)), 2) + + def test_distinct(self): + """Distinct searches evaluate more designs in as many generations.""" + distinct = optimize_pymoo( + _study(), OBJECTIVES, termination=("n_gen", 5), seed=1 + ) + plain = optimize_pymoo( + _study(), OBJECTIVES, termination=("n_gen", 5), seed=1, distinct=False + ) + self.assertGreater(len(distinct.designs), len(plain.designs)) + with self.assertRaises(ValueError): + optimize_pymoo(_study(), OBJECTIVES, algorithm=object(), seed=1) + @unittest.skipUnless(HAS_OPTUNA, "requires optuna") class TestOptunaConstraints(unittest.TestCase): @@ -241,12 +290,12 @@ def setUp(self): def test_violations(self): """Trials record the violations of their designs' constraints.""" - optuna_study, _ = optimize_optuna( + optuna_study = optimize_optuna( _study(), OBJECTIVES, n_trials=80, sampler=self.optuna.samplers.RandomSampler(seed=3), - ) + ).state states = {trial.state for trial in optuna_study.trials} self.assertEqual(states, {self.optuna.trial.TrialState.COMPLETE}) violations = [trial.constraints["feasibility"] for trial in optuna_study.trials] @@ -264,13 +313,13 @@ def test_violations(self): def test_pruning(self): """Without constraints, infeasible trials are pruned.""" - optuna_study, _ = optimize_optuna( + optuna_study = optimize_optuna( _study(), OBJECTIVES, n_trials=60, sampler=self.optuna.samplers.RandomSampler(seed=3), constraints=False, - ) + ).state states = {trial.state for trial in optuna_study.trials} self.assertIn(self.optuna.trial.TrialState.PRUNED, states) self.assertTrue(all(not trial.constraints for trial in optuna_study.trials)) @@ -315,62 +364,50 @@ class TestRequirements(unittest.TestCase): Unit tests for requirements in searches. """ - REQUIREMENTS = [Requirement("value p0", ">=", 2)] - STATISTICS = {"value p0": Minimum("value")} + CRITERIA = Criteria( + OBJECTIVES, + statistics={"value p0": Minimum("value")}, + requirements=[Requirement("value p0", ">=", 2)], + ) def test_evaluations(self): """Evaluations give the violations of requirements on statistics.""" - evaluations = Evaluations( - _study(), OBJECTIVES, self.STATISTICS, self.REQUIREMENTS - ) + evaluations = Evaluations(_study(), self.CRITERIA) designs = [d for d in _space().enumerate() if d.layout.choice == "single"] values = evaluations.evaluate(designs) for design, value in zip(designs, values): violation = evaluations.violations[design.key][0] - # the least value over replicates is the quality less the noise - self.assertAlmostEqual(violation, max(2 - value[1], 0), delta=0.02) + # the least value over replicates is the quality less the noise, + # and violations are relative to the required value + self.assertAlmostEqual(violation, max(2 - value[1], 0) / 2, delta=0.01) + with self.assertRaises(ValueError): + Evaluations(_study(), Criteria(OBJECTIVES, by="sensor")) def test_optuna(self): """Trials record the violation of each requirement.""" import optuna # pylint: disable=import-outside-toplevel optuna.logging.set_verbosity(optuna.logging.WARNING) - optuna_study, _ = optimize_optuna( + optuna_study = optimize_optuna( _study(), - OBJECTIVES, + self.CRITERIA, n_trials=40, sampler=optuna.samplers.RandomSampler(seed=1), - statistics=self.STATISTICS, - requirements=self.REQUIREMENTS, - ) + ).state keys = {tuple(sorted(trial.constraints)) for trial in optuna_study.trials} self.assertEqual(keys, {("feasibility", "value p0 >= 2")}) violations = [t.constraints["value p0 >= 2"] for t in optuna_study.trials] self.assertTrue(any(v > 0 for v in violations)) with self.assertRaises(ValueError): - optimize_optuna( - _study(), - OBJECTIVES, - n_trials=1, - constraints=False, - requirements=self.REQUIREMENTS, - statistics=self.STATISTICS, - ) + optimize_optuna(_study(), self.CRITERIA, n_trials=1, constraints=False) def test_pymoo(self): """Problems have a constraint for each requirement.""" - problem = make_pymoo_problem( - _study(), OBJECTIVES, self.STATISTICS, self.REQUIREMENTS - ) + problem = make_pymoo_problem(_study(), self.CRITERIA) self.assertEqual(problem.n_ieq_constr, 2) - result, _ = optimize_pymoo( - _study(), - OBJECTIVES, - termination=("n_gen", 3), - seed=1, - statistics=self.STATISTICS, - requirements=self.REQUIREMENTS, - ) + result = optimize_pymoo( + _study(), self.CRITERIA, termination=("n_gen", 3), seed=1 + ).state self.assertEqual(result.pop.get("G").shape[1], 2) @@ -389,20 +426,21 @@ def test_dynamic_options(self): option=Categorical(lambda d: ["x", "y"] if d.kind == "a" else ["z"]), ) study = Study(space, lambda d: d, lambda d: {"f": float(d.option == "x")}) - optuna_study, results = optimize_optuna( + search = optimize_optuna( study, {"f": "max"}, n_trials=20, sampler=optuna.samplers.RandomSampler(seed=1), ) + optuna_study, results = search.state, search.results self.assertEqual(set(results.option), {"x", "y", "z"}) self.assertEqual(optuna_study.best_value, 1.0) def test_default_sampler(self): """The default sampler lies about pending trials in batches.""" study = Study(DesignSpace(x=Integer(0, 9)), lambda d: d, lambda d: {"f": d.x}) - batched, _ = optimize_optuna(study, {"f": "min"}, n_trials=4, batch_size=2) - single, _ = optimize_optuna(study, {"f": "min"}, n_trials=2, batch_size=1) + batched = optimize_optuna(study, {"f": "min"}, n_trials=4, batch_size=2).state + single = optimize_optuna(study, {"f": "min"}, n_trials=2, batch_size=1).state # pylint: disable=protected-access self.assertTrue(batched.sampler._constant_liar) self.assertFalse(single.sampler._constant_liar) @@ -410,10 +448,16 @@ def test_default_sampler(self): def test_max_designs(self): """The search stops once it has evaluated the most designs.""" study = Study(DesignSpace(x=Integer(0, 2)), lambda d: d, lambda d: {"f": d.x}) - optuna_study, results = optimize_optuna( + search = optimize_optuna( study, {"f": "min"}, n_trials=50, max_designs=2, batch_size=1 ) + optuna_study, results = search.state, search.results self.assertEqual(results.design.nunique(), 2) + # the designs of the search, in the order of their evaluation + self.assertEqual( + [design.key for design in search.designs], + results.design.drop_duplicates().tolist(), + ) self.assertLessEqual(len(optuna_study.trials), 50) def test_partially_infeasible(self): @@ -422,7 +466,7 @@ def test_partially_infeasible(self): def build(d): if d.x == 1 and d.noise < 0.5: - raise ValueError("unlucky") + raise Infeasible("unlucky") return d study = Study(space, build, lambda d: {"f": d.x}, replicates=8) @@ -433,7 +477,7 @@ def build(d): share = evaluations.infeasibility[space.enumerate()[1].key] self.assertGreater(share, 0) self.assertLess(share, 1) - optuna_study, _ = optimize_optuna(study, {"f": "max"}, n_trials=6) + optuna_study = optimize_optuna(study, {"f": "max"}, n_trials=6).state for trial in optuna_study.trials: if trial.params.get("x") == 1: self.assertAlmostEqual(trial.constraints["feasibility"], share) diff --git a/tests/tradespace/test_pareto.py b/tests/tradespace/test_pareto.py index e429eb54..93aa6385 100644 --- a/tests/tradespace/test_pareto.py +++ b/tests/tradespace/test_pareto.py @@ -11,7 +11,10 @@ import pandas as pd from tatc.tradespace import ( + Criteria, + Requirement, hypervolume, + hypervolume_progress, pareto_front, pareto_probability, pareto_ranks, @@ -94,14 +97,40 @@ def test_tolerance(self): ) # c is worse than a and b by 0.01 and 0.03 in value, within the # tolerance; d is not - loose = pareto_front(frame, objectives, tolerance={"value": 0.05}) - self.assertEqual(list(loose), [True, True, True, False]) - ranks = pareto_ranks(frame, objectives, tolerance={"value": 0.05}) - self.assertEqual(list(ranks), [0, 0, 0, 1]) + loose = Criteria(objectives, tolerance={"value": 0.05}) + self.assertEqual(list(pareto_front(frame, loose)), [True, True, True, False]) + self.assertEqual(list(pareto_ranks(frame, loose)), [0, 0, 0, 1]) # a larger tolerance keeps d (worse than a by 0.5 in value) - self.assertTrue(pareto_front(frame, objectives, tolerance={"value": 0.6}).all()) + looser = Criteria(objectives, tolerance={"value": 0.6}) + self.assertTrue(pareto_front(frame, looser).all()) + + def test_requirements_and_groups(self): + """Rows that miss requirements are not efficient, and groups are separate.""" + frame = self.frame.assign( + reliability=[1.0, 1.0, 0.2, 1.0, 1.0, np.nan], sensor=list("xxxxxy") + ) + criteria = Criteria( + self.objectives, requirements=[Requirement("reliability", ">=", 0.5)] + ) + front = pareto_front(frame, criteria) + # c (efficient by its objectives) and f (unknown) miss the + # requirement, and e is efficient without c + self.assertEqual(list(front[front].index), ["a", "b", "e"]) + ranks = pareto_ranks(frame, criteria) + self.assertEqual(list(ranks[list("abde")]), [0, 0, 1, 0]) + # those that miss it rank after, in order of their violations + self.assertEqual(list(ranks[["c", "f"]]), [2, 3]) + area = hypervolume(frame, criteria, {"cost": 5, "value": 0}) + self.assertAlmostEqual(area, 4 * 1 + 3 * 2 + 1 * 1) + # f is alone in its group + grouped = Criteria(self.objectives, by="sensor") + front = pareto_front(frame, grouped) + self.assertEqual(list(front[front].index), ["a", "b", "c", "f"]) + self.assertEqual(pareto_ranks(frame, grouped)["f"], 0) with self.assertRaises(ValueError): - pareto_front(frame, objectives, tolerance={"other": 1}) + hypervolume(frame, grouped, [5, 0]) + with self.assertRaises(ValueError): + pareto_front(self.frame, criteria) # no column of the requirement class TestRelativeTolerance(unittest.TestCase): @@ -115,13 +144,11 @@ def test_relative(self): objectives = {"cost": "min", "value": "max"} # 5% of 96 (4.8) tolerates 96 against 100; 5% of 3 (0.15) does not # tolerate 3 against 4 - front = pareto_front(frame, objectives, tolerance={"value": "5%"}) + front = pareto_front(frame, Criteria(objectives, tolerance={"value": "5%"})) self.assertEqual(list(front), [True, True, False, False]) # an absolute tolerance of 1 does not tolerate 96 against 100 - absolute = pareto_front(frame, objectives, tolerance={"value": 1.0}) + absolute = pareto_front(frame, Criteria(objectives, tolerance={"value": 1.0})) self.assertEqual(list(absolute), [True, False, False, False]) - with self.assertRaises(ValueError): - pareto_front(frame, objectives, tolerance={"value": "5"}) class TestParetoProbability(unittest.TestCase): @@ -181,7 +208,7 @@ def test_groups(self): ] ) probability = pareto_probability( - results, {"cost": "min", "value": "max"}, by=["sensor"] + results, Criteria({"cost": "min", "value": "max"}, by=["sensor"]) ) winners = probability[probability.pareto_probability == 1] self.assertEqual( @@ -241,6 +268,66 @@ def test_many_points(self): front = pareto_front(frame, {"a": "min", "b": "min", "c": "max"}) self.assertGreater(front.sum(), 0) tolerant = pareto_front( - frame, {"a": "min", "b": "min", "c": "max"}, tolerance={"c": "5%"} + frame, Criteria({"a": "min", "b": "min", "c": "max"}, tolerance={"c": "5%"}) ) self.assertTrue((tolerant >= front).all()) + + +class TestHypervolumeProgress(unittest.TestCase): + """ + Unit tests for the hypervolume of searches as they proceed. + """ + + def test_progress(self): + """The hypervolume of the first designs evaluated, in steps.""" + results = pd.DataFrame( + { + "design": ["a", "a", "b", "c", "d"], + "replicate": [0, 1, 0, 0, 0], + "feasible": [True, True, True, True, False], + "x": [1.0, 3.0, 4.0, 1.0, np.nan], + "y": [4.0, 6.0, 8.0, 2.0, np.nan], + } + ) + objectives = {"x": "min", "y": "max"} + # a (2, 5) and b (4, 8) dominate 58 of the box to (10, 0), and c (1, + # 2) adds 2; the infeasible design d adds nothing + progress = hypervolume_progress(results, objectives, (10, 0), step=2) + self.assertEqual(progress.index.tolist(), [2, 4]) + np.testing.assert_allclose(progress.values, [58.0, 60.0]) + last = hypervolume_progress(results, objectives, (10, 0), step=3) + self.assertEqual(last.index.tolist(), [3, 4]) + np.testing.assert_allclose(last.values, [60.0, 60.0]) + with self.assertRaises(ValueError): + hypervolume_progress(results, objectives, (10, 0), step=0) + + +class TestStandardErrors(unittest.TestCase): + """ + Unit tests for the standard errors of the objectives of designs. + """ + + def test_standard_errors(self): + """The bootstrap gives the standard error of each objective.""" + rng = np.random.default_rng(0) + results = pd.DataFrame( + [ + { + "design": design, + "replicate": r, + "feasible": True, + "x": float(i), + "y": i + rng.normal(0, 2), + } + for i, design in enumerate("ab") + for r in range(40) + ] + ) + probability = pareto_probability( + results, {"x": "min", "y": "max"}, n_resamples=2000 + ) + np.testing.assert_allclose(probability["x se"], 0.0) + expected = results.groupby("design").y.std(ddof=0) / np.sqrt(40) + np.testing.assert_allclose( + probability.set_index("design")["y se"], expected, rtol=0.15 + ) diff --git a/tests/tradespace/test_refinement.py b/tests/tradespace/test_refinement.py index f052855c..63546d88 100644 --- a/tests/tradespace/test_refinement.py +++ b/tests/tradespace/test_refinement.py @@ -8,8 +8,10 @@ import warnings import numpy as np +import pandas as pd from tatc.tradespace import ( + Criteria, DesignSpace, Integer, Quantile, @@ -18,6 +20,7 @@ pareto_probability, refine, ) +from tatc.tradespace.refinement import _precise OBJECTIVES = {"cost": "min", "value": "max"} @@ -113,8 +116,10 @@ def test_statistics(self): self.study, self.designs, self.results, - {"cost": "min", "value p25": "max"}, - statistics={"value p25": Quantile("value", 0.25)}, + Criteria( + {"cost": "min", "value p25": "max"}, + statistics={"value p25": Quantile("value", 0.25)}, + ), max_rounds=1, ) self.assertIn("value p25", refinement.probability.columns) @@ -122,21 +127,15 @@ def test_statistics(self): def test_tolerance(self): """A tolerance settles designs that are within it of the front.""" strict = pareto_probability(self.results, OBJECTIVES, n_resamples=300) - tolerant = pareto_probability( - self.results, OBJECTIVES, n_resamples=300, tolerance={"value": 2.0} - ) + criteria = Criteria(OBJECTIVES, tolerance={"value": 2.0}) + tolerant = pareto_probability(self.results, criteria, n_resamples=300) # designs efficient for sure, of the better variant (within 2 of each other) self.assertGreater( (tolerant.pareto_probability >= 0.95).sum(), (strict.pareto_probability >= 0.95).sum(), ) refinement = refine( - self.study, - self.designs, - self.results, - OBJECTIVES, - max_rounds=1, - tolerance={"value": 2.0}, + self.study, self.designs, self.results, criteria, max_rounds=1 ) settled = refinement.probability.pareto_probability >= 0.95 self.assertGreaterEqual( @@ -192,3 +191,87 @@ def test_warns_without_tolerance(self): """Designs that remain uncertain without a tolerance give a warning.""" with self.assertWarns(UserWarning): refine(self.study, self.designs, self.results, OBJECTIVES, max_rounds=1) + + def test_precision(self): + """A design about a tolerance from the front stops once precise enough.""" + space = DesignSpace(variant=Integer(0, 1), noise=Uncertain.normal(0, 1)) + # variant 1 is one tolerance below variant 0, with noise: whether it is + # within the tolerance of the front stays uncertain (with this seed) + study = Study( + space, + lambda d: d, + lambda d: {"cost": 1, "value": 10.0 - d.variant * (2.0 - d.noise)}, + replicates=5, + seed=2, + ) + designs = space.enumerate() + results = study.run(designs) + criteria = Criteria(OBJECTIVES, tolerance={"value": 2.0}) + + def refined(precision): + refinement = refine( + study, + designs, + results, + criteria, + step=5, + max_replicates=40, + precision=precision, + ) + replicates = refinement.results.groupby("design").replicate.nunique() + return refinement, replicates[designs[1].key] + + _, unlimited = refined(None) + self.assertEqual(unlimited, 40) + # a standard error below a tenth of the tolerance (0.2) takes about 25 + refinement, precise = refined(0.1) + self.assertGreaterEqual(precise, 20) + self.assertLessEqual(precise, 30) + self.assertEqual(refinement.indifferent.design.tolist(), [designs[1].key]) + self.assertEqual(len(refinement.uncertain), 0) + self.assertEqual(refinement.history.indifferent.iloc[-1], 1) + with self.assertRaises(ValueError): + refine(study, designs, results, criteria, precision=0) + + def test_budget(self): + """A budget limits the evaluations, refining the least settled designs first.""" + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + refinement = refine( + self.study, self.designs, self.results, OBJECTIVES, step=5, budget=12 + ) + nothing = refine( + self.study, self.designs, self.results, OBJECTIVES, budget=0 + ) + self.assertEqual(refinement.history.evaluations.sum(), 12) + replicates = refinement.results.groupby("design").replicate.nunique() + self.assertEqual(sorted(replicates[replicates > 5]), [7, 10, 10]) + # the designs whose probability was nearest 0.5 + before = pareto_probability(self.results, OBJECTIVES, n_resamples=500, seed=0) + before = before.sort_values("design") + distance = (before.pareto_probability - 0.5).abs() + nearest = before.design[distance.sort_values(kind="stable").index[:3]] + self.assertEqual(set(replicates[replicates > 5].index), set(nearest)) + self.assertEqual(len(nothing.results), len(self.results)) + + def test_precise(self): + """Designs are precise if each varying objective is within its tolerance.""" + probability = pd.DataFrame( + { + "cost": [1.0, 1.0, 1.0], + "cost se": [0.0, 0.0, 0.1], + "value": [100.0, 100.0, 100.0], + "value se": [1.0, 6.0, 1.0], + } + ) + # a tolerance of 10% of 100: precise below a standard error of 5 + criteria = Criteria(OBJECTIVES, tolerance={"value": "10%"}) + np.testing.assert_array_equal( + _precise(probability, criteria, 0.5), [True, False, False] + ) + np.testing.assert_array_equal( + _precise(probability, criteria, None), [False, False, False] + ) + np.testing.assert_array_equal( + _precise(probability, Criteria(OBJECTIVES), 0.5), [False, False, False] + ) diff --git a/tests/tradespace/test_screening.py b/tests/tradespace/test_screening.py index 19015871..e50080df 100644 --- a/tests/tradespace/test_screening.py +++ b/tests/tradespace/test_screening.py @@ -9,6 +9,7 @@ import numpy as np from tatc.tradespace import ( + Criteria, DesignSpace, Integer, Study, @@ -103,3 +104,20 @@ def test_three_stages(self): self.assertGreaterEqual(counts[2], 10) with self.assertRaises(ValueError): screen(self.designs, [_study(0, 1)] * 3, OBJECTIVES, keep=[0.5]) + with self.assertRaises(ValueError): + screen(self.designs, [_study(0, 1)], Criteria(OBJECTIVES, by="sensor")) + + def test_criteria_tolerance(self): + """Stages use the tolerance of the criteria unless given their own.""" + stages = [_study(0.3, 1), _study(0, 1)] + criteria = Criteria(OBJECTIVES, tolerance={"value": 0.6}) + tolerant = screen(self.designs, stages, criteria, keep=0.1) + overridden = screen( + self.designs, stages, criteria, keep=0.1, tolerance={"value": 0.0} + ) + self.assertGreater(len(tolerant.designs), len(overridden.designs)) + # the last stage ranks with the criteria's tolerance + final = tolerant.final + self.assertTrue( + (final.pareto_rank == 0).sum() >= pareto_front(final, OBJECTIVES).sum() + ) diff --git a/tests/tradespace/test_space.py b/tests/tradespace/test_space.py index a3a8a3aa..cf42599f 100644 --- a/tests/tradespace/test_space.py +++ b/tests/tradespace/test_space.py @@ -12,6 +12,7 @@ Choice, Derived, DesignSpace, + Fixed, Infeasible, Integer, Real, @@ -232,6 +233,72 @@ def test_uncertain_choice(self): self.assertIsNone(design.epoch) self.assertEqual({design.realize(r).epoch for r in range(20)}, {"jan", "jul"}) + def test_scenario(self): + """A scenario gives fixed values and uncertain parameters other values.""" + space = DesignSpace( + a=Integer(1, 2), + level=Fixed(1.0), + double=Derived(lambda d: 2 * d.level), + u=Uncertain.uniform(0, 1), + v=Uncertain.uniform(0, 1), + parts=Repeat(DesignSpace(k=Fixed(1)), count=2), + ) + design = space.enumerate()[0] + plain = design.realize(3, seed=5) + scenario = {"level": 3.0, "u": 0.25, "parts[*].k": 7} + changed = design.realize(3, seed=5, scenario=scenario) + self.assertEqual((changed.level, changed.double, changed.u), (3.0, 6.0, 0.25)) + self.assertEqual([part.k for part in changed.parts], [7, 7]) + # other parameters are drawn as without the scenario + self.assertEqual(changed.v, plain.v) + self.assertEqual((plain.level, plain.double), (1.0, 2.0)) + self.assertEqual(design.realize(3, seed=5, scenario={}).flat(), plain.flat()) + for values in ({"a": 2}, {"double": 1.0}, {"w": 1}): + with self.subTest(values=values): + with self.assertRaises(ValueError): + design.realize(3, scenario=values) + + def test_uncertain_paths(self): + """Uncertain parameters are listed by path, with [*] for items.""" + self.assertEqual(_planes_space().uncertain_paths(), ["planes[*].phase"]) + space = DesignSpace( + seed=Uncertain.seed(), + layout=Choice( + a=DesignSpace(phase=Uncertain.uniform(0, 1)), + b=DesignSpace(planes=Repeat(Uncertain.uniform(0, 1), count=2)), + ), + ) + self.assertEqual( + space.uncertain_paths(), ["seed", "layout.a.phase", "layout.b.planes[*]"] + ) + self.assertEqual(DesignSpace(a=Integer(1, 2)).uncertain_paths(), []) + + def test_shift(self): + """A shift draws named parameters as in other replicates.""" + space = DesignSpace( + u=Uncertain.uniform(0, 1), + v=Uncertain.uniform(0, 1), + planes=Repeat(DesignSpace(phase=Uncertain.uniform(0, 360)), count=2), + ) + design = space.enumerate()[0] + mixed = design.realize(3, seed=5, shift={"u": 10, "planes[*].phase": 1}) + self.assertEqual(mixed.u, design.realize(13, seed=5).u) + self.assertEqual(mixed.v, design.realize(3, seed=5).v) + self.assertEqual( + [p.phase for p in mixed.planes], + [p.phase for p in design.realize(4, seed=5).planes], + ) + self.assertEqual(mixed.replicate, 3) + self.assertEqual( + design.realize(3, shift={"u": 0}).flat(), design.realize(3).flat() + ) + independent = design.realize(3, common=False, shift={"u": 10}) + self.assertEqual(independent.u, design.realize(13, common=False).u) + with self.assertRaises(ValueError): + design.realize(3, shift={"w": 1}) + with self.assertRaises(ValueError): + design.realize(3, shift={"planes[0].phase": 1}) + class TestEnumeration(unittest.TestCase): """ diff --git a/tests/tradespace/test_store.py b/tests/tradespace/test_store.py index 33975e09..9ff58753 100644 --- a/tests/tradespace/test_store.py +++ b/tests/tradespace/test_store.py @@ -4,10 +4,17 @@ @author Paul T. Grogan """ +import json +import math +import sqlite3 import tempfile import unittest +from concurrent.futures import ThreadPoolExecutor +from contextlib import closing +from datetime import date, datetime, time, timedelta, timezone from pathlib import Path +import numpy as np import pandas as pd from tatc.tradespace import DesignSpace, Integer, ResultStore, Study, Uncertain @@ -17,6 +24,12 @@ class _Interrupt(Exception): """An interruption of a study.""" +def _stop_at_four(d): + if d.a == 4: + raise ValueError("stop") + return {"value": d.a} + + class TestResultStore(unittest.TestCase): """ Unit tests for stores of results. @@ -58,8 +71,8 @@ def test_store_and_get(self): self.assertEqual(len(other), 0) store.clear() self.assertEqual(len(store), 0) - with self.assertRaises(ValueError): - ResultStore(self.path, "") + # a store without a namespace has its own records + self.assertEqual(len(ResultStore(self.path)), 0) def test_resume(self): """An interrupted study resumes, evaluating only what is not stored.""" @@ -126,11 +139,170 @@ def test_other_definitions(self): self.assertEqual(len(self.calls), 12) # another value that the evaluation closes over self.calls.clear() - for offset in (0.0, 1.0): - Study( + + def study(offset): + return Study( self.space, lambda d: d, lambda d, offset=offset: self.calls.append(1) or {"value": offset}, store=ResultStore(self.path, "closure"), - ).run() + ) + + study(0.0).run() + with self.assertWarnsRegex(UserWarning, r"defaults\[0\]: 0.0 -> 1.0"): + study(1.0).run() self.assertEqual(len(self.calls), 8) + + def test_records_as_json(self): + """Records are kept as JSON, and read as they were written.""" + record = { + "float": 1.5, + "nan": float("nan"), + "infinite": -math.inf, + "numpy": np.float64(2.5), + "integer": np.int64(3), + "flag": np.bool_(True), + "none": None, + "when": datetime(2026, 1, 1, 12, tzinfo=timezone.utc), + "naive": datetime(2026, 1, 1, 12, 30), + "day": date(2026, 1, 2), + "time": time(13, 30), + "duration": timedelta(days=1, microseconds=5), + "pair": (1, "a"), + "list": [1, (2, 3)], + "nested": {"a": {"b": 1}}, + "keys": {1: "a", ("x", 2): "b"}, + "tagged": {"$float": "x"}, + "array": np.arange(3), + } + store = ResultStore(self.path, "x") + store.put([("d1", 0, [record])]) + read = store.get([("d1", 0)])[("d1", 0)][0] + self.assertEqual(set(read), set(record)) + self.assertTrue(math.isnan(read.pop("nan"))) + np.testing.assert_array_equal(read.pop("array"), record["array"]) + for key, value in read.items(): + # numpy scalars are read as Python's + written = record[key] + written = written.item() if isinstance(written, np.generic) else written + self.assertEqual(value, written, key) + self.assertIs(type(value), type(written), key) + # the records are JSON, which SQLite reads + with closing(sqlite3.connect(self.path)) as connection: + text, value = connection.execute( + "SELECT records, json_extract(records, '$[0].float') FROM results" + ).fetchone() + self.assertEqual(json.loads(text)[0]["integer"], 3) + self.assertEqual(value, 1.5) + + def test_definitions(self): + """A store keeps the definitions of studies, which explain changes.""" + store = ResultStore(self.path, "study") + study = self._study(store) + study.run() + self.assertEqual(store.definition(study.fingerprint), study.definition) + self.assertIsNone(store.definition("other")) + reseeded = self._study(store, seed=1) + with self.assertWarnsRegex(UserWarning, "latest differs in: seed: 0 -> 1"): + reseeded.run() + # contexts in the order they were defined, the latest last + self.assertEqual( + list(store.contexts()), [study.fingerprint, reseeded.fingerprint] + ) + # the records of other definitions are removed + self.assertEqual(store.prune(reseeded.fingerprint), 12) + self.assertEqual(store.contexts(), {reseeded.fingerprint: 12}) + self.assertIsNone(store.definition(study.fingerprint)) + store.clear() + self.assertIsNone(store.definition(reseeded.fingerprint)) + + def test_parallel_interruption(self): + """Workers store each evaluation as it completes, before an error.""" + store = ResultStore(self.path, "interrupted") + # an executor that waits for the chunks in progress as it shuts down + with ThreadPoolExecutor(2) as executor: + study = Study( + DesignSpace(a=Integer(1, 8)), + lambda d: d, + _stop_at_four, + store=store, + executor=executor, + chunks_per_job=1, + ) + with self.assertRaises(ValueError): + study.run() + # the designs evaluated before the error in its chunk (1 to 4) are kept + designs = study.space.enumerate() + stored = store.get(((d.key, 0) for d in designs), study.fingerprint) + values = sorted(records[0]["value"] for records in stored.values()) + self.assertEqual(values[:3], [1, 2, 3]) + self.assertNotIn(4, values) + + def test_variants(self): + """Variants of replicates are kept apart from plain replicates.""" + store = ResultStore(self.path, "x") + store.put([("d1", 0, [{"value": 1}])]) + store.put([("d1", 0, [{"value": 2}])], variant='{"u": 5}') + self.assertEqual(store.get([("d1", 0)]), {("d1", 0): [{"value": 1}]}) + self.assertEqual( + store.get([("d1", 0)], variant='{"u": 5}'), {("d1", 0): [{"value": 2}]} + ) + self.assertEqual(store.get([("d1", 0)], variant='{"u": 6}'), {}) + self.assertEqual(len(store), 2) + + def test_shifted_runs(self): + """Shifted replicates are stored and reused apart from plain ones.""" + store = ResultStore(self.path, "study") + plain = self._study(store).run() + shifted = self._study(store).run(shift={"noise": 3}) + self.assertEqual(len(self.calls), 2 * 4 * 3) + self.assertEqual(list(shifted.replicate), list(plain.replicate)) + later = self._study(store).run(replicates=range(3, 6)) + np.testing.assert_array_equal(shifted.noise, later.noise) + self.calls.clear() + again = self._study(store).run(shift={"noise": 3}) + self.assertEqual(self.calls, []) + pd.testing.assert_frame_equal( + again.drop(columns="seconds"), shifted.drop(columns="seconds") + ) + unshifted = self._study(store).run(shift={"noise": 0}) + self.assertEqual(self.calls, []) + pd.testing.assert_frame_equal( + unshifted.drop(columns="seconds"), plain.drop(columns="seconds") + ) + with self.assertRaises(ValueError): + self._study(store).run(shift={"other": 1}) + + def test_table_without_variants(self): + """Evaluations stored before replicates had variants are plain.""" + with closing(sqlite3.connect(self.path)) as connection: + with connection: + connection.execute( + "CREATE TABLE results (namespace TEXT, context TEXT, design TEXT, " + + "replicate INTEGER, records TEXT, " + + "PRIMARY KEY (namespace, context, design, replicate))" + ) + connection.execute( + "INSERT INTO results VALUES ('x', '', 'd1', 0, '[{\"value\": 1}]')" + ) + store = ResultStore(self.path, "x") + self.assertEqual(store.get([("d1", 0)]), {("d1", 0): [{"value": 1}]}) + store.put([("d1", 0, [{"value": 2}])], variant="v") + self.assertEqual(len(store), 2) + self.assertEqual(len(ResultStore(self.path, "x")), 2) + + def test_earlier_format(self): + """Files with evaluations of an earlier format are read as empty.""" + with closing(sqlite3.connect(self.path)) as connection: + with connection: + connection.execute( + "CREATE TABLE evaluations (namespace TEXT, context TEXT, " + + "design TEXT, replicate INTEGER, records BLOB)" + ) + connection.execute( + "INSERT INTO evaluations VALUES ('x', '', 'd1', 0, x'00')" + ) + store = ResultStore(self.path, "x") + self.assertEqual(len(store), 0) + store.put([("d1", 0, [{"value": 1}])]) + self.assertEqual(store.get([("d1", 0)]), {("d1", 0): [{"value": 1}]}) diff --git a/tests/tradespace/test_study.py b/tests/tradespace/test_study.py index eb5e69db..752906a5 100644 --- a/tests/tradespace/test_study.py +++ b/tests/tradespace/test_study.py @@ -6,16 +6,23 @@ import tempfile import unittest +import warnings from pathlib import Path from concurrent.futures import ThreadPoolExecutor -from datetime import datetime, timezone +from datetime import datetime, time, timezone import numpy as np import pandas as pd -from tatc.schemas import CircularOrbit, Satellite, WalkerConstellation +from tatc.schemas import ( + CircularOrbit, + Satellite, + SunSynchronousOrbit, + WalkerConstellation, +) from tatc.tradespace import ( DesignSpace, + Infeasible, Integer, Real, ResultStore, @@ -112,6 +119,30 @@ def build(d): self.assertTrue((feasible.members == feasible.satellites).all()) self.assertIsInstance(build(space.enumerate()[0])[0], Satellite) + def test_design_argument(self): + """An evaluation with a parameter named design is given the realized design.""" + build = lambda d: d.planes # pylint: disable=unnecessary-lambda-assignment + given = Study( + self.space, + build, + lambda planes, design: {"score": planes + design.noise}, + replicates=2, + ).run() + np.testing.assert_allclose(given.score, given.planes + given.noise) + + def keyword(planes, *, design): + return {"satellites": planes * design.per_plane} + + results = Study(self.space, build, keyword).run() + self.assertTrue( + (results.satellites == results.planes * results.per_plane).all() + ) + # functions without the parameter, or without signatures, are given the + # built object only + Study(self.space, build, lambda planes: {"score": planes}).run() + results = Study(self.space, lambda d: {"value": d.planes}, dict).run() + self.assertEqual(list(results.value), list(results.planes)) + def test_progress(self): """Progress is reported as evaluations complete.""" calls = [] @@ -212,10 +243,163 @@ def test_record(self): failed = results[~results.feasible] self.assertEqual(list(failed.a), [3]) self.assertEqual(failed.error.iloc[0], "RuntimeError: diverged") - self.assertNotIn("_failed", results.columns) + self.assertFalse([c for c in results.columns if c.startswith("_")]) self.assertEqual(len(store), 3) # a later run evaluates the failed evaluation again self.fail = False again = study.run() self.assertTrue(again.feasible.all()) self.assertEqual(len(store), 4) + + +class TestFeasibility(unittest.TestCase): + """ + Unit tests for designs that studies reject, and mistakes in their functions. + """ + + def setUp(self): + self.space = DesignSpace(a=Integer(1, 4)) + self.mistaken = True + self.built = [] + + @staticmethod + def _store(directory: str) -> ResultStore: + return ResultStore(Path(directory) / "results.sqlite", "feasibility") + + def test_rejected(self): + """Designs that either function rejects with Infeasible are stored as infeasible.""" + + def build(d): + if d.a == 1: + raise Infeasible("too small") + return d.a + + def evaluate(a): + if a == 2: + raise Infeasible("too slow") + return {"value": a} + + with tempfile.TemporaryDirectory() as directory: + store = self._store(directory) + results = Study(self.space, build, evaluate, store=store).run() + self.assertEqual(list(results.feasible), [False, False, True, True]) + self.assertEqual(list(results.error[:2]), ["too small", "too slow"]) + self.assertEqual(len(store), 4) + + def _build_orbit(self, d): + self.built.append(d.a) + return SunSynchronousOrbit( + altitude=d.a * 2000e3, + equator_crossing_time=time(10, 30), + epoch=datetime(2026, 1, 1, tzinfo=timezone.utc), + ) + + def test_validation_not_stored(self): + """Designs that fail validation are infeasible, and evaluated again later.""" + with tempfile.TemporaryDirectory() as directory: + store = self._store(directory) + study = Study( + self.space, + self._build_orbit, + lambda orbit: {"inclination": orbit.get_inclination()}, + store=store, + ) + results = study.run() + # too high to be sun-synchronous + self.assertEqual(list(results.feasible), [True, True, False, False]) + self.assertTrue(results.error[2:].str.contains("altitude").all()) + self.assertEqual(len(store), 2) + self.built.clear() + again = study.run() + self.assertEqual(self.built, [3, 4]) + self.assertEqual(list(again.feasible), list(results.feasible)) + + def _build_mistaken(self, d): + if self.mistaken: + # pylint: disable-next=unbalanced-tuple-unpacking,unused-variable + first, second = [d.a] + return d.a + + def test_mistakes_not_infeasible(self): + """Other errors, such as a ValueError of a mistake, fail rather than reject designs.""" + + def evaluate(a): + return {"value": a} + + with self.assertRaisesRegex(ValueError, "not enough values to unpack"): + Study(self.space, self._build_mistaken, evaluate).run() + with tempfile.TemporaryDirectory() as directory: + store = self._store(directory) + study = Study( + self.space, + self._build_mistaken, + evaluate, + errors="record", + store=store, + ) + with self.assertWarnsRegex(UserWarning, "none of the 4 designs"): + failed = study.run() + self.assertTrue(failed.error.str.startswith("ValueError: not enough").all()) + self.assertEqual(len(store), 0) + # a fix that the study's fingerprint cannot see + self.mistaken = False + self.assertTrue(study.run().feasible.all()) + self.assertEqual(len(store), 4) + + def test_warning_without_feasible(self): + """A run of several designs, none feasible, warns with the most common error.""" + + def build(d): + raise Infeasible("never" if d.a > 1 else "once") + + study = Study(self.space, build, lambda built: {}) + with self.assertWarnsRegex(UserWarning, r"\(3 of 4 evaluations\): never"): + study.run() + with warnings.catch_warnings(): + warnings.simplefilter("error") + # a single design, or any feasible design + study.run(self.space.enumerate()[:1]) + Study(self.space, lambda d: d, lambda d: {}).run() + + +class TestMetricNames(unittest.TestCase): + """ + Unit tests for the names of the metrics of evaluations. + """ + + def test_reserved_names(self): + """Metrics named as status columns, or replacing values of designs, raise errors.""" + space = DesignSpace(a=Integer(1, 2), noise=Uncertain.uniform(0, 1)) + for metrics in ({"replicate": 0}, {"error": 0.1}, {"a": 9}, {"noise": 0.5}): + for errors in ("raise", "record"): + with self.subTest(metrics=metrics, errors=errors): + study = Study( + space, lambda d: d, lambda d, m=metrics: m, errors=errors + ) + with self.assertRaisesRegex(ValueError, "metrics named"): + study.run() + + def test_restated_values(self): + """A metric may restate a value of the design, such as a variable that is an objective.""" + space = DesignSpace(a=Integer(1, 2), noise=Uncertain.uniform(0, 1)) + study = Study( + space, + lambda d: d, + lambda d: {"a": float(d.a), "noise": d.noise, "value": 2 * d.a}, + replicates=2, + ) + results = study.run() + self.assertEqual(list(results.a), [1, 1, 2, 2]) + self.assertEqual(list(results.value), [2, 2, 4, 4]) + + def test_reserved_index(self): + """Named indices of data frame outcomes are metrics too.""" + space = DesignSpace(a=Integer(1, 2)) + frame = pd.DataFrame({"value": [1]}, index=pd.Index([0], name="a")) + with self.assertRaisesRegex(ValueError, r"\['a'\]"): + Study(space, lambda d: d, lambda d: frame).run() + # other names are kept + renamed = frame.rename_axis("sensor") + results = Study(space, lambda d: d, lambda d: renamed).run() + self.assertEqual(list(results.a), [1, 2]) + self.assertEqual(list(results.sensor), [0, 0]) From 2ef1b98c5f16dfc62ebc54488cc057db988ae97a Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Wed, 11 Nov 2026 21:58:32 -0700 Subject: [PATCH 26/52] attribute the variance of replicates, and judge designs across scenarios and by utility - attribute_variance attributes the variance of metrics between the replicates of each design to its uncertain parameters (first and total shares, by drawing each again with the others held, with bootstrap standard errors); Attribution.summary pools designs, and differences attributes the variance of differences between pairs of designs. - robustness gives the Pareto trace of each design across scenarios, and its regret in each scenario and at most. - Utility combines single-attribute utilities of metrics (LinearUtility, ExponentialUtility, PiecewiseUtility) by weights, additively or in the multiplicative form, as a metric of any statistic (its mean is the expected utility). --- src/tatc/tradespace/__init__.py | 15 + src/tatc/tradespace/attribution.py | 581 +++++++++++++++++++++++++++ src/tatc/tradespace/scenarios.py | 147 +++++++ src/tatc/tradespace/utility.py | 290 +++++++++++++ tests/tradespace/test_attribution.py | 413 +++++++++++++++++++ tests/tradespace/test_scenarios.py | 265 ++++++++++++ tests/tradespace/test_utility.py | 212 ++++++++++ 7 files changed, 1923 insertions(+) create mode 100644 src/tatc/tradespace/attribution.py create mode 100644 src/tatc/tradespace/scenarios.py create mode 100644 src/tatc/tradespace/utility.py create mode 100644 tests/tradespace/test_attribution.py create mode 100644 tests/tradespace/test_scenarios.py create mode 100644 tests/tradespace/test_utility.py diff --git a/src/tatc/tradespace/__init__.py b/src/tatc/tradespace/__init__.py index 67df6e66..650e67fe 100644 --- a/src/tatc/tradespace/__init__.py +++ b/src/tatc/tradespace/__init__.py @@ -116,8 +116,17 @@ Values, configure, ) +from .attribution import Attribution, attribute_variance +from .scenarios import robustness +from .utility import ( + ExponentialUtility, + LinearUtility, + PiecewiseUtility, + Utility, +) __all__ = [ + "Attribution", "Bathtub", "Categorical", "Choice", @@ -133,6 +142,7 @@ "DesignSpace", "Evaluations", "Exponential", + "ExponentialUtility", "FailureModel", "Fixed", "Infeasible", @@ -140,6 +150,7 @@ "Launch", "LaunchCost", "Lifetime", + "LinearUtility", "Maximum", "Mean", "Minimum", @@ -148,6 +159,7 @@ "Phase", "PhaseCache", "Piecewise", + "PiecewiseUtility", "Probability", "Production", "Quantile", @@ -168,11 +180,13 @@ "Statistic", "Study", "Uncertain", + "Utility", "Values", "Variable", "Weibull", "aggregate", "allocate_histories", + "attribute_variance", "build_constellation", "compare_definitions", "configure", @@ -200,6 +214,7 @@ "policy_space", "refine", "remove_failures", + "robustness", "screen", "sensitivity", "sso_planes_space", diff --git a/src/tatc/tradespace/attribution.py b/src/tatc/tradespace/attribution.py new file mode 100644 index 00000000..d83e2fcd --- /dev/null +++ b/src/tatc/tradespace/attribution.py @@ -0,0 +1,581 @@ +""" +Attribution of the variance of the outcomes of designs to their uncertain +parameters: which uncertainties spread the outcomes of a design between its +replicates, found by drawing each again while holding the others. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +import warnings +from collections.abc import Mapping, Sequence +from dataclasses import dataclass, field +from itertools import combinations + +import numpy as np +import pandas as pd + +from .space import Design, DesignSpace, _check_uncertain, _generic +from .study import Study + +_SHARES = ("first", "total") +"""The shares of variance of a parameter (see `attribute_variance`).""" + + +@dataclass +class Attribution: + """ + The attribution of the variance of the metrics of designs between their + replicates to their uncertain parameters (see `attribute_variance`). + """ + + results: pd.DataFrame + """pandas.DataFrame: The results of every evaluation (see `Study.run`): + the plain replicates, and the mixed replicates, whose `redrawn` column + names the parameter (or group of parameters) drawn as in other + replicates (`None` for plain replicates). Those of differences (see + `differences`) are the differences of the metrics of two designs + (`design` less `other`) in each replicate.""" + shares: pd.DataFrame + """pandas.DataFrame: A row per design (and group of `by`), metric + (`metric`), and parameter (`parameter`): the variance of the metric + between the design's replicates (`variance`), the share of the variance + that knowing the parameter would remove (`first`), the share that the + parameter causes, alone or with others (`total`), and the standard + errors of the shares (`first se` and `total se`, by a bootstrap). Those + of differences (see `differences`) are of a pair of designs (`design` + and `other`).""" + by: tuple[str, ...] = () + """tuple[str, ...]: The columns that separate the records of an + evaluation (see `attribute_variance`).""" + samples: dict[str, np.ndarray] = field(default_factory=dict, repr=False) + """dict[str, numpy.ndarray]: The variances that the parameter of each row + of `shares` explains (`first` and `total`), and the variance of the + metric (`variance`), in each resample of the bootstrap (a row per row of + `shares`, and a column per resample, of the same replicates for every + design), from which `summary` estimates the standard errors of shares + over designs.""" + resamples: np.ndarray | None = field(default=None, repr=False) + """numpy.ndarray | None: The rows of A, B, and the mixed replicates in + each resample of the bootstrap (a row per resample), which `differences` + resamples too.""" + + def summary(self, share: str = "total") -> pd.DataFrame: + """ + Gets the shares of the variance of each metric that each parameter + explains over every design (and for each group of `by`): the + variances that it explains, summed over the designs in which it is + drawn, as a share of their variances (a mean of the designs' shares, + weighted by their variances), with their standard errors (by the + bootstrap of the shares, whose resamples are of the same replicates + for every design). + + Args: + share (str): `"total"` for the shares that the parameters cause, + alone or with others, or `"first"` for the shares that knowing + them would remove. + + Returns: + pandas.DataFrame: a row per parameter (and group of `by`), and a + column per metric, then a column of the standard errors of + each (` se`) + """ + if share not in _SHARES: + raise ValueError(f"share must be 'first' or 'total', not {share!r}") + frame = self.shares + metrics = list(pd.unique(frame["metric"])) + columns = [*metrics, *(f"{metric} se" for metric in metrics)] + if frame.empty: + return pd.DataFrame(columns=columns) + index = [*self.by, "parameter"] + usable = (frame[share].notna() & frame["variance"].notna()).to_numpy() + explained = np.where(usable, frame[share] * frame["variance"], 0.0) + variance = np.where(usable, frame["variance"], 0.0) + sampled = np.where(usable[:, None], self.samples[share], np.nan) + sampled_variance = np.where(usable[:, None], self.samples["variance"], np.nan) + records = [] + with warnings.catch_warnings(): + # parameters drawn in no design, or without variance + warnings.simplefilter("ignore", RuntimeWarning) + groups = frame.groupby([*index, "metric"], sort=False).indices + for key, rows in groups.items(): + # the share in each resample, of the designs it is estimated for + known = ~np.isnan(sampled[rows]) & ~np.isnan(sampled_variance[rows]) + resampled = np.where(known, sampled[rows], 0).sum(axis=0) / np.where( + known, sampled_variance[rows], 0 + ).sum(axis=0) + records.append( + { + **dict(zip([*index, "metric"], key)), + "share": explained[rows].sum() / variance[rows].sum(), + "se": np.nanstd(resampled, ddof=1), + } + ) + table = pd.DataFrame(records) + result = pd.concat( + [ + table.pivot(index=index, columns="metric", values="share"), + table.pivot(index=index, columns="metric", values="se").add_suffix( + " se" + ), + ], + axis=1, + ).reindex(columns=columns) + result.columns.name = None + if not self.by: + result = result.reindex(index=list(pd.unique(frame["parameter"]))) + return result + + def differences( + self, pairs: Sequence[tuple[Design | str, Design | str]] | None = None + ) -> Attribution: + """ + Attributes the variance of the differences of the metrics between + pairs of designs (the first less the other, in the same replicates) + to the uncertain parameters, from the evaluations of the designs, + without evaluating them again: the plain and mixed replicates of both + designs are the same replicates, so that their differences are those + of the difference. + + With common random numbers (see `Design.realize`), the parameters that + act alike on both designs cancel in their difference, and those that + act differently remain: the parameters with large shares of the + variance of a difference are those whose noise keeps the order of + the designs unsettled (such as their order on a front, see + `pareto_probability`), which more replicates, or less of that noise, + would settle. A parameter may spread the metrics of both designs but + not their difference, such as the growth of a cost that both share. + Without common random numbers, nothing cancels: the variance of a + difference is the sum of the designs' variances. + + A design that does not draw a parameter (such as one of a branch it + does not choose) is not evaluated for it, as it does not depend on + it: its values with the parameter drawn again are those of A. The + shares of a parameter that neither design draws are `NaN`, and the + replicates in which either design is infeasible are left out. + + Args: + pairs (Sequence[tuple[Design | str, Design | str]] | None): The + pairs of designs (or their keys), or `None` for every pair of + the designs, in their order. + + Returns: + Attribution: the differences (`results`) and their shares, whose + rows give both designs (`design` and `other`) + + Raises: + ValueError: if a design of a pair is not attributed, or a pair is + of a design with itself. + """ + if "other" in self.shares.columns or self.resamples is None: + raise ValueError("differences need an attribution of designs") + designs = list(pd.unique(self.results["design"])) + pairs = list(combinations(designs, 2)) if pairs is None else pairs + keyed = [(getattr(a, "key", a), getattr(b, "key", b)) for a, b in pairs] + unknown = sorted({key for pair in keyed for key in pair} - set(designs)) + if unknown: + raise ValueError(f"designs that are not attributed: {unknown}") + same = [a for a, b in keyed if a == b] + if same: + raise ValueError(f"pairs of a design with itself: {same}") + metrics = list(pd.unique(self.shares["metric"])) + names = list(pd.unique(self.shares["parameter"])) + n = self.resamples.shape[1] + tables = { + key: _tables(self.results, key, metrics, names, self.by) + for key in dict.fromkeys(key for pair in keyed for key in pair) + } + frames = [] + for first, other in keyed: + for name in [None, *names]: + a, b = tables[first].get(name), tables[other].get(name) + if a is None and b is None: + continue # neither design draws the parameter + # a design that does not draw a parameter is as in A + a = _first_replicates(tables[first][None], n) if a is None else a + b = _first_replicates(tables[other][None], n) if b is None else b + frames.append( + _difference(a, b, metrics).assign( + design=first, other=other, redrawn=name + ) + ) + columns = [*self.by, "replicate", *metrics, "feasible"] + differences = ( + pd.concat(frames, ignore_index=True) + if frames + else pd.DataFrame(columns=[*columns, "design", "other", "redrawn"]) + ) + shares, samples = _shares( + differences, + ("design", "other"), + keyed, + names, + metrics, + self.by, + self.resamples, + ) + return Attribution( + results=differences, + shares=shares, + by=self.by, + samples=samples, + resamples=self.resamples, + ) + + +def _groups_of( + space: DesignSpace, parameters: Sequence[str] | Mapping[str, Sequence[str]] | None +) -> dict[str, list[str]]: + """ + Gets the groups of uncertain parameters to attribute variance to, by + name: each parameter of the design space, each given parameter, or the + given groups of parameters. + """ + if not space.uncertain_paths(): + raise ValueError("the design space has no uncertain parameters") + if parameters is None: + groups = {path: [path] for path in space.uncertain_paths()} + elif isinstance(parameters, str): + groups = {parameters: [parameters]} + elif isinstance(parameters, Mapping): + groups = { + name: [paths] if isinstance(paths, str) else list(paths) + for name, paths in parameters.items() + } + else: + groups = {path: [path] for path in parameters} + if not groups: + raise ValueError("no parameters to attribute variance to") + paths = [path for group in groups.values() for path in group] + _check_uncertain(space, paths) + repeated = sorted({path for path in paths if paths.count(path) > 1}) + if repeated: + raise ValueError(f"parameters in more than one group: {repeated}") + empty = [name for name, group in groups.items() if not group] + if empty: + raise ValueError(f"groups without parameters: {empty}") + return groups + + +def _draws(design: Design, paths: Sequence[str]) -> bool: + """ + Whether a design draws any of the uncertain parameters (by their paths, + see `DesignSpace.uncertain_paths`), which those of branches it does not + choose (or of the items of an empty repetition) it does not. + """ + drawn = {_generic(path) for path in design.flat()} + return any(path in drawn for path in paths) + + +def _estimate( + plain: np.ndarray, + mixed: np.ndarray, + n: int, + resamples: np.ndarray, +) -> dict[str, np.ndarray]: + """ + Estimates the variance of a metric and the first and total shares of each + group of parameters, from the metric in the plain replicates (`2 n`: the + rows of A, then of B) and the mixed replicates of each group (a row per + group, of `n`: the rows of A with the group drawn as in B), which are + `NaN` where infeasible (or not evaluated), with the variances that the + groups explain and the variance in each resample of a bootstrap + (`resamples`, indices of rows, resamples x n), and the standard errors + of the shares. + + The estimators are Jansen's: the total effect of a group is half the + mean squared difference between A and its mixed replicates (which differ + in the group alone), and the first-order effect is the variance less + half the mean squared difference between B and the mixed replicates + (which share the group alone). + """ + a, b = plain[:n], plain[n:] + # the rows in which A, B, and the mixed replicates are all feasible + joint = ~np.isnan(a) & ~np.isnan(b) & ~np.isnan(mixed) + halves = { + "first": np.where(joint, (b - mixed) ** 2, np.nan) / 2, + "total": np.where(joint, (a - mixed) ** 2, np.nan) / 2, + } + values = plain[~np.isnan(plain)] + variance = float(np.var(values, ddof=1)) if len(values) > 1 else np.nan + # shares need a variance, and two rows feasible in every replicate + valid = (joint.sum(axis=1) >= 2) & (variance > 0) + estimates: dict = {"variance": variance} + with warnings.catch_warnings(): + # designs that are infeasible (or groups not drawn) give empty slices + warnings.simplefilter("ignore", RuntimeWarning) + both = np.concatenate([a[resamples], b[resamples]], axis=1) + sampled_variance = np.nanvar(both, axis=1, ddof=1) + sampled_variance = np.where(sampled_variance > 0, sampled_variance, np.nan) + estimates["variance samples"] = sampled_variance + for share, terms in halves.items(): + explained = np.nanmean(terms, axis=1) + sampled = np.nanmean(terms[:, resamples], axis=2) + if share == "first": + explained, sampled = variance - explained, sampled_variance - sampled + estimates[share] = np.where(valid, explained / variance, np.nan) + estimates[f"{share} samples"] = np.where(valid[:, None], sampled, np.nan) + estimates[f"{share} se"] = np.where( + valid, np.nanstd(sampled / sampled_variance, axis=1, ddof=1), np.nan + ) + return estimates + + +def _tables( + results: pd.DataFrame, + key: str, + metrics: Sequence[str], + names: Sequence[str], + by: Sequence[str], +) -> dict[str | None, pd.DataFrame]: + """ + Gets the metrics of a design (`NaN` where infeasible) and whether it is + feasible, by (the groups of `by` and) replicate: in its plain replicates + (`None`), and in its mixed replicates of each group of parameters it was + evaluated for. + """ + rows = results[results["design"] == key] + + def table(part: pd.DataFrame) -> pd.DataFrame: + indexed = part.set_index([*by, "replicate"]) + feasible = indexed["feasible"].astype(bool).to_numpy() + values = indexed.reindex(columns=list(metrics)).to_numpy(dtype=float) + values[~feasible] = np.nan + frame = pd.DataFrame(values, index=indexed.index, columns=list(metrics)) + frame["feasible"] = feasible + return frame + + tables: dict[str | None, pd.DataFrame] = {None: table(rows[rows["redrawn"].isna()])} + for name in names: + part = rows[rows["redrawn"] == name] + if len(part): + tables[name] = table(part) + return tables + + +def _first_replicates(table: pd.DataFrame, n: int) -> pd.DataFrame: + """ + Gets the rows of a table (see `_tables`) of the first `n` replicates (A). + """ + return table[table.index.get_level_values("replicate") < n] + + +def _difference( + a: pd.DataFrame, b: pd.DataFrame, metrics: Sequence[str] +) -> pd.DataFrame: + """ + Gets the differences of the metrics of two tables (see `_tables`) in the + same rows, which are feasible if both are. + """ + index = a.index.union(b.index) + difference = a.reindex(index)[list(metrics)] - b.reindex(index)[list(metrics)] + difference["feasible"] = a["feasible"].reindex(index, fill_value=False) & b[ + "feasible" + ].reindex(index, fill_value=False) + return difference.reset_index() + + +def _by_replicate( + group: pd.DataFrame, metric: str, rows: pd.Series, size: int +) -> np.ndarray: + """ + Gets a metric of the rows of a group of results in the order of their + replicates, up to `size` (`NaN` where a replicate is missing). + """ + values = group.loc[rows, metric].astype(float) + return values.set_axis(group.loc[rows, "replicate"]).reindex(range(size)).to_numpy() + + +def _shares( + results: pd.DataFrame, + identity: Sequence[str], + keys: Sequence[tuple], + names: Sequence[str], + metrics: Sequence[str], + by: Sequence[str], + resamples: np.ndarray, +) -> tuple[pd.DataFrame, dict[str, np.ndarray]]: + """ + Estimates the shares of the variance of each metric of each design (or + pair of designs, by the values of the `identity` columns of the results + in `keys`, and of each group of `by`) of each group of parameters (see + `attribute_variance`), with a bootstrap of the resamples of the rows of + A, B, and the mixed replicates (`resamples x n`), whose samples it also + returns (see `Attribution.samples`). + """ + n = resamples.shape[1] + feasible = results[results["feasible"].astype(bool)] + grouped = { + key if isinstance(key, tuple) else (key,): group + for key, group in feasible.groupby(list(identity), sort=False) + } + rows = [] + samples: dict[str, list] = {"first": [], "total": [], "variance": []} + for key in keys: + if key not in grouped: + continue # infeasible in every replicate + records = grouped[key] + separated = records.groupby(list(by), sort=False) if by else [((), records)] + for values, group in separated: + labels = dict(zip(by, values if isinstance(values, tuple) else (values,))) + redrawn = group["redrawn"] + for metric in (metric for metric in metrics if metric in group.columns): + estimates = _estimate( + _by_replicate(group, metric, redrawn.isna(), 2 * n), + np.array( + [ + _by_replicate(group, metric, redrawn == name, n) + for name in names + ] + ), + n, + resamples, + ) + rows.extend( + { + **dict(zip(identity, key)), + **labels, + "metric": metric, + "parameter": name, + "variance": estimates["variance"], + **{ + share: estimates[share][i] + for share in ("first", "total", "first se", "total se") + }, + } + for i, name in enumerate(names) + ) + for share in _SHARES: + samples[share].extend(estimates[f"{share} samples"]) + samples["variance"].extend([estimates["variance samples"]] * len(names)) + columns = [*identity, *by, "metric", "parameter", "variance"] + shares = pd.DataFrame( + rows, columns=[*columns, "first", "total", "first se", "total se"] + ) + return shares, { + name: np.array(arrays, dtype=float).reshape(len(shares), len(resamples)) + for name, arrays in samples.items() + } + + +def attribute_variance( + study: Study, + designs: Sequence[Design], + metrics: Sequence[str], + parameters: Sequence[str] | Mapping[str, Sequence[str]] | None = None, + replicates: int | None = None, + by: Sequence[str] = (), + n_resamples: int = 500, + seed: int = 0, +) -> Attribution: + """ + Attributes the variance of metrics between the replicates of each design + to its uncertain parameters (see `Uncertain`): which uncertainties spread + its outcomes, and by how much. For example, the spread of a share of + points sampled between replicates may be noise of the sample of points + (which more points would reduce), and that of a cost, a risk of the + growth of the cost. + + The effect of a parameter is measured by drawing it again while holding + the others (a pick-freeze design, as of Sobol' indices), as its values + need not relate to the outcomes in any order (as those of a seed do + not). The designs are evaluated in `2 n` plain replicates (`n` of + `replicates`): A, the first `n`, and B, the next `n` (those evaluated + before are taken from the study's store). For each parameter (or group + of parameters), they are also evaluated in `n` mixed replicates: those + of A, with the parameter drawn as in B (see `Study.run`'s `shift`), which + takes `n` evaluations of each design for each parameter. + + Two shares of the variance of a metric are estimated for each parameter, + by Jansen's estimators (with common random numbers, the designs share + the parameters of each replicate): + + * `total`: the share that the parameter causes, alone or with others + (half the mean squared difference between A and the mixed replicates, + which differ in the parameter alone, as a share of the variance). A + parameter whose total share is near 0 could be fixed at any value + without changing the spread of the metric. + * `first`: the share that knowing the parameter would remove (the + variance less half the mean squared difference between B and the + mixed replicates, which share the parameter alone, as a share of the + variance). The first shares of the parameters sum to at most 1; the + rest is caused by the parameters together (their interactions). + + The shares are of the variance of a replicate, and so also of the + variance of a mean of replicates. They are not clipped (an estimate of a + share near 0 may be slightly negative), and their standard errors are + estimated by a bootstrap of the rows of A, B, and the mixed replicates + together. A share is `NaN` if the metric does not vary between the + design's replicates, if the design does not draw the parameter (such as + one of a branch it does not choose, which it is not evaluated for), or + if fewer than two rows are feasible in A, B, and the mixed replicates. + Infeasible evaluations are left out (and designs infeasible in every + replicate have no shares). + + The evaluations must be determined by the uncertain parameters (as a + study's store assumes): randomness from another source (such as a + generator that is not seeded by a parameter, see `Uncertain.seed`) adds + to the total share of every parameter. + + Args: + study (Study): The study that evaluates designs. + designs (Sequence[Design]): The designs. + metrics (Sequence[str]): The metrics (columns of the results). + parameters (Sequence[str] | Mapping[str, Sequence[str]] | None): The + uncertain parameters to attribute variance to (by their paths, + see `DesignSpace.uncertain_paths`), groups of them (by name), or + `None` for each of the design space's. Parameters not given vary + between replicates, but are not attributed variance. + replicates (int | None): The replicates of A and of B (`n`), or + `None` for the study's. + by (Sequence[str]): The columns that separate the records of an + evaluation, if it has several (such as a sensor). + n_resamples (int): The number of resamples of the bootstrap. + seed (int): The seed of the bootstrap. + + Returns: + Attribution: the results, and the shares of each design, metric, and + parameter + """ + n = study.replicates if replicates is None else int(replicates) + if n < 2: + raise ValueError("replicates must be at least 2") + if n_resamples < 2: + raise ValueError("n_resamples must be at least 2") + groups = _groups_of(study.space, parameters) + metrics, by = list(metrics), tuple(by) + unique = list({design.key: design for design in designs}.values()) + plain = study.run(unique, replicates=range(2 * n)) + missing = [column for column in (*metrics, *by) if column not in plain.columns] + if missing and plain["feasible"].any(): + raise ValueError(f"columns that are not in the results: {missing}") + keys = ["design", *by, "replicate"] + if not missing and plain.duplicated(keys).any(): + raise ValueError( + "the results have several records of an evaluation (a design in a " + + "replicate): give the columns that separate them as `by`" + ) + frames = [plain.assign(redrawn=None)] + for name, paths in groups.items(): + drawing = [design for design in unique if _draws(design, paths)] + if drawing: + mixed = study.run( + drawing, replicates=range(n), shift={path: n for path in paths} + ) + frames.append(mixed.assign(redrawn=name)) + results = pd.concat(frames, ignore_index=True) + + resamples = np.random.default_rng(seed).integers(n, size=(n_resamples, n)) + shares, samples = _shares( + results, + ("design",), + [(design.key,) for design in unique], + list(groups), + metrics, + by, + resamples, + ) + return Attribution( + results=results, shares=shares, by=by, samples=samples, resamples=resamples + ) diff --git a/src/tatc/tradespace/scenarios.py b/src/tatc/tradespace/scenarios.py new file mode 100644 index 00000000..5e25e48e --- /dev/null +++ b/src/tatc/tradespace/scenarios.py @@ -0,0 +1,147 @@ +""" +Scenarios: conditions under which designs are compared rather than averaged +over (see `Study`), such as the requirements of a mission or the field it +must sample, and the robustness of designs across them. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +import dataclasses +from collections.abc import Mapping + +import numpy as np +import pandas as pd + +from .criteria import Criteria, _as_criteria, _get_tolerances, aggregate +from .pareto import pareto_front + + +def _scales(criteria: Criteria, scale: Mapping[str, float] | None) -> np.ndarray: + """ + Gets the scale of each objective of criteria: the given one, or its + absolute tolerance (if any), or 1. + """ + objectives = list(criteria.objectives) + scale = dict(scale or {}) + unknown = sorted(set(scale) - set(objectives)) + if unknown: + raise ValueError(f"scales of names that are not objectives: {unknown}") + absolute = _get_tolerances(criteria.objectives, criteria.tolerance)[0] + values = np.array( + [ + float(scale[name]) if name in scale else (absolute[i] or 1.0) + for i, name in enumerate(objectives) + ] + ) + if not np.all(values > 0): + raise ValueError("the scales of the objectives must be positive") + return values + + +def robustness( + results: pd.DataFrame, + criteria: Criteria | Mapping[str, str], + scenario: str = "scenario", + scale: Mapping[str, float] | None = None, +) -> pd.DataFrame: + """ + Measures the robustness of designs across scenarios (see `Study`): how + often each design is efficient, and how far it falls from the front of + each scenario, from the results of a study in each scenario (judged by + the criteria in each scenario, see `aggregate` and `pareto_front`). + + * `pareto trace`: the share of the scenarios in which the design is + efficient (with the tolerances of the criteria, within which designs + near the front are efficient, as in epoch-era analysis's fuzzy + normalized Pareto trace). A design efficient in every scenario has a + trace of 1. + * ` regret`: in each scenario, the improvement in every + objective (in units of its `scale`) that the design would need to match + a design of the scenario's front (the additive epsilon indicator, as + the fuzzy Pareto number of epoch-era analysis): 0 if it is efficient, + and infinite if it misses the requirements of the criteria (or is + infeasible in every replicate). With one objective, it is the + difference from the best design. + * `max regret`: the largest regret of the design over the scenarios, which + the most robust designs minimize (minimax regret). + + With objectives of few levels (such as numbers of satellites), regret is + at most a design's distance in them from the cheapest design of the + front, whatever its other objectives, as dropping that much matches it: + for the regret of the other objectives at a cost, require the cost (see + `Requirement`) rather than minimizing it. + + Designs are compared with the others of the results, by the statistics of + their replicates, whose uncertainty these measures do not show (see + `pareto_probability`, with criteria `by` the scenario). + + Args: + results (pandas.DataFrame): The results of a study with scenarios + (see `Study.run`). + criteria (Criteria | Mapping[str, str]): The criteria, by which + designs are judged in each scenario (`by` none, or the scenario), + or the objectives (metrics whose means they are) and their + directions (`"min"` or `"max"`). + scenario (str): The column of the scenarios. + scale (Mapping[str, float] | None): The units of regret of + objectives (by name): by default, the absolute tolerance of an + objective (if it has one), or else 1 (its units). + + Returns: + pandas.DataFrame: a row per design (`design`): its `pareto trace`, + `max regret`, and regret in each scenario (` regret`) + + Raises: + ValueError: if the results have no scenarios, or the criteria group + records by other columns. + """ + criteria = _as_criteria(criteria) + if criteria.by not in ((), (scenario,)): + raise ValueError( + f"criteria judge designs by the scenario ({scenario!r}) alone: " + + f"give criteria without other columns `by`, not {list(criteria.by)}" + ) + if scenario not in results.columns: + raise ValueError( + f"the results have no column {scenario!r} of scenarios (see Study)" + ) + judged = dataclasses.replace(criteria, by=(scenario,)) + objectives = list(criteria.objectives) + # each objective in units of its scale, larger being better + signs = np.array( + [1.0 if d == "max" else -1.0 for d in criteria.objectives.values()] + ) + units = signs / _scales(criteria, scale) + summary = aggregate(results, judged) + efficient = pareto_front(summary, judged).to_numpy() + scenarios = list(pd.unique(results[scenario])) + designs = list(pd.unique(results["design"])) + regret = pd.DataFrame(np.inf, index=designs, columns=scenarios) + trace = pd.Series(0.0, index=designs) + for name in scenarios: + rows = (summary[scenario] == name).to_numpy() + group, front = summary[rows], efficient[rows] + keys = group["design"].to_numpy() + values = group[objectives].to_numpy(dtype=float) * units + needed = np.full(len(group), np.inf) + if front.any(): + # the improvement in every objective that each design needs to + # match a design of the front: the least over the front of the + # largest shortfall over the objectives + shortfall = values[front][None, :, :] - values[:, None, :] + needed = np.maximum(shortfall.max(axis=2).min(axis=1), 0.0) + meets = group["meets_requirements"].to_numpy(dtype=bool) + regret.loc[keys, name] = np.where(front, 0.0, np.where(meets, needed, np.inf)) + trace[keys[front]] += 1 + frame = pd.DataFrame( + { + "design": designs, + "pareto trace": (trace / max(len(scenarios), 1)).to_numpy(), + "max regret": regret.max(axis=1).to_numpy(), + } + ) + for name in scenarios: + frame[f"{name} regret"] = regret[name].to_numpy() + return frame diff --git a/src/tatc/tradespace/utility.py b/src/tatc/tradespace/utility.py new file mode 100644 index 00000000..812a5976 --- /dev/null +++ b/src/tatc/tradespace/utility.py @@ -0,0 +1,290 @@ +""" +Utility: the value of the metrics of designs to their stakeholders, as a +single-attribute utility of each metric (from 0 at its worst acceptable +value to 1 at its best) combined into a multi-attribute utility (by the +weights of the metrics, additively or in Keeney and Raiffa's multiplicative +form), for trade spaces of utility against cost (as in multi-attribute +tradespace exploration). + +A utility is a metric computed from others in each replicate (or each row +of a summary), so that statistics of it judge designs as statistics of any +metric do (see `Statistic`): its mean over the replicates is the expected +utility, whose curvature expresses an attitude to the risks that the +replicates draw. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +import math +from collections.abc import Callable, Mapping, Sequence +from dataclasses import dataclass +from typing import Any + +import numpy as np +import pandas as pd + + +def _normalized(values: Any, worst: float, best: float) -> np.ndarray: + """Gets values as shares of the way from the worst to the best, clipped + to [0, 1] (`NaN` kept).""" + share = (np.asarray(values, dtype=float) - worst) / (best - worst) + return np.clip(share, 0.0, 1.0) + + +@dataclass(frozen=True) +class LinearUtility: + """ + A single-attribute utility linear in the value of a metric: 0 at the worst + value and 1 at the best (and beyond them), for a metric to maximize + (`worst < best`) or to minimize (`worst > best`). + + Args: + worst (float): The worst acceptable value (utility 0). + best (float): The best value (utility 1). + """ + + worst: float + best: float + + def __post_init__(self): + if self.worst == self.best: + raise ValueError("the worst and best values must differ") + + def __call__(self, values: Any) -> np.ndarray: + return _normalized(values, self.worst, self.best) + + +@dataclass(frozen=True) +class ExponentialUtility: + """ + A single-attribute utility exponential in the value of a metric (of + constant absolute risk aversion): 0 at the worst value and 1 at the best, + and `(1 - exp(-risk z)) / (1 - exp(-risk))` between, where `z` is the share + of the way from the worst value to the best. A positive `risk` is averse + (concave: the first gains matter most, and a sure value is preferred to + a gamble of the same mean), a negative one is seeking (convex), and 0 is + linear (see `LinearUtility`). + + Args: + worst (float): The worst acceptable value (utility 0). + best (float): The best value (utility 1). + risk (float): The coefficient of risk aversion (of the shares `z`). + """ + + worst: float + best: float + risk: float = 0.0 + + def __post_init__(self): + if self.worst == self.best: + raise ValueError("the worst and best values must differ") + + def __call__(self, values: Any) -> np.ndarray: + share = _normalized(values, self.worst, self.best) + if self.risk == 0: + return share + return np.expm1(-self.risk * share) / math.expm1(-self.risk) + + +@dataclass(frozen=True) +class PiecewiseUtility: + """ + A single-attribute utility interpolated linearly between points (value, + utility), and constant beyond the first and last, such as a utility + elicited at a few values. + + Args: + points (Sequence[tuple[float, float]]): The points: values (distinct) + and their utilities (between 0 and 1). + """ + + points: Sequence[tuple[float, float]] + + def __post_init__(self): + points = tuple(sorted((float(x), float(u)) for x, u in self.points)) + if len(points) < 2: + raise ValueError("a piecewise utility needs at least two points") + values = [x for x, _ in points] + if len(set(values)) != len(values): + raise ValueError("the values of the points must be distinct") + if not all(0 <= u <= 1 for _, u in points): + raise ValueError("utilities must be between 0 and 1") + object.__setattr__(self, "points", points) + + def __call__(self, values: Any) -> np.ndarray: + array = np.asarray(values, dtype=float) + xs, us = zip(*self.points) + result = np.interp(array, xs, us) + return np.where(np.isnan(array), np.nan, result) + + +_FORMS = ("additive", "multiplicative") + + +def _scaling_constant(weights: Sequence[float]) -> float: + """ + Gets the scaling constant `K` of a multiplicative utility, the root other + than 0 of `1 + K = prod(1 + K k)` (0 if the weights sum to 1): between -1 + and 0 if they sum to more than 1, and positive if less. + """ + total = sum(weights) + if len(weights) < 2 or math.isclose(total, 1.0): + return 0.0 + + def excess(k: float) -> float: + return math.prod(1 + k * w for w in weights) - (1 + k) + + if total > 1: + low, high = -1.0 + 1e-12, -1e-12 + else: + low, high = 1e-12, 1.0 + while excess(high) < 0: + high *= 2 + for _ in range(200): + middle = (low + high) / 2 + if (excess(middle) > 0) == (excess(low) > 0): + low = middle + else: + high = middle + return (low + high) / 2 + + +@dataclass(frozen=True, eq=False) +class Utility: + """ + A multi-attribute utility of the metrics of a design: the single-attribute + utility of each metric (see `LinearUtility`, `ExponentialUtility`, and + `PiecewiseUtility`, or any function of the values that gives utilities + from 0 to 1), combined by weights: + + * `"additive"`: the weighted sum of the utilities (by weights normalized + to sum to 1), for metrics that are preferentially independent and whose + gains add. + * `"multiplicative"`: Keeney and Raiffa's multiplicative form, `1 + K U = + prod(1 + K k u)`, with the weights `k` (each between 0 and 1) the utility + of each metric at its best with the others at their worst, and `K` from + them: weights that sum to less than 1 make the metrics complements (a + design must do well in all), and more than 1 substitutes (doing well in + one suffices). + + A utility is a metric of statistics (such as `Mean(utility)`, its expected + value over the replicates, see `Statistic`), computed in each replicate + from its metrics. The expected utility suits replicates that draw risks + of a mission (such as cost growth, or failures): a concave utility then + penalizes the spread of outcomes, as a risk-averse stakeholder would. + Where the spread between replicates is noise of an estimate (such as of + a sample of points, see `attribute_variance`), the expected utility + penalizes the noise rather than the design: judge the utility of the + means instead (`utility(summary)`, of a summary of the means of the + metrics, see `aggregate`). + + Args: + attributes (Mapping[str, Callable]): The single-attribute utility of + each metric. + weights (Mapping[str, float]): The weight of each metric. + form (str): `"additive"` or `"multiplicative"`. + """ + + attributes: Mapping[str, Callable[[Any], Any]] + weights: Mapping[str, float] + form: str = "additive" + + def __post_init__(self): + attributes, weights = dict(self.attributes), dict(self.weights) + if not attributes: + raise ValueError("a utility needs attributes") + if set(weights) != set(attributes): + raise ValueError( + "a utility needs a weight for each attribute, and no others" + ) + if self.form not in _FORMS: + raise ValueError(f"form must be one of {list(_FORMS)}, not {self.form!r}") + if any(not weight > 0 for weight in weights.values()): + raise ValueError("weights must be positive") + if self.form == "multiplicative" and any(w > 1 for w in weights.values()): + raise ValueError( + "the weights of a multiplicative utility must be at most 1" + ) + object.__setattr__(self, "attributes", attributes) + object.__setattr__( + self, "weights", {name: weights[name] for name in attributes} + ) + + def __eq__(self, other: object) -> bool: + return ( + isinstance(other, Utility) + and self.attributes == other.attributes + and self.weights == other.weights + and self.form == other.form + ) + + def __hash__(self) -> int: + return hash( + (tuple(self.attributes.items()), tuple(self.weights.items()), self.form) + ) + + @property + def columns(self) -> tuple[str, ...]: + """tuple[str, ...]: The metrics of the utility.""" + return tuple(self.attributes) + + @property + def scaling(self) -> float: + """float: The scaling constant `K` of a multiplicative utility (0 for + an additive one, or weights that sum to 1).""" + if self.form == "additive": + return 0.0 + return _scaling_constant(list(self.weights.values())) + + def evaluate(self, values: Mapping[str, Any]) -> np.ndarray: + """ + Computes the utility of values of the metrics (arrays of the same + shape, such as of designs by replicates). + + Args: + values (Mapping[str, Any]): The values of each metric. + + Returns: + numpy.ndarray: the utility of each value + """ + utilities = { + name: np.asarray(function(values[name]), dtype=float) + for name, function in self.attributes.items() + } + weights = self.weights + scaling = self.scaling + if scaling == 0.0: + total = sum(weights.values()) + return sum(weights[name] / total * u for name, u in utilities.items()) + product = np.ones_like(next(iter(utilities.values()))) + for name, u in utilities.items(): + product = product * (1 + scaling * weights[name] * u) + return (product - 1) / scaling + + def __call__(self, frame: pd.DataFrame | Mapping[str, Any]) -> Any: + """ + Computes the utility of each row of a data frame (such as the records + of a study, or a summary of the means of designs), or of values of + the metrics. + + Args: + frame (pandas.DataFrame | Mapping[str, Any]): The metrics. + + Returns: + pandas.Series | numpy.ndarray: the utility of each row (with the + frame's index), or of the values + """ + if isinstance(frame, pd.DataFrame): + missing = [name for name in self.columns if name not in frame.columns] + if missing: + raise ValueError( + f"metrics of the utility that are not columns: {missing}" + ) + values = {name: frame[name].to_numpy(dtype=float) for name in self.columns} + return pd.Series(self.evaluate(values), index=frame.index, name="utility") + return self.evaluate(frame) + + def __repr__(self) -> str: + return f"Utility({list(self.attributes)}, {self.form})" diff --git a/tests/tradespace/test_attribution.py b/tests/tradespace/test_attribution.py new file mode 100644 index 00000000..875cd51f --- /dev/null +++ b/tests/tradespace/test_attribution.py @@ -0,0 +1,413 @@ +""" +Unit tests for the attribution of variance to uncertain parameters. + +@author Paul T. Grogan +""" + +import tempfile +import unittest +from pathlib import Path + +import numpy as np +import pandas as pd + +from tatc.tradespace import ( + Choice, + DesignSpace, + Infeasible, + Integer, + ResultStore, + Study, + Uncertain, + attribute_variance, +) + +SPACE = DesignSpace( + x=Integer(1, 2), + u1=Uncertain.normal(0, 1), + u2=Uncertain.normal(0, 1), + s=Uncertain.seed(), +) + + +def _evaluate(d): + """Metrics with known shares: y = x (u1 + 2 u2) (0.2 and 0.8 of u1 and u2, + without interactions), z = u1 u2 (only their interaction), v (a draw of a + seed), and w (constant).""" + return { + "y": d.x * (d.u1 + 2 * d.u2), + "z": d.u1 * d.u2, + "v": float(np.random.default_rng(d.s).normal()), + "w": 1.0, + } + + +def _share(attribution, metric, parameter, share="total", design=None): + shares = attribution.shares + rows = shares[(shares.metric == metric) & (shares.parameter == parameter)] + if design is not None: + rows = rows[rows.design == design] + return rows[share].to_numpy() + + +class TestAttributeVariance(unittest.TestCase): + """ + Unit tests for attributing variance to uncertain parameters. + """ + + @classmethod + def setUpClass(cls): + cls.study = Study(SPACE, lambda d: d, _evaluate, replicates=2) + cls.designs = SPACE.enumerate() + cls.attribution = attribute_variance( + cls.study, + cls.designs, + ["y", "z", "v", "w"], + replicates=300, + n_resamples=200, + ) + + def test_known_shares(self): + """The shares of additive effects and interactions are estimated (within + three standard errors), and those of parameters without effects are 0.""" + a = self.attribution + expected = { + ("y", "u1"): (0.2, 0.2), + ("y", "u2"): (0.8, 0.8), + ("z", "u1"): (0.0, 1.0), + ("z", "u2"): (0.0, 1.0), + ("v", "s"): (1.0, 1.0), + } + for (metric, parameter), values in expected.items(): + for share, value in zip(("first", "total"), values): + with self.subTest(metric=metric, parameter=parameter, share=share): + estimate = _share(a, metric, parameter, share) + error = _share(a, metric, parameter, f"{share} se") + self.assertTrue((np.abs(estimate - value) <= 3 * error).all()) + np.testing.assert_array_equal(_share(a, "y", "s"), 0.0) + np.testing.assert_array_equal(_share(a, "z", "s"), 0.0) + np.testing.assert_array_equal(_share(a, "v", "u1"), 0.0) + np.testing.assert_array_equal(_share(a, "v", "s", "first"), 1.0) + # with common random numbers, the shares of y do not depend on x + np.testing.assert_allclose(*_share(a, "y", "u1").reshape(2, 1)) + + def test_standard_errors(self): + """The standard errors are those of the shares' estimates.""" + shares = self.attribution.shares + y = shares[(shares.metric == "y") & (shares.parameter != "s")] + self.assertTrue((y["total se"] > 0).all() and (y["total se"] < 0.1).all()) + # a share of 0 or 1 that every resample gives has no error + v = shares[(shares.metric == "v") & (shares.parameter == "s")] + np.testing.assert_array_equal(v["first se"], 0.0) + + def test_constant_metric(self): + """The shares of a metric that does not vary are undefined.""" + shares = self.attribution.shares + w = shares[shares.metric == "w"] + self.assertTrue((w["variance"] == 0).all()) + self.assertTrue( + w[["first", "total", "first se", "total se"]].isna().all().all() + ) + + def test_results(self): + """The results have the plain and the mixed replicates.""" + results = self.attribution.results + plain = results[results.redrawn.isna()] + self.assertEqual(sorted(plain.replicate.unique()), list(range(600))) + for name in ("u1", "u2", "s"): + mixed = results[results.redrawn == name] + self.assertEqual(len(mixed), 2 * 300) + self.assertEqual(sorted(mixed.replicate.unique()), list(range(300))) + # a mixed replicate draws its parameter as in B, and others as in A + a = plain.set_index(["design", "replicate"]) + mixed = results[results.redrawn == "u1"].set_index(["design", "replicate"]) + shifted = [(d, r + 300) for d, r in mixed.index] + np.testing.assert_array_equal(mixed.u1, a.loc[shifted].u1) + np.testing.assert_array_equal(mixed.u2, a.loc[mixed.index].u2) + + def test_summary(self): + """The summary pools the designs' shares, weighted by their variances.""" + a = self.attribution + summary = a.summary() + metrics = ["y", "z", "v", "w"] + self.assertEqual( + list(summary.columns), [*metrics, *(f"{m} se" for m in metrics)] + ) + self.assertEqual(list(summary.index), ["u1", "u2", "s"]) + rows = a.shares[(a.shares.metric == "y") & (a.shares.parameter == "u2")] + expected = (rows.total * rows.variance).sum() / rows.variance.sum() + self.assertAlmostEqual(summary.loc["u2", "y"], expected) + self.assertTrue(summary[["w", "w se"]].isna().all().all()) + # with common random numbers, the shares of y of both designs are the + # same in every resample, and so is their pooled share + np.testing.assert_allclose(summary.loc["u2", "y se"], rows["total se"]) + self.assertTrue((summary.loc[["u1", "u2"], ["y se", "z se"]] > 0).all().all()) + np.testing.assert_array_equal(summary.loc["s", ["y se", "z se"]], 0.0) + first = a.summary("first") + self.assertAlmostEqual(first.loc["s", "v"], 1.0) + self.assertAlmostEqual(first.loc["s", "v se"], 0.0) + self.assertEqual(a.samples["total"].shape, (len(a.shares), 200)) + with self.assertRaises(ValueError): + a.summary("second") + + def test_groups(self): + """Groups of parameters are redrawn together.""" + a = attribute_variance( + self.study, + self.designs[:1], + ["y"], + parameters={"normal": ["u1", "u2"], "seed": "s"}, + replicates=50, + n_resamples=50, + ) + self.assertEqual(list(a.shares.parameter), ["normal", "seed"]) + np.testing.assert_allclose(_share(a, "y", "normal", "first"), 1.0) + np.testing.assert_allclose(_share(a, "y", "normal", "total"), 1.0, atol=0.3) + np.testing.assert_array_equal(_share(a, "y", "seed", "total"), 0.0) + named = attribute_variance( + self.study, self.designs[:1], ["y"], parameters=["u2"], replicates=50 + ) + self.assertEqual(list(named.shares.parameter), ["u2"]) + self.assertEqual(set(named.results.redrawn.dropna()), {"u2"}) + + def test_validation(self): + """Unknown, repeated, or missing parameters and too few replicates raise.""" + for parameters in (["u3"], {"a": ["u1"], "b": ["u1", "u2"]}, {"a": []}, {}): + with self.subTest(parameters=parameters): + with self.assertRaises(ValueError): + attribute_variance( + self.study, self.designs, ["y"], parameters, replicates=2 + ) + with self.assertRaises(ValueError): + attribute_variance(self.study, self.designs, ["y"], replicates=1) + with self.assertRaises(ValueError): + attribute_variance(self.study, self.designs, ["q"], replicates=2) + certain = Study(DesignSpace(x=Integer(1, 2)), lambda d: d, lambda d: {"y": d.x}) + with self.assertRaises(ValueError): + attribute_variance(certain, certain.space.enumerate(), ["y"]) + + def test_inactive_branches(self): + """Designs that do not draw a parameter are not evaluated for it.""" + space = DesignSpace( + layout=Choice( + a=DesignSpace(phase=Uncertain.uniform(0, 1)), + b=DesignSpace(size=Integer(1, 2)), + ), + noise=Uncertain.uniform(0, 1), + ) + + def evaluate(d): + phase = d.layout.phase if d.layout.choice == "a" else 0.0 + return {"y": phase + d.noise} + + study = Study(space, lambda d: d, evaluate) + designs = space.enumerate() + a = attribute_variance(study, designs, ["y"], replicates=20, n_resamples=20) + redrawn = a.results[a.results.redrawn == "layout.a.phase"] + self.assertEqual(set(redrawn.design), {designs[0].key}) + shares = a.shares.set_index(["design", "parameter"]) + for design in designs[1:]: + self.assertTrue( + np.isnan(shares.loc[(design.key, "layout.a.phase"), "total"]) + ) + self.assertAlmostEqual( + shares.loc[(design.key, "noise"), "total"], 1.0, delta=0.5 + ) + + def test_infeasible(self): + """Infeasible evaluations are left out.""" + + def build(d): + if d.u1 > 1: + raise Infeasible("too large") + return d + + study = Study(SPACE, build, _evaluate) + a = attribute_variance( + study, self.designs[:1], ["y"], parameters=["u1", "u2"], replicates=100 + ) + self.assertFalse(a.results.feasible.all()) + self.assertTrue(a.shares[["first", "total"]].notna().all().all()) + + def reject(d): + raise Infeasible("never") + + never = Study(SPACE, reject, _evaluate) + with self.assertWarns(UserWarning): + none = attribute_variance(never, self.designs, ["y"], replicates=2) + self.assertEqual(len(none.shares), 0) + self.assertEqual(len(none.summary()), 0) + with self.assertWarns(UserWarning): + separated = attribute_variance( + never, self.designs, ["y"], replicates=2, by=["sensor"] + ) + self.assertEqual(len(separated.shares), 0) + + def test_by(self): + """The records of an evaluation are separated by `by`.""" + + def evaluate(d): + return pd.DataFrame( + {"y": [d.u1, d.u2]}, index=pd.Index(["one", "two"], name="sensor") + ) + + study = Study(SPACE, lambda d: d, evaluate) + a = attribute_variance( + study, + self.designs[:1], + ["y"], + parameters=["u1", "u2"], + replicates=20, + by=["sensor"], + ) + shares = a.shares.set_index(["sensor", "parameter"])["total"] + self.assertAlmostEqual(shares["one", "u1"], 1.0, delta=0.5) + self.assertEqual(shares["one", "u2"], 0.0) + self.assertEqual(shares["two", "u1"], 0.0) + self.assertEqual(list(a.summary().index.names), ["sensor", "parameter"]) + with self.assertRaises(ValueError): + attribute_variance(study, self.designs[:1], ["y"], replicates=2) + + def test_store(self): + """The evaluations are stored, and taken from the store again.""" + self.calls = [] + + def evaluate(d): + self.calls.append(d.replicate) + return _evaluate(d) + + with tempfile.TemporaryDirectory() as directory: + store = ResultStore(Path(directory) / "results.sqlite", "attribution") + study = Study(SPACE, lambda d: d, evaluate, replicates=3, store=store) + first = attribute_variance(study, self.designs, ["y"], replicates=3) + self.assertEqual(len(self.calls), 2 * (2 * 3 + 3 * 3)) + self.calls.clear() + again = attribute_variance(study, self.designs, ["y"], replicates=3) + self.assertEqual(self.calls, []) + pd.testing.assert_frame_equal(first.shares, again.shares) + + +def _evaluate_pairs(d): + """Metrics of differences with known shares: y = x (u1 + 2 u2), whose + difference between the designs is that of one design, and c = x u1 + u2, + whose difference is u1 alone (u2 cancels).""" + return {"y": d.x * (d.u1 + 2 * d.u2), "c": d.x * d.u1 + d.u2} + + +class TestDifferences(unittest.TestCase): + """ + Unit tests for attributing the variance of differences between designs. + """ + + @classmethod + def setUpClass(cls): + cls.designs = SPACE.enumerate() + cls.study = Study(SPACE, lambda d: d, _evaluate_pairs) + cls.attribution = attribute_variance( + cls.study, + cls.designs, + ["y", "c"], + parameters=["u1", "u2"], + replicates=200, + n_resamples=200, + ) + cls.differences = cls.attribution.differences() + + def test_cancelled(self): + """Parameters that act alike on both designs cancel in differences.""" + d = self.differences + self.assertEqual(list(d.shares.columns[:2]), ["design", "other"]) + self.assertEqual( + (d.shares.design.iloc[0], d.shares.other.iloc[0]), + (self.designs[0].key, self.designs[1].key), + ) + # c differs by u1 alone: u2 explains none of its variance in any resample + np.testing.assert_allclose(_share(d, "c", "u2"), 0.0, atol=1e-12) + np.testing.assert_allclose(_share(d, "c", "u1", "first"), 1.0) + estimate, error = _share(d, "c", "u1"), _share(d, "c", "u1", "total se") + self.assertTrue((np.abs(estimate - 1) <= 3 * error).all()) + self.assertAlmostEqual(d.summary().loc["u2", "c se"], 0.0) + # u2 spreads c of both designs, but not their difference + self.assertTrue((_share(self.attribution, "c", "u2") > 0.1).all()) + + def test_differences_of_one_design(self): + """The difference of y is that of a design, whose shares it has.""" + d, a = self.differences, self.attribution + for share in ("first", "total", "first se", "total se"): + for parameter in ("u1", "u2"): + np.testing.assert_allclose( + _share(d, "y", parameter, share), + _share(a, "y", parameter, share, self.designs[0].key), + ) + + def test_results(self): + """The results are the differences in each replicate.""" + results, differences = self.attribution.results, self.differences.results + plain = results[results.redrawn.isna()].set_index(["design", "replicate"]) + first, other = self.designs[0].key, self.designs[1].key + expected = plain.loc[first, "c"] - plain.loc[other, "c"] + found = differences[differences.redrawn.isna()].set_index("replicate")["c"] + np.testing.assert_allclose(found.sort_index(), expected.sort_index()) + self.assertEqual(len(differences), 2 * 200 + 2 * 200) + + def test_pairs(self): + """Pairs are given by designs or keys, and reversed pairs have the + same shares.""" + first, other = self.designs + reversed_ = self.attribution.differences([(other, first.key)]) + columns = ["variance", "first", "total", "first se", "total se"] + np.testing.assert_allclose( + reversed_.shares[columns], self.differences.shares[columns] + ) + self.assertEqual(reversed_.shares.design.iloc[0], other.key) + for pairs in ([(first, first)], [(first.key, "unknown")]): + with self.subTest(pairs=pairs): + with self.assertRaises(ValueError): + self.attribution.differences(pairs) + with self.assertRaises(ValueError): + self.differences.differences() + + def test_inactive_branches(self): + """A design that does not draw a parameter is as in A.""" + space = DesignSpace( + layout=Choice( + a=DesignSpace(phase=Uncertain.uniform(0, 1)), + b=DesignSpace(size=Integer(1, 2)), + ), + noise=Uncertain.uniform(0, 1), + ) + + def evaluate(d): + if d.layout.choice == "a": + return {"y": d.layout.phase + d.noise} + return {"y": d.layout.size * d.noise} + + study = Study(space, lambda d: d, evaluate) + designs = space.enumerate() + a = attribute_variance(study, designs, ["y"], replicates=20, n_resamples=20) + d = a.differences().shares.set_index(["design", "other", "parameter"]) + branch_a, b1, b2 = (design.key for design in designs) + # a less b1 is the phase alone + self.assertAlmostEqual(d.loc[(branch_a, b1, "noise"), "total"], 0.0) + self.assertAlmostEqual(d.loc[(branch_a, b1, "layout.a.phase"), "first"], 1.0) + # neither b1 nor b2 draws the phase + self.assertTrue(np.isnan(d.loc[(b1, b2, "layout.a.phase"), "total"])) + self.assertAlmostEqual(d.loc[(b1, b2, "noise"), "first"], 1.0) + + def test_independent_draws(self): + """Without common random numbers, no parameter cancels.""" + study = Study(SPACE, lambda d: d, _evaluate_pairs, common_random_numbers=False) + a = attribute_variance( + study, self.designs, ["c"], parameters=["u1", "u2"], replicates=200 + ) + d = a.differences() + # c of the designs differs by u1 of both and u2 of both: 5 and 2 of 7 + for parameter, value in (("u1", 5 / 7), ("u2", 2 / 7)): + estimate, error = _share(d, "c", parameter), _share( + d, "c", parameter, "total se" + ) + self.assertTrue((np.abs(estimate - value) <= 3 * error).all()) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/tradespace/test_scenarios.py b/tests/tradespace/test_scenarios.py new file mode 100644 index 00000000..3dee00be --- /dev/null +++ b/tests/tradespace/test_scenarios.py @@ -0,0 +1,265 @@ +""" +Unit tests for scenarios of studies and the robustness of designs across them. + +@author Paul T. Grogan +""" + +import math +import tempfile +import unittest +from concurrent.futures import ThreadPoolExecutor +from pathlib import Path + +import numpy as np +import pandas as pd + +from tatc.tradespace import ( + Criteria, + DesignSpace, + Fixed, + Integer, + Requirement, + ResultStore, + Study, + Uncertain, + aggregate, + attribute_variance, + robustness, +) + +SPACE = DesignSpace(x=Integer(1, 3), level=Fixed(1.0), noise=Uncertain.uniform(0, 1)) +SCENARIOS = {"low": {}, "high": {"level": 3.0}, "pinned": {"noise": 0.5}} + + +def _evaluate(d): + return {"y": d.x * d.level + d.noise, "cost": float(d.x)} + + +class TestStudyScenarios(unittest.TestCase): + """ + Unit tests for studies in scenarios. + """ + + def setUp(self): + self.directory = tempfile.TemporaryDirectory() + self.path = Path(self.directory.name) / "results.sqlite" + self.calls = [] + + def tearDown(self): + self.directory.cleanup() + + def _study(self, scenarios=None, **options): + def evaluate(d): + self.calls.append((d.x, d.replicate)) + return _evaluate(d) + + return Study( + SPACE, lambda d: d, evaluate, replicates=2, scenarios=scenarios, **options + ) + + def test_results(self): + """Each design is evaluated in each scenario in each replicate.""" + results = self._study(SCENARIOS).run() + self.assertEqual(len(results), 3 * 3 * 2) + self.assertEqual(list(results.columns[:3]), ["design", "replicate", "scenario"]) + first = results[results.design == results.design.iloc[0]] + self.assertEqual( + list(zip(first.scenario, first.replicate)), + [(s, r) for s in SCENARIOS for r in range(2)], + ) + by = results.set_index(["design", "replicate", "scenario"]) + low, high = by.xs("low", level="scenario"), by.xs("high", level="scenario") + # the same uncertain parameters in every scenario + np.testing.assert_array_equal(low.noise, high.noise) + np.testing.assert_allclose(high.y - low.y, 2 * low.cost) + pinned = by.xs("pinned", level="scenario") + self.assertTrue((pinned.noise == 0.5).all()) + # judged in each scenario + summary = aggregate(results, Criteria({"y": "max"}, by="scenario")) + self.assertEqual(len(summary), 3 * 3) + with self.assertRaises(ValueError): + aggregate(results, Criteria({"y": "max"})) + + def test_without_scenarios(self): + """A study without scenarios has no column of them.""" + results = self._study().run() + self.assertNotIn("scenario", results) + self.assertEqual(len(results), 3 * 2) + + def test_parallel(self): + """Studies in scenarios run in parallel as in sequence.""" + serial = self._study(SCENARIOS).run() + with ThreadPoolExecutor(2) as executor: + parallel = self._study(SCENARIOS, executor=executor).run() + columns = [c for c in serial.columns if c != "seconds"] + pd.testing.assert_frame_equal(serial[columns], parallel[columns]) + + def test_store(self): + """The evaluations of each scenario are stored by its values.""" + store = ResultStore(self.path, "scenarios") + plain = self._study(store=store).run() + self.assertEqual(len(self.calls), 6) + # a scenario without values shares the evaluations without scenarios + self.calls.clear() + both = self._study({"low": {}, "high": {"level": 3.0}}, store=store).run() + self.assertEqual(len(self.calls), 6) + low = both[both.scenario == "low"].drop(columns="scenario") + columns = [c for c in plain.columns if c != "seconds"] + pd.testing.assert_frame_equal( + low[columns].reset_index(drop=True), plain[columns] + ) + # renamed scenarios are taken from the store, changed ones evaluated + self.calls.clear() + self._study({"base": {}, "raised": {"level": 3.0}}, store=store).run() + self.assertEqual(self.calls, []) + self._study({"raised": {"level": 4.0}}, store=store).run() + self.assertEqual(len(self.calls), 6) + # the evaluations of scenarios are stored without their names + self.calls.clear() + again = self._study(store=store).run() + self.assertEqual(self.calls, []) + self.assertNotIn("scenario", again) + + def test_attribution(self): + """The variance of designs in each scenario is attributed to their + uncertain parameters.""" + store = ResultStore(self.path, "scenarios") + study = self._study(SCENARIOS, store=store) + a = attribute_variance( + study, SPACE.enumerate(), ["y"], replicates=20, by=["scenario"] + ) + shares = a.shares.set_index(["design", "scenario"])["total"] + key = SPACE.enumerate()[0].key + # y varies by its noise alone, but for the scenario that pins it + self.assertAlmostEqual(shares[key, "low"], 1.0, delta=0.5) + self.assertAlmostEqual(shares[key, "high"], 1.0, delta=0.5) + self.assertTrue(np.isnan(shares[key, "pinned"])) + self.calls.clear() + attribute_variance( + study, SPACE.enumerate(), ["y"], replicates=20, by=["scenario"] + ) + self.assertEqual(self.calls, []) + + def test_invalid(self): + """Scenarios set fixed values and uncertain parameters alone.""" + for scenarios in ({"a": {"x": 2}}, {"a": {"other": 1}}): + with self.subTest(scenarios=scenarios): + with self.assertRaises(ValueError): + self._study(scenarios) + for scenarios in ({"a": 1}, {1: {}}, [("a", {})]): + with self.subTest(scenarios=scenarios): + with self.assertRaises(TypeError): + self._study(scenarios) + named = DesignSpace(x=Integer(1, 2), scenario=Fixed("a")) + with self.assertRaises(ValueError): + Study(named, lambda d: d, _evaluate, scenarios={"a": {}}) + + +def _results(rows): + """Results of one replicate of designs in scenarios, from (design, + scenario, perf, cost) rows (`None` for infeasible).""" + records = [ + { + "design": design, + "replicate": 0, + "scenario": scenario, + "feasible": perf is not None, + "perf": math.nan if perf is None else perf, + "cost": math.nan if cost is None else cost, + } + for design, scenario, perf, cost in rows + ] + return pd.DataFrame(records) + + +# in s1, B dominates C (A and B are efficient); in s2, B dominates A and C +RESULTS = _results( + [ + ("A", "s1", 10, 5), + ("B", "s1", 8, 3), + ("C", "s1", 7, 4), + ("A", "s2", 6, 5), + ("B", "s2", 9, 3), + ("C", "s2", 9, 4), + ] +) +OBJECTIVES = {"perf": "max", "cost": "min"} + + +class TestRobustness(unittest.TestCase): + """ + Unit tests for the robustness of designs across scenarios. + """ + + def _robustness(self, results=RESULTS, criteria=OBJECTIVES, **options): + return robustness(results, criteria, **options).set_index("design") + + def test_trace_and_regret(self): + """The share of scenarios in which designs are efficient, and their + regret: the improvement in every objective to match the front.""" + r = self._robustness() + self.assertEqual( + list(r.columns), ["pareto trace", "max regret", "s1 regret", "s2 regret"] + ) + np.testing.assert_allclose(r["pareto trace"], [0.5, 1.0, 0.0]) + # C in s1: 1 short of B in both objectives (3 short of A in perf) + np.testing.assert_allclose(r["s1 regret"], [0, 0, 1]) + # A in s2: 3 short of B in perf (2 in cost); C: 1 short of B in cost + np.testing.assert_allclose(r["s2 regret"], [3, 0, 1]) + np.testing.assert_allclose(r["max regret"], [3, 0, 1]) + + def test_scale(self): + """Regret is in units of the scales of the objectives.""" + r = self._robustness(scale={"perf": 2}) + np.testing.assert_allclose(r["s1 regret"], [0, 0, 1]) + np.testing.assert_allclose(r["s2 regret"], [2, 0, 1]) + with self.assertRaises(ValueError): + self._robustness(scale={"other": 1}) + with self.assertRaises(ValueError): + self._robustness(scale={"perf": 0}) + + def test_tolerance(self): + """With tolerances, designs near the front are efficient, and regret + is in tolerances by default.""" + criteria = Criteria(OBJECTIVES, tolerance={"cost": 2}) + r = self._robustness(criteria=criteria) + np.testing.assert_allclose(r["pareto trace"], [0.5, 1.0, 1.0]) + # A in s2: 3 short of B and C in perf + np.testing.assert_allclose(r["s2 regret"], [3, 0, 0]) + + def test_requirements(self): + """Designs that miss the requirements, or are infeasible, have + infinite regret.""" + criteria = Criteria(OBJECTIVES, requirements=[Requirement("perf", ">=", 7)]) + r = self._robustness(criteria=criteria) + self.assertEqual(r.loc["A", "s2 regret"], math.inf) + self.assertEqual(r.loc["A", "max regret"], math.inf) + infeasible = pd.concat([RESULTS, _results([("D", "s1", None, None)])]) + infeasible = pd.concat( + [infeasible, _results([("D", "s2", 9, 2)])], ignore_index=True + ) + r = self._robustness(results=infeasible) + self.assertEqual(r.loc["D", "s1 regret"], math.inf) + self.assertEqual(r.loc["D", "s2 regret"], 0) + self.assertEqual(r.loc["D", "pareto trace"], 0.5) + + def test_invalid(self): + """Robustness needs scenarios, and criteria by them alone.""" + with self.assertRaises(ValueError): + robustness(RESULTS.drop(columns="scenario"), OBJECTIVES) + with self.assertRaises(ValueError): + robustness(RESULTS, Criteria(OBJECTIVES, by="other")) + r = robustness(RESULTS, Criteria(OBJECTIVES, by="scenario")) + self.assertEqual(len(r), 3) + + def test_study(self): + """The robustness of the designs of a study in scenarios.""" + results = Study(SPACE, lambda d: d, _evaluate, scenarios=SCENARIOS).run() + r = robustness(results, {"y": "max", "cost": "min"}) + # every design trades y against cost, in every scenario + np.testing.assert_allclose(r["pareto trace"], 1.0) + self.assertEqual(len(r), 3) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/tradespace/test_utility.py b/tests/tradespace/test_utility.py new file mode 100644 index 00000000..e021a762 --- /dev/null +++ b/tests/tradespace/test_utility.py @@ -0,0 +1,212 @@ +""" +Unit tests for utilities of the metrics of designs. + +@author Paul T. Grogan +""" + +import math +import unittest + +import numpy as np +import pandas as pd + +from tatc.tradespace import ( + Criteria, + ExponentialUtility, + LinearUtility, + Mean, + PiecewiseUtility, + Probability, + Quantile, + Requirement, + Utility, + aggregate, + pareto_front, +) + + +class TestSingleAttribute(unittest.TestCase): + """ + Unit tests for single-attribute utilities. + """ + + def test_linear(self): + """Linear utilities are 0 at the worst value and 1 at the best.""" + u = LinearUtility(0, 100) + np.testing.assert_allclose( + u([-10, 0, 50, 100, 120, np.nan]), [0, 0, 0.5, 1, 1, np.nan] + ) + # a metric to minimize + self.assertAlmostEqual(float(LinearUtility(10, 2)(6)), 0.5) + with self.assertRaises(ValueError): + LinearUtility(1, 1) + + def test_exponential(self): + """Exponential utilities are concave if averse, convex if seeking.""" + np.testing.assert_allclose(ExponentialUtility(0, 10, 2)([0, 10]), [0, 1]) + averse = float(ExponentialUtility(0, 10, 2)(5)) + self.assertAlmostEqual(averse, (1 - math.exp(-1)) / (1 - math.exp(-2))) + self.assertGreater(averse, 0.5) + self.assertLess(float(ExponentialUtility(0, 10, -2)(5)), 0.5) + np.testing.assert_allclose( + ExponentialUtility(0, 10)([2, 7]), LinearUtility(0, 10)([2, 7]) + ) + self.assertTrue(np.isnan(ExponentialUtility(0, 10, 2)(np.nan))) + + def test_piecewise(self): + """Piecewise utilities interpolate between points.""" + u = PiecewiseUtility([(50, 0.8), (0, 0), (100, 1)]) + np.testing.assert_allclose(u([-5, 25, 50, 75, 200]), [0, 0.4, 0.8, 0.9, 1]) + decreasing = PiecewiseUtility([(0, 1), (10, 0)]) + self.assertAlmostEqual(float(decreasing(2.5)), 0.75) + self.assertTrue(np.isnan(u(np.nan))) + for points in ([(0, 0)], [(0, 0), (0, 1)], [(0, 0), (1, 2)]): + with self.subTest(points=points): + with self.assertRaises(ValueError): + PiecewiseUtility(points) + + +class TestUtility(unittest.TestCase): + """ + Unit tests for multi-attribute utilities. + """ + + def setUp(self): + self.attributes = {"a": LinearUtility(0, 1), "b": LinearUtility(0, 1)} + + def test_additive(self): + """Additive utilities are weighted sums, by normalized weights.""" + u = Utility(self.attributes, {"a": 3, "b": 1}) + np.testing.assert_allclose( + u.evaluate( + {"a": np.array([1.0, 0.0, 0.5]), "b": np.array([0.0, 1.0, 0.5])} + ), + [0.75, 0.25, 0.5], + ) + self.assertEqual(u.scaling, 0.0) + self.assertEqual(u.columns, ("a", "b")) + + def test_multiplicative(self): + """Multiplicative utilities solve their scaling constant from the + weights: complements if they sum to less than 1, substitutes if more.""" + complements = Utility(self.attributes, {"a": 0.5, "b": 0.3}, "multiplicative") + # 1 + K = (1 + 0.5 K)(1 + 0.3 K) + self.assertAlmostEqual(complements.scaling, 4 / 3, places=9) + substitutes = Utility(self.attributes, {"a": 0.7, "b": 0.6}, "multiplicative") + self.assertAlmostEqual(substitutes.scaling, -0.3 / 0.42, places=9) + for u in (complements, substitutes): + values = { + "a": np.array([0.0, 1.0, 1.0, 0.0]), + "b": np.array([0.0, 1.0, 0.0, 1.0]), + } + weights = u.weights + np.testing.assert_allclose( + u.evaluate(values), [0, 1, weights["a"], weights["b"]], atol=1e-9 + ) + # complements reward doing well in both, substitutes in either + half = {"a": np.array([0.5]), "b": np.array([0.5])} + self.assertLess(complements.evaluate(half)[0], substitutes.evaluate(half)[0]) + # weights that sum to 1 are additive + additive = Utility(self.attributes, {"a": 0.4, "b": 0.6}, "multiplicative") + self.assertEqual(additive.scaling, 0.0) + + def test_frame(self): + """Utilities of the rows of a data frame.""" + u = Utility(self.attributes, {"a": 1, "b": 1}) + frame = pd.DataFrame({"a": [1.0, 0.0], "b": [1.0, 0.5]}, index=["x", "y"]) + pd.testing.assert_series_equal( + u(frame), pd.Series([1.0, 0.25], index=["x", "y"], name="utility") + ) + with self.assertRaises(ValueError): + u(frame.drop(columns="b")) + + def test_invalid(self): + """Utilities need a positive weight of each attribute.""" + for weights, form in ( + ({"a": 1}, "additive"), + ({"a": 1, "b": 1, "c": 1}, "additive"), + ({"a": 0, "b": 1}, "additive"), + ({"a": 1, "b": 1}, "other"), + ({"a": 1.5, "b": 0.5}, "multiplicative"), + ): + with self.subTest(weights=weights, form=form): + with self.assertRaises(ValueError): + Utility(self.attributes, weights, form) + with self.assertRaises(ValueError): + Utility({}, {}) + + +def _results(): + """Two designs in two replicates: x varies between replicates, y does not + (with the same mean of a).""" + return pd.DataFrame( + { + "design": ["x", "x", "y", "y"], + "replicate": [0, 1, 0, 1], + "feasible": True, + "a": [0.0, 1.0, 0.5, 0.5], + "cost": [1.0, 1.0, 2.0, 2.0], + } + ) + + +class TestStatistics(unittest.TestCase): + """ + Unit tests for statistics of utilities. + """ + + def setUp(self): + self.utility = Utility({"a": ExponentialUtility(0, 1, 2)}, {"a": 1}) + + def test_expected_utility(self): + """The mean of a utility is its expected value over the replicates, + which penalizes the spread of a risk-averse utility.""" + criteria = Criteria({"utility": "max"}, statistics={"utility": self.utility}) + self.assertEqual(criteria.metrics, ["a"]) + summary = aggregate(_results(), criteria).set_index("design") + expected = (0 + 1) / 2 + self.assertAlmostEqual(summary.loc["x", "utility"], expected) + self.assertAlmostEqual( + summary.loc["y", "utility"], float(ExponentialUtility(0, 1, 2)(0.5)) + ) + # the utility of the means is the same for both + means = aggregate(_results(), ["a"]).set_index("design") + np.testing.assert_allclose(self.utility(means), self.utility(means).iloc[0]) + + def test_statistics(self): + """Utilities are metrics of any statistic.""" + statistics = { + "worst": Quantile(self.utility, 0), + "reliable": Probability(self.utility, ">=", 0.5), + "expected": Mean(self.utility), + } + summary = aggregate(_results(), statistics).set_index("design") + self.assertEqual(summary.loc["x", "worst"], 0.0) + self.assertEqual(summary.loc["x", "reliable"], 0.5) + self.assertEqual(summary.loc["y", "reliable"], 1.0) + self.assertEqual(Mean(self.utility), Mean(self.utility)) + self.assertEqual(len({Mean(self.utility), Mean(self.utility)}), 1) + + def test_utility_against_cost(self): + """Designs trade the utility of their metrics against cost.""" + criteria = Criteria( + {"utility": "max", "cost": "min"}, + statistics={"utility": self.utility}, + requirements=[Requirement("worst", ">=", 0.1)], + ) + # a requirement on a statistic that the criteria do not name + with self.assertRaises(ValueError): + aggregate(_results(), criteria) + criteria = Criteria( + {"utility": "max", "cost": "min"}, + statistics={"utility": self.utility, "worst": Quantile(self.utility, 0)}, + requirements=[Requirement("worst", ">=", 0.1)], + ) + summary = aggregate(_results(), criteria) + front = summary[pareto_front(summary, criteria)] + # x is cheaper, but misses the requirement on its worst replicate + self.assertEqual(list(front.design), ["y"]) + + +if __name__ == "__main__": + unittest.main() From 79abd87aabac8c386a752a281d0feb63e8a99132 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Wed, 11 Nov 2026 21:59:15 -0700 Subject: [PATCH 27/52] describe layouts of constellations, and stage deployments by rules - Layouts of constellations (Layout and Plane, by layout_of: Walker, sun-synchronous planes, planes, and several layouts) replace the dispatch on the kind of a layout; launches and production move to a module of events, so that modules import one way. - A Stage of a deployment is produced and launched only if its rule decides to, at times during the mission, from what it knows then (a Decision) and the values of the design; deployed stages are replaced and restored as other planes, and others cost nothing. Exact expectations of missions need deployments that are not staged. - The metrics of phases, missions, and their cache are given the design if they take it (keyed by scenario). - Phases are documented as quasi-static (one window represents the mission), a design life as not retiring a satellite, and a planned replacement whose launch fails as not flown again. --- src/tatc/tradespace/__init__.py | 12 +- src/tatc/tradespace/constellations.py | 461 ++++++++++++++++++------ src/tatc/tradespace/cost.py | 25 -- src/tatc/tradespace/deployment.py | 200 +++++----- src/tatc/tradespace/events.py | 72 ++++ src/tatc/tradespace/histories.py | 34 +- src/tatc/tradespace/mission.py | 149 +++++++- tests/tradespace/test_constellations.py | 111 +++++- tests/tradespace/test_failures.py | 24 ++ tests/tradespace/test_stages.py | 163 +++++++++ 10 files changed, 1001 insertions(+), 250 deletions(-) create mode 100644 src/tatc/tradespace/events.py create mode 100644 tests/tradespace/test_stages.py diff --git a/src/tatc/tradespace/__init__.py b/src/tatc/tradespace/__init__.py index 650e67fe..d5fa2755 100644 --- a/src/tatc/tradespace/__init__.py +++ b/src/tatc/tradespace/__init__.py @@ -21,13 +21,16 @@ LaunchCost, OperationsCost, SatelliteCost, - plane_sizes, ) from .constellations import ( build_constellation, count_planes, count_satellites, + Layout, + Plane, hours_to_time, + layout_of, + plane_sizes, planes_space, remove_failures, sso_planes_space, @@ -38,6 +41,7 @@ DeploymentSchedule, Launch, Production, + Stage, ) from .histories import ( allocate_histories, @@ -46,6 +50,7 @@ summarize_missions, ) from .mission import ( + Decision, MissionHistory, Phase, PhaseCache, @@ -135,6 +140,7 @@ "CostEstimate", "CostModel", "Criteria", + "Decision", "Deployment", "DeploymentSchedule", "Derived", @@ -149,6 +155,7 @@ "Integer", "Launch", "LaunchCost", + "Layout", "Lifetime", "LinearUtility", "Maximum", @@ -160,6 +167,7 @@ "PhaseCache", "Piecewise", "PiecewiseUtility", + "Plane", "Probability", "Production", "Quantile", @@ -175,6 +183,7 @@ "Scope", "Screening", "Search", + "Stage", "StandardDeviation", "StandardError", "Statistic", @@ -202,6 +211,7 @@ "hours_to_time", "hypervolume", "hypervolume_progress", + "layout_of", "main_effects", "make_pymoo_problem", "optimize_optuna", diff --git a/src/tatc/tradespace/constellations.py b/src/tatc/tradespace/constellations.py index 4dc2bdbf..69d68063 100644 --- a/src/tatc/tradespace/constellations.py +++ b/src/tatc/tradespace/constellations.py @@ -29,13 +29,19 @@ def build(d): the design space, or the items of a `Repeat` of a `Choice` of layouts), whose satellites `build_constellation` builds together. +The values of a fragment in a design are those of a `Layout` (see +`layout_of`), which gives its planes and the orbits of their satellites, and +which other layouts extend. + @author: Paul T. Grogan """ from __future__ import annotations from collections.abc import Callable, Sequence +from dataclasses import dataclass from datetime import datetime, time, timedelta +from functools import partial from typing import Any import numpy as np @@ -50,7 +56,7 @@ def build(d): ) from .nodes import Derived, Fixed, Integer, Real, Repeat, Uncertain from .space import DesignSpace -from .values import ChoiceValues, RepeatValues, Scope, Values +from .values import ChoiceValues, RepeatValues, Scope WALKER = "walker" """The kind of the layouts of `walker_space`.""" @@ -329,73 +335,364 @@ def planes_space( return DesignSpace(constraints=constraints, **children) -def _layouts(layout: Any) -> list[Any] | None: +@dataclass(frozen=True) +class Plane: """ - Gets the layouts of several (a list or a repetition of layouts), or - `None` for a single layout. + An orbit plane of a layout (see `Layout`): its number of satellites, and + its values in a design. """ - if isinstance(layout, (list, tuple, RepeatValues)): - return list(layout) - return None + satellites: int + """int: The number of satellites.""" + values: Any = None + """Any: The values of the plane in a design (such as those of each plane + of `sso_planes_space`), or `None` (as for the planes of a Walker + constellation), as given to the `order` of a `DeploymentSchedule`.""" + + +class Layout: + """ + The satellites of a constellation, plane by plane: a Walker + constellation (`WalkerLayout`), planes of sun-synchronous orbits + (`SSOPlanesLayout`) or of inclined orbits (`PlanesLayout`), or several + layouts flown together (`Layouts`). `layout_of` gets the layout of the + values of a design (of `walker_space`, `sso_planes_space`, or + `planes_space`). The functions of layouts (`build_constellation`, + `count_satellites`, `count_planes`, `plane_sizes`, and + `DeploymentSchedule.plan`) take either. + + The satellites of a layout are those of its planes in order, and those of + each plane in their order in it, so that the satellites that `build` + builds are those of the planes that a deployment launches (see + `DeploymentSchedule.plan` and `MissionHistory.phases`). + + Other layouts subclass it, implementing `planes` and `orbits` (and + `names`, for names other than `"

-"`), so that they are + built, counted, deployed, and costed as the others. + """ + + def planes(self) -> list[Plane]: + """ + Gets the planes, in order. + + Returns: + list[Plane]: the planes + """ + raise NotImplementedError + + def orbits(self, epoch: datetime, altitude: float | None = None) -> list[list[Any]]: + """ + Gets the orbits of the satellites of each plane, in the order of the + planes. + + Args: + epoch (datetime.datetime): The epoch of the orbits. + altitude (float | None): The altitude (meters), or `None` for + that of the layout. + + Returns: + list[list]: the orbits of the satellites of each plane + + Raises: + ValueError: if no altitude is given and the layout has none. + """ + raise NotImplementedError + + def names(self, name: str) -> list[list[str]]: + """ + Gets the names of the satellites of each plane: `"

-"` + (plane `p`, satellite `s`). + + Args: + name (str): The prefix of the names. + + Returns: + list[list[str]]: the names of the satellites of each plane + """ + return [ + [f"{name} {p + 1}-{s + 1}" for s in range(plane.satellites)] + for p, plane in enumerate(self.planes()) + ] + + @property + def satellites(self) -> int: + """int: The number of satellites.""" + return sum(plane.satellites for plane in self.planes()) + + def build( + self, + payload: Payload, + *, + epoch: datetime, + altitude: float | None = None, + name: str = "satellite", + time_step: float | None = None, + ) -> list[Satellite]: + """ + Builds the satellites, in the order of the planes, each with a + payload (see `build_constellation`). + + Args: + payload (Payload): The payload of each satellite. + epoch (datetime.datetime): The epoch of the orbits. + altitude (float | None): The altitude (meters), if the layout does + not give it. + name (str): The prefix of the names of the satellites. + time_step (float | None): The analysis time step (seconds), for + catalog configurations that tailor a field of view to it. + + Returns: + list[Satellite]: the satellites + + Raises: + ValueError: if the orbits or names of the satellites do not match + the planes. + """ + counts = [plane.satellites for plane in self.planes()] + orbits, names = self.orbits(epoch, altitude), self.names(name) + if [len(o) for o in orbits] != counts or [len(n) for n in names] != counts: + raise ValueError("the orbits and names of a layout must match its planes") + return [ + _make_satellite(payload, satellite, orbit, time_step) + for plane_names, plane_orbits in zip(names, orbits) + for satellite, orbit in zip(plane_names, plane_orbits) + ] + + +def _get_altitude(values: Any, altitude: float | None) -> float: + """Gets the given altitude, or that of the values of a layout.""" + altitude = getattr(values, "altitude", None) if altitude is None else altitude + if altitude is None: + raise ValueError("the layout has no altitude: give one") + return altitude + + +class WalkerLayout(Layout): + """ + A Walker constellation (see `tatc.schemas.WalkerConstellation`): the + values of `walker_space` in a design. Its satellites are named + `" "`, in order. + + Args: + values (Values): The values of the layout. + """ + + def __init__(self, values: Any): + self.values = values + + def planes(self) -> list[Plane]: + return [Plane(int(self.values.per_plane))] * int(self.values.planes) + + def orbits(self, epoch: datetime, altitude: float | None = None) -> list[list[Any]]: + values = self.values + members = WalkerConstellation( + name="walker", + configuration=values.configuration, + orbit=CircularOrbit( + altitude=_get_altitude(values, altitude), + inclination=values.inclination, + true_anomaly=getattr(values, "true_anomaly", 0.0), + right_ascension_ascending_node=getattr(values, "right_ascension", 0.0), + epoch=epoch, + ), + number_planes=values.planes, + number_satellites=values.planes * values.per_plane, + relative_spacing=values.relative_spacing, + ).generate_members() + # the members of each plane follow each other + size = int(values.per_plane) + return [ + [member.orbit for member in members[p * size : (p + 1) * size]] + for p in range(int(values.planes)) + ] + + def names(self, name: str) -> list[list[str]]: + size = int(self.values.per_plane) + return [ + [f"{name} {p * size + s + 1}" for s in range(size)] + for p in range(int(self.values.planes)) + ] + + +class _PlanesLayout(Layout): + """ + Planes of circular orbits, each with its own number of satellites, + evenly spaced or in a train (see `sso_planes_space`). + """ + + def __init__(self, values: Any): + self.values = values + + def planes(self) -> list[Plane]: + return [Plane(int(plane.satellites), plane) for plane in self.values.planes] + + def _orbit(self, plane: Any, epoch: datetime, altitude: float, anomaly: float): + """Gets the orbit of a satellite of a plane at a true anomaly.""" + raise NotImplementedError + + def orbits(self, epoch: datetime, altitude: float | None = None) -> list[list[Any]]: + altitude = _get_altitude(self.values, altitude) + repeat_ground_track = getattr(self.values, "repeat_ground_track", True) + return [ + _plane_orbits( + partial(self._orbit, plane, epoch, altitude), plane, repeat_ground_track + ) + for plane in self.values.planes + ] + + +class SSOPlanesLayout(_PlanesLayout): + """ + Planes of sun-synchronous orbits (see `tatc.schemas.SunSynchronousOrbit`): + the values of `sso_planes_space` in a design. Its satellites are named + `"

-"` (plane `p`, satellite `s`). + + Args: + values (Values): The values of the layout. + """ + + def _orbit(self, plane: Any, epoch: datetime, altitude: float, anomaly: float): + return SunSynchronousOrbit( + altitude=altitude, + equator_crossing_time=hours_to_time(plane.crossing), + equator_crossing_ascending=self.values.ascending, + epoch=epoch, + true_anomaly=anomaly, + ) + + +class PlanesLayout(_PlanesLayout): + """ + Planes of inclined circular orbits (see `tatc.schemas.CircularOrbit`): + the values of `planes_space` in a design. Its satellites are named + `"

-"` (plane `p`, satellite `s`). + + Args: + values (Values): The values of the layout. + """ + + def _orbit(self, plane: Any, epoch: datetime, altitude: float, anomaly: float): + return CircularOrbit( + altitude=altitude, + inclination=plane.inclination, + right_ascension_ascending_node=float(plane.node) % 360, + epoch=epoch, + true_anomaly=anomaly, + ) + + +class Layouts(Layout): + """ + Several layouts flown together (such as the shells of a mixed + constellation): their planes in turn, whose satellites are named with a + letter for each layout (`" A 1"`, `" B 1-1"`). + + Args: + layouts (Sequence): The layouts, or the values of each (see + `layout_of`). + """ + + def __init__(self, layouts: Sequence[Any]): + self.layouts = [layout_of(layout) for layout in layouts] + + def planes(self) -> list[Plane]: + return [plane for layout in self.layouts for plane in layout.planes()] -def _layout(layout: Any) -> Any: - """Gets the values of a layout (the chosen branch of a choice).""" - return layout.value if isinstance(layout, ChoiceValues) else layout + def orbits(self, epoch: datetime, altitude: float | None = None) -> list[list[Any]]: + return [ + orbits + for layout in self.layouts + for orbits in layout.orbits(epoch, altitude) + ] + def names(self, name: str) -> list[list[str]]: + return [ + names + for k, layout in enumerate(self.layouts) + for names in layout.names(f"{name} {chr(65 + k) if k < 26 else k + 1}") + ] + + +_KINDS = {WALKER: WalkerLayout, SSO_PLANES: SSOPlanesLayout, PLANES: PlanesLayout} +"""The layouts of the kinds of the fragments of design spaces.""" + + +def layout_of(layout: Any) -> Layout: + """ + Gets the layout of the values of a design: those of `walker_space`, + `sso_planes_space`, or `planes_space` (or of a choice of them), or of + several (a list or a repetition of layouts, see `Layouts`). A layout is + its own. + + Args: + layout (Any): The values of the layout (or layouts), or a layout. -def _kind(layout: Any) -> str: - try: - return layout.kind - except AttributeError: + Returns: + Layout: the layout + + Raises: + ValueError: if the values are not those of a layout. + """ + if isinstance(layout, Layout): + return layout + if isinstance(layout, (list, tuple, RepeatValues)): + return Layouts(list(layout)) + if isinstance(layout, ChoiceValues): + layout = layout.value + kind = getattr(layout, "kind", None) + if not isinstance(kind, str) or kind not in _KINDS: raise ValueError( "a layout must be the values of walker_space, sso_planes_space, " - + "or planes_space" - ) from None + + "or planes_space, or a Layout" + ) + return _KINDS[kind](layout) def count_satellites(layout: Any) -> int: """ Counts the satellites of a layout (the values of `walker_space`, - `sso_planes_space`, or `planes_space`, or of a choice of them), or of - several (a list or a repetition of layouts), for objectives and + `sso_planes_space`, or `planes_space`, or of a choice of them, or of + several, or a `Layout`, see `layout_of`), for objectives and constraints. Args: - layout (Any): The values of the layout (or layouts). + layout (Any): The values of the layout (or layouts), or a layout. Returns: int: the number of satellites """ - several = _layouts(layout) - if several is not None: - return sum(count_satellites(item) for item in several) - layout = _layout(layout) - if _kind(layout) == WALKER: - return int(layout.planes * layout.per_plane) - return int(sum(plane.satellites for plane in layout.planes)) + return layout_of(layout).satellites def count_planes(layout: Any) -> int: """ Counts the orbit planes of a layout (the values of `walker_space`, - `sso_planes_space`, or `planes_space`, or of a choice of them), or of - several (a list or a repetition of layouts), each of which needs its own + `sso_planes_space`, or `planes_space`, or of a choice of them, or of + several, or a `Layout`, see `layout_of`), each of which needs its own launch. Args: - layout (Any): The values of the layout (or layouts). + layout (Any): The values of the layout (or layouts), or a layout. Returns: int: the number of planes """ - several = _layouts(layout) - if several is not None: - return sum(count_planes(item) for item in several) - layout = _layout(layout) - if _kind(layout) == WALKER: - return int(layout.planes) - return len(layout.planes) + return len(layout_of(layout).planes()) + + +def plane_sizes(layout: Any) -> list[int]: + """ + Gets the number of satellites of each orbit plane of a layout (the + values of `walker_space`, `sso_planes_space`, or `planes_space`, or of a + choice of them, or of several, or a `Layout`, see `layout_of`). + + Args: + layout (Any): The values of the layout (or layouts), or a layout. + + Returns: + list[int]: the number of satellites of each plane + """ + return [plane.satellites for plane in layout_of(layout).planes()] def hours_to_time(hours: float) -> time: @@ -487,7 +784,7 @@ def _plane_orbits( def build_constellation( - layout: Values | ChoiceValues | Sequence[Values | ChoiceValues] | RepeatValues, + layout: Any, payload: Payload, *, epoch: datetime, @@ -498,7 +795,8 @@ def build_constellation( """ Builds the satellites of a layout: the values of `walker_space`, `sso_planes_space`, or `planes_space` in a design (or of a choice of - them), at the layout's altitude (or the given one), each with a payload: + them), or a `Layout` (see `layout_of`), at the layout's altitude (or the + given one), each with a payload: * an `Instrument` (or a list of instruments); * the identifier of an entry of the instrument catalog (see @@ -511,17 +809,17 @@ def build_constellation( * a function of a name and an orbit that builds a satellite. Satellites of Walker constellations are named `" "`, and - those of planes `"

-"` (plane `p`, satellite `s`). + those of planes `"

-"` (plane `p`, satellite `s`), in the + order of the planes (see `Layout`). Several layouts (a list or a repetition of layouts, such as the shells - of a mixed constellation) are built in turn, with the same payload, and - the names of their satellites are prefixed by a letter for each layout - (`" A 1"`, `" B 1-1"`). Build layouts with different - payloads in separate calls, with different names. + of a mixed constellation, see `Layouts`) are built in turn, with the + same payload, and the names of their satellites are prefixed by a + letter for each layout (`" A 1"`, `" B 1-1"`). Build layouts + with different payloads in separate calls, with different names. Args: - layout (Values | ChoiceValues | Sequence): The values of the layout - (or layouts). + layout (Any): The values of the layout (or layouts), or a layout. payload (Payload): The payload of each satellite. epoch (datetime.datetime): The epoch of the orbits. altitude (float | None): The altitude (meters), if the layout does @@ -533,76 +831,9 @@ def build_constellation( Returns: list[Satellite]: the satellites """ - several = _layouts(layout) - if several is not None: - return [ - satellite - for k, item in enumerate(several) - for satellite in build_constellation( - item, - payload, - epoch=epoch, - altitude=altitude, - name=f"{name} {chr(65 + k) if k < 26 else k + 1}", - time_step=time_step, - ) - ] - layout = _layout(layout) - kind = _kind(layout) - altitude = getattr(layout, "altitude", None) if altitude is None else altitude - if altitude is None: - raise ValueError("the layout has no altitude: give one") - if kind == WALKER: - members = WalkerConstellation( - name=name, - configuration=layout.configuration, - orbit=CircularOrbit( - altitude=altitude, - inclination=layout.inclination, - true_anomaly=getattr(layout, "true_anomaly", 0.0), - right_ascension_ascending_node=getattr(layout, "right_ascension", 0.0), - epoch=epoch, - ), - number_planes=layout.planes, - number_satellites=layout.planes * layout.per_plane, - relative_spacing=layout.relative_spacing, - ).generate_members() - return [ - _make_satellite(payload, f"{name} {k + 1}", member.orbit, time_step) - for k, member in enumerate(members) - ] - satellites = [] - for p, plane in enumerate(layout.planes): - if kind == SSO_PLANES: - - def make(anomaly, plane=plane): - return SunSynchronousOrbit( - altitude=altitude, - equator_crossing_time=hours_to_time(plane.crossing), - equator_crossing_ascending=layout.ascending, - epoch=epoch, - true_anomaly=anomaly, - ) - - else: - - def make(anomaly, plane=plane): - return CircularOrbit( - altitude=altitude, - inclination=plane.inclination, - right_ascension_ascending_node=float(plane.node) % 360, - epoch=epoch, - true_anomaly=anomaly, - ) - - orbits = _plane_orbits( - make, plane, getattr(layout, "repeat_ground_track", True) - ) - satellites.extend( - _make_satellite(payload, f"{name} {p + 1}-{s + 1}", orbit, time_step) - for s, orbit in enumerate(orbits) - ) - return satellites + return layout_of(layout).build( + payload, epoch=epoch, altitude=altitude, name=name, time_step=time_step + ) def remove_failures( diff --git a/src/tatc/tradespace/cost.py b/src/tatc/tradespace/cost.py index 9118ab5b..0930df59 100644 --- a/src/tatc/tradespace/cost.py +++ b/src/tatc/tradespace/cost.py @@ -40,7 +40,6 @@ def evaluate(built): import numpy as np import pandas as pd -from .constellations import PLANES, SSO_PLANES, WALKER, _kind, _layout, _layouts from .deployment import Deployment from .mission import MissionHistory @@ -48,30 +47,6 @@ def evaluate(built): """The elements of the cost of a constellation.""" -def plane_sizes(layout: Any) -> list[int]: - """ - Gets the number of satellites of each orbit plane of a layout (the - values of `walker_space`, `sso_planes_space`, or `planes_space`, or of a - choice of them), or of several (a list or a repetition of layouts). - - Args: - layout (Any): The values of the layout (or layouts). - - Returns: - list[int]: the number of satellites of each plane - """ - several = _layouts(layout) - if several is not None: - return [size for item in several for size in plane_sizes(item)] - layout = _layout(layout) - kind = _kind(layout) - if kind == WALKER: - return [int(layout.per_plane)] * int(layout.planes) - if kind in (SSO_PLANES, PLANES): - return [int(plane.satellites) for plane in layout.planes] - raise ValueError(f"unknown layout {kind!r}") - - @dataclass(frozen=True) class SatelliteCost: """ diff --git a/src/tatc/tradespace/deployment.py b/src/tatc/tradespace/deployment.py index 3d4558b4..a3226c7f 100644 --- a/src/tatc/tradespace/deployment.py +++ b/src/tatc/tradespace/deployment.py @@ -16,10 +16,19 @@ what is produced and launched, which a `CostModel` prices, and of the satellites that operate. Their changes divide the mission into phases (`MissionHistory.phases`) of constant sets of operating satellites, each -evaluated over the study's representative period (`evaluate_phases`) and -combined over the mission (`summarize_phases`), such as the time-weighted +evaluated over the study's representative period (`evaluate_phases`, which +states what these quasi-static phases assume) and combined over the mission +(`summarize_phases`), such as the time-weighted mean of a metric and the time until it first meets a requirement. +A deployment may be staged (see `Stage`): planes that are produced and +launched only if a rule decides to, at times during the mission, from what +it knows then (see `Decision`), such as a second plane that is launched only +if the mission turns out to need it. Whether and how to stage a deployment +is a decision of a design, whose flexibility (the cost saved where a stage +is not needed, against the capability lost by deferring it where it is) the +analyses of a study compare with deployments that are not staged. + @author: Paul T. Grogan """ @@ -28,91 +37,73 @@ import math from collections.abc import Callable, Mapping, Sequence from dataclasses import dataclass, field -from typing import TYPE_CHECKING, Any +from typing import Any from ..schemas import Satellite -from .constellations import PLANES, SSO_PLANES, WALKER, _kind, _layout, _layouts +from .constellations import layout_of +from .events import Launch, PerType, Production, _per_type from .failures import FailureModel, RestorationPolicy +from .histories import _simulate_many +from .histories import expected_metrics as _expected_metrics +from .mission import Decision, MissionHistory, Phase, _Simulation from .values import Values -if TYPE_CHECKING: - from .mission import MissionHistory, Phase - -PerType = float | Mapping[Any, float] -"""A value for every type of satellite, or for each (by its name).""" - - -def _per_type(value: Any, kind: Any, name: str) -> Any: - """Gets the value of a type of satellite.""" - if isinstance(value, Mapping): - if kind not in value: - raise ValueError(f"no {name} of satellites of kind {kind!r}") - return value[kind] - return value - - -def _planes(layout: Any) -> list[tuple[int, Any]]: - """ - Gets the planes of a layout (or several): the number of satellites of - each, and its values (or `None` for the planes of a Walker layout). - """ - several = _layouts(layout) - if several is not None: - return [plane for item in several for plane in _planes(item)] - layout = _layout(layout) - kind = _kind(layout) - if kind == WALKER: - return [(int(layout.per_plane), None)] * int(layout.planes) - if kind in (SSO_PLANES, PLANES): - return [(int(plane.satellites), plane) for plane in layout.planes] - raise ValueError(f"unknown layout {kind!r}") - @dataclass(frozen=True) -class Launch: +class Stage: """ - A launch of satellites of a plane (see `Deployment` and - `MissionHistory`). - """ - - time: float - """float: The time (years from the start of development).""" - plane: int - """int: The plane (its index, in the order of the layouts' planes).""" - kind: Any - """Any: The type of its satellites.""" - first: int - """int: The position in its plane of its first satellite (-1 for the - launches of restorations and spares).""" - satellites: int - """int: The number of satellites (including spares).""" - generation: int = 0 - """int: The generation (0 for the first, others planned replacements).""" - purpose: str = "deployment" - """str: `"deployment"`, `"replacement"` (planned, at the end of a - design life), `"restoration"` (of failed satellites), or `"spare"` (a - spare in orbit replenished).""" - failed: bool = False - """bool: Whether the launch failed, losing its satellites.""" - + A stage of a deployment (see `DeploymentSchedule.plan`): planes that are + deployed only if (and when) a rule decides to. At each of its `times` + (years after the first launch) until it is deployed, the rule is given + what is known then (see `Decision`) and returns whether to deploy the + stage. A deployed stage's satellites are produced on their type's line + `lead_years` after the decision (after the work before them), and + launched at the next launch slots (in as many launches as they need, see + `DeploymentSchedule`); they are then replaced at the end of their design + life and restored if they fail, as the satellites of other planes. A + stage that is not deployed is neither produced nor launched, and its + satellites never operate. + + A rule that depends on the values of a design (such as an uncertain + parameter or a value of a scenario, known by the time of the decision) + reads them from the design, as stages made for each design (see + `MissionPlan`) can: for example, `Stage([1], 1.0, lambda decision: + design.decorrelation_time < timedelta(hours=6))`. -@dataclass(frozen=True) -class Production: - """ - The production of satellites of a type (see `Deployment` and - `MissionHistory`). + Args: + planes (Sequence[int] | int): The planes of the stage (their indices, + in the order of the layouts' planes), produced and launched in + this order. + times (float | Sequence[float]): The times of the decisions, in years + after the first launch. + rule (Callable | None): A function of a `Decision` that returns + whether to deploy the stage, or `None` to deploy it at the first + time (a planned delay). + lead_years (float): The time from a decision to the start of the + production of the stage's satellites (such as to procure + long-lead items). """ - kind: Any - """Any: The type of the satellites.""" - begin: float - """float: The start of their production (years).""" - end: float - """float: The end of their production (years).""" - satellites: int - """int: The number of satellites.""" - purpose: str = "deployment" - """str: `"deployment"`, `"replacement"`, `"restoration"`, or `"spare"`.""" + planes: Sequence[int] | int + times: float | Sequence[float] = 0.0 + rule: Callable[[Decision], bool] | None = None + lead_years: float = 0.0 + + def __post_init__(self): + planes = (self.planes,) if isinstance(self.planes, int) else self.planes + planes = tuple(int(plane) for plane in planes) + if not planes: + raise ValueError("a stage needs planes") + if len(set(planes)) != len(planes) or min(planes) < 0: + raise ValueError("the planes of a stage must be distinct indices") + times = self.times if isinstance(self.times, Sequence) else (self.times,) + times = tuple(sorted(float(time) for time in times)) + if not times or times[0] < 0: + raise ValueError("a stage needs times of decisions, not negative") + if self.lead_years < 0: + raise ValueError("lead_years must not be negative") + object.__setattr__(self, "planes", planes) + object.__setattr__(self, "times", times) @dataclass @@ -137,6 +128,9 @@ class Deployment: """list[Launch]: The launches (and planned replacements), in order.""" masses: dict[Any, float | None] = field(default_factory=dict) """dict: The mass (kg) of each type of satellite, if given.""" + stages: tuple[Stage, ...] = () + """tuple[Stage, ...]: The stages deployed only if their rules decide to + (whose planes the production and launches above do not include).""" _planned: MissionHistory | None = field(default=None, repr=False, compare=False) @property @@ -187,6 +181,11 @@ def simulate( same age in the same replicate of every design. Spares in orbit do not age or fail until they take a failed satellite's place. + A planned replacement (at the end of a design life) whose launch + fails is not flown again: the satellite it would replace operates + until it fails (and is then restored, by a policy that restores + failures). + Args: failures (FailureModel | None): The failures, or `None` for none. policy (RestorationPolicy | None): The policy for failed @@ -198,9 +197,6 @@ def simulate( Returns: MissionHistory: the history of the mission """ - # pylint: disable=import-outside-toplevel - from .mission import _Simulation - return _Simulation( self, failures or FailureModel(), policy or RestorationPolicy(), seed ).run() @@ -275,9 +271,6 @@ def simulate_many( Returns: list[MissionHistory]: the histories """ - # pylint: disable=import-outside-toplevel - from .histories import _simulate_many - if histories < 1: raise ValueError("histories must be at least 1") if seed is None: @@ -310,15 +303,13 @@ def expected_metrics( Returns: dict[str, float]: the mean of each measure """ - # pylint: disable=import-outside-toplevel - from .histories import expected_metrics - - return expected_metrics(self, failures, policy, histories, seed, sampling) + return _expected_metrics(self, failures, policy, histories, seed, sampling) def phases(self, satellites: Sequence[Satellite | str]) -> list[Phase]: """ Gets the phases of the mission without failures (see - `MissionHistory.phases`). + `MissionHistory.phases`), each evaluated over the same window (see + `evaluate_phases`). Args: satellites (Sequence[Satellite | str]): The satellites (or their @@ -350,7 +341,10 @@ class DeploymentSchedule: * The mission lasts `years` from the first launch. Satellites are replaced at the end of their `design_life` (if before the end of the mission), each replacement produced at the production rate just - before it is needed and launched then. + before it is needed and launched then. A design life does not retire + a satellite: one that is not replaced (as near the end of the mission, + or if its replacement's launch fails) operates until it fails (by the + wear-out of its life, see `FailureModel`). A schedule that is itself a decision (such as the launch cadence) is a design variable, with the schedule made for each design (such as with @@ -432,11 +426,15 @@ def plan( kind: Any = None, spares: int = 0, masses: PerType | None = None, + stages: Sequence[Stage] = (), ) -> Deployment: """ Plans the deployment of a constellation: the layout (or layouts) of its satellites, of one type (`kind`), or a mapping of types to - layouts (such as the shells of a mixed constellation). + layouts (such as the shells of a mixed constellation). The planes of + `stages` are deployed only if (and when) their rules decide to, in a + simulation of the mission (see `Stage` and `Deployment.simulate`), and + the others as planned. Args: layout (Any): The layout (or layouts) of the satellites, or a @@ -447,19 +445,29 @@ def plan( failed satellites (see `RestorationPolicy`). masses (float | Mapping | None): The mass (kg) of the satellites (of each type), for a launch capacity in mass. + stages (Sequence[Stage]): The stages deployed later, if their + rules decide to. Returns: Deployment: the deployment + + Raises: + ValueError: if a plane is in several stages or is not a plane of + the layouts, or if no satellites are planned. """ # pylint: disable=too-many-locals if spares < 0: raise ValueError("spares must not be negative") + stages = tuple(stages) + staged = [plane for stage in stages for plane in stage.planes] + if len(set(staged)) != len(staged): + raise ValueError("a plane is in several stages") # a mapping of types to layouts (the values of a layout are a mapping too) if isinstance(layout, Mapping) and not isinstance(layout, Values): fleets = dict(layout) else: fleets = {kind: layout} - deployment = Deployment(schedule=self) + deployment = Deployment(schedule=self, stages=stages) planes = [] # (ready, index, kind, satellites, mass) for name, item in fleets.items(): developed = float(_per_type(self.development_years, name, "development")) @@ -468,10 +476,11 @@ def plan( deployment.development[name] = developed deployment.masses[name] = mass listed = [] - for size, values in _planes(item): + for plane in layout_of(item).planes(): + size, values = plane.satellites, plane.values index = len(deployment.planes) deployment.planes.append((name, size, spares if size > 0 else 0)) - if size > 0: + if size > 0 and index not in staged: listed.append((index, size + spares, values)) if self.order is not None: listed.sort(key=lambda plane: self.order(plane[0], plane[2])) @@ -481,8 +490,13 @@ def plan( deployment.production.append(Production(name, line, ready, size)) planes.append((ready, index, name, size, mass)) line = ready + unknown = sorted(set(staged) - set(range(len(deployment.planes)))) + if unknown: + raise ValueError( + f"stages of planes that the layouts do not have: {unknown}" + ) if not planes: - raise ValueError("a deployment requires satellites") + raise ValueError("a deployment requires satellites (that are not staged)") cadence = -math.inf for ready, index, name, size, mass in sorted(planes, key=lambda p: p[0]): count = self.launches_of(size, mass) diff --git a/src/tatc/tradespace/events.py b/src/tatc/tradespace/events.py new file mode 100644 index 00000000..2f3e57ff --- /dev/null +++ b/src/tatc/tradespace/events.py @@ -0,0 +1,72 @@ +""" +Events of the deployments of constellations: the production and launches of +satellites (see `Deployment` and `MissionHistory`), and values given for +each type of satellite. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +from collections.abc import Mapping +from dataclasses import dataclass +from typing import Any + +PerType = float | Mapping[Any, float] +"""A value for every type of satellite, or for each (by its name).""" + + +def _per_type(value: Any, kind: Any, name: str) -> Any: + """Gets the value of a type of satellite.""" + if isinstance(value, Mapping): + if kind not in value: + raise ValueError(f"no {name} of satellites of kind {kind!r}") + return value[kind] + return value + + +@dataclass(frozen=True) +class Launch: + """ + A launch of satellites of a plane (see `Deployment` and + `MissionHistory`). + """ + + time: float + """float: The time (years from the start of development).""" + plane: int + """int: The plane (its index, in the order of the layouts' planes).""" + kind: Any + """Any: The type of its satellites.""" + first: int + """int: The position in its plane of its first satellite (-1 for the + launches of restorations and spares).""" + satellites: int + """int: The number of satellites (including spares).""" + generation: int = 0 + """int: The generation (0 for the first, others planned replacements).""" + purpose: str = "deployment" + """str: `"deployment"`, `"replacement"` (planned, at the end of a + design life), `"restoration"` (of failed satellites), or `"spare"` (a + spare in orbit replenished).""" + failed: bool = False + """bool: Whether the launch failed, losing its satellites.""" + + +@dataclass(frozen=True) +class Production: + """ + The production of satellites of a type (see `Deployment` and + `MissionHistory`). + """ + + kind: Any + """Any: The type of the satellites.""" + begin: float + """float: The start of their production (years).""" + end: float + """float: The end of their production (years).""" + satellites: int + """int: The number of satellites.""" + purpose: str = "deployment" + """str: `"deployment"`, `"replacement"`, `"restoration"`, or `"spare"`.""" diff --git a/src/tatc/tradespace/histories.py b/src/tatc/tradespace/histories.py index 0234822c..6d38874d 100644 --- a/src/tatc/tradespace/histories.py +++ b/src/tatc/tradespace/histories.py @@ -14,7 +14,7 @@ import math import warnings from collections.abc import Callable, Mapping, Sequence -from typing import Any +from typing import TYPE_CHECKING, Any import numpy as np import pandas as pd @@ -22,17 +22,20 @@ from ..schemas import Satellite from .cache import get_satellite_key from .criteria import _OPERATORS, Requirement -from .deployment import Deployment from .failures import FailureModel, RestorationPolicy from .mission import ( MissionHistory, Phase, PhaseCache, _Simulation, + _given_design, evaluate_phases, summarize_phases, ) +if TYPE_CHECKING: + from .deployment import Deployment + def evaluate_missions( histories: Sequence[MissionHistory], @@ -42,6 +45,7 @@ def evaluate_missions( context: Any = None, cost_model: Any = None, growth: Any = 1.0, + design: Any = None, ) -> pd.DataFrame: """ Evaluates histories of a mission (such as those of a replicate, see @@ -64,6 +68,8 @@ def evaluate_missions( cache. cost_model (CostModel | None): A model of the cost of each history. growth (float | Mapping[str, float]): The growth of the cost. + design (Design | None): The (realized) design of the mission, for a + metric with a parameter named `design` (see `PhaseCache`). Returns: pandas.DataFrame: a row per history (with its likelihood ratio, @@ -75,9 +81,11 @@ def evaluate_missions( for history in histories: phases = history.phases(satellites) if isinstance(metric, PhaseCache): - capability = metric.evaluate(phases, observations, keys, context) + capability = metric.evaluate(phases, observations, keys, context, design) else: - capability = evaluate_phases(phases, observations, metric) + capability = evaluate_phases( + phases, observations, _given_design(metric, design) + ) row = {**summarize_phases(capability), **history.metrics()} if weighted: row["weight"] = history.weight @@ -519,6 +527,7 @@ def expected_missions( tolerance: float = 1e-3, steps: int = 400, max_sets: int = 200_000, + design: Any = None, ) -> dict[str, float]: """ Computes the expected capability of a mission without restoration @@ -565,8 +574,17 @@ def expected_missions( Returns: dict[str, float]: the expected metrics + + Raises: + ValueError: if the deployment is staged (see `Stage`), whose launches + depend on its rules. """ # pylint: disable=too-many-locals + if deployment.stages: + raise ValueError( + "exact expectations need a deployment that is not staged: " + + "simulate histories of a staged deployment instead" + ) names = [s.name for s in satellites] built = sum(b for _, b, _ in deployment.planes) if len(names) != built: @@ -611,9 +629,13 @@ def expected_missions( for weight, members in weights: phase = Phase(begin, end, tuple(names[k] for k in members)) if isinstance(metric, PhaseCache): - values = metric.evaluate([phase], observations, keys, context).iloc[0] + values = metric.evaluate([phase], observations, keys, context, design).iloc[ + 0 + ] else: - values = evaluate_phases([phase], observations, metric).iloc[0] + values = evaluate_phases( + [phase], observations, _given_design(metric, design) + ).iloc[0] for name, value in values.items(): if name in ("start", "end", "duration", "satellites"): continue diff --git a/src/tatc/tradespace/mission.py b/src/tatc/tradespace/mission.py index d13a05b8..e9e2b133 100644 --- a/src/tatc/tradespace/mission.py +++ b/src/tatc/tradespace/mission.py @@ -14,7 +14,8 @@ import math from collections.abc import Callable, Mapping, Sequence from dataclasses import dataclass, field, replace -from typing import Any +from functools import partial +from typing import TYPE_CHECKING, Any import numpy as np import pandas as pd @@ -22,8 +23,12 @@ from ..schemas import Satellite from .cache import get_satellite_key from .criteria import _OPERATORS, Requirement -from .deployment import Deployment, DeploymentSchedule, Launch, Production, _per_type +from .events import Launch, Production, _per_type from .failures import FailureModel, RestorationPolicy +from .study import _takes_design + +if TYPE_CHECKING: + from .deployment import Deployment, DeploymentSchedule @dataclass(frozen=True) @@ -81,6 +86,9 @@ class MissionHistory: weight: float = 1.0 """float: The likelihood ratio of the history, drawn from stressed failures (see `Deployment.simulate_many`), or 1.""" + stages: list[float | None] = field(default_factory=list) + """list: When each stage of the deployment was decided (years from the + start of development, see `Stage`), or `None` if it was not.""" @property def schedule(self) -> DeploymentSchedule: @@ -196,7 +204,7 @@ def metrics(self) -> dict[str, float]: operated = sum(b - a for spans in self.operating.values() for a, b in spans) possible = sum(b - a for spans in planned.operating.values() for a, b in spans) delays = [restored - failed for *_, failed, restored, _ in self.restorations] - return { + metrics = { "failures": float(len(self.failures)), "launch failures": float(sum(launch.failed for launch in self.launches)), "restorations": float(len(self.restorations)), @@ -206,6 +214,32 @@ def metrics(self) -> dict[str, float]: "restoration years": float(np.mean(delays)) if delays else math.nan, "availability": operated / possible if possible > 0 else math.nan, } + if self.deployment.stages: + metrics["stages deployed"] = float( + sum(time is not None for time in self.stages) + ) + return metrics + + +@dataclass(frozen=True) +class Decision: + """ + What the rule of a stage of a deployment knows when it decides whether to + deploy the stage (see `Stage`). + """ + + time: float + """float: The time of the decision, in years after the first launch.""" + stage: int + """int: The stage (its index).""" + operating: int + """int: The number of satellites operating.""" + history: MissionHistory + """MissionHistory: The history of the mission so far: its production, + launches, failures, restorations, and the periods of operation that + have ended.""" + deployed: tuple[int, ...] + """tuple[int, ...]: The stages deployed so far.""" @dataclass @@ -276,6 +310,7 @@ def __init__( self.booked = sorted(launch.time for launch in deployment.launches) self.open: dict[int, list[_Booking]] = {} self.launches_of_plane: dict[int, int] = {} + self.decided: dict[int, float] = {} # --- randomness @@ -343,6 +378,9 @@ def run(self) -> MissionHistory: self._push(ready, "stock", kind, count) for launch in self.deployment.launches: self._push(launch.time, "planned", launch) + for index, stage in enumerate(self.deployment.stages): + for time in stage.times: + self._push(self.deployment.begin + time, "decide", index) steps = 0 while self.events: time, _, kind, payload = heapq.heappop(self.events) @@ -359,6 +397,9 @@ def run(self) -> MissionHistory: if self.spares[plane] > 0: self.history.parked.append((since, self.end, self.spares[plane])) self.history.weight = math.exp(self.log_weight) + self.history.stages = [ + self.decided.get(index) for index in range(len(self.deployment.stages)) + ] self.history.production.sort(key=lambda batch: batch.begin) self.history.launches.sort(key=lambda launch: (launch.time, launch.plane)) return self.history @@ -398,6 +439,23 @@ def _on_planned(self, time: float, launch: Launch) -> None: max(0, min(spares, level - self.spares[launch.plane])), ) + def _on_decide(self, time: float, index: int) -> None: + if index in self.decided: + return # deployed at an earlier decision + stage = self.deployment.stages[index] + if stage.rule is not None: + decision = Decision( + time - self.deployment.begin, + index, + sum(slot["up"] is not None for slot in self.slots.values()), + self.history, + tuple(sorted(self.decided)), + ) + if not stage.rule(decision): + return + self.decided[index] = time + self._deploy(time, stage) + def _on_fail(self, time: float, plane: int, position: int, generation: int) -> None: slot = self.slots[plane, position] if slot["generation"] != generation or slot["up"] is None: @@ -515,6 +573,50 @@ def _park(self, time: float, plane: int, change: int) -> None: self.spares[plane] += change self.spares_since[plane] = time + def _deploy(self, time: float, stage: Any) -> None: + """ + Deploys the planes of a stage: produced after its lead time (on their + type's line), launched at the next launch slots, and replaced at the + end of their design life. + """ + life = self.schedule.design_life + for plane in stage.planes: + kind, size, spares = self.deployment.planes[plane] + count = size + spares + if count == 0: + continue + begin = max(self.line[kind], time + stage.lead_years) + ready = begin + self._producing(kind, count) + self.line[kind] = ready + self.history.production.append(Production(kind, begin, ready, count)) + launches = self.schedule.launches_of( + count, self.deployment.masses.get(kind) + ) + position = 0 + for j in range(launches): + carried = count // launches + (1 if j < count % launches else 0) + at = self._slot(ready) + self.booked = sorted(self.booked + [at]) + self._push(at, "planned", Launch(at, plane, kind, position, carried)) + need, generation = at + (math.inf if life is None else life), 1 + while need < self.end - 1e-9: + self.history.production.append( + Production( + kind, + need - self._producing(kind, carried), + need, + carried, + "replacement", + ) + ) + replacement = Launch( + need, plane, kind, position, carried, generation, "replacement" + ) + self.booked = sorted(self.booked + [need]) + self._push(need, "planned", replacement) + need, generation = need + life, generation + 1 + position += carried + def _producing(self, kind: Any, count: int) -> float: rate = _per_type(self.schedule.production_rate, kind, "production rate") return 0.0 if rate is None else count / rate @@ -575,6 +677,18 @@ def evaluate_phases( as from a `SatelliteCache`, filtered to those of each phase). Phases of the same satellites are evaluated once. + The phases are quasi-static: each is evaluated over the same window, as + if the geometry of the constellation (and the season) were that of the + window throughout the mission. This misses the drift of the relative + nodes of shells of different inclinations or altitudes (which precess at + different rates), the drift of the local times of planes that are not + sun-synchronous, and seasons (for metrics that depend on the sun, or on + fields that vary with the seasons). Replicates average over these if the + epoch of the window is an uncertain parameter drawn over the mission (see + `Observations`), as are the relative nodes of shells (such as the nodes + of `planes_space`). A constellation whose planes share an altitude and + inclination keeps its geometry, so that only seasons remain. + Args: phases (Sequence[Phase]): The phases (see `MissionHistory.phases`). observations (pandas.DataFrame): The observations of every @@ -666,6 +780,14 @@ def subset(names: frozenset = names) -> pd.DataFrame: return pd.DataFrame(rows) +def _given_design(metric: Callable, design: Any) -> Callable: + """ + Gets a metric of observations alone: the metric, given the design if it + has a parameter named `design` (see `Study`). + """ + return partial(metric, design=design) if _takes_design(metric) else metric + + class PhaseCache: """ A cache of a metric of the phases of missions (see `evaluate_phases`), @@ -675,17 +797,21 @@ class PhaseCache: the phases of missions with the same satellites (of other histories, policies, or designs, in the same replicate) are evaluated once. - The metric must depend only on the observations, not on the names of the - satellites. Copies sent to the parallel workers of a study start with an - empty memory, which the evaluations of a chunk share (consecutive - evaluations of the same replicate, see `Study`). + The metric must depend only on the observations (of the one window of + the observations, see `evaluate_phases`), not on the names of the + satellites. A metric with a parameter named `design` is given the design + of the mission (see `evaluate`), on which it must depend only through + what the context identifies (such as a scenario). Copies sent to the + parallel workers of a study start with an empty memory, which the + evaluations of a chunk share (consecutive evaluations of the same + replicate, see `Study`). Args: metric (Callable): A function of the observations of a phase (which may be empty) that gives its metrics. """ - def __init__(self, metric: Callable[[pd.DataFrame], Mapping[str, float]]): + def __init__(self, metric: Callable[..., Mapping[str, float]]): self.metric = metric self.hits = 0 """int: The phases taken from the cache.""" @@ -704,6 +830,7 @@ def evaluate( observations: pd.DataFrame, satellites: Sequence[Satellite] | Mapping[str, str], context: Any, + design: Any = None, ) -> pd.DataFrame: """ Evaluates the phases of a mission (see `evaluate_phases`), taking @@ -719,6 +846,8 @@ def evaluate( of their names, see `get_satellite_key`). context (Any): A hashable identifier of the observations (such as the seed of their targets and their period). + design (Design | None): The (realized) design of the mission, + for a metric with a parameter named `design`. Returns: pandas.DataFrame: a row per phase: its `start`, `end`, @@ -730,13 +859,15 @@ def evaluate( else {s.name: get_satellite_key(s) for s in satellites} ) + metric = _given_design(self.metric, design) + def cached(subset: Callable[[], pd.DataFrame], names: frozenset) -> dict: key = (context, frozenset(keys[name] for name in names)) if key in self._memory: self.hits += 1 else: self.misses += 1 - self._memory[key] = dict(self.metric(subset())) + self._memory[key] = dict(metric(subset())) return self._memory[key] return _evaluate_phases(phases, observations, cached) diff --git a/tests/tradespace/test_constellations.py b/tests/tradespace/test_constellations.py index 50c096a1..cb468230 100644 --- a/tests/tradespace/test_constellations.py +++ b/tests/tradespace/test_constellations.py @@ -9,13 +9,16 @@ import numpy as np -from tatc.schemas import Instrument, Satellite +from tatc.schemas import CircularOrbit, Instrument, Satellite from tatc.tradespace import ( Categorical, Choice, Derived, + DeploymentSchedule, DesignSpace, Integer, + Layout, + Plane, Real, Repeat, Uncertain, @@ -23,11 +26,14 @@ count_planes, count_satellites, hours_to_time, + layout_of, + plane_sizes, planes_space, remove_failures, sso_planes_space, walker_space, ) +from tatc.tradespace.constellations import Layouts, SSOPlanesLayout, WalkerLayout EPOCH = datetime(2026, 1, 1, tzinfo=timezone.utc) IMAGER = Instrument(name="imager", field_of_regard=60) @@ -512,3 +518,106 @@ def test_repeat_of_choice(self): self.assertEqual(len(satellites), 3) self.assertEqual(count_satellites(design.shells), 3) self.assertEqual(count_planes(design.shells), 2) + + +class _Pair(Layout): + """Two satellites in each of two planes of given nodes, for the tests.""" + + def __init__(self, nodes, altitude=None): + self.nodes, self.altitude = nodes, altitude + + def planes(self): + return [Plane(2, node) for node in self.nodes] + + def orbits(self, epoch, altitude=None): + altitude = self.altitude if altitude is None else altitude + return [ + [ + CircularOrbit( + altitude=altitude, + inclination=50, + right_ascension_ascending_node=node, + true_anomaly=anomaly, + epoch=epoch, + ) + for anomaly in (0, 180) + ] + for node in self.nodes + ] + + +class TestLayout(unittest.TestCase): + """ + Unit tests for layouts. + """ + + def test_layout_of(self): + """The values of each fragment are those of a layout.""" + designs = _space().enumerate() + walker = next(d for d in designs if d.layout.choice == "walker") + sso = next(d for d in designs if d.layout.choice == "sso") + self.assertIsInstance(layout_of(walker.layout), WalkerLayout) + self.assertIsInstance(layout_of(sso.layout), SSOPlanesLayout) + both = layout_of([walker.layout, sso.layout]) + self.assertIsInstance(both, Layouts) + self.assertEqual(both.satellites, count_satellites(walker.layout) + 1) + self.assertIs(layout_of(both), both) + planes = layout_of(sso.layout).planes() + self.assertEqual(planes[0].values.crossing, sso.layout.planes[0].crossing) + self.assertIsNone(layout_of(walker.layout).planes()[0].values) + with self.assertRaises(ValueError): + layout_of({"kind": "flower"}) + + def test_walker_planes(self): + """The satellites of a Walker layout follow each other plane by plane.""" + space = DesignSpace( + layout=walker_space( + inclination=60.0, planes=3, per_plane=2, relative_spacing=1 + ) + ) + layout = layout_of(_single(space).layout) + self.assertEqual([p.satellites for p in layout.planes()], [2, 2, 2]) + orbits = layout.orbits(EPOCH, 700e3) + nodes = [{o.right_ascension_ascending_node for o in plane} for plane in orbits] + self.assertEqual(nodes, [{0.0}, {120.0}, {240.0}]) + self.assertEqual( + [s.name for s in layout.build(IMAGER, epoch=EPOCH, altitude=700e3)], + [f"satellite {k}" for k in range(1, 7)], + ) + with self.assertRaises(ValueError): + layout.orbits(EPOCH) # no altitude + + def test_custom_layout(self): + """Other layouts are built, counted, and deployed as the others.""" + layout = _Pair([0, 90], altitude=600e3) + satellites = build_constellation(layout, IMAGER, epoch=EPOCH) + self.assertEqual( + [s.name for s in satellites], + ["satellite 1-1", "satellite 1-2", "satellite 2-1", "satellite 2-2"], + ) + self.assertEqual(satellites[2].orbit.right_ascension_ascending_node, 90) + self.assertEqual(count_satellites(layout), 4) + self.assertEqual(count_planes(layout), 2) + self.assertEqual(plane_sizes(layout), [2, 2]) + # the nodes of the planes order their deployment (90, 45, then 0) + schedule = DeploymentSchedule( + years=3, production_rate=2, order=lambda index, node: -node + ) + layouts = [layout, _Pair([45], altitude=600e3)] + deployment = schedule.plan(layouts) + self.assertEqual([launch.plane for launch in deployment.launches], [1, 2, 0]) + phases = deployment.phases(build_constellation(layouts, IMAGER, epoch=EPOCH)) + self.assertEqual([len(phase.satellites) for phase in phases], [2, 4, 6]) + + def test_mismatched_orbits(self): + """A layout whose orbits do not match its planes is not built.""" + + class Short(_Pair): + """A layout with an orbit missing.""" + + def orbits(self, epoch, altitude=None): + orbits = super().orbits(epoch, altitude) + return [orbits[0][:1], *orbits[1:]] + + with self.assertRaises(ValueError): + Short([0, 90], altitude=600e3).build(IMAGER, epoch=EPOCH) diff --git a/tests/tradespace/test_failures.py b/tests/tradespace/test_failures.py index e2b5ecf2..4eb0c641 100644 --- a/tests/tradespace/test_failures.py +++ b/tests/tradespace/test_failures.py @@ -296,6 +296,30 @@ def test_planned_replacement(self): # launched at 1, failed at 2.5, replaced at 3, failed at 4.5 self.assertEqual(history.operating[0, 0], [(1, 2.5), (3, 4.5)]) + def test_design_life_does_not_retire(self): + """A satellite whose planned replacement fails to launch operates past + its design life, and the replacement is not flown again.""" + schedule = DeploymentSchedule(years=6, design_life=2, development_years=1) + deployment = schedule.plan(self.layout) + launches_fail = FailureModel(launch=0.5) + for seed in range(50): + history = deployment.simulate( + launches_fail, RestorationPolicy(restore=False), seed + ) + deployed = [l for l in history.launches if l.purpose == "deployment"] + replaced = [l for l in history.launches if l.purpose == "replacement"] + if not deployed[0].failed and replaced[0].failed: + break + else: + self.fail("no history with a failed replacement") + failed = replaced[0] + spans = history.operating[failed.plane, failed.first] + self.assertTrue(any(a < failed.time < b for a, b in spans)) + # only the planned replacements are launched: none is flown again + self.assertEqual( + len(replaced), sum(l.purpose == "replacement" for l in deployment.launches) + ) + def test_common_random_numbers(self): """The satellite at the same position fails at the same age.""" failures = FailureModel(life=Exponential(0.3), launch=0.1) diff --git a/tests/tradespace/test_stages.py b/tests/tradespace/test_stages.py new file mode 100644 index 00000000..50aff598 --- /dev/null +++ b/tests/tradespace/test_stages.py @@ -0,0 +1,163 @@ +""" +Unit tests for staged deployments. + +@author Paul T. Grogan +""" + +import unittest + +from tatc.tradespace import ( + CostModel, + DeploymentSchedule, + DesignSpace, + Exponential, + FailureModel, + RestorationPolicy, + SatelliteCost, + Stage, + expected_missions, + walker_space, +) + +# three planes of two satellites +LAYOUT = DesignSpace(layout=walker_space(inclination=60, planes=3, per_plane=2)) +SCHEDULE = DeploymentSchedule( + years=5, design_life=3, development_years=1, production_rate=4, launch_interval=0.5 +) +COSTS = CostModel(SatelliteCost(development=10, first_unit=2)) + + +def _layout(): + return LAYOUT.enumerate()[0].layout + + +def _launches(history, plane): + return [ + (launch.time, launch.purpose) + for launch in history.launches + if launch.plane == plane + ] + + +class TestStages(unittest.TestCase): + """ + Unit tests for stages of deployments. + """ + + def test_planned_delay(self): + """A stage without a rule is deployed at its first time.""" + deployment = SCHEDULE.plan(_layout(), stages=[Stage(2, 1.0)]) + self.assertEqual({launch.plane for launch in deployment.launches}, {0, 1}) + history = deployment.simulate() + decided = deployment.begin + 1.0 + self.assertEqual(history.stages, [decided]) + # produced from the decision (after the line's earlier work) and launched + produced = [b for b in history.production if b.begin == decided] + self.assertEqual( + [(b.satellites, b.purpose) for b in produced], [(2, "deployment")] + ) + launched = _launches(history, 2) + self.assertEqual(launched[0], (decided + 2 / 4, "deployment")) + # replaced at the end of its design life, within the mission + self.assertEqual(launched[1], (decided + 2 / 4 + 3, "replacement")) + self.assertEqual(history.operating[2, 0][0][0], decided + 2 / 4) + self.assertEqual(history.metrics()["stages deployed"], 1.0) + + def test_not_deployed(self): + """A stage that its rule does not deploy is neither produced nor launched.""" + never = SCHEDULE.plan( + _layout(), stages=[Stage([1, 2], [0.5, 1.0], lambda d: False)] + ) + history = never.simulate() + self.assertEqual(history.stages, [None]) + self.assertEqual(_launches(history, 1) + _launches(history, 2), []) + self.assertNotIn((1, 0), history.operating) + self.assertEqual(history.metrics()["stages deployed"], 0.0) + plain = SCHEDULE.plan(_layout()) + self.assertLess(COSTS.estimate(never).total, COSTS.estimate(plain).total) + self.assertNotIn("stages deployed", plain.simulate().metrics()) + + def test_decisions(self): + """Rules decide at their times, until they deploy, from what is known.""" + seen = [] + + def rule(decision): + seen.append(decision) + return decision.time >= 1.0 + + stages = [Stage(1, 0.25), Stage(2, [0.5, 1.0, 1.5], rule)] + history = SCHEDULE.plan(_layout(), stages=stages).simulate() + self.assertEqual([d.time for d in seen], [0.5, 1.0]) + self.assertEqual({d.stage for d in seen}, {1}) + self.assertEqual(seen[0].deployed, (0,)) + # the satellites of the first plane operate (those of the second are + # still being produced) + self.assertEqual(seen[0].operating, 2) + begin = min(launch.time for launch in history.launches) + self.assertEqual(history.stages, [begin + 0.25, begin + 1.0]) + + def test_contingency(self): + """A rule on failures deploys a stage in the histories that need it.""" + failures = FailureModel(life=Exponential(0.1)) + policy = RestorationPolicy(restore=False) + stage = Stage(2, [0.5, 1.0, 1.5, 2.0], lambda d: d.operating < 4) + deployment = SCHEDULE.plan(_layout(), stages=[stage]) + self.assertEqual(deployment.simulate().stages, [None]) + histories = deployment.simulate_many(failures, policy, seed=1, histories=20) + deployed = [h.stages[0] is not None for h in histories] + self.assertTrue(any(deployed) and not all(deployed)) + for history in histories: + failed = [t for t, *_ in history.failures] + if history.stages[0] is not None: + self.assertLess(min(failed), history.stages[0]) + # the same history draws the same failures again + again = deployment.simulate_many(failures, policy, seed=1, histories=20) + self.assertEqual([h.stages for h in again], [h.stages for h in histories]) + + def test_lead_and_launches(self): + """A lead time delays production, and launch capacity splits launches.""" + schedule = DeploymentSchedule( + years=5, development_years=1, production_rate=4, launch_capacity=1 + ) + deployment = schedule.plan( + _layout(), spares=1, stages=[Stage(2, 1.0, lead_years=0.5)] + ) + history = deployment.simulate() + # the line is free by the end of the lead time + decided = history.stages[0] + launched = [l for l in history.launches if l.plane == 2] + self.assertEqual([l.satellites for l in launched], [1, 1, 1]) + self.assertEqual(launched[0].time, decided + 0.5 + 3 / 4) + # the spare of the staged plane waits in orbit + self.assertTrue( + any(start >= launched[0].time for start, _, _ in history.parked) + ) + + def test_exact_expectations(self): + """Exact expectations need a deployment that is not staged.""" + deployment = SCHEDULE.plan(_layout(), stages=[Stage(2, 1.0)]) + with self.assertRaises(ValueError): + expected_missions( + deployment, FailureModel(life=Exponential(0.2)), [], None, len + ) + + def test_invalid(self): + """Stages are of distinct planes of the layout, after some planned ones.""" + for stages in ( + [Stage(1), Stage([1, 2])], + [Stage(3)], + [Stage([0, 1, 2])], + ): + with self.subTest(stages=stages): + with self.assertRaises(ValueError): + SCHEDULE.plan(_layout(), stages=stages) + for arguments in (([],), ([1, 1],), ([-1],), (1, -1.0), (1, [])): + with self.subTest(arguments=arguments): + with self.assertRaises(ValueError): + Stage(*arguments) + with self.assertRaises(ValueError): + Stage(1, lead_years=-1) + + +if __name__ == "__main__": + unittest.main() From 885e0636f91ae66923b14da8dac7130467bc0ef5 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Wed, 11 Nov 2026 21:59:51 -0700 Subject: [PATCH 28/52] add studies of the observations of constellations, and plots of trade spaces - ObservationStudy runs a standard pipeline: the targets of each replicate (Targets, fixed or generated from a seed of the design), the observations of each satellite over a period, cached on disk (Observations, whose start may be a value of the design, such as an epoch drawn for each replicate), a MissionPlan of deployment, costs, and stages, Failures, or the phases of deployment, and metrics that may take the design. - plot_designs, plot_progress, and plot_means plot designs, the progress of searches, and means with their uncertainty (matplotlib, in the tradespace extra); hypervolume_progress gives the progress of a search. - A test keeps the general modules of trade studies from importing those of constellations and missions, and the modules free of cycles. --- pyproject.toml | 1 + src/tatc/tradespace/__init__.py | 52 +- src/tatc/tradespace/observations.py | 653 ++++++++++++++++++++++++++ src/tatc/tradespace/plotting.py | 308 ++++++++++++ tests/tradespace/test_layering.py | 97 ++++ tests/tradespace/test_observations.py | 417 ++++++++++++++++ tests/tradespace/test_plotting.py | 106 +++++ 7 files changed, 1614 insertions(+), 20 deletions(-) create mode 100644 src/tatc/tradespace/observations.py create mode 100644 src/tatc/tradespace/plotting.py create mode 100644 tests/tradespace/test_layering.py create mode 100644 tests/tradespace/test_observations.py create mode 100644 tests/tradespace/test_plotting.py diff --git a/pyproject.toml b/pyproject.toml index 81a83473..9f1aed74 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -109,6 +109,7 @@ preprocess = [ ] tradespace = [ "joblib", + "matplotlib", "optuna", "pymoo" ] diff --git a/src/tatc/tradespace/__init__.py b/src/tatc/tradespace/__init__.py index d5fa2755..b7ded55e 100644 --- a/src/tatc/tradespace/__init__.py +++ b/src/tatc/tradespace/__init__.py @@ -2,17 +2,22 @@ Trade space analysis: design spaces of (hierarchical) design variables and uncertain parameters, building blocks of constellations (their deployment and life-cycle cost, and capability over the phases of deployment), -trade studies that evaluate their designs (with caches -of analyses by satellite, in parallel), statistics of replicates and -requirements on them, Pareto efficiency (with the uncertainty of replicates), +trade studies that evaluate their designs (in scenarios, with caches +of analyses by satellite, in parallel), studies of the observations of +constellations (their targets, deployment, costs, failures, and phases), criteria that judge designs by +statistics of their replicates (of metrics or their utility) and requirements on them, Pareto efficiency +(with the uncertainty of replicates), adaptive replication, confirmation of selected designs with new replicates, -persistent stores of results (keyed by fingerprints of studies), sensitivity analysis, +persistent stores of results (keyed by fingerprints of studies), sensitivity analysis +(to design variables, and attribution of variance to uncertain parameters), screening with analyses of increasing fidelity, -and searches with optimizers (Optuna and pymoo, optional dependencies). +searches with optimizers (Optuna and pymoo, optional dependencies), +and plots of results (matplotlib, an optional dependency). @author: Paul T. Grogan """ +from .attribution import Attribution, attribute_variance from .cache import SatelliteCache, get_satellite_key from .confirmation import Confirmation, confirm from .cost import ( @@ -89,6 +94,14 @@ optimize_pymoo, ) from .fingerprint import compare_definitions, get_definition, get_fingerprint +from .observations import ( + Failures, + MissionPlan, + ObservationStudy, + Observations, + Targets, + value_of, +) from .pareto import ( hypervolume, hypervolume_progress, @@ -96,8 +109,10 @@ pareto_probability, pareto_ranks, ) +from .plotting import plot_designs, plot_means, plot_progress, style_axes from .refinement import Refinement, refine from .screening import Screening, screen +from .scenarios import robustness from .sensitivity import main_effects, sensitivity from .nodes import ( Categorical, @@ -114,21 +129,8 @@ from .space import Design, DesignSpace from .store import ResultStore from .study import Study -from .values import ( - ChoiceValues, - RepeatValues, - Scope, - Values, - configure, -) -from .attribution import Attribution, attribute_variance -from .scenarios import robustness -from .utility import ( - ExponentialUtility, - LinearUtility, - PiecewiseUtility, - Utility, -) +from .utility import ExponentialUtility, LinearUtility, PiecewiseUtility, Utility +from .values import ChoiceValues, RepeatValues, Scope, Values, configure __all__ = [ "Attribution", @@ -150,6 +152,7 @@ "Exponential", "ExponentialUtility", "FailureModel", + "Failures", "Fixed", "Infeasible", "Integer", @@ -162,6 +165,9 @@ "Mean", "Minimum", "MissionHistory", + "MissionPlan", + "ObservationStudy", + "Observations", "OperationsCost", "Phase", "PhaseCache", @@ -188,6 +194,7 @@ "StandardError", "Statistic", "Study", + "Targets", "Uncertain", "Utility", "Values", @@ -221,6 +228,9 @@ "pareto_ranks", "plane_sizes", "planes_space", + "plot_designs", + "plot_means", + "plot_progress", "policy_space", "refine", "remove_failures", @@ -228,8 +238,10 @@ "screen", "sensitivity", "sso_planes_space", + "style_axes", "summarize", "summarize_missions", "summarize_phases", + "value_of", "walker_space", ] diff --git a/src/tatc/tradespace/observations.py b/src/tatc/tradespace/observations.py new file mode 100644 index 00000000..36e4a6a6 --- /dev/null +++ b/src/tatc/tradespace/observations.py @@ -0,0 +1,653 @@ +""" +Studies of the observations of constellations: the targets of each replicate, +the observations of each satellite (cached), and the metrics of a design's +observations, its deployment and costs, the histories of its failures, and +the phases of its mission. + +The parts refer to the values of designs by name (such as `"points_seed"` +for `d.points_seed`, or a path of `Design.flat`, such as +`"layout.walker.planes"`), or by a function of the (realized) design. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +import dataclasses +import os +from collections.abc import Callable, Mapping, Sequence +from datetime import datetime, timedelta +from functools import partial +from typing import Any + +import pandas as pd + +from ..analysis import collect_observations +from ..schemas import Satellite +from .cache import SatelliteCache +from .constellations import count_planes +from .cost import CostModel +from .criteria import Requirement +from .deployment import DeploymentSchedule +from .failures import FailureModel, RestorationPolicy +from .histories import evaluate_missions, expected_missions, summarize_missions +from .mission import PhaseCache, _given_design, evaluate_phases, summarize_phases +from .space import Design, DesignSpace, _scenario_of +from .study import Study, _takes_design +from .values import configure + +_MAX_TARGETS = 32 +"""The most sets of targets (of seeds) kept in memory.""" + + +def value_of(design: Design, reference: Any) -> Any: + """ + Gets a value of a design that a reference names: a string names a value + (`d.`, or a path of `Design.flat`, such as `"layout.walker.planes"`), + a function computes it from the design, and `None` is `None`. + + Args: + design (Design): The (realized) design. + reference (Any): The reference: a string, a function, or `None`. + + Returns: + Any: the value + """ + if reference is None: + return None + if callable(reference): + return reference(design) + if not isinstance(reference, str): + raise TypeError(f"a reference to a value of a design, not {reference!r}") + if "." in reference or "[" in reference: + values = design.flat() + if reference not in values: + raise KeyError(f"no value {reference!r} of the design") + return values[reference] + return getattr(design, reference) + + +@dataclasses.dataclass(frozen=True, eq=False, init=False) +class Targets: + """ + The targets of observations (such as points): fixed (a data frame), or + generated in each replicate by a function (such as + `tatc.generation.generate_points_rotated_lattice`) given the `arguments` + and `keywords`, and a seed that is a value of the design (as its keyword + `seed`, such as of `Uncertain.seed`), so that each replicate samples + other targets. Generated targets are kept in memory by seed. + + Args: + source (pandas.DataFrame | Callable): The targets, or a function that + generates them. + *arguments (Any): The arguments of the function. + seed (Any): The value of the design that seeds the function (see + `value_of`), or `None` (to generate the same targets). + **keywords (Any): The keyword arguments of the function. + """ + + source: Any + arguments: tuple + keywords: dict + seed: Any + + def __init__(self, source: Any, *arguments: Any, seed: Any = None, **keywords: Any): + if isinstance(source, pd.DataFrame): + if arguments or keywords or seed is not None: + raise ValueError("fixed targets take no arguments or seed") + elif not callable(source): + raise TypeError( + "targets are a data frame or a function that generates them" + ) + object.__setattr__(self, "source", source) + object.__setattr__(self, "arguments", tuple(arguments)) + object.__setattr__(self, "keywords", dict(keywords)) + object.__setattr__(self, "seed", seed) + object.__setattr__(self, "_memory", {}) + + def __getstate__(self) -> dict: + # copies sent to parallel workers start with empty memories + state = self.__dict__.copy() + state["_memory"] = {} + return state + + def seed_of(self, design: Design | None) -> Any: + """ + Gets the seed of the targets of a design (`None` if they are fixed). + + Args: + design (Design | None): The (realized) design. + + Returns: + Any: the seed + """ + if self.seed is None: + return None + if design is None: + raise ValueError( + "targets generated from a seed of the design need a design" + ) + return value_of(design, self.seed) + + def of(self, design: Design | None = None) -> pd.DataFrame: + """ + Gets the targets of a design (of its replicate). + + Args: + design (Design | None): The (realized) design, or `None` for fixed + targets. + + Returns: + pandas.DataFrame: the targets + """ + if isinstance(self.source, pd.DataFrame): + return self.source + seed = self.seed_of(design) + memory = self._memory + if seed not in memory: + if len(memory) >= _MAX_TARGETS: + memory.pop(next(iter(memory))) + keywords = ( + self.keywords if self.seed is None else {**self.keywords, "seed": seed} + ) + memory[seed] = self.source(*self.arguments, **keywords) + return memory[seed] + + +def _observe( + analysis: Callable, + targets: Any, + start: datetime, + end: datetime, + satellite: Satellite, +) -> pd.DataFrame: + """The observations of the targets by a satellite (see `Observations`).""" + return analysis(targets, satellite, start, end) + + +@dataclasses.dataclass(frozen=True, eq=False) +class Observations: + """ + The observations of targets by satellites over a period, by an analysis + of one satellite (such as `tatc.analysis.collect_observations`, called + as `analysis(targets, satellite, start, end)`), cached for each satellite + (see `SatelliteCache`) and each set of targets (of a seed, see + `Targets`), in memory, or on disk in a `directory` (shared by the + parallel workers of a study, and between sessions). The results on disk + are keyed by the fingerprint of the analysis, which describes the + targets by their content: the `namespace` need only identify data that + the analysis reads (such as from files) and the code of other modules it + calls (other than TAT-C's). + + The period is one window that represents the mission (see + `evaluate_phases`): its start may be a value of the design (see + `value_of`), such as an uncertain epoch drawn for each replicate over the + mission (`Uncertain`), so that the replicates average over the geometry + of the mission (such as the drift of the relative nodes of shells of + different inclinations or altitudes) and its seasons. With common random + numbers, the designs of a replicate share its epoch. The observations of + each epoch (and set of targets) are cached apart. + + Args: + targets (Targets | pandas.DataFrame): The targets. + start (datetime | Any): The start of the period, or a value of the + design that gives it (see `value_of`). + duration (timedelta): The duration of the period. + analysis (Callable): The analysis of one satellite. + directory (str | os.PathLike | None): A directory of the cache on + disk, or `None` to cache in memory only. + namespace (str): An identifier of what the fingerprint of the + analysis cannot see. + """ + + targets: Targets | pd.DataFrame + start: datetime | Any + duration: timedelta + analysis: Callable = collect_observations + directory: str | os.PathLike | None = dataclasses.field( + default=None, metadata={"fingerprint": False} + ) + namespace: str = "" + + def __post_init__(self): + if isinstance(self.targets, pd.DataFrame): + object.__setattr__(self, "targets", Targets(self.targets)) + object.__setattr__(self, "_caches", {}) + + def __getstate__(self) -> dict: + # copies sent to parallel workers start without caches + state = self.__dict__.copy() + state["_caches"] = {} + return state + + @property + def end(self) -> datetime: + """datetime: The end of the period (of a fixed start, see `end_of`).""" + if not isinstance(self.start, datetime): + raise ValueError("the start is a value of the design: see end_of") + return self.start + self.duration + + def start_of(self, design: Design | None = None) -> datetime: + """ + Gets the start of the period of a design (of its replicate). + + Args: + design (Design | None): The (realized) design, or `None` for a + fixed start. + + Returns: + datetime: the start + """ + if isinstance(self.start, datetime): + return self.start + if design is None: + raise ValueError("a start that is a value of the design needs a design") + start = value_of(design, self.start) + if not isinstance(start, datetime): + raise TypeError(f"the start of the period is not a datetime: {start!r}") + return start + + def end_of(self, design: Design | None = None) -> datetime: + """ + Gets the end of the period of a design (of its replicate). + + Args: + design (Design | None): The (realized) design, or `None` for a + fixed start. + + Returns: + datetime: the end + """ + return self.start_of(design) + self.duration + + def context_of(self, design: Design | None = None) -> tuple: + """ + Gets a key of the observations of a design: the seed of its targets + and the period (such as the context of a `PhaseCache`). + + Args: + design (Design | None): The (realized) design. + + Returns: + tuple: the key + """ + return (self.targets.seed_of(design), self.start_of(design), self.duration) + + def cache_of(self, design: Design | None = None) -> SatelliteCache: + """ + Gets the cache of the observations of the targets of a design (by the + seed of its targets and its period), in a namespace of the targets' + seed and the period (and the `namespace`), + so that a cache warns of results of other definitions (see + `SatelliteCache`) of the same targets and period. + + Args: + design (Design | None): The (realized) design. + + Returns: + SatelliteCache: the cache + """ + seed, start = self.targets.seed_of(design), self.start_of(design) + if (seed, start) not in self._caches: + if len(self._caches) >= _MAX_TARGETS: + self._caches.pop(next(iter(self._caches))) + function = partial( + _observe, + self.analysis, + self.targets.of(design), + start, + start + self.duration, + ) + context = ( + f"targets of seed {seed}, from {start.isoformat()} for {self.duration}" + ) + namespace = f"{self.namespace}: {context}" if self.namespace else context + self._caches[seed, start] = SatelliteCache( + function, self.directory, namespace + ) + return self._caches[seed, start] + + def __call__( + self, satellites: Sequence[Satellite], design: Design | None = None + ) -> pd.DataFrame: + """ + Gets the observations of the targets of a design by satellites. + + Args: + satellites (Sequence[Satellite]): The satellites. + design (Design | None): The (realized) design. + + Returns: + pandas.DataFrame: the observations (empty without satellites) + """ + return self.cache_of(design)(satellites) + + +@dataclasses.dataclass(frozen=True) +class MissionPlan: + """ + The deployment of the satellites of each design (see + `DeploymentSchedule.plan`) and its costs (see `CostModel`), from the + values of the design (see `value_of`). + + Args: + schedule (DeploymentSchedule): The schedule of the deployment. + cost_model (CostModel | None): The costs, or `None`. + kind (Any): The kind of the satellites (for schedules and costs of + several kinds), as a value of the design. + spares (Any): The spares in orbit in each plane, or a value of the + design (replaced by the `orbit_spares` of a design's policy, see + `Failures`). + growth (Any): The growth of the costs (see `CostModel.estimate`): a + factor, a value of the design, or a mapping of each element (such + as `"development"`) to a factor or a value of the design. + stages (Sequence[Stage] | Callable): The stages of the deployment + (see `Stage`), or a function of the (realized) design that gives + them, such as of a decision whether to stage it and of the values + its rules read. + """ + + schedule: DeploymentSchedule + cost_model: CostModel | None = None + kind: Any = None + spares: Any = 0 + growth: Any = 1.0 + stages: Any = () + + def stages_of(self, design: Design) -> tuple: + """ + Gets the stages of the deployment of a design. + + Args: + design (Design): The (realized) design. + + Returns: + tuple[Stage, ...]: the stages + """ + stages = self.stages(design) if callable(self.stages) else self.stages + return tuple(stages or ()) + + def growth_of(self, design: Design) -> Any: + """ + Gets the growth of the costs of a design. + + Args: + design (Design): The (realized) design. + + Returns: + Any: a factor, or a mapping of each element to its factor + """ + if isinstance(self.growth, Mapping): + return {element: _number(design, g) for element, g in self.growth.items()} + return _number(design, self.growth) + + +def _number(design: Design, value: Any) -> Any: + """A number, or a value of a design that a reference names.""" + return value if isinstance(value, (int, float)) else value_of(design, value) + + +@dataclasses.dataclass(frozen=True) +class Failures: + """ + The failures of the satellites of each design: histories of its mission + (see `Deployment.simulate_many`), restored by a policy (or by the policy + of each design of a design space with a value `policy`, see + `policy_space`, which configures the policy, see `configure`, and the + spares in orbit), summarized over the histories (see + `summarize_missions`): the mean of each metric over the phases of the + mission and the histories, `quantiles` and `requirements` of them, and + their costs. Without restoration, the means of the metrics and the + availability are the exact expectations over the failures (see + `expected_missions`) if `exact`. + + Args: + model (FailureModel): The failures. + policy (RestorationPolicy | None): The policy (`None` not to restore). + histories (int): The histories of each replicate. + seed (Any): The value of the design that seeds the failures (see + `value_of`, such as of `Uncertain.seed`), or `None` for the one + history without failures. + sampling (str): The sampling of the histories (see + `Deployment.simulate_many`). + quantiles (Mapping | None): Quantiles of the metrics of the + histories (see `summarize_missions`). + requirements (Sequence[Requirement]): Requirements on the metrics of + the histories (see `summarize_missions`). + exact (bool): `True` for exact expectations without restoration. + """ + + model: FailureModel + policy: RestorationPolicy | None = None + histories: int = 1 + seed: Any = None + sampling: str = "stratified" + quantiles: Mapping[str, float | Sequence[float]] | None = None + requirements: Sequence[Requirement] = () + exact: bool = True + + +@dataclasses.dataclass(frozen=True, eq=False) +class _Evaluation: + """ + The evaluation of the satellites of a design (see `ObservationStudy`). + """ + + observations: Observations + metrics: Callable[[pd.DataFrame], Mapping[str, Any]] + layout: Any = None + plan: MissionPlan | None = None + failures: Failures | None = None + phases: tuple[Requirement, ...] | None = None + + def __post_init__(self): + object.__setattr__(self, "_phase_cache", PhaseCache(self.metrics)) + + def _policy(self, design: Design) -> tuple[RestorationPolicy | None, Any]: + """The policy of a design, and its spares in orbit in each plane.""" + base = None if self.failures is None else self.failures.policy + spares = _number(design, self.plan.spares) + decided = design.values.get("policy") + if decided is None: + return base, spares + return configure(base or RestorationPolicy(), decided), decided.orbit_spares + + def __call__(self, satellites: Sequence[Satellite], design: Design) -> dict: + observations = self.observations(satellites, design) + record: dict[str, Any] = {"satellites": len(satellites)} + layout = value_of(design, self.layout) + if layout is not None: + record["planes"] = count_planes(layout) + if self.plan is not None: + policy, spares = self._policy(design) + kind = value_of(design, self.plan.kind) + deployment = self.plan.schedule.plan( + layout, kind=kind, spares=spares, stages=self.plan.stages_of(design) + ) + growth = self.plan.growth_of(design) + if self.plan.cost_model is not None: + record.update( + self.plan.cost_model.estimate(deployment, growth).metrics() + ) + metrics = _given_design(self.metrics, design) + record.update(metrics(observations)) + # the metrics of phases are cached by the observations and, if they + # are given the design, by its scenario + context = self.observations.context_of(design) + if _takes_design(self.metrics): + context = (context, _scenario_of(design)) + if self.failures is not None: + histories = deployment.simulate_many( + self.failures.model, + policy, + value_of(design, self.failures.seed), + self.failures.histories, + sampling=self.failures.sampling, + ) + missions = evaluate_missions( + histories, + satellites, + observations, + self._phase_cache, + context=context, + cost_model=self.plan.cost_model, + growth=growth, + design=design, + ) + record.update( + summarize_missions( + missions, + quantiles=self.failures.quantiles, + requirements=self.failures.requirements, + ) + ) + # exact expectations are of deployments that are not staged + if ( + self.failures.exact + and policy is not None + and not policy.restore + and not deployment.stages + ): + exact = expected_missions( + deployment, + self.failures.model, + satellites, + observations, + self._phase_cache, + context=context, + design=design, + ) + record.update( + { + key: value + for key, value in exact.items() + if key.endswith(" mean") or key == "availability" + } + ) + elif self.phases is not None: + capability = evaluate_phases( + deployment.phases(satellites), observations, metrics + ) + record.update(summarize_phases(capability, requirements=self.phases)) + return record + + +class ObservationStudy(Study): + """ + A trade study of the observations of constellations: each replicate of a + design builds its satellites, observes the targets of the replicate (see + `Observations`), and records the number of `satellites` (and of `planes`, + with a `layout`), the `metrics` of the observations, and, with a mission + `plan`, the costs of its deployment, and either the summaries of the + histories of its `failures` (see `Failures`) or of the `phases` of its + deployment (see `evaluate_phases` and `summarize_phases`, with + requirements, if any). + + The metrics are a function of the observations of any set of satellites + (which may be empty), so that failures and phases evaluate them for the + satellites that operate in each phase, over the one window of the + observations (see `evaluate_phases` for what this assumes, and + `Observations` for an epoch drawn for each replicate). A metrics function + with a parameter named `design` is also given the realized design, such + as for the window of an epoch drawn for each replicate or for values that + scenarios set (see `Study`): the metrics of phases are cached by the + satellites that operate, the targets and window of the observations, and + the scenario, so such a function must depend on the design only through + these. As a `Study`, it runs as any other (see `Study.run`), such as in + parallel, with a store of its records, and in searches (such as + `refine`, `confirm`, `screen`, and the optimizers). Its fingerprint (see + `Study.fingerprint`) describes its parts, including targets by their + content (or the recipe of generated targets), so that its store needs no + namespace but for what the fingerprint cannot see. + + Args: + space (DesignSpace): The design space. + satellites (Callable): A function of a realized design that builds + its satellites (such as with `build_constellation`). + observations (Observations): The observations of the targets. + metrics (Callable): A function of observations (and of the realized + design, if it has a parameter named `design`) that gives their + metrics (a mapping). + layout (Any): The value of the design that is its layout (see + `value_of` and `layout_of`), if any, which a `plan` requires. + plan (MissionPlan | None): The deployment and costs, if any. + failures (Failures | None): The failures, if any, which require a + plan. + phases (Sequence[Requirement] | bool | None): `True` (or requirements + on the metrics) to summarize the phases of the deployment, which + require a plan. + **options (Any): The settings of the study (see `Study`), such as + `replicates`, `seed`, `n_jobs`, and `store`. + """ + + def __init__( + self, + space: DesignSpace, + satellites: Callable[[Design], Sequence[Satellite]], + observations: Observations, + metrics: Callable[[pd.DataFrame], Mapping[str, Any]], + layout: Any = None, + plan: MissionPlan | None = None, + failures: Failures | None = None, + phases: Sequence[Requirement] | bool | None = None, + **options: Any, + ): + # the requirements on the phases, if they are summarized + phases = None if phases is None or phases is False else phases + phases = () if phases is True else None if phases is None else tuple(phases) + if plan is None and (failures is not None or phases is not None): + raise ValueError("failures and phases require a mission plan") + if plan is not None and layout is None: + raise ValueError("a mission plan requires a layout") + if failures is not None and phases is not None: + raise ValueError( + "failures summarize the phases of their histories: give one or the other" + ) + self.observations, self.metrics, self.layout = observations, metrics, layout + self.plan, self.failures, self.phases = plan, failures, phases + evaluation = _Evaluation(observations, metrics, layout, plan, failures, phases) + super().__init__(space, satellites, evaluation, **options) + + def satellites_of(self, design: Design, replicate: int = 0) -> list[Satellite]: + """ + Gets the satellites of a replicate of a design. + + Args: + design (Design): The design. + replicate (int): The replicate. + + Returns: + list[Satellite]: the satellites + """ + return list(self.build(self._realize(design, replicate))) + + def targets_of(self, design: Design, replicate: int = 0) -> pd.DataFrame: + """ + Gets the targets of a replicate of a design. + + Args: + design (Design): The design. + replicate (int): The replicate. + + Returns: + pandas.DataFrame: the targets + """ + return self.observations.targets.of(self._realize(design, replicate)) + + def observations_of(self, design: Design, replicate: int = 0) -> pd.DataFrame: + """ + Gets the observations of a replicate of a design (such as for analyses + other than its metrics). + + Args: + design (Design): The design. + replicate (int): The replicate. + + Returns: + pandas.DataFrame: the observations + """ + realized = self._realize(design, replicate) + return self.observations(self.build(realized), realized) + + def _realize(self, design: Design, replicate: int) -> Design: + return design.realize(replicate, self.seed, self.common_random_numbers) diff --git a/src/tatc/tradespace/plotting.py b/src/tatc/tradespace/plotting.py new file mode 100644 index 00000000..5f6777ac --- /dev/null +++ b/src/tatc/tradespace/plotting.py @@ -0,0 +1,308 @@ +""" +Plots of the results of trade studies (with matplotlib, an optional +dependency, imported when a plot is drawn): designs by two metrics, with the +efficient designs ringed and labeled; the progress of searches; and the +means of metrics over replicates. Each plot draws on given axes (or new +ones) and returns them, for further labels and annotations. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +from collections.abc import Callable, Mapping, Sequence +from typing import Any + +import numpy as np +import pandas as pd + +from .criteria import Criteria +from .pareto import pareto_front + +COLORS = ( + "#2a78d6", + "#eb6834", + "#1baf7a", + "#eda100", + "#8f5bd6", + "#d6457a", + "#5aa8b0", + "#8a6b4f", +) +"""The colors of groups, in order.""" + +INK = "#2b2b29" +"""The color of text and of the rings of efficient designs.""" + +GRAY = "#8a8a86" +"""The color of references (such as lines of equal values).""" + +GRID = "#e6e6e3" +"""The color of grids.""" + + +def _axes(ax: Any, size: tuple[float, float]) -> Any: + """Gets the axes to draw on: those given, or those of a new figure.""" + if ax is not None: + return ax + try: + # pylint: disable-next=import-outside-toplevel + import matplotlib.pyplot as plt + except ImportError as error: + raise ImportError( + "plots require matplotlib (pip install matplotlib)" + ) from error + _, ax = plt.subplots(figsize=size) + return ax + + +def style_axes(ax: Any, grid: str | None = "y") -> Any: + """ + Styles axes plainly: a light grid behind the data, and no top or right + spines. + + Args: + ax (matplotlib.axes.Axes): The axes. + grid (str | None): The axes of the grid (`"x"`, `"y"`, or `"both"`), + or `None` for none. + + Returns: + matplotlib.axes.Axes: the axes + """ + if grid is not None: + ax.grid(axis=grid, color=GRID, lw=0.8) + ax.set_axisbelow(True) + for side in ("top", "right"): + ax.spines[side].set_visible(False) + return ax + + +def _color(colors: Sequence[str] | Mapping[Any, str], value: Any, k: int) -> str: + if isinstance(colors, Mapping): + return colors[value] + return colors[k % len(colors)] + + +def _name(names: Mapping[Any, str] | Callable[[Any], str] | None, value: Any) -> str: + if names is None: + return str(value) + if callable(names): + return names(value) + return names.get(value, str(value)) + + +def _groups(frame: pd.DataFrame, by: str) -> list: + """Gets the values of a column, sorted if they can be.""" + values = list(pd.unique(frame[by].dropna())) + try: + return sorted(values) + except TypeError: + return values + + +def plot_designs( + frame: pd.DataFrame, + x: str, + y: str, + by: str | None = None, + front: str | Criteria | Mapping[str, str] | None = None, + labels: str | Callable[[pd.Series], str] | None = None, + names: Mapping[Any, str] | Callable[[Any], str] | None = None, + jitter: float = 0.0, + colors: Sequence[str] | Mapping[Any, str] = COLORS, + legend: str | None = "best", + ax: Any = None, + seed: int = 0, +) -> Any: + """ + Plots designs (such as a summary of a study, see `aggregate`) by two + metrics: a point per row, colored by the value of a column `by` (if + any), with the efficient designs (`front`) ringed and labeled. + + Args: + frame (pandas.DataFrame): A row per design. + x (str): The column of the horizontal axis. + y (str): The column of the vertical axis. + by (str | None): A column whose values color the designs, or `None`. + front (str | Criteria | Mapping | None): The efficient designs: a + boolean column, criteria (see `pareto_front`), or `None`. + labels (str | Callable | None): The labels of the efficient designs: + a column, a function of a row, or `None`. + names (Mapping | Callable | None): The names of the values of `by` in + the legend (by default, the values). + jitter (float): The most that `x` is shifted at random (in its units), + to separate designs of the same `x` (such as numbers of + satellites). + colors (Sequence[str] | Mapping): The colors of the values of `by`, + in order (or by value). + legend (str | None): The location of the legend, or `None` for none. + ax (matplotlib.axes.Axes | None): The axes, or `None` for a new figure. + seed (int): The seed of the jitter. + + Returns: + matplotlib.axes.Axes: the axes + """ + ax = _axes(ax, (9, 4.5)) + shift = np.random.default_rng(seed).uniform(-jitter, jitter, len(frame)) + xs = frame[x].to_numpy(dtype=float) + (shift if jitter else 0.0) + ys = frame[y].to_numpy(dtype=float) + if by is None: + ax.scatter(xs, ys, s=14, color=_color(colors, None, 0), alpha=0.55, lw=0) + else: + for k, value in enumerate(_groups(frame, by)): + selected = (frame[by] == value).to_numpy() + ax.scatter( + xs[selected], + ys[selected], + s=14, + color=_color(colors, value, k), + alpha=0.55, + lw=0, + label=_name(names, value), + ) + if front is not None: + if isinstance(front, str): + efficient = frame[front].to_numpy(dtype=bool) + else: + efficient = np.asarray(pareto_front(frame, front), dtype=bool) + ax.scatter( + xs[efficient], + ys[efficient], + s=70, + facecolor="none", + edgecolor=INK, + lw=1.5, + label="Pareto-efficient", + ) + if labels is not None: + rows = frame[efficient] + for (_, row), point in zip( + rows.iterrows(), zip(xs[efficient], ys[efficient]) + ): + ax.annotate( + labels(row) if callable(labels) else str(row[labels]), + point, + xytext=(8, -3), + textcoords="offset points", + fontsize=8, + color=INK, + ) + ax.set(xlabel=x, ylabel=y) + style_axes(ax) + if legend is not None and (by is not None or front is not None): + ax.legend(loc=legend, fontsize=8, frameon=False, markerscale=1.6) + return ax + + +def plot_progress( + progress: Mapping[str, pd.Series], + colors: Sequence[str] | Mapping[str, str] = COLORS, + legend: str | None = "lower right", + ax: Any = None, +) -> Any: + """ + Plots the progress of searches: a line of each (such as the hypervolume + of the designs evaluated, see `hypervolume_progress`) by the number of + designs evaluated, labeled at its end. + + Args: + progress (Mapping[str, pandas.Series]): The progress of each search, + by its name: a value by the number of designs evaluated. + colors (Sequence[str] | Mapping): The colors of the searches, in + order (or by name). + legend (str | None): The location of the legend, or `None` for none. + ax (matplotlib.axes.Axes | None): The axes, or `None` for a new figure. + + Returns: + matplotlib.axes.Axes: the axes + """ + ax = _axes(ax, (9, 4.2)) + for k, (name, series) in enumerate(progress.items()): + ax.plot( + series.index, series.values, color=_color(colors, name, k), lw=2, label=name + ) + if len(series) > 0: + ax.annotate( + name, + (series.index[-1], series.values[-1]), + xytext=(6, 0), + textcoords="offset points", + va="center", + fontsize=8, + color=INK, + ) + ax.set(xlabel="Designs evaluated", xlim=(0, None)) + style_axes(ax) + if legend is not None and progress: + ax.legend(loc=legend, fontsize=8, frameon=False) + return ax + + +def plot_means( + results: pd.DataFrame, + x: str, + y: str, + by: str | None = None, + names: Mapping[Any, str] | Callable[[Any], str] | None = None, + colors: Sequence[str] | Mapping[Any, str] = COLORS, + legend: str | None = "best", + ax: Any = None, +) -> Any: + """ + Plots the mean of a metric over the feasible records of each value of a + column (such as over the replicates of the designs of each number of + satellites), with a band of one standard deviation about it, a line for + each value of a column `by` (if any). + + Args: + results (pandas.DataFrame): The results of a study (see `Study.run`). + x (str): The column of the horizontal axis. + y (str): The metric. + by (str | None): A column whose values have their own lines, or + `None`. + names (Mapping | Callable | None): The names of the values of `by` in + the legend (by default, the values). + colors (Sequence[str] | Mapping): The colors of the values of `by`, + in order (or by value). + legend (str | None): The location of the legend, or `None` for none. + ax (matplotlib.axes.Axes | None): The axes, or `None` for a new figure. + + Returns: + matplotlib.axes.Axes: the axes + """ + ax = _axes(ax, (6.5, 4.2)) + if "feasible" in results.columns: + results = results[results["feasible"].astype(bool)] + groups = ( + [(None, results)] + if by is None + else [(value, results[results[by] == value]) for value in _groups(results, by)] + ) + for k, (value, group) in enumerate(groups): + stats = group.groupby(x)[y].agg(["mean", "std"]).sort_index() + spread = stats["std"].fillna(0.0) + color = _color(colors, value, k) + ax.fill_between( + stats.index, + stats["mean"] - spread, + stats["mean"] + spread, + color=color, + alpha=0.12, + lw=0, + ) + ax.plot( + stats.index, + stats["mean"], + marker="o", + ms=5, + lw=2, + color=color, + mec="white", + mew=1.2, + label=None if value is None else _name(names, value), + ) + ax.set(xlabel=x, ylabel=y) + style_axes(ax) + if legend is not None and by is not None: + ax.legend(loc=legend, fontsize=8, frameon=False) + return ax diff --git a/tests/tradespace/test_layering.py b/tests/tradespace/test_layering.py new file mode 100644 index 00000000..6d837f00 --- /dev/null +++ b/tests/tradespace/test_layering.py @@ -0,0 +1,97 @@ +""" +Unit tests for the structure of the trade space module: the general modules +of trade studies do not depend on those of constellations and missions, and +the modules import each other without cycles. + +@author Paul T. Grogan +""" + +import ast +import unittest +from pathlib import Path + +import tatc.tradespace + +PACKAGE = Path(tatc.tradespace.__file__).parent + +GENERAL = { + "attribution", + "confirmation", + "criteria", + "fingerprint", + "nodes", + "optimization", + "pareto", + "plotting", + "refinement", + "scenarios", + "screening", + "sensitivity", + "space", + "store", + "study", + "utility", + "values", +} +"""The modules of trade studies of any designs.""" + + +def _imports(path: Path) -> set[str]: + """ + Gets the modules of the package that a module imports when it runs (at + the top or within functions, not only for type checking). + """ + found: set[str] = set() + + def visit(node: ast.AST) -> None: + if ( + isinstance(node, ast.If) + and getattr(node.test, "id", None) == "TYPE_CHECKING" + ): + return + if isinstance(node, ast.ImportFrom) and node.level == 1 and node.module: + found.add(node.module.split(".")[0]) + elif isinstance(node, ast.ImportFrom) and node.level == 1: + found.update(alias.name for alias in node.names) + for child in ast.iter_child_nodes(node): + visit(child) + + visit(ast.parse(path.read_text(encoding="utf-8"))) + return found + + +class TestLayering(unittest.TestCase): + """ + Unit tests for the dependencies between the modules of trade studies. + """ + + def setUp(self): + self.modules = { + path.stem: _imports(path) + for path in PACKAGE.glob("*.py") + if path.stem != "__init__" + } + + def test_general_modules(self): + """General modules do not import those of constellations and missions.""" + self.assertLessEqual(GENERAL, set(self.modules)) + for module in sorted(GENERAL): + with self.subTest(module=module): + self.assertLessEqual(self.modules[module], GENERAL) + + def test_no_cycles(self): + """Modules import each other without cycles.""" + state: dict[str, str] = {} + + def visit(module: str, path: list[str]) -> None: + if state.get(module) == "done": + return + if state.get(module) == "visiting": + self.fail(f"import cycle: {' -> '.join(path + [module])}") + state[module] = "visiting" + for imported in sorted(self.modules.get(module, ())): + visit(imported, path + [module]) + state[module] = "done" + + for module in sorted(self.modules): + visit(module, []) diff --git a/tests/tradespace/test_observations.py b/tests/tradespace/test_observations.py new file mode 100644 index 00000000..571c23a9 --- /dev/null +++ b/tests/tradespace/test_observations.py @@ -0,0 +1,417 @@ +""" +Unit tests for studies of the observations of constellations. + +@author Paul T. Grogan +""" + +import pickle +import tempfile +import unittest +from datetime import datetime, timedelta, timezone +from functools import partial +from pathlib import Path + +import pandas as pd + +from tatc.analysis import collect_observations +from tatc.generation import generate_points_rotated_lattice +from tatc.schemas import Instrument +from tatc.tradespace import ( + Categorical, + CostModel, + DeploymentSchedule, + DesignSpace, + Exponential, + FailureModel, + Failures, + Integer, + MissionPlan, + ObservationStudy, + Observations, + Real, + Requirement, + RestorationPolicy, + SatelliteCost, + Stage, + Study, + Targets, + Uncertain, + build_constellation, + count_planes, + count_satellites, + policy_space, + value_of, + walker_space, +) + +START = datetime(2026, 7, 1, tzinfo=timezone.utc) +HOURS = timedelta(hours=3) +N_POINTS = 20 +SPACE = DesignSpace( + altitude=Real(600e3, 700e3, step=100e3), + layout=walker_space(inclination=60, planes=Integer(1, 2), per_plane=Integer(1, 2)), + growth=Uncertain.uniform(1.0, 1.5), + points_seed=Uncertain.seed(), + failure_seed=Uncertain.seed(), +) +TARGETS = Targets(generate_points_rotated_lattice, N_POINTS, seed="points_seed") +SCHEDULE = DeploymentSchedule(years=3, production_rate=4, launch_interval=0.5) +COSTS = CostModel(SatelliteCost(development=10, first_unit=2)) +PLAN = MissionPlan(SCHEDULE, COSTS, growth={"development": "growth"}) +FAILURES = FailureModel(life=Exponential(0.2)) + + +def _build(d): + imager = Instrument(name="imager", field_of_regard=60) + return build_constellation(d.layout, imager, epoch=START, altitude=d.altitude) + + +def _metrics(observations): + """The share (%) of the points observed.""" + if len(observations) == 0: + return {"observed": 0.0} + return {"observed": 100 * observations.target_hash.nunique() / N_POINTS} + + +def _observations(directory=None): + return Observations(TARGETS, START, HOURS, directory=directory) + + +class TestReferences(unittest.TestCase): + """ + Unit tests for references to the values of designs. + """ + + def test_value_of(self): + """References name values, paths of values, or compute them.""" + d = SPACE.enumerate()[0].realize(0) + self.assertEqual(value_of(d, "altitude"), d.altitude) + self.assertEqual(value_of(d, "layout.planes"), d.layout.planes) + self.assertEqual(value_of(d, lambda d: 2 * d.altitude), 2 * d.altitude) + self.assertIsNone(value_of(d, None)) + with self.assertRaises(KeyError): + value_of(d, "layout.other") + with self.assertRaises(TypeError): + value_of(d, 3) + + +class TestTargets(unittest.TestCase): + """ + Unit tests for the targets of observations. + """ + + def test_generated(self): + """Targets generated from a seed of the design differ by replicate.""" + design = SPACE.enumerate()[0] + first, second = design.realize(0), design.realize(1) + targets = TARGETS.of(first) + pd.testing.assert_frame_equal( + targets, generate_points_rotated_lattice(N_POINTS, seed=first.points_seed) + ) + self.assertIs(TARGETS.of(first), targets) # kept in memory + self.assertFalse(TARGETS.of(second).equals(targets)) + self.assertEqual(pickle.loads(pickle.dumps(TARGETS))._memory, {}) + with self.assertRaises(ValueError): + TARGETS.of() + + def test_fixed(self): + """Fixed targets are the same in every replicate.""" + points = generate_points_rotated_lattice(5, seed=1) + targets = Targets(points) + self.assertIs(targets.of(), points) + self.assertIsNone(targets.seed_of(None)) + same = Targets(generate_points_rotated_lattice, 5, seed=None) + self.assertTrue(same.of().equals(same.of())) + with self.assertRaises(ValueError): + Targets(points, seed="points_seed") + with self.assertRaises(TypeError): + Targets([1, 2]) + + +class TestObservations(unittest.TestCase): + """ + Unit tests for the observations of targets. + """ + + def test_matches_analysis(self): + """The observations are those of the analysis of the targets.""" + d = SPACE.enumerate()[3].realize(0) + satellites = _build(d) + observations = _observations()(satellites, d) + direct = collect_observations(TARGETS.of(d), satellites, START, START + HOURS) + columns = ["target_hash", "satellite", "epoch"] + pd.testing.assert_frame_equal( + observations.sort_values(columns, ignore_index=True)[direct.columns], + direct.sort_values(columns, ignore_index=True), + ) + self.assertEqual(_observations().context_of(d), (d.points_seed, START, HOURS)) + + def test_disk_cache(self): + """Observations on disk are kept by the seed of the targets and the period.""" + designs = [d.realize(r) for d in SPACE.enumerate()[:2] for r in (0, 1)] + with tempfile.TemporaryDirectory() as directory: + observations = _observations(directory) + for d in designs: + observations(_build(d), d) + namespaces = sorted( + (p / "namespace.txt").read_text() for p in Path(directory).iterdir() + ) + self.assertEqual(len(namespaces), 2) # the targets of two replicates + self.assertTrue(all("targets of seed" in n for n in namespaces)) + again = _observations(directory) + again(_build(designs[0]), designs[0]) + self.assertEqual(again.cache_of(designs[0]).misses, 0) + + def test_directory_not_in_fingerprint(self): + """The directory of a cache does not change the fingerprint of a study.""" + prints = { + ObservationStudy( + SPACE, _build, _observations(directory), _metrics + ).fingerprint + for directory in (None, "a", "b") + } + self.assertEqual(len(prints), 1) + other = Observations(TARGETS, START, 2 * HOURS) + self.assertNotIn( + ObservationStudy(SPACE, _build, other, _metrics).fingerprint, prints + ) + + +class TestObservationStudy(unittest.TestCase): + """ + Unit tests for studies of observations. + """ + + def test_matches_study(self): + """A study of observations matches a study of the same parts.""" + designs = SPACE.enumerate() + + def evaluate(satellites, design): + deployment = SCHEDULE.plan(design.layout) + observations = collect_observations( + TARGETS.of(design), satellites, START, START + HOURS + ) + return { + "satellites": len(satellites), + "planes": count_planes(design.layout), + **COSTS.estimate(deployment, {"development": design.growth}).metrics(), + **_metrics(observations), + } + + plain = Study(SPACE, _build, evaluate, replicates=2).run(designs) + study = ObservationStudy( + SPACE, + _build, + _observations(), + _metrics, + layout="layout", + plan=PLAN, + replicates=2, + ) + results = study.run(designs) + columns = [c for c in plain.columns if c != "seconds"] + pd.testing.assert_frame_equal(results[columns], plain[columns]) + # the parts of a design, for other analyses + d = designs[3] + self.assertEqual(len(study.satellites_of(d, 1)), count_satellites(d.layout)) + self.assertEqual(len(study.targets_of(d, 1)), N_POINTS) + self.assertGreater(len(study.observations_of(d, 1)), 0) + + def test_phases_and_failures(self): + """Studies summarize phases, or the histories of failures.""" + designs = SPACE.enumerate()[:2] + phased = ObservationStudy( + SPACE, + _build, + _observations(), + _metrics, + layout="layout", + plan=PLAN, + phases=[Requirement("observed", ">=", 50)], + ).run(designs) + self.assertIn("observed mean", phased) + self.assertIn("observed time", phased) + failures = Failures( + FAILURES, RestorationPolicy(restore=False), histories=4, seed="failure_seed" + ) + degraded = ObservationStudy( + SPACE, + _build, + _observations(), + _metrics, + layout="layout", + plan=PLAN, + failures=failures, + ).run(designs) + self.assertTrue({"observed mean", "availability", "cost"} <= set(degraded)) + # the policy of each design + trade = DesignSpace( + **SPACE.children, policy=policy_space(orbit_spares=Integer(0, 1)) + ) + restored = ObservationStudy( + trade, + _build, + _observations(), + _metrics, + layout="layout", + plan=PLAN, + failures=Failures(FAILURES, histories=4, seed="failure_seed"), + ).run(trade.enumerate()[:4]) + self.assertTrue(restored.feasible.all()) + spares = restored.groupby("policy.orbit_spares")["cost production"].mean() + self.assertGreater(spares[1], spares[0]) + + def test_scenarios(self): + """Metrics given the design read the values of scenarios, also of the + phases of missions (cached by scenario).""" + + def observed_at(observations, design): + """The share (%) of the points observed at least a number of times.""" + if len(observations) == 0: + return {"observed": 0.0} + counts = observations.groupby("target_hash").size() + return {"observed": 100 * (counts >= design.times).sum() / N_POINTS} + + def space(times): + return DesignSpace(**SPACE.children, times=times) + + def study(times, **options): + return ObservationStudy( + space(times), + _build, + _observations(), + observed_at, + layout="layout", + plan=PLAN, + failures=Failures( + FAILURES, + RestorationPolicy(restore=False), + histories=4, + seed="failure_seed", + ), + replicates=2, + **options, + ) + + scenarios = {"once": {}, "twice": {"times": 2}} + both = study(1, scenarios=scenarios).run(space(1).enumerate()) + columns = ["observed", "observed mean", "availability", "cost"] + once = both[both.scenario == "once"].reset_index(drop=True) + twice = both[both.scenario == "twice"].reset_index(drop=True) + self.assertTrue((once.observed >= twice.observed).all()) + self.assertTrue((once["observed mean"] > twice["observed mean"]).any()) + # as studies with the values of the scenarios + for times, expected in ((1, once), (2, twice)): + alone = study(times).run(space(times).enumerate()) + pd.testing.assert_frame_equal( + alone[columns], expected[columns], check_names=False + ) + + def test_epoch(self): + """The period may start at an epoch of the design, such as one drawn for + each replicate, whose observations are those of the period at that epoch.""" + later = START + timedelta(days=100) + space = DesignSpace(**SPACE.children, epoch=Uncertain.choice([START, later])) + observations = Observations(TARGETS, "epoch", HOURS) + design = space.enumerate()[3] + realized = {} + for replicate in range(10): + d = design.realize(replicate) + realized.setdefault(d.epoch, d) + self.assertEqual(set(realized), {START, later}) + for epoch, d in realized.items(): + self.assertEqual(observations.start_of(d), epoch) + self.assertEqual(observations.end_of(d), epoch + HOURS) + self.assertEqual(observations.context_of(d)[1], epoch) + satellites = _build(d) + fixed = Observations(TARGETS, epoch, HOURS)(satellites, d) + pd.testing.assert_frame_equal(observations(satellites, d), fixed) + satellites = _build(realized[START]) + self.assertFalse( + observations(satellites, realized[START]).equals( + observations(satellites, realized[later]) + ) + ) + with self.assertRaises(ValueError): + _ = observations.end + with self.assertRaises(ValueError): + observations.start_of(None) + self.assertEqual(Observations(TARGETS, START, HOURS).end, START + HOURS) + # a study with an epoch drawn for each replicate + results = ObservationStudy( + space, _build, observations, _metrics, layout="layout", replicates=4 + ).run(space.enumerate()[:2]) + self.assertEqual(set(results.epoch), {START, later}) + + def test_stages(self): + """Plans stage the deployments of designs that decide to.""" + space = DesignSpace(**SPACE.children, staged=Categorical([False, True])) + designs = [d for d in space.enumerate() if d.layout.planes == 2] + + def stages(design): + """A second plane, never deployed, for a staged design.""" + return [Stage(1, 1.0, lambda decision: False)] if design.staged else [] + + plan = MissionPlan( + SCHEDULE, COSTS, growth={"development": "growth"}, stages=stages + ) + options = {"layout": "layout", "plan": plan, "replicates": 2} + phased = ObservationStudy( + space, + _build, + _observations(), + _metrics, + phases=[Requirement("observed", ">=", 50)], + **options, + ).run(designs) + means = phased.groupby("staged")[["observed mean", "cost"]].mean() + self.assertLess( + means.loc[True, "observed mean"], means.loc[False, "observed mean"] + ) + self.assertLess(means.loc[True, "cost"], means.loc[False, "cost"]) + # failures without restoration: histories are sampled rather than exact + failures = Failures( + FAILURES, RestorationPolicy(restore=False), histories=4, seed="failure_seed" + ) + degraded = ObservationStudy( + space, _build, _observations(), _metrics, failures=failures, **options + ).run(designs) + self.assertTrue(degraded.feasible.all()) + self.assertTrue(any("stages deployed" in column for column in degraded)) + + def test_invalid(self): + """Failures and phases need a plan, and a plan needs a layout.""" + observations = _observations() + with self.assertRaises(ValueError): + ObservationStudy(SPACE, _build, observations, _metrics, phases=True) + with self.assertRaises(ValueError): + ObservationStudy(SPACE, _build, observations, _metrics, plan=PLAN) + with self.assertRaises(ValueError): + ObservationStudy( + SPACE, + _build, + observations, + _metrics, + layout="layout", + plan=PLAN, + failures=Failures(FAILURES), + phases=True, + ) + + def test_parallel(self): + """Studies of observations run in parallel, with a cache on disk.""" + designs = SPACE.enumerate() + with tempfile.TemporaryDirectory() as directory: + study = partial( + ObservationStudy, + SPACE, + _build, + _observations(directory), + _metrics, + layout="layout", + replicates=2, + ) + serial = study().run(designs) + parallel = study(n_jobs=2).run(designs) + columns = [c for c in serial.columns if c != "seconds"] + pd.testing.assert_frame_equal(serial[columns], parallel[columns]) diff --git a/tests/tradespace/test_plotting.py b/tests/tradespace/test_plotting.py new file mode 100644 index 00000000..02ac4a58 --- /dev/null +++ b/tests/tradespace/test_plotting.py @@ -0,0 +1,106 @@ +""" +Unit tests for plots of the results of trade studies. + +@author Paul T. Grogan +""" + +import unittest + +import numpy as np +import pandas as pd + +from tatc.tradespace import pareto_front, plot_designs, plot_means, plot_progress + +try: + import matplotlib + + matplotlib.use("Agg") + import matplotlib.pyplot as plt +except ImportError: # pragma: no cover + plt = None + + +@unittest.skipIf(plt is None, "requires matplotlib") +class TestPlots(unittest.TestCase): + """ + Unit tests for plots. + """ + + def setUp(self): + self.summary = pd.DataFrame( + { + "design": list("abcdef"), + "satellites": [1, 2, 2, 3, 4, 4], + "planes": [1, 1, 2, 1, 2, 1], + "sufficient": [10.0, 30.0, 20.0, 50.0, 60.0, 40.0], + } + ) + + def tearDown(self): + plt.close("all") + + def test_designs(self): + """Designs are colored by group, and the efficient ones ringed and labeled.""" + objectives = {"satellites": "min", "sufficient": "max"} + self.summary["pareto"] = pareto_front(self.summary, objectives) + ax = plot_designs( + self.summary, + "satellites", + "sufficient", + by="planes", + front="pareto", + labels="design", + names=lambda planes: f"{planes} planes", + jitter=0.2, + ) + # a collection of each group, and of the efficient designs + self.assertEqual(len(ax.collections), 3) + efficient = int(self.summary.pareto.sum()) + self.assertEqual(len(ax.collections[-1].get_offsets()), efficient) + self.assertEqual( + sorted(t.get_text() for t in ax.texts), + sorted(self.summary.design[self.summary.pareto]), + ) + legend = [t.get_text() for t in ax.get_legend().get_texts()] + self.assertEqual(legend, ["1 planes", "2 planes", "Pareto-efficient"]) + # jitter shifts only the horizontal positions + offsets = np.concatenate([c.get_offsets() for c in ax.collections[:2]]) + self.assertTrue(np.all(np.abs(offsets[:, 0] - np.round(offsets[:, 0])) <= 0.2)) + # criteria find the front + ax = plot_designs(self.summary, "satellites", "sufficient", front=objectives) + self.assertEqual(len(ax.collections[-1].get_offsets()), efficient) + self.assertEqual(ax.get_xlabel(), "satellites") + + def test_given_axes(self): + """Plots draw on given axes.""" + _, ax = plt.subplots() + self.assertIs(plot_designs(self.summary, "satellites", "sufficient", ax=ax), ax) + self.assertIsNone(ax.get_legend()) + + def test_progress(self): + """Searches are lines, labeled at their ends.""" + progress = { + "one": pd.Series([1.0, 2.0, 3.0], index=[10, 20, 30]), + "two": pd.Series([2.0, 2.5], index=[10, 20]), + } + ax = plot_progress(progress) + self.assertEqual(len(ax.lines), 2) + self.assertEqual([t.get_text() for t in ax.texts], ["one", "two"]) + self.assertEqual(ax.get_xlim()[0], 0) + + def test_means(self): + """Means over replicates, with bands, by group (feasible records only).""" + results = pd.DataFrame( + { + "satellites": [1, 1, 2, 2, 1, 2], + "sensor": ["a", "a", "a", "a", "b", "b"], + "feasible": [True, True, True, False, True, True], + "resolved": [1.0, 3.0, 4.0, np.nan, 5.0, 7.0], + } + ) + ax = plot_means(results, "satellites", "resolved", by="sensor") + self.assertEqual(len(ax.lines), 2) + self.assertEqual(len(ax.collections), 2) # the bands + np.testing.assert_allclose(ax.lines[0].get_ydata(), [2.0, 4.0]) + single = plot_means(results, "satellites", "resolved") + self.assertEqual(len(single.lines), 1) From 05638445df609773d9d0ff613f30ce3c4cd7b38b Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Wed, 11 Nov 2026 22:00:31 -0700 Subject: [PATCH 29/52] document the trade space refactor in the changelog, API reference, and example SearchTradeSpace runs on observation studies, and adds sections that compare designs across scenarios (fields of different decorrelation times), find what spreads the replicates (and their differences), trade utility against cost for two stakeholders, stage the deployment of a second plane, and check the one window of quasi-static phases against epochs drawn over a year. Its refinement stops at a precision, and its pymoo search proposes no design twice. --- CHANGELOG.md | 22 +- docs/api_reference/tradespace.rst | 132 +- docs/examples/SearchTradeSpace.ipynb | 2955 ++++++++++++++++++-------- 3 files changed, 2235 insertions(+), 874 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 805ee2ac..72d64da4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,20 +12,26 @@ Added: - Field `type` (`instrument`, `pointed`, or `conical`) of `Instrument`, `PointedInstrument`, and `ConicalInstrument`, which identifies the instrument class in serialized data. Data without a `type` loads as the class its fields imply. - Function `generation.generate_points_rotated_lattice`, the points of a Fibonacci lattice in a random orientation: a stratified sample of the sphere (or of a mask), each point uniform by area, whose statistics have about 1.5 to 4 times less variance between replicates of trade studies than those of random points. - Analysis methods of the statistical sufficiency of observations (module `analysis.sufficiency`): `estimate_sampling_error`, the error of estimating the mean of a field over a period from each target's samples, for a field with a standard deviation and an exponential correlation in time (exact, see `sampling_error_variance`), with the effective number of independent samples; `sample_field`, which samples a field (an xarray `DataArray`, such as a nature run) at the time and place of each observation, and `compare_sampled_means`, which measures the sampling error against it; `compute_revisit_statistics`, the quantiles of revisits and the longest gap of each target (including the edges of the period); and `compute_local_time_coverage`, the distribution of samples in local time of day. The decorrelation time of `estimate_sampling_error` may differ between targets. The validation notebook `ValidateSamplingErrorIMERG` compares its predictions with the errors of monthly means of IMERG precipitation sampled by four constellation designs. `estimate_sampling_error` and `compute_revisit_statistics` compute the statistics of every target at once (the sum of the correlations between pairs of samples by a recursion over their times, and the gaps and their quantiles from the samples in order), with the same results 3 to 12 times faster. - - Module `tradespace` (prototype) for trade studies. A `DesignSpace` declares design variables (`Real`, `Integer`, `Categorical`), fixed and `Derived` values, and `Uncertain` parameters (drawn per replicate, not searched), grouped hierarchically with `Choice` (one of several branches) and `Repeat` (a variable number of items, such as orbit planes, optionally unordered). Bounds, derived values, and constraints are callables of the values decided before them. `DesignSpace.enumerate` gives every feasible design (a full factorial design, including variables that exist only in some designs), and `sample` a Latin hypercube or random sample. A `Design` has a `key` from its decisions and `flat` values by path, and `realize` draws a replicate's uncertain parameters, with common random numbers between designs by default. `Study` builds and evaluates designs in replicates into a data frame, recording designs that fail validation as infeasible, in worker processes with `n_jobs` (or on an `executor`); `summarize` gives the mean, standard deviation, and standard error of metrics over replicates. - - Class `tradespace.SatelliteCache`, which caches an analysis of single satellites by their content (orbit, instruments, and attitude, not their name, see `get_satellite_key`), in memory or on disk, so that designs that share satellites compute their results once. + - Module `tradespace` (prototype) for trade studies. A `DesignSpace` declares design variables (`Real`, `Integer`, `Categorical`), fixed and `Derived` values, and `Uncertain` parameters (drawn per replicate, not searched), grouped hierarchically with `Choice` (one of several branches) and `Repeat` (a variable number of items, such as orbit planes, optionally unordered). Bounds, derived values, and constraints are callables of the values decided before them. `DesignSpace.enumerate` gives every feasible design (a full factorial design, including variables that exist only in some designs), and `sample` a Latin hypercube or random sample. A `Design` has a `key` from its decisions and `flat` values by path, and `realize` draws a replicate's uncertain parameters, with common random numbers between designs by default. `Study` builds and evaluates designs in replicates into a data frame, in worker processes with `n_jobs` (or on an `executor`; idle workers wait two minutes for more evaluations before they exit), giving the realized design to an evaluation function with a parameter named `design`, recording as infeasible the designs that its functions reject with `Infeasible` or that fail the validation of TAT-C's schemas (other errors, including other `ValueError`s, are raised or recorded as failed), and raising an error for metrics that would replace its status columns or a design's values; `summarize` gives the mean, standard deviation, and standard error of metrics over replicates. + - Class `tradespace.SatelliteCache`, which caches an analysis of single satellites by their content (orbit, instruments, and attitude, not their name, see `get_satellite_key`), in memory or on disk, so that designs that share satellites compute their results once. On disk, results are kept by namespace and by the definition of the function (see `get_definition`); a cache warns if its namespace has results only of other definitions, naming what differs, `SatelliteCache.prune` removes them, and results that cannot be read are computed again. - Functions `tradespace.pareto_front`, `pareto_ranks` (both with optional tolerances of objectives, within which designs near the front are efficient), and `hypervolume` (exact) of designs with several objectives to minimize or maximize, and `pareto_probability`, the probability that each design is efficient given the uncertainty of its replicates (a bootstrap that resamples the same replicates for every design). - - Statistics of metrics over replicates (`tradespace.Mean`, `StandardDeviation`, `Minimum`, `Maximum`, `Quantile`, and `Probability`, the share of replicates that meet a threshold) and requirements on them (`Requirement`, output constraints that designs meet or violate by an amount once evaluated). `aggregate` gives the statistics and violations of each design; objectives and requirements of `pareto_probability` (which also gives the probability of meeting the requirements), `screen` (which ranks designs that miss requirements after those that meet them), `optimize_optuna` (a constraint of each trial for each requirement), and `optimize_pymoo` (a constraint for each requirement) name statistics, or metrics whose means they are. - - Function `tradespace.refine` (and class `Refinement`), which adds replicates only to the designs whose Pareto efficiency is uncertain, until it is settled, optionally with a tolerance of differences that do not matter (also of `pareto_probability`); `Study.run` evaluates given replicates (`replicates`). - - Class `tradespace.ResultStore`, a persistent store (SQLite) of the evaluations of a study (argument `store` of `Study`), from which a study that is interrupted or extended takes the evaluations stored before. Function `tradespace.sensitivity` (and `main_effects`), the share of the variance of metrics explained by each design variable where it is active. Tolerances of objectives may be percentages of their values (such as `"5%"`). `Uncertain.seed` draws a seed of random numbers for each replicate, and `remove_failures` removes the satellites that fail, the same in every design. - - Building blocks of constellations: fragments of design spaces of Walker constellations (`tradespace.walker_space`) and planes of sun-synchronous orbits (`sso_planes_space`, whose planes have different crossing times), `build_constellation`, which builds the satellites of either with instruments or entries of the instrument catalog (with their validated attitudes, and several entries on one satellite), and `count_satellites` and `count_planes`. The phase and node of the lead satellite of a Walker constellation (`phase_fraction` and `node_fraction`, design variables or uncertain parameters) are fractions of the intervals over which they give distinct constellations (`360 / per_plane` degrees of phase, and `360 / planes` degrees of node for a delta configuration or 360 for a star), so that a search does not evaluate the same constellation at several phases or nodes. Planes of inclined orbits (`planes_space`), each with its own inclination and node (uncertain by default, as of satellites launched as secondary payloads). The satellites of the planes of `sso_planes_space` and `planes_space` are evenly spaced, or follow each other in a train at an `interval` (minutes), on the same ground track or in the same plane (`repeat_ground_track`). The phase of each plane (`phase_fraction`, which replaces `phase` of `sso_planes_space`) is a fraction of the interval over which it gives distinct planes (`360 / satellites` degrees for evenly spaced satellites, 360 for a train), from which each fragment derives the plane's `true_anomaly`, as for the lead satellite of a Walker constellation. `build_constellation`, `count_satellites`, and `count_planes` take several layouts (a list, or a `Repeat` of a `Choice` of layouts), such as the shells of a mixed constellation. + - Criteria by which designs are judged (`tradespace.Criteria`): objectives to minimize or maximize, requirements (`Requirement`, output constraints that designs meet or violate once evaluated, by an amount relative to the required value or a `scale`), the statistics over replicates that they name (`Mean`, `StandardDeviation`, `StandardError`, `Minimum`, `Maximum`, `Quantile`, and `Probability`, the share of replicates that meet a threshold; other names are means of metrics), tolerances of objectives, and the columns that group the records of an evaluation (`by`, such as a sensor), whose designs are judged separately. `aggregate` gives statistics of each design (and, with criteria, the violations of their requirements), and `summarize` means with their standard deviations and standard errors. `pareto_front`, `pareto_ranks` (which ranks designs that miss requirements after those that meet them), `hypervolume`, `pareto_probability` (which also gives the probability of meeting the requirements), `refine`, `confirm`, `screen`, `optimize_optuna` (a constraint of each trial for each requirement), and `optimize_pymoo` (a constraint for each requirement) take criteria, or a mapping of objectives to their directions. Results with several records of an evaluation that `by` does not separate raise an error rather than being averaged. + - Function `tradespace.refine` (and class `Refinement`), which adds replicates only to the designs whose Pareto efficiency is uncertain, until it is settled, optionally with a tolerance of differences that do not matter (also of `pareto_probability`), and within a `budget` of evaluations (refining the least settled designs first). Designs about a tolerance from the front, which more replicates settle only slowly, are `indifferent` and not refined once their objectives are known to within a share of their tolerances (`precision`, from the standard errors of the objectives that `pareto_probability` gives). `Study.run` evaluates given replicates (`replicates`). + - Class `tradespace.ResultStore`, a persistent store (SQLite) of the evaluations of a study (argument `store` of `Study`), from which a study that is interrupted or extended takes the evaluations stored before (except evaluations that failed and designs that failed validation, which are evaluated again). Workers add each evaluation as it completes, so that an interrupted run loses only the evaluations in progress, and records are kept as JSON (with values such as dates and infinite numbers tagged, so that they are read exactly). Function `tradespace.sensitivity` (and `main_effects`), the share of the variance of metrics explained by each design variable where it is active. Tolerances of objectives may be percentages of their values (such as `"5%"`). `Uncertain.seed` draws a seed of random numbers for each replicate, and `remove_failures` removes the satellites that fail, the same in every design. + - Building blocks of constellations: fragments of design spaces of Walker constellations (`tradespace.walker_space`) and planes of sun-synchronous orbits (`sso_planes_space`, whose planes have different crossing times), `build_constellation`, which builds the satellites of either with instruments or entries of the instrument catalog (with their validated attitudes, and several entries on one satellite), and `count_satellites` and `count_planes`. The phase and node of the lead satellite of a Walker constellation (`phase_fraction` and `node_fraction`, design variables or uncertain parameters) are fractions of the intervals over which they give distinct constellations (`360 / per_plane` degrees of phase, and `360 / planes` degrees of node for a delta configuration or 360 for a star), so that a search does not evaluate the same constellation at several phases or nodes. Planes of inclined orbits (`planes_space`), each with its own inclination and node (uncertain by default, as of satellites launched as secondary payloads). The satellites of the planes of `sso_planes_space` and `planes_space` are evenly spaced, or follow each other in a train at an `interval` (minutes), on the same ground track or in the same plane (`repeat_ground_track`). The phase of each plane (`phase_fraction`, which replaces `phase` of `sso_planes_space`) is a fraction of the interval over which it gives distinct planes (`360 / satellites` degrees for evenly spaced satellites, 360 for a train), from which each fragment derives the plane's `true_anomaly`, as for the lead satellite of a Walker constellation. `build_constellation`, `count_satellites`, and `count_planes` take several layouts (a list, or a `Repeat` of a `Choice` of layouts), such as the shells of a mixed constellation. The values of each fragment in a design are those of a `Layout` (`layout_of`, with `WalkerLayout`, `SSOPlanesLayout`, `PlanesLayout`, and `Layouts` of several), which gives its `Plane`s and the orbits of their satellites in order; other layouts subclass it and are built, counted (`plane_sizes`), deployed, and costed as the others. - Function `tradespace.screen` (and class `Screening`), which screens designs with studies of increasing fidelity, keeping whole fronts of the best designs of each stage for the next. - - Searches of design spaces with optional optimizers: `tradespace.optimize_optuna` suggests designs with Optuna trials (`DesignSpace.suggest`, define-by-run over the hierarchical space), and `optimize_pymoo` and `make_pymoo_problem` search the unit hypercube that encodes a design space (`DesignSpace.unit_paths`, `encode`, and `decode`) with pymoo. Each design is evaluated once, and the designs proposed together are evaluated together, in parallel if the study is. Constraints of a design space may return the amount of their violation (`Infeasible.violation`), which Optuna's trials record (`set_constraint`) for its constraint-aware samplers, and which is the constraint value of pymoo problems. Optional dependencies `tradespace` (joblib, Optuna, and pymoo). + - Searches of design spaces with optional optimizers: `tradespace.optimize_optuna` suggests designs with Optuna trials (`DesignSpace.suggest`, define-by-run over the hierarchical space), and `optimize_pymoo` and `make_pymoo_problem` search the unit hypercube that encodes a design space (`DesignSpace.unit_paths`, `encode`, and `decode`) with pymoo, whose algorithms eliminate the proposals of designs proposed or evaluated before (`distinct`, by design rather than by point of the hypercube, `make_pymoo_problem`'s `duplicates`). Each design is evaluated once, and the designs proposed together are evaluated together, in parallel if the study is. A search returns its results and designs (`Search`), which `refine` and `confirm` refine and confirm as for any study. Constraints of a design space may return the amount of their violation (`Infeasible.violation`), which Optuna's trials record (`set_constraint`) for its constraint-aware samplers, and which is the constraint value of pymoo problems. Optional dependencies `tradespace` (joblib, Optuna, and pymoo). - Deployment of constellations (`tradespace.DeploymentSchedule`): from the rates and durations of a study (the mission and design life, the development of each type of satellite, its production on a line at a production rate, and launches at a cadence and capacity, in number or mass, optionally in an order of planes), each design's deployment (`DeploymentSchedule.plan`, a `Deployment` of its `Production`, `Launch`es, and replacements), so that a design of more satellites and planes takes longer to deploy. Its launches divide the mission into phases of constant sets of operating satellites (`Deployment.phases`), evaluated over the study's representative period from the observations of the full constellation (`evaluate_phases`) and combined over the mission (`summarize_phases`: the time-weighted mean of each metric and the time until it first meets a requirement). - Simulated missions with failures (`Deployment.simulate`, a `MissionHistory` for each replicate, drawn from its seed with common random numbers between designs): lives of satellites whose failure rates vary over the lifecycle (`tradespace.Exponential`, `Weibull`, `Bathtub` of competing causes, and `Piecewise` rates by age, `Lifetime`), failures of launches (`FailureModel`), and a policy that degrades or restores failed satellites (`RestorationPolicy`) by spares in orbit (taking a failed satellite's place after drifting), spares on the ground (launched at the next launch slot), or satellites produced when needed (after procurement, on the production line), optionally replenishing spares and batching restorations in launches. A history gives the phases in which satellites operate (`MissionHistory.phases`), measures of the mission (`MissionHistory.metrics`: failures, restorations, spares used, time to restore, and availability), and, priced by a `CostModel`, the cost of what it produces and launches. Policies are decisions of designs with a fragment of a design space (`policy_space`: whether to restore, spares in orbit and on the ground, and other fields of the policy, without spares that would never be used), and `configure` makes a policy (or a deployment schedule, or another dataclass) from the values of a design. Many histories of a replicate's mission (`Deployment.simulate_many`) share its sample of targets: `evaluate_missions` evaluates them (with their measures and costs) with a cache that evaluates each set of operating satellites once (`PhaseCache`, keyed by the content of the satellites and shared by the histories, policies, and designs of a replicate), and `summarize_missions` gives their means, quantiles (the risk of the mission), and probabilities of meeting requirements, as one record of the replicate. The histories of a replicate are stratified by default (a Latin hypercube over the histories of each satellite's life and each launch, drawn from uniform numbers by `Lifetime.from_uniform`), which estimates the means of missions 3 to 15 times more precisely than independent histories, and means may be estimated with control variates (`summarize_missions(controls=...)`, such as the availability of the mission, whose expected value simulations alone estimate, `Deployment.expected_metrics`). `allocate_histories` recommends the histories of each replicate (and the replicates, for a standard error) from a pilot with independent histories, by the variances between replicates and between histories and their costs (`summarize_missions(spread=True)` gives the standard deviations of the histories). `expected_missions` computes the expected capability and availability of a mission without restoration exactly (the sets of operating satellites by their probabilities, from the survival of each launch group, with planned replacements), without sampling error. Histories may be drawn from stressed failures for importance sampling (`simulate_many(stress=...)`: hazards and launch failures times a factor, each history weighted by its likelihood ratio censored at the end of the mission, `Lifetime.stressed` and `MissionHistory.weight`), which `summarize_missions` weighs in every statistic, with the effective number of histories: the probabilities of rare losses with 30 to 70 times less variance. - Life-cycle costs of deployments for trade studies (`tradespace.CostModel`): the development of each type of satellite, the production of its units on a learning curve (`SatelliteCost`), launches (per launch, or prices per satellite and kg, `LaunchCost`), operations (`OperationsCost`), replacements, and spares in orbit, dated by the deployment for their present value at a discount rate (`CostEstimate.present_value`, metric `cost present`) and annual costs (`CostEstimate.annual`, metric `cost peak annual`), with growth factors for cost risk (such as uncertain parameters, whose quantiles over replicates give the cost at a confidence level). TAT-C does not include cost-estimating relationships: the costs are given by the study. Fingerprints describe dataclasses (such as cost models) by their fields. - - Function `tradespace.confirm` (and class `Confirmation`), which evaluates selected designs (such as a front) with new replicates that played no part in their selection, removing the optimism of the selection (the winner's curse, `Confirmation.optimism`). `ResultStore` keys evaluations by the fingerprint of a study (`Study.fingerprint`, see `get_fingerprint`: its seed, use of common random numbers, design space, and build and evaluation functions, and the version of TAT-C), warning if it holds evaluations of other definitions, which are not reused; `SatelliteCache` keys results on disk by the fingerprint of its function. Fingerprints include a hash of the source of TAT-C (its code and resources, `get_source_hash`), so that results computed with other code of TAT-C, in development as well as in other versions, are not reused. `refine` treats designs with fewer than `min_replicates` (5) as uncertain whatever their probability, adds the replicates left to `max_replicates` in a last partial step, and warns if designs remain uncertain without a tolerance. `sensitivity` gives adjusted shares (epsilon squared) by default, without the share that the levels of a variable explain by chance (`adjusted=False` for correlation ratios). + - Function `tradespace.confirm` (and class `Confirmation`), which evaluates selected designs (such as a front) with new replicates that played no part in their selection, removing the optimism of the selection (the winner's curse, `Confirmation.optimism`). `ResultStore` keys evaluations by the fingerprint of a study (`Study.fingerprint`, a hash of `Study.definition`, see `get_definition`: its seed, use of common random numbers, design space, and build and evaluation functions, with the data frames they are given described by their content, the version of Python, and the source of the modules of TAT-C and resource files they depend on, found from their imports) and keeps each definition, so that a study warns of evaluations of other definitions, which are not reused, naming what differs (`compare_definitions`); `ResultStore.prune` removes them. Changes to TAT-C that a study does not depend on (such as to modules it does not use) keep its results. Namespaces of stores and caches are optional, for what fingerprints cannot see (data that functions read from files, and the code of other modules). `refine` treats designs with fewer than `min_replicates` (5) as uncertain whatever their probability, adds the replicates left to `max_replicates` in a last partial step, and warns if designs remain uncertain without a tolerance. `sensitivity` gives adjusted shares (epsilon squared) by default, without the share that the levels of a variable explain by chance (`adjusted=False` for correlation ratios). + - The start of the period of `tradespace.Observations` may be a value of the design (`start_of` and `end_of` give a design's period), such as an uncertain epoch drawn for each replicate over the mission, whose observations are cached apart, so that replicates average over the geometry and seasons of the mission that the one window of quasi-static phases misses (as `evaluate_phases` now states). The schedule of deployments states that a design life does not retire a satellite that is not replaced, and simulations that a planned replacement whose launch fails is not flown again. + - Utilities of the metrics of designs (`tradespace.Utility`), for trade spaces of utility against cost: a single-attribute utility of each metric (`LinearUtility`, `ExponentialUtility` of a risk attitude, `PiecewiseUtility`, or any function), combined by weights additively or in Keeney and Raiffa's multiplicative form. A utility is a metric of any statistic (its `Mean` is the expected utility over the replicates, and a utility given as a statistic of `Criteria` is its mean), computed in each replicate, and gives the utility of each row of a data frame (such as a summary of the means of designs). Statistics name the columns they need (`Statistic.columns`). + - Staged deployments (`tradespace.Stage`, argument `stages` of `DeploymentSchedule.plan` and `MissionPlan`, which may give the stages of each design): planes that are produced and launched only if a rule decides to, at times during the mission, from what it knows then (`Decision`: the satellites operating, the history so far, and, through the design, its uncertain parameters and scenario), after a lead time and at the next launch slots, and replaced and restored as other planes. A stage that is not deployed is neither produced, launched, nor priced; `MissionHistory.stages` gives when each was deployed, and its metrics the `stages deployed`. Exact expectations of missions without restoration (`expected_missions`) need deployments that are not staged, so that studies of staged deployments sample their histories. + - Scenarios of studies (argument `scenarios` of `tradespace.Study`): conditions under which designs are compared rather than averaged over, each giving fixed values or uncertain parameters of the design space other values (`Design.realize` takes a `scenario`), so that each design is evaluated in each scenario (recorded as `scenario`, and judged in each with criteria `by` it). Each scenario's evaluations are stored by its values, so that a scenario added later is evaluated alone. Function `tradespace.robustness` gives each design's Pareto trace (the share of scenarios in which it is efficient) and its regret in each scenario (the improvement in every objective it would need to match the scenario's front) and the largest. The metrics of an `ObservationStudy` (and of `PhaseCache`, `evaluate_missions`, and `expected_missions`) are given the realized design if they have a parameter named `design`. + - Function `tradespace.attribute_variance` (and class `Attribution`), which attributes the variance of metrics between the replicates of each design to its uncertain parameters (or groups of them): the share that each causes, alone or with others, and the share that knowing it would remove, with standard errors, by evaluating designs with one parameter drawn as in other replicates and the others held (which works for seeds, whose values do not order outcomes); `Attribution.summary` pools the shares of several designs, and `Attribution.differences` attributes the variance of the differences between pairs of designs, from the same evaluations (parameters that act alike on both cancel, with common random numbers). `Design.realize` and `Study.run` take a `shift`, which draws named parameters as in other replicates (kept apart in a `ResultStore` as a variant of the replicates), and `DesignSpace.uncertain_paths` lists the uncertain parameters. - Searches with Optuna accept categorical options that depend on earlier decisions (a parameter for each set of options), use TPE with a constant liar in batches by default (which spreads the trials of a batch), and stop after `max_designs` designs evaluated (trials that suggest designs evaluated before are told their objectives without evaluating them again). A design infeasible in some of its replicates violates its feasibility by their share (`Evaluations.infeasibility`), and the first design evaluated in a search is evaluated alone, to check that evaluations give one record each. `Study` records errors of evaluations as infeasible, without storing them, with `errors="record"`. Enumeration walks the items of unordered repetitions in one order only (the same designs, in the same order, four times faster for three sun-synchronous planes), and `DesignSpace.size` counts designs without keeping them. Pareto fronts are found by a vectorized sweep in lexicographic order that compares designs only with the efficient designs before them, and fronts with tolerances by comparing designs only with the efficient designs without tolerances (which dominate every design that any design dominates within the tolerances), in blocks of bounded memory: 20,000 designs in 0.05 s (0.11 s with tolerances) rather than 17 s, and the bootstraps of `pareto_probability` (and so `refine`) about 20 times faster. + - Studies of the observations of constellations (`tradespace.ObservationStudy`): the targets of each replicate (`Targets`, fixed or generated from a seed of the design), the observations of each satellite, cached on disk (`Observations`), the metrics of the observations, and, with a `MissionPlan`, the costs of the deployment and the summaries of its phases or of the histories of its `Failures`. Plots of the results of studies (`plot_designs`, `plot_progress`, and `plot_means`, with matplotlib, now in the `tradespace` extra), and the hypervolume of a search as it proceeds (`hypervolume_progress`). - Example `SearchTradeSpace`, which searches a hierarchical trade space of constellations for the designs that sample points sufficiently: by evaluating every design, ranking them with the uncertainty of their replicates, screening, and searching with Optuna and pymoo. - The `RunOSSEMonsoon` example declares its constellation trade as a design space, caches the looks of each satellite, evaluates its replicates in parallel, and finds its Pareto-efficient designs. diff --git a/docs/api_reference/tradespace.rst b/docs/api_reference/tradespace.rst index 08a65f6c..246e440c 100644 --- a/docs/api_reference/tradespace.rst +++ b/docs/api_reference/tradespace.rst @@ -7,7 +7,7 @@ Design Spaces ------------- .. autoclass:: tatc.tradespace.DesignSpace - :members: enumerate, size, sample, design, suggest, unit_paths, encode, decode + :members: enumerate, size, sample, design, suggest, unit_paths, uncertain_paths, encode, decode .. autoclass:: tatc.tradespace.Variable :members: domain @@ -67,6 +67,23 @@ Constellations .. autofunction:: tatc.tradespace.count_planes +.. autofunction:: tatc.tradespace.plane_sizes + +.. autoclass:: tatc.tradespace.Layout + :members: planes, orbits, names, satellites, build + +.. autoclass:: tatc.tradespace.Plane + +.. autofunction:: tatc.tradespace.layout_of + +.. autoclass:: tatc.tradespace.constellations.WalkerLayout + +.. autoclass:: tatc.tradespace.constellations.SSOPlanesLayout + +.. autoclass:: tatc.tradespace.constellations.PlanesLayout + +.. autoclass:: tatc.tradespace.constellations.Layouts + .. autofunction:: tatc.tradespace.hours_to_time .. autofunction:: tatc.tradespace.remove_failures @@ -87,6 +104,10 @@ Deployment .. autoclass:: tatc.tradespace.Production +.. autoclass:: tatc.tradespace.Stage + +.. autoclass:: tatc.tradespace.Decision + Failures and Missions --------------------- @@ -155,31 +176,56 @@ Costs .. autoclass:: tatc.tradespace.CostEstimate :members: total, present_value, annual, metrics -.. autofunction:: tatc.tradespace.plane_sizes - Trade Studies ------------- .. autoclass:: tatc.tradespace.Study - :members: run, workers, fingerprint + :members: run, workers, definition, fingerprint -.. autofunction:: tatc.tradespace.summarize +Observation Studies +------------------- + +.. automodule:: tatc.tradespace.observations + :no-members: + +.. autoclass:: tatc.tradespace.ObservationStudy + :members: satellites_of, targets_of, observations_of + +.. autoclass:: tatc.tradespace.Targets + :members: of, seed_of + +.. autoclass:: tatc.tradespace.Observations + :members: end, start_of, end_of, cache_of, context_of, __call__ -Statistics and Requirements ---------------------------- +.. autoclass:: tatc.tradespace.MissionPlan + :members: growth_of, stages_of + +.. autoclass:: tatc.tradespace.Failures + +.. autofunction:: tatc.tradespace.value_of + +Criteria, Statistics, and Requirements +-------------------------------------- .. automodule:: tatc.tradespace.criteria :no-members: +.. autoclass:: tatc.tradespace.Criteria + :members: names, metrics, statistic + .. autofunction:: tatc.tradespace.aggregate +.. autofunction:: tatc.tradespace.summarize + .. autoclass:: tatc.tradespace.Statistic - :members: reduce + :members: reduce, columns, values_of .. autoclass:: tatc.tradespace.Mean .. autoclass:: tatc.tradespace.StandardDeviation +.. autoclass:: tatc.tradespace.StandardError + .. autoclass:: tatc.tradespace.Minimum .. autoclass:: tatc.tradespace.Maximum @@ -191,15 +237,38 @@ Statistics and Requirements .. autoclass:: tatc.tradespace.Requirement :members: violation +Utility +------- + +.. automodule:: tatc.tradespace.utility + :no-members: + +.. autoclass:: tatc.tradespace.Utility + :members: columns, scaling, evaluate, __call__ + +.. autoclass:: tatc.tradespace.LinearUtility + +.. autoclass:: tatc.tradespace.ExponentialUtility + +.. autoclass:: tatc.tradespace.PiecewiseUtility + Stores of Results ----------------- .. autoclass:: tatc.tradespace.ResultStore - :members: get, put, contexts, clear + :members: get, put, define, definition, contexts, prune, clear + +Fingerprints +------------ + +.. automodule:: tatc.tradespace.fingerprint + :no-members: .. autofunction:: tatc.tradespace.get_fingerprint -.. autofunction:: tatc.tradespace.get_source_hash +.. autofunction:: tatc.tradespace.get_definition + +.. autofunction:: tatc.tradespace.compare_definitions Caches ------ @@ -208,7 +277,7 @@ Caches :no-members: .. autoclass:: tatc.tradespace.SatelliteCache - :members: get, clear, __call__ + :members: get, prune, clear, __call__ .. autofunction:: tatc.tradespace.get_satellite_key @@ -221,6 +290,8 @@ Pareto Efficiency .. autofunction:: tatc.tradespace.hypervolume +.. autofunction:: tatc.tradespace.hypervolume_progress + .. autofunction:: tatc.tradespace.pareto_probability Adaptive Replication @@ -229,7 +300,7 @@ Adaptive Replication .. autofunction:: tatc.tradespace.refine .. autoclass:: tatc.tradespace.Refinement - :members: uncertain + :members: uncertain, indifferent Confirmation ------------ @@ -246,6 +317,25 @@ Sensitivity .. autofunction:: tatc.tradespace.main_effects +Scenarios +--------- + +.. automodule:: tatc.tradespace.scenarios + :no-members: + +.. autofunction:: tatc.tradespace.robustness + +Attribution of Variance +----------------------- + +.. automodule:: tatc.tradespace.attribution + :no-members: + +.. autofunction:: tatc.tradespace.attribute_variance + +.. autoclass:: tatc.tradespace.Attribution + :members: summary, differences + Screening --------- @@ -266,5 +356,21 @@ Optimizers .. autofunction:: tatc.tradespace.make_pymoo_problem +.. autoclass:: tatc.tradespace.Search + .. autoclass:: tatc.tradespace.Evaluations - :members: evaluate, results, worst + :members: evaluate, results, worst, designs + +Plots +----- + +.. automodule:: tatc.tradespace.plotting + :no-members: + +.. autofunction:: tatc.tradespace.plot_designs + +.. autofunction:: tatc.tradespace.plot_progress + +.. autofunction:: tatc.tradespace.plot_means + +.. autofunction:: tatc.tradespace.style_axes diff --git a/docs/examples/SearchTradeSpace.ipynb b/docs/examples/SearchTradeSpace.ipynb index 558ba191..ccc23e7e 100644 --- a/docs/examples/SearchTradeSpace.ipynb +++ b/docs/examples/SearchTradeSpace.ipynb @@ -17,7 +17,7 @@ "id": "b2e1d4c3", "metadata": {}, "source": [ - "## Configure the Scenario\n", + "## Configure the Analysis\n", "\n", "The analysis covers one day, with 100 points in each of five replicates. A design may have at most 10 satellites." ] @@ -28,10 +28,10 @@ "id": "c3d2e5f4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T18:29:30.102760Z", - "iopub.status.busy": "2026-11-11T18:29:30.102510Z", - "iopub.status.idle": "2026-11-11T18:29:30.830083Z", - "shell.execute_reply": "2026-11-11T18:29:30.829355Z" + "iopub.execute_input": "2026-11-11T23:50:28.225118Z", + "iopub.status.busy": "2026-11-11T23:50:28.225118Z", + "iopub.status.idle": "2026-11-11T23:50:29.544504Z", + "shell.execute_reply": "2026-11-11T23:50:29.543784Z" } }, "outputs": [], @@ -51,9 +51,7 @@ "SAMPLES_PER_DAY = 4 # a point is sufficiently sampled if it is observed at least this often\n", "MAX_SATELLITES = 10\n", "DECORRELATION_TIME = timedelta(hours=3) # of the field whose daily mean is estimated\n", - "MAX_RELATIVE_ERROR = 0.5 # a point is accurately sampled within this share of the field's standard deviation\n", - "\n", - "BLUE, ORANGE, AQUA, YELLOW, GRAY, INK = \"#2a78d6\", \"#eb6834\", \"#1baf7a\", \"#eda100\", \"#8a8a86\", \"#2b2b29\"" + "MAX_RELATIVE_ERROR = 0.5 # a point is accurately sampled within this share of the field's standard deviation" ] }, { @@ -68,7 +66,7 @@ "* a **Walker delta** constellation (`walker_space`), with an inclination, a number of planes, a number of satellites in each plane, and the relative spacing of the satellites between planes (whose upper bound depends on the number of planes), or\n", "* one or two **sun-synchronous** planes (`sso_planes_space`, a `Repeat` of planes), each with its own equator crossing time and number of satellites. The planes are unordered: two planes in either order are the same design. A constraint of the building block requires the planes to have different crossing times (otherwise, they would be the same plane).\n", "\n", - "The points sampled in each replicate are an `Uncertain` parameter (the seed of a random orientation of a lattice of points, `Uncertain.seed`), drawn for each replicate rather than designed, as are the failures of satellites and the growth of the cost of developing the satellites (both used below). The replicates use common random numbers: every design samples the same points in the same replicate, so that differences between designs are not differences between their samples. The points of a replicate are a Fibonacci lattice in a random orientation (`generate_points_rotated_lattice`): each point is as likely to fall anywhere as a random point, but the points cover the Earth evenly rather than clustering by chance, so that the shares of points vary less between replicates than with random points (`generate_points_random`; here, with 1.5 to 4 times less variance), and fewer replicates estimate them as precisely.\n", + "The points sampled in each replicate are an `Uncertain` parameter (the seed of a random orientation of a lattice of points, `Uncertain.seed`), drawn for each replicate rather than designed, as are the failures of satellites and the growth of the cost of developing the satellites (both used below). The replicates use common random numbers: every design samples the same points in the same replicate, so that differences between designs are not differences between their samples. The points of a replicate are a Fibonacci lattice in a random orientation (`generate_points_rotated_lattice`): each point is as likely to fall anywhere as a random point, but the points cover the Earth evenly rather than clustering by chance, so that the shares of points vary less between replicates than with random points (`generate_points_random`; here, with 1.5 to 4 times less variance), and fewer replicates estimate them as precisely. The decorrelation time of the field whose daily mean is estimated is a `Fixed` value of the design space, which the metrics read from each design, rather than a constant of the metrics, so that scenarios can change it (see below).\n", "\n", "The constraint on the number of satellites returns the number in excess of the limit (a number that is not positive if the design satisfies it), rather than `True` or `False`, so that optimizers can tell how far an infeasible design is from a feasible one." ] @@ -79,10 +77,10 @@ "id": "e5f4a7b6", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T18:29:30.832202Z", - "iopub.status.busy": "2026-11-11T18:29:30.831943Z", - "iopub.status.idle": "2026-11-11T18:29:32.013063Z", - "shell.execute_reply": "2026-11-11T18:29:32.012311Z" + "iopub.execute_input": "2026-11-11T23:50:29.544504Z", + "iopub.status.busy": "2026-11-11T23:50:29.544504Z", + "iopub.status.idle": "2026-11-11T23:50:30.987111Z", + "shell.execute_reply": "2026-11-11T23:50:30.987111Z" } }, "outputs": [ @@ -99,6 +97,7 @@ " Categorical,\n", " Choice,\n", " DesignSpace,\n", + " Fixed,\n", " Integer,\n", " Real,\n", " Uncertain,\n", @@ -117,6 +116,8 @@ " points_seed=Uncertain.seed(),\n", " failure_seed=Uncertain.seed(),\n", " cost_growth=Uncertain(lambda rng: float(rng.triangular(0.9, 1.0, 1.6))), # of development, for cost risk\n", + " decorrelation_time=Fixed(DECORRELATION_TIME), # of the field, which scenarios may change (see below)\n", + " epoch=Fixed(START), # the start of the analysis, which may be drawn for each replicate (see below)\n", " constraints=[lambda d: count_satellites(d.layout) - MAX_SATELLITES],\n", ")\n", "designs = space.enumerate()\n", @@ -130,11 +131,11 @@ "source": [ "## Define the Study\n", "\n", - "A `Study` builds each design into its satellites (`build`, with `build_constellation`, which builds the satellites of either layout with a payload: here, an imager, but also entries of the instrument catalog) and evaluates them (`evaluate`) in each replicate. The evaluation collects the observations of the replicate's points by each satellite, from a `SatelliteCache`: designs share many satellites (the same orbit and imager, if not the same name), whose observations are computed once. The cache is kept on disk, where the parallel worker processes of the study (`n_jobs=-1`, one per processor) share it, and where it persists between sessions. Its namespace identifies the analysis: the points, the start, and the duration.\n", + "An `ObservationStudy` evaluates each design in each replicate: it builds the design's satellites (`build`, with `build_constellation`, which builds the satellites of either layout with a payload: here, an imager, but also entries of the instrument catalog), collects their observations of the replicate's targets (`Observations`), and computes the metrics of the observations (`sample`). The targets are the points of a randomly oriented lattice, generated in each replicate from its seed (`Targets`, from the design's uncertain `points_seed`). The observations of each satellite are cached on disk: designs share many satellites (the same orbit and imager, if not the same name), whose observations are computed once, by the parallel worker processes of the study (`n_jobs=-1`, one per processor), and kept between sessions. A `ResultStore` keeps the records of the evaluations in a file, so that running the notebook again (or resuming it after an interruption) takes them from the file rather than evaluating them again. Both are keyed by the definition of the study (its fingerprint), which describes the points by the recipe that generates them and the code of TAT-C that the study uses: a changed study evaluates its designs again, and says why. The kinds of studies below share the file, each in its own namespace.\n", "\n", - "The evaluation computes both objectives: the share of points with at least four samples, and the share whose sampling error (`tatc.analysis.estimate_sampling_error`, for an exponential correlation in time with a decorrelation time of 3 hours) is at most half the field's standard deviation. A `ResultStore` keeps the records of the evaluations in a file, so that running the notebook again (or resuming it after an interruption) takes them from the file rather than evaluating them again.\n", + "The metrics are the two objectives: the share of points with at least four samples a day, and the share whose sampling error (`tatc.analysis.estimate_sampling_error`, for an exponential correlation in time with a decorrelation time of 3 hours) is at most half the field's standard deviation. The study also records the numbers of satellites and of orbit planes (of the design's `layout`), and plans the deployment of each design and estimates its life-cycle cost (`MissionPlan`, of a `DeploymentSchedule` and a `CostModel`, used below).\n", "\n", - "`make_study` makes studies of other durations and numbers of replicates, of the phases of deployment, and with failures, as for screening, deployment, and robustness (below). Each evaluation also plans the deployment of the design (`DeploymentSchedule`) and estimates its life-cycle cost (`CostModel`, both used below), and reports the cost of its computation (`satellite_days`, the satellites times the days analyzed), which measures the computation independently of the cache." + "`make_study` makes studies of other durations and numbers of replicates, of the phases of deployment, and with failures, as for screening, deployment, and robustness (below)." ] }, { @@ -143,37 +144,32 @@ "id": "a7b6c9d8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T18:29:32.015114Z", - "iopub.status.busy": "2026-11-11T18:29:32.014747Z", - "iopub.status.idle": "2026-11-11T18:29:32.027309Z", - "shell.execute_reply": "2026-11-11T18:29:32.026505Z" + "iopub.execute_input": "2026-11-11T23:50:30.987111Z", + "iopub.status.busy": "2026-11-11T23:50:30.987111Z", + "iopub.status.idle": "2026-11-11T23:50:31.003116Z", + "shell.execute_reply": "2026-11-11T23:50:31.003116Z" } }, "outputs": [], "source": [ - "from tatc.analysis import collect_observations, estimate_sampling_error\n", + "from functools import partial\n", + "\n", + "from tatc.analysis import estimate_sampling_error\n", "from tatc.generation import generate_points_rotated_lattice\n", "from tatc.schemas import Instrument\n", "from tatc.tradespace import (\n", " CostModel,\n", " DeploymentSchedule,\n", " LaunchCost,\n", + " MissionPlan,\n", + " ObservationStudy,\n", + " Observations,\n", " OperationsCost,\n", - " PhaseCache,\n", " Requirement,\n", - " RestorationPolicy,\n", " ResultStore,\n", - " SatelliteCache,\n", " SatelliteCost,\n", - " Study,\n", + " Targets,\n", " build_constellation,\n", - " configure,\n", - " count_planes,\n", - " evaluate_missions,\n", - " evaluate_phases,\n", - " expected_missions,\n", - " summarize_missions,\n", - " summarize_phases,\n", ")\n", "\n", "# the deployment of each design: 3 years of development, a production line of 4 satellites a year, launches of up to 3\n", @@ -191,103 +187,64 @@ " discount_rate=0.03,\n", ")\n", "\n", + "# the deployment and cost of each design: satellites of the kind of its field of regard, with its growth of\n", + "# development costs\n", + "PLAN = MissionPlan(SCHEDULE, COST_MODEL, kind=\"field_of_regard\", growth={\"development\": \"cost_growth\"})\n", + "# the points of each replicate: a randomly oriented lattice, generated from the replicate's seed\n", + "TARGETS = Targets(generate_points_rotated_lattice, N_POINTS, seed=\"points_seed\")\n", "CACHE_DIRECTORY = Path(tempfile.gettempdir()) / \"tatc-search-trade-space\"\n", - "caches = {}\n", "\n", "\n", - "def get_cache(seed, duration):\n", - " \"\"\"A cache of the observations by each satellite of the points of a seed over a duration.\"\"\"\n", - " if (seed, duration) not in caches:\n", - " points = generate_points_rotated_lattice(N_POINTS, seed=seed)\n", - " caches[seed, duration] = SatelliteCache(\n", - " lambda satellite: collect_observations(points, satellite, START, START + duration),\n", - " directory=CACHE_DIRECTORY,\n", - " namespace=f\"{N_POINTS} lattice points, seed {seed}, start {START.isoformat()}, duration {duration}\",\n", - " )\n", - " return caches[seed, duration]\n", + "def sample(observations, design, duration=DURATION):\n", + " \"\"\"The shares (%) of points sampled sufficiently and accurately by observations over a duration from the design's\n", + " epoch (of the field of the design's decorrelation time).\"\"\"\n", + " if len(observations) == 0: # no satellites\n", + " return {\"sufficient\": 0.0, \"accurate\": 0.0}\n", + " samples = observations.groupby(\"target_hash\").size()\n", + " error = estimate_sampling_error(observations, design.epoch, design.epoch + duration, design.decorrelation_time)\n", + " threshold = SAMPLES_PER_DAY * duration / timedelta(days=1)\n", + " return {\n", + " \"sufficient\": 100 * (samples >= threshold).sum() / N_POINTS,\n", + " \"accurate\": 100 * (error.relative_error <= MAX_RELATIVE_ERROR).sum() / N_POINTS,\n", + " }\n", + "\n", + "\n", + "def build(d):\n", + " \"\"\"The satellites of a design: an imager of its field of regard in each orbit of its layout.\"\"\"\n", + " imager = Instrument(name=\"imager\", field_of_regard=d.field_of_regard)\n", + " return build_constellation(d.layout, imager, epoch=START, altitude=d.altitude)\n", "\n", "\n", "def make_study(\n", " duration=DURATION,\n", " replicates=N_REPLICATES,\n", " failures=None,\n", - " policy=None,\n", - " spares=0,\n", - " histories=1,\n", " phased=False,\n", " design_space=None,\n", + " scenarios=None,\n", + " plan=PLAN,\n", + " label=None,\n", "):\n", " \"\"\"A study of the shares (%) of points sampled sufficiently and accurately over a duration by the satellites of\n", - " each design, and (if phased) their means over the phases of the mission as the satellites are deployed and the\n", - " time until half of the points are sampled sufficiently, or (with failures) their means over the phases of\n", - " histories of the mission in which satellites fail and are restored (by a policy, or the policy of each design of\n", - " a design space with one), and their worst 10% of the histories, and the cost at 70% confidence (with the exact expectation over the\n", - " failures of the means of a policy that does not restore satellites).\"\"\"\n", - " threshold = SAMPLES_PER_DAY * duration / timedelta(days=1)\n", - "\n", - " def sample(observations):\n", - " \"\"\"The shares (%) of points sampled sufficiently and accurately by observations.\"\"\"\n", - " if len(observations) == 0: # no satellites\n", - " return {\"sufficient\": 0.0, \"accurate\": 0.0}\n", - " samples = observations.groupby(\"target_hash\").size()\n", - " error = estimate_sampling_error(observations, START, START + duration, DECORRELATION_TIME)\n", - " return {\n", - " \"sufficient\": 100 * (samples >= threshold).sum() / N_POINTS,\n", - " \"accurate\": 100 * (error.relative_error <= MAX_RELATIVE_ERROR).sum() / N_POINTS,\n", - " }\n", - "\n", - " # the shares of the sets of satellites that operate in phases, shared by the histories, policies, and designs of a\n", - " # replicate (in a worker's chunk of evaluations)\n", - " phase_cache = PhaseCache(sample)\n", - "\n", - " def build(d):\n", - " imager = Instrument(name=\"imager\", field_of_regard=d.field_of_regard)\n", - " return d, build_constellation(d.layout, imager, epoch=START, altitude=d.altitude)\n", - "\n", - " def evaluate(built):\n", - " d, members = built\n", - " # the policy of the design (see policy_space), or the study's\n", - " decided = d.values.get(\"policy\")\n", - " restoration = policy if decided is None else configure(policy or RestorationPolicy(), decided)\n", - " orbit_spares = spares if decided is None else decided.orbit_spares\n", - " deployment = SCHEDULE.plan(d.layout, kind=d.field_of_regard, spares=orbit_spares)\n", - " growth = {\"development\": d.cost_growth}\n", - " record = {\n", - " \"satellites\": len(members),\n", - " \"planes\": count_planes(d.layout),\n", - " **COST_MODEL.estimate(deployment, growth).metrics(),\n", - " }\n", - " cache = get_cache(d.points_seed, duration)\n", - " record.update(sample(cache(members)), satellite_days=len(members) * duration / timedelta(days=1))\n", - " if failures:\n", - " # histories of the mission in the replicate, with failures drawn from its seed, on its points\n", - " missions = evaluate_missions(\n", - " deployment.simulate_many(failures, restoration, d.failure_seed, histories, sampling=\"stratified\"),\n", - " members,\n", - " cache(members),\n", - " phase_cache,\n", - " context=(d.points_seed, duration),\n", - " cost_model=COST_MODEL,\n", - " growth=growth,\n", - " )\n", - " record.update(summarize_missions(missions, quantiles={\"accurate mean\": 0.1, \"cost\": 0.7}))\n", - " if restoration is not None and not restoration.restore:\n", - " # without restoration, the satellites fail independently: the exact expectation of the means\n", - " exact = expected_missions(\n", - " deployment, failures, members, cache(members), phase_cache, context=(d.points_seed, duration)\n", - " )\n", - " record.update({key: exact[key] for key in (\"sufficient mean\", \"accurate mean\", \"availability\")})\n", - " elif phased:\n", - " capability = evaluate_phases(deployment.phases(members), cache(members), sample)\n", - " record.update(summarize_phases(capability, requirements=[Requirement(\"sufficient\", \">=\", 50)]))\n", - " return record\n", - "\n", - " store = ResultStore(\n", - " CACHE_DIRECTORY / \"results.sqlite\",\n", - " namespace=f\"{N_POINTS} lattice points, start {START.isoformat()}, duration {duration}, \"\n", - " + f\"accuracy {MAX_RELATIVE_ERROR} at {DECORRELATION_TIME}\",\n", + " each design (of the design space, or another), and of its cost (by the mission plan), and (if phased) their means\n", + " over the phases of the mission as the satellites are deployed and the time until half of the points are sampled\n", + " sufficiently, or (with failures) their summaries over histories of the mission in which satellites fail (see\n", + " Failures), in scenarios, if any. Studies of other design spaces or plans are stored apart, by a label.\"\"\"\n", + " kind = (\"failures\" if failures else \"phases\" if phased else \"observations\") + (f\" {label}\" if label else \"\")\n", + " return ObservationStudy(\n", + " design_space or space,\n", + " build,\n", + " Observations(TARGETS, \"epoch\", duration, directory=CACHE_DIRECTORY),\n", + " partial(sample, duration=duration),\n", + " layout=\"layout\",\n", + " plan=plan,\n", + " failures=failures,\n", + " phases=[Requirement(\"sufficient\", \">=\", 50)] if phased else None,\n", + " replicates=replicates,\n", + " scenarios=scenarios,\n", + " n_jobs=-1,\n", + " store=ResultStore(CACHE_DIRECTORY / \"results.sqlite\", namespace=f\"{kind} over {duration}\"),\n", " )\n", - " return Study(design_space or space, build, evaluate, replicates=replicates, n_jobs=-1, store=store)\n", "\n", "\n", "OBJECTIVES = {\"satellites\": \"min\", \"planes\": \"min\", \"sufficient\": \"max\"}\n", @@ -310,10 +267,10 @@ "id": "c9d8e1f0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T18:29:32.029044Z", - "iopub.status.busy": "2026-11-11T18:29:32.028785Z", - "iopub.status.idle": "2026-11-11T18:30:12.233126Z", - "shell.execute_reply": "2026-11-11T18:30:12.232400Z" + "iopub.execute_input": "2026-11-11T23:50:31.003116Z", + "iopub.status.busy": "2026-11-11T23:50:31.003116Z", + "iopub.status.idle": "2026-11-11T23:52:17.656647Z", + "shell.execute_reply": "2026-11-11T23:52:17.656647Z" } }, "outputs": [ @@ -481,16 +438,16 @@ "id": "d0e9f2a1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T18:30:12.234938Z", - "iopub.status.busy": "2026-11-11T18:30:12.234678Z", - "iopub.status.idle": "2026-11-11T18:30:12.444235Z", - "shell.execute_reply": "2026-11-11T18:30:12.443408Z" + "iopub.execute_input": "2026-11-11T23:52:17.658653Z", + "iopub.status.busy": "2026-11-11T23:52:17.658653Z", + "iopub.status.idle": "2026-11-11T23:52:17.892528Z", + "shell.execute_reply": "2026-11-11T23:52:17.892528Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "

" ] @@ -500,44 +457,33 @@ } ], "source": [ - "fig, ax = plt.subplots(figsize=(9, 4.5))\n", - "PLANE_COLORS = {1: BLUE, 2: ORANGE, 3: AQUA, 4: YELLOW}\n", - "jitter = np.random.default_rng(0).uniform(-0.18, 0.18, len(summary))\n", - "for planes, color in PLANE_COLORS.items():\n", - " selected = summary.planes == planes\n", - " ax.scatter(\n", - " summary.satellites[selected] + jitter[selected],\n", - " summary.sufficient[selected],\n", - " s=14,\n", - " color=color,\n", - " alpha=0.55,\n", - " lw=0,\n", - " label=f\"{planes} plane{'s' if planes > 1 else ''}\",\n", - " )\n", - "# the efficient designs, ringed and labeled\n", - "ax.scatter(front.satellites, front.sufficient, s=70, facecolor=\"none\", edgecolor=INK, lw=1.5, label=\"Pareto-efficient\")\n", - "for _, row in front.iterrows():\n", - " ax.annotate(\n", - " f\"{row.satellites:.0f} sat., {row.planes:.0f} pl.\",\n", - " (row.satellites, row.sufficient),\n", - " xytext=(8, -3),\n", - " textcoords=\"offset points\",\n", - " fontsize=8,\n", - " color=INK,\n", - " )\n", + "from tatc.tradespace import plot_designs\n", + "\n", + "\n", + "def planes_name(planes):\n", + " \"\"\"The name of a number of planes.\"\"\"\n", + " return f\"{planes:.0f} plane{'s' if planes > 1 else ''}\"\n", + "\n", + "\n", + "ax = plot_designs(\n", + " summary,\n", + " \"satellites\",\n", + " \"sufficient\",\n", + " by=\"planes\",\n", + " front=\"pareto\",\n", + " labels=lambda row: f\"{row.satellites:.0f} sat., {row.planes:.0f} pl.\",\n", + " names=planes_name,\n", + " jitter=0.18, # satellites, for legibility\n", + " legend=\"upper left\",\n", + ")\n", "ax.set(\n", " xlabel=\"Satellites\",\n", " ylabel=\"Points sufficiently sampled (%)\",\n", " xticks=range(1, MAX_SATELLITES + 1),\n", " ylim=(0, 105),\n", ")\n", - "ax.grid(axis=\"y\", color=\"#e6e6e3\", lw=0.8)\n", - "ax.set_axisbelow(True)\n", - "for side in (\"top\", \"right\"):\n", - " ax.spines[side].set_visible(False)\n", - "ax.legend(loc=\"upper left\", fontsize=8, frameon=False, markerscale=1.6)\n", "ax.set_title(\"Every design: mean over 5 replicates (satellites jittered for legibility)\", fontsize=10)\n", - "fig.tight_layout()\n", + "ax.figure.tight_layout()\n", "plt.show()" ] }, @@ -565,10 +511,10 @@ "id": "a2b3c4d5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T18:30:12.446118Z", - "iopub.status.busy": "2026-11-11T18:30:12.445846Z", - "iopub.status.idle": "2026-11-11T18:30:12.516654Z", - "shell.execute_reply": "2026-11-11T18:30:12.515674Z" + "iopub.execute_input": "2026-11-11T23:52:17.892528Z", + "iopub.status.busy": "2026-11-11T23:52:17.892528Z", + "iopub.status.idle": "2026-11-11T23:52:18.066661Z", + "shell.execute_reply": "2026-11-11T23:52:18.065907Z" } }, "outputs": [ @@ -776,16 +722,16 @@ "id": "b3c4d5e6", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T18:30:12.518605Z", - "iopub.status.busy": "2026-11-11T18:30:12.518320Z", - "iopub.status.idle": "2026-11-11T18:30:12.765306Z", - "shell.execute_reply": "2026-11-11T18:30:12.764493Z" + "iopub.execute_input": "2026-11-11T23:52:18.069173Z", + "iopub.status.busy": "2026-11-11T23:52:18.069173Z", + "iopub.status.idle": "2026-11-11T23:52:18.255867Z", + "shell.execute_reply": "2026-11-11T23:52:18.255867Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -795,21 +741,15 @@ } ], "source": [ + "from tatc.tradespace import style_axes\n", + "from tatc.tradespace.plotting import GRAY\n", + "\n", "fig, ax = plt.subplots(figsize=(6.5, 5))\n", - "for planes, color in PLANE_COLORS.items():\n", - " selected = accuracy.planes == planes\n", - " ax.scatter(\n", - " accuracy.sufficient[selected], accuracy.accurate[selected], s=14, color=color, alpha=0.6, lw=0,\n", - " label=f\"{planes} plane{'s' if planes > 1 else ''}\",\n", - " )\n", + "plot_designs(accuracy, \"sufficient\", \"accurate\", by=\"planes\", names=planes_name, legend=\"upper left\", ax=ax)\n", "ax.plot([0, 100], [0, 100], color=GRAY, lw=1, ls=\"--\")\n", "ax.annotate(\"equal shares\", (80, 80), xytext=(6, -10), textcoords=\"offset points\", fontsize=8, color=GRAY)\n", "ax.set(xlabel=\"Points sufficiently sampled (%)\", ylabel=\"Points accurately sampled (%)\", xlim=(0, 102), ylim=(0, 102))\n", - "ax.grid(color=\"#e6e6e3\", lw=0.8)\n", - "ax.set_axisbelow(True)\n", - "for side in (\"top\", \"right\"):\n", - " ax.spines[side].set_visible(False)\n", - "ax.legend(loc=\"upper left\", fontsize=8, frameon=False, markerscale=1.6)\n", + "style_axes(ax, grid=\"both\")\n", "ax.set_title(\"Sampling counts and sampling errors of every design\", fontsize=10)\n", "fig.tight_layout()\n", "plt.show()" @@ -829,10 +769,10 @@ "id": "d5e6f7a8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T18:30:12.767151Z", - "iopub.status.busy": "2026-11-11T18:30:12.766884Z", - "iopub.status.idle": "2026-11-11T18:30:12.930298Z", - "shell.execute_reply": "2026-11-11T18:30:12.929620Z" + "iopub.execute_input": "2026-11-11T23:52:18.255867Z", + "iopub.status.busy": "2026-11-11T23:52:18.255867Z", + "iopub.status.idle": "2026-11-11T23:52:18.556287Z", + "shell.execute_reply": "2026-11-11T23:52:18.556287Z" } }, "outputs": [ @@ -933,12 +873,12 @@ "first = four[four.planes == 1].iloc[0]\n", "second = four.sort_values(\"accurate\", ascending=False).iloc[0]\n", "by_key = {d.key: d for d in designs}\n", + "study = make_study()\n", "rows = []\n", "for row in (first, second):\n", - " d = by_key[row.design].realize(0)\n", - " _, members = make_study().build(d)\n", - " observations = get_cache(d.points_seed, DURATION)(members)\n", - " points = generate_points_rotated_lattice(N_POINTS, seed=d.points_seed)\n", + " # the observations of the design's first replicate, and its points\n", + " observations = study.observations_of(by_key[row.design])\n", + " points = study.targets_of(by_key[row.design])\n", " revisits = compute_revisit_statistics(observations, START, START + DURATION, targets=points)\n", " local = compute_local_time_coverage(observations, targets=points)\n", " observed = revisits[revisits.samples > 0]\n", @@ -979,10 +919,10 @@ "id": "a8b9c0d1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T18:30:12.932076Z", - "iopub.status.busy": "2026-11-11T18:30:12.931821Z", - "iopub.status.idle": "2026-11-11T18:30:12.960626Z", - "shell.execute_reply": "2026-11-11T18:30:12.959820Z" + "iopub.execute_input": "2026-11-11T23:52:18.556287Z", + "iopub.status.busy": "2026-11-11T23:52:18.556287Z", + "iopub.status.idle": "2026-11-11T23:52:18.588823Z", + "shell.execute_reply": "2026-11-11T23:52:18.588160Z" } }, "outputs": [ @@ -1092,7 +1032,7 @@ "source": [ "from tatc.tradespace import sensitivity\n", "\n", - "frame = accuracy.join(values.drop(columns=[\"satellites\", \"planes\", \"satellite_days\"]), on=\"design\")\n", + "frame = accuracy.join(values.drop(columns=[\"satellites\", \"planes\"]), on=\"design\")\n", "variables = [\n", " \"altitude\",\n", " \"field_of_regard\",\n", @@ -1130,10 +1070,10 @@ "id": "a3b2c5d4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T18:30:12.962412Z", - "iopub.status.busy": "2026-11-11T18:30:12.962163Z", - "iopub.status.idle": "2026-11-11T18:30:14.503562Z", - "shell.execute_reply": "2026-11-11T18:30:14.502799Z" + "iopub.execute_input": "2026-11-11T23:52:18.588823Z", + "iopub.status.busy": "2026-11-11T23:52:18.588823Z", + "iopub.status.idle": "2026-11-11T23:52:20.032880Z", + "shell.execute_reply": "2026-11-11T23:52:20.032880Z" } }, "outputs": [ @@ -1373,7 +1313,7 @@ "\n", "Five replicates settle the efficiency of most designs, but not of all. More replicates of every design would settle them, at the cost of evaluating every design again for each. `refine` instead adds replicates only to the designs whose efficiency is uncertain (efficient in more than 5% and fewer than 95% of the resamples), five at a time, and estimates their probabilities again, until none is uncertain (or a design has 40 replicates). The added replicates are the next ones after each design's own, which keeps common random numbers between the designs refined together.\n", "\n", - "Some designs differ by less than any number of replicates could separate, such as those that sample nearly every point: a difference of a tenth of a percentage point does not matter to the trade. A tolerance of 1 percentage point of the share treats designs within it of the front as efficient (see `pareto_front`), so that refinement does not spend replicates on differences that do not matter." + "Some designs differ by less than any number of replicates could separate, such as those that sample nearly every point: a difference of a tenth of a percentage point does not matter to the trade. A tolerance of 1 percentage point of the share, part of the criteria by which designs are judged (`Criteria`), treats designs within it of the front as efficient (see `pareto_front`), so that refinement does not spend replicates on differences that do not matter. A design about one tolerance below the front stays uncertain instead: more replicates settle which side of the tolerance it falls on only slowly, though it does not matter. `refine` stops refining such a design once the standard error of its share is less than half the tolerance (`precision`): it is then `indifferent`. A `budget` would limit the evaluations, refining the least settled designs first." ] }, { @@ -1382,10 +1322,10 @@ "id": "b5d3f7a9", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T18:30:14.505542Z", - "iopub.status.busy": "2026-11-11T18:30:14.505342Z", - "iopub.status.idle": "2026-11-11T18:30:49.909930Z", - "shell.execute_reply": "2026-11-11T18:30:49.909243Z" + "iopub.execute_input": "2026-11-11T23:52:20.034888Z", + "iopub.status.busy": "2026-11-11T23:52:20.034888Z", + "iopub.status.idle": "2026-11-11T23:52:49.196732Z", + "shell.execute_reply": "2026-11-11T23:52:49.196732Z" } }, "outputs": [ @@ -1393,7 +1333,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "555 evaluations added, 1.4% of those of 40 replicates of every design\n" + "215 evaluations added, 0.6% of those of 40 replicates of every design\n" ] }, { @@ -1419,6 +1359,7 @@ " \n", " round\n", " uncertain\n", + " indifferent\n", " refined\n", " evaluations\n", " \n", @@ -1428,88 +1369,80 @@ " 0\n", " 0\n", " 31\n", - " 31\n", - " 155\n", + " 2\n", + " 29\n", + " 145\n", " \n", " \n", " 1\n", " 1\n", " 16\n", - " 16\n", - " 80\n", + " 11\n", + " 5\n", + " 25\n", " \n", " \n", " 2\n", " 2\n", - " 13\n", - " 13\n", - " 65\n", + " 14\n", + " 11\n", + " 3\n", + " 15\n", " \n", " \n", " 3\n", " 3\n", + " 14\n", " 12\n", - " 12\n", - " 60\n", + " 2\n", + " 10\n", " \n", " \n", " 4\n", " 4\n", - " 9\n", - " 9\n", - " 45\n", + " 14\n", + " 13\n", + " 1\n", + " 5\n", " \n", " \n", " 5\n", " 5\n", - " 11\n", - " 11\n", - " 55\n", + " 14\n", + " 13\n", + " 1\n", + " 5\n", " \n", " \n", " 6\n", " 6\n", - " 11\n", - " 11\n", - " 55\n", - " \n", - " \n", - " 7\n", - " 7\n", - " 12\n", - " 5\n", - " 25\n", - " \n", - " \n", - " 8\n", - " 8\n", + " 14\n", " 12\n", " 2\n", " 10\n", " \n", " \n", - " 9\n", - " 9\n", + " 7\n", + " 7\n", + " 13\n", " 12\n", - " 1\n", - " 5\n", + " 0\n", + " 0\n", " \n", " \n", "\n", "" ], "text/plain": [ - " round uncertain refined evaluations\n", - "0 0 31 31 155\n", - "1 1 16 16 80\n", - "2 2 13 13 65\n", - "3 3 12 12 60\n", - "4 4 9 9 45\n", - "5 5 11 11 55\n", - "6 6 11 11 55\n", - "7 7 12 5 25\n", - "8 8 12 2 10\n", - "9 9 12 1 5" + " round uncertain indifferent refined evaluations\n", + "0 0 31 2 29 145\n", + "1 1 16 11 5 25\n", + "2 2 14 11 3 15\n", + "3 3 14 12 2 10\n", + "4 4 14 13 1 5\n", + "5 5 14 13 1 5\n", + "6 6 14 12 2 10\n", + "7 7 13 12 0 0" ] }, "execution_count": 11, @@ -1518,11 +1451,12 @@ } ], "source": [ - "from tatc.tradespace import refine\n", + "from tatc.tradespace import Criteria, refine\n", "\n", "TOLERANCE = {\"sufficient\": 1.0} # percentage points of the share that do not matter\n", + "CRITERIA = Criteria(OBJECTIVES, tolerance=TOLERANCE)\n", "refinement = refine(\n", - " make_study(), designs, results, OBJECTIVES, step=5, max_replicates=40, n_resamples=1000, tolerance=TOLERANCE\n", + " make_study(), designs, results, CRITERIA, step=5, max_replicates=40, precision=0.5, n_resamples=1000\n", ")\n", "added = len(refinement.results) - len(results)\n", "print(f\"{added} evaluations added, {added / (len(designs) * 35):.1%} of those of 40 replicates of every design\")\n", @@ -1535,10 +1469,10 @@ "id": "c6e4a8b0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T18:30:49.911695Z", - "iopub.status.busy": "2026-11-11T18:30:49.911513Z", - "iopub.status.idle": "2026-11-11T18:30:49.972883Z", - "shell.execute_reply": "2026-11-11T18:30:49.972203Z" + "iopub.execute_input": "2026-11-11T23:52:49.196732Z", + "iopub.status.busy": "2026-11-11T23:52:49.196732Z", + "iopub.status.idle": "2026-11-11T23:52:49.261059Z", + "shell.execute_reply": "2026-11-11T23:52:49.260196Z" } }, "outputs": [ @@ -1570,88 +1504,130 @@ " replicates\n", " pareto\n", " pareto_probability\n", + " indifferent\n", " \n", " \n", " \n", " \n", + " 500\n", + " 600 km, 60 deg FOR, SSO: 1 at 09:00\n", + " 1.0\n", + " 1.0\n", + " 1.80\n", + " 10\n", + " False\n", + " 0.12\n", + " True\n", + " \n", + " \n", + " 230\n", + " 500 km, 60 deg FOR, SSO: 1 at 15:00\n", + " 1.0\n", + " 1.0\n", + " 1.90\n", + " 10\n", + " False\n", + " 0.14\n", + " True\n", + " \n", + " \n", " 498\n", " 600 km, 60 deg FOR, SSO: 1 at 06:00\n", " 1.0\n", " 1.0\n", - " 1.92\n", - " 40\n", + " 1.90\n", + " 10\n", " False\n", - " 0.14\n", + " 0.19\n", + " True\n", " \n", " \n", - " 743\n", - " 700 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac...\n", + " 504\n", + " 600 km, 60 deg FOR, SSO: 1 at 15:00\n", " 1.0\n", " 1.0\n", - " 1.92\n", - " 40\n", + " 2.10\n", + " 10\n", " False\n", - " 0.15\n", + " 0.18\n", + " True\n", " \n", " \n", " 502\n", " 600 km, 60 deg FOR, SSO: 1 at 12:00\n", " 1.0\n", " 1.0\n", - " 2.00\n", - " 40\n", - " False\n", - " 0.20\n", + " 2.20\n", + " 10\n", + " True\n", + " 0.40\n", + " True\n", " \n", " \n", - " 780\n", - " 700 km, 60 deg FOR, SSO: 1 at 18:00\n", + " 506\n", + " 600 km, 60 deg FOR, SSO: 1 at 18:00\n", " 1.0\n", " 1.0\n", - " 2.45\n", - " 40\n", + " 2.20\n", + " 10\n", + " True\n", + " 0.32\n", + " True\n", + " \n", + " \n", + " 1017\n", + " 800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac...\n", + " 1.0\n", + " 1.0\n", + " 2.40\n", + " 10\n", + " True\n", + " 0.57\n", " True\n", - " 0.62\n", " \n", " \n", " 774\n", " 700 km, 60 deg FOR, SSO: 1 at 09:00\n", " 1.0\n", " 1.0\n", - " 2.52\n", - " 40\n", + " 2.50\n", + " 10\n", + " True\n", + " 0.76\n", " True\n", - " 0.70\n", " \n", " \n", - " 778\n", - " 700 km, 60 deg FOR, SSO: 1 at 15:00\n", + " 780\n", + " 700 km, 60 deg FOR, SSO: 1 at 18:00\n", " 1.0\n", " 1.0\n", - " 2.62\n", - " 40\n", + " 2.50\n", + " 10\n", + " True\n", + " 0.79\n", " True\n", - " 0.78\n", " \n", " \n", - " 776\n", - " 700 km, 60 deg FOR, SSO: 1 at 12:00\n", + " 778\n", + " 700 km, 60 deg FOR, SSO: 1 at 15:00\n", " 1.0\n", " 1.0\n", - " 2.70\n", - " 40\n", + " 2.53\n", + " 15\n", + " True\n", + " 0.70\n", " True\n", - " 0.83\n", " \n", " \n", - " 1017\n", - " 800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac...\n", + " 776\n", + " 700 km, 60 deg FOR, SSO: 1 at 12:00\n", " 1.0\n", " 1.0\n", - " 2.75\n", - " 40\n", + " 2.80\n", + " 10\n", " True\n", - " 0.80\n", + " 0.95\n", + " False\n", " \n", " \n", " 772\n", @@ -1662,6 +1638,7 @@ " 10\n", " True\n", " 0.98\n", + " False\n", " \n", " \n", " 1052\n", @@ -1672,6 +1649,7 @@ " 10\n", " True\n", " 0.98\n", + " False\n", " \n", " \n", " 1046\n", @@ -1681,7 +1659,8 @@ " 3.10\n", " 10\n", " True\n", - " 0.99\n", + " 0.98\n", + " False\n", " \n", " \n", " 1054\n", @@ -1691,7 +1670,8 @@ " 3.10\n", " 10\n", " True\n", - " 0.98\n", + " 0.99\n", + " False\n", " \n", " \n", " 1048\n", @@ -1702,6 +1682,7 @@ " 10\n", " True\n", " 0.99\n", + " False\n", " \n", " \n", " 1050\n", @@ -1712,6 +1693,7 @@ " 10\n", " True\n", " 0.99\n", + " False\n", " \n", " \n", " 960\n", @@ -1722,6 +1704,7 @@ " 5\n", " True\n", " 1.00\n", + " False\n", " \n", " \n", " 963\n", @@ -1732,6 +1715,7 @@ " 5\n", " True\n", " 1.00\n", + " False\n", " \n", " \n", " 961\n", @@ -1742,16 +1726,7 @@ " 5\n", " True\n", " 1.00\n", - " \n", - " \n", - " 1001\n", - " 800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac...\n", - " 3.0\n", - " 3.0\n", - " 36.10\n", - " 30\n", " False\n", - " 0.12\n", " \n", " \n", " 972\n", @@ -1760,18 +1735,20 @@ " 3.0\n", " 37.02\n", " 40\n", - " True\n", - " 0.35\n", + " False\n", + " 0.19\n", + " False\n", " \n", " \n", " 971\n", " 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...\n", " 3.0\n", " 3.0\n", - " 37.83\n", - " 40\n", + " 38.48\n", + " 25\n", + " True\n", + " 0.89\n", " True\n", - " 0.73\n", " \n", " \n", " 962\n", @@ -1782,6 +1759,7 @@ " 5\n", " True\n", " 1.00\n", + " False\n", " \n", " \n", " 965\n", @@ -1791,7 +1769,8 @@ " 69.60\n", " 5\n", " True\n", - " 0.97\n", + " 0.96\n", + " False\n", " \n", " \n", " 1026\n", @@ -1802,6 +1781,7 @@ " 5\n", " True\n", " 1.00\n", + " False\n", " \n", " \n", " 1025\n", @@ -1812,6 +1792,7 @@ " 5\n", " True\n", " 1.00\n", + " False\n", " \n", " \n", " 479\n", @@ -1822,6 +1803,7 @@ " 5\n", " True\n", " 0.97\n", + " False\n", " \n", " \n", " 480\n", @@ -1832,6 +1814,7 @@ " 5\n", " True\n", " 0.97\n", + " False\n", " \n", " \n", " 753\n", @@ -1842,6 +1825,7 @@ " 5\n", " True\n", " 1.00\n", + " False\n", " \n", " \n", " 754\n", @@ -1852,6 +1836,7 @@ " 5\n", " True\n", " 1.00\n", + " False\n", " \n", " \n", " 1027\n", @@ -1862,6 +1847,7 @@ " 5\n", " True\n", " 1.00\n", + " False\n", " \n", " \n", " 1028\n", @@ -1872,6 +1858,7 @@ " 5\n", " True\n", " 1.00\n", + " False\n", " \n", " \n", " 768\n", @@ -1882,6 +1869,7 @@ " 5\n", " True\n", " 1.00\n", + " False\n", " \n", " \n", " 769\n", @@ -1892,6 +1880,7 @@ " 5\n", " True\n", " 1.00\n", + " False\n", " \n", " \n", " 770\n", @@ -1902,6 +1891,7 @@ " 5\n", " True\n", " 1.00\n", + " False\n", " \n", " \n", " 1043\n", @@ -1912,6 +1902,7 @@ " 5\n", " True\n", " 1.00\n", + " False\n", " \n", " \n", " 1044\n", @@ -1922,6 +1913,7 @@ " 5\n", " True\n", " 1.00\n", + " False\n", " \n", " \n", " 1045\n", @@ -1932,26 +1924,29 @@ " 5\n", " True\n", " 1.00\n", + " False\n", " \n", " \n", " 761\n", " 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " 9.0\n", " 3.0\n", - " 97.53\n", - " 15\n", + " 96.80\n", + " 5\n", + " False\n", + " 0.39\n", " True\n", - " 0.99\n", " \n", " \n", " 487\n", " 600 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " 9.0\n", " 3.0\n", - " 97.60\n", - " 10\n", + " 97.40\n", + " 5\n", " True\n", - " 1.00\n", + " 0.97\n", + " False\n", " \n", " \n", " 762\n", @@ -1962,6 +1957,7 @@ " 5\n", " True\n", " 1.00\n", + " False\n", " \n", " \n", " 763\n", @@ -1972,6 +1968,7 @@ " 5\n", " True\n", " 1.00\n", + " False\n", " \n", " \n", " 1035\n", @@ -1982,6 +1979,7 @@ " 5\n", " True\n", " 1.00\n", + " False\n", " \n", " \n", " 1036\n", @@ -1992,6 +1990,7 @@ " 5\n", " True\n", " 1.00\n", + " False\n", " \n", " \n", " 1037\n", @@ -2002,6 +2001,7 @@ " 5\n", " True\n", " 1.00\n", + " False\n", " \n", " \n", "\n", @@ -2009,14 +2009,17 @@ ], "text/plain": [ " description satellites planes \\\n", + "500 600 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", + "230 500 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", "498 600 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", - "743 700 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac... 1.0 1.0 \n", + "504 600 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", "502 600 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", - "780 700 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", + "506 600 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", + "1017 800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac... 1.0 1.0 \n", "774 700 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", + "780 700 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", "778 700 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", "776 700 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", - "1017 800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac... 1.0 1.0 \n", "772 700 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", "1052 800 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", "1046 800 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", @@ -2026,7 +2029,6 @@ "960 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 1.0 \n", "963 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", "961 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 1.0 \n", - "1001 800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac... 3.0 3.0 \n", "972 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", "971 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", "962 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", @@ -2053,50 +2055,52 @@ "1036 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", "1037 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", "\n", - " sufficient replicates pareto pareto_probability \n", - "498 1.92 40 False 0.14 \n", - "743 1.92 40 False 0.15 \n", - "502 2.00 40 False 0.20 \n", - "780 2.45 40 True 0.62 \n", - "774 2.52 40 True 0.70 \n", - "778 2.62 40 True 0.78 \n", - "776 2.70 40 True 0.83 \n", - "1017 2.75 40 True 0.80 \n", - "772 2.90 10 True 0.98 \n", - "1052 2.90 10 True 0.98 \n", - "1046 3.10 10 True 0.99 \n", - "1054 3.10 10 True 0.98 \n", - "1048 3.20 10 True 0.99 \n", - "1050 3.20 10 True 0.99 \n", - "960 16.60 5 True 1.00 \n", - "963 30.20 5 True 1.00 \n", - "961 38.00 5 True 1.00 \n", - "1001 36.10 30 False 0.12 \n", - "972 37.02 40 True 0.35 \n", - "971 37.83 40 True 0.73 \n", - "962 68.20 5 True 1.00 \n", - "965 69.60 5 True 0.97 \n", - "1026 97.60 5 True 1.00 \n", - "1025 97.80 5 True 1.00 \n", - "479 97.40 5 True 0.97 \n", - "480 97.40 5 True 0.97 \n", - "753 97.60 5 True 1.00 \n", - "754 97.60 5 True 1.00 \n", - "1027 97.80 5 True 1.00 \n", - "1028 97.80 5 True 1.00 \n", - "768 97.60 5 True 1.00 \n", - "769 97.60 5 True 1.00 \n", - "770 97.60 5 True 1.00 \n", - "1043 97.80 5 True 1.00 \n", - "1044 97.80 5 True 1.00 \n", - "1045 97.80 5 True 1.00 \n", - "761 97.53 15 True 0.99 \n", - "487 97.60 10 True 1.00 \n", - "762 97.60 5 True 1.00 \n", - "763 97.60 5 True 1.00 \n", - "1035 97.80 5 True 1.00 \n", - "1036 97.80 5 True 1.00 \n", - "1037 97.80 5 True 1.00 " + " sufficient replicates pareto pareto_probability indifferent \n", + "500 1.80 10 False 0.12 True \n", + "230 1.90 10 False 0.14 True \n", + "498 1.90 10 False 0.19 True \n", + "504 2.10 10 False 0.18 True \n", + "502 2.20 10 True 0.40 True \n", + "506 2.20 10 True 0.32 True \n", + "1017 2.40 10 True 0.57 True \n", + "774 2.50 10 True 0.76 True \n", + "780 2.50 10 True 0.79 True \n", + "778 2.53 15 True 0.70 True \n", + "776 2.80 10 True 0.95 False \n", + "772 2.90 10 True 0.98 False \n", + "1052 2.90 10 True 0.98 False \n", + "1046 3.10 10 True 0.98 False \n", + "1054 3.10 10 True 0.99 False \n", + "1048 3.20 10 True 0.99 False \n", + "1050 3.20 10 True 0.99 False \n", + "960 16.60 5 True 1.00 False \n", + "963 30.20 5 True 1.00 False \n", + "961 38.00 5 True 1.00 False \n", + "972 37.02 40 False 0.19 False \n", + "971 38.48 25 True 0.89 True \n", + "962 68.20 5 True 1.00 False \n", + "965 69.60 5 True 0.96 False \n", + "1026 97.60 5 True 1.00 False \n", + "1025 97.80 5 True 1.00 False \n", + "479 97.40 5 True 0.97 False \n", + "480 97.40 5 True 0.97 False \n", + "753 97.60 5 True 1.00 False \n", + "754 97.60 5 True 1.00 False \n", + "1027 97.80 5 True 1.00 False \n", + "1028 97.80 5 True 1.00 False \n", + "768 97.60 5 True 1.00 False \n", + "769 97.60 5 True 1.00 False \n", + "770 97.60 5 True 1.00 False \n", + "1043 97.80 5 True 1.00 False \n", + "1044 97.80 5 True 1.00 False \n", + "1045 97.80 5 True 1.00 False \n", + "761 96.80 5 False 0.39 True \n", + "487 97.40 5 True 0.97 False \n", + "762 97.60 5 True 1.00 False \n", + "763 97.60 5 True 1.00 False \n", + "1035 97.80 5 True 1.00 False \n", + "1036 97.80 5 True 1.00 False \n", + "1037 97.80 5 True 1.00 False " ] }, "execution_count": 12, @@ -2108,7 +2112,7 @@ "refined = refinement.probability\n", "refined[\"description\"] = [describe(values.loc[key]) for key in refined.design]\n", "refined[refined.pareto_probability >= 0.1].sort_values([\"satellites\", \"planes\", \"sufficient\"])[\n", - " [\"description\", \"satellites\", \"planes\", \"sufficient\", \"replicates\", \"pareto\", \"pareto_probability\"]\n", + " [\"description\", \"satellites\", \"planes\", \"sufficient\", \"replicates\", \"pareto\", \"pareto_probability\", \"indifferent\"]\n", "].round(2)" ] }, @@ -2117,7 +2121,7 @@ "id": "d7f5b9c1", "metadata": {}, "source": [ - "Refinement adds 555 evaluations, 1.4% of those that 40 replicates of every design would take, to the few designs whose efficiency is uncertain. With the tolerance, the designs that sample nearly every point (six to nine satellites, about 98%) are all efficient candidates, with probabilities of 0.97 or more, rather than uncertain: they differ by less than matters. The designs that stay uncertain with 40 replicates lie about one tolerance below the front, such as single satellites that sample 1.9 to 2.8% of the points against the best single satellite's 3.2%, and three satellites in three planes that sample 37.0 and 37.8% against 38.0% in one plane: whether they are within the tolerance of the front is a question that more replicates settle only slowly, and one that does not change the trade. An absolute tolerance suits a share near saturation better than one near zero; a tolerance proportional to the objective would treat both alike." + "Refinement adds 215 evaluations, 0.6% of those that 40 replicates of every design would take, to the few designs whose efficiency is uncertain. With the tolerance, the designs that sample nearly every point (six to nine satellites, about 98%) are efficient candidates, with probabilities of 0.97 or more, rather than uncertain: they differ by less than matters. The designs that remain uncertain lie about one tolerance below the front, such as single satellites that sample 1.8 to 2.5% of the points against the best single satellite's 3.2%, or nine satellites that sample 96.8% against 97.8%: whether they are within the tolerance of the front is a question that more replicates settle only slowly, and one that does not change the trade. They are indifferent once their shares are known to within half the tolerance (a standard error of 0.5 percentage points), after 10 or 15 replicates of the single satellites (and the first five of the nine satellites); without a precision (`precision=None`), refinement would refine them to the limit of 40 replicates, for 555 evaluations. The shares of three satellites vary more between replicates: three satellites in three planes that sample 38.5% are indifferent after 25 replicates, and those that sample 37.0% remain uncertain with 40. An absolute tolerance suits a share near saturation better than one near zero; a tolerance proportional to the objective would treat both alike." ] }, { @@ -2136,10 +2140,10 @@ "id": "f2a3b4c5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T18:30:49.974634Z", - "iopub.status.busy": "2026-11-11T18:30:49.974389Z", - "iopub.status.idle": "2026-11-11T18:31:02.187962Z", - "shell.execute_reply": "2026-11-11T18:31:02.187044Z" + "iopub.execute_input": "2026-11-11T23:52:49.261059Z", + "iopub.status.busy": "2026-11-11T23:52:49.261059Z", + "iopub.status.idle": "2026-11-11T23:53:10.820066Z", + "shell.execute_reply": "2026-11-11T23:53:10.819684Z" } }, "outputs": [ @@ -2182,57 +2186,77 @@ " \n", " \n", " \n", + " 4\n", + " 600 km, 60 deg FOR, SSO: 1 at 18:00\n", + " 1.0\n", + " 1.0\n", + " 2.20\n", + " 2.25\n", + " 20\n", + " False\n", + " \n", + " \n", + " 3\n", + " 600 km, 60 deg FOR, SSO: 1 at 12:00\n", + " 1.0\n", + " 1.0\n", + " 2.20\n", + " 2.35\n", + " 20\n", + " False\n", + " \n", + " \n", " 23\n", " 800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac...\n", " 1.0\n", " 1.0\n", - " 2.75\n", + " 2.40\n", " 2.60\n", " 20\n", " False\n", " \n", " \n", - " 14\n", + " 15\n", " 700 km, 60 deg FOR, SSO: 1 at 15:00\n", " 1.0\n", " 1.0\n", - " 2.62\n", + " 2.53\n", " 2.85\n", " 20\n", " True\n", " \n", " \n", - " 15\n", + " 16\n", " 700 km, 60 deg FOR, SSO: 1 at 18:00\n", " 1.0\n", " 1.0\n", - " 2.45\n", + " 2.50\n", " 2.85\n", " 20\n", " True\n", " \n", " \n", - " 12\n", + " 13\n", " 700 km, 60 deg FOR, SSO: 1 at 09:00\n", " 1.0\n", " 1.0\n", - " 2.52\n", + " 2.50\n", " 2.90\n", " 20\n", " True\n", " \n", " \n", - " 13\n", + " 14\n", " 700 km, 60 deg FOR, SSO: 1 at 12:00\n", " 1.0\n", " 1.0\n", - " 2.70\n", + " 2.80\n", " 2.95\n", " 20\n", " True\n", " \n", " \n", - " 11\n", + " 12\n", " 700 km, 60 deg FOR, SSO: 1 at 06:00\n", " 1.0\n", " 1.0\n", @@ -2292,7 +2316,7 @@ " True\n", " \n", " \n", - " 16\n", + " 17\n", " 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...\n", " 2.0\n", " 1.0\n", @@ -2302,7 +2326,7 @@ " True\n", " \n", " \n", - " 19\n", + " 20\n", " 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...\n", " 2.0\n", " 2.0\n", @@ -2312,7 +2336,7 @@ " True\n", " \n", " \n", - " 17\n", + " 18\n", " 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...\n", " 3.0\n", " 1.0\n", @@ -2322,27 +2346,17 @@ " True\n", " \n", " \n", - " 21\n", + " 22\n", " 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...\n", " 3.0\n", " 3.0\n", - " 37.83\n", + " 38.48\n", " 35.60\n", " 20\n", " False\n", " \n", " \n", - " 22\n", - " 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...\n", - " 3.0\n", - " 3.0\n", - " 37.02\n", - " 37.05\n", - " 20\n", - " True\n", - " \n", - " \n", - " 18\n", + " 19\n", " 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...\n", " 4.0\n", " 1.0\n", @@ -2352,7 +2366,7 @@ " True\n", " \n", " \n", - " 20\n", + " 21\n", " 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...\n", " 4.0\n", " 2.0\n", @@ -2402,7 +2416,7 @@ " True\n", " \n", " \n", - " 3\n", + " 5\n", " 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...\n", " 8.0\n", " 2.0\n", @@ -2412,7 +2426,7 @@ " True\n", " \n", " \n", - " 4\n", + " 6\n", " 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...\n", " 8.0\n", " 2.0\n", @@ -2442,7 +2456,7 @@ " True\n", " \n", " \n", - " 8\n", + " 9\n", " 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...\n", " 8.0\n", " 4.0\n", @@ -2452,7 +2466,7 @@ " True\n", " \n", " \n", - " 9\n", + " 10\n", " 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...\n", " 8.0\n", " 4.0\n", @@ -2462,7 +2476,7 @@ " True\n", " \n", " \n", - " 10\n", + " 11\n", " 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...\n", " 8.0\n", " 4.0\n", @@ -2502,27 +2516,17 @@ " True\n", " \n", " \n", - " 5\n", - " 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", - " 9.0\n", - " 3.0\n", - " 97.53\n", - " 97.45\n", - " 20\n", - " True\n", - " \n", - " \n", " 2\n", " 600 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " 9.0\n", " 3.0\n", - " 97.60\n", + " 97.40\n", " 97.85\n", " 20\n", " True\n", " \n", " \n", - " 6\n", + " 7\n", " 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " 9.0\n", " 3.0\n", @@ -2532,7 +2536,7 @@ " True\n", " \n", " \n", - " 7\n", + " 8\n", " 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...\n", " 9.0\n", " 3.0\n", @@ -2577,83 +2581,83 @@ ], "text/plain": [ " description satellites planes \\\n", + "4 600 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", + "3 600 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", "23 800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac... 1.0 1.0 \n", - "14 700 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", - "15 700 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", - "12 700 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", - "13 700 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", - "11 700 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", + "15 700 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", + "16 700 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", + "13 700 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", + "14 700 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", + "12 700 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", "35 800 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", "38 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", "37 800 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", "34 800 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", "36 800 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", - "16 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 1.0 \n", - "19 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", - "17 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 1.0 \n", - "21 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", + "17 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 1.0 \n", + "20 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", + "18 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 1.0 \n", "22 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", - "18 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", - "20 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", + "19 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", + "21 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", "25 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", "24 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", "0 600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", "1 600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "3 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "4 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", + "5 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", + "6 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", "26 800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", "27 800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "8 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", "9 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", "10 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "11 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", "31 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", "32 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", "33 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "5 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", "2 600 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "6 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", "7 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "8 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", "28 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", "29 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", "30 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", "\n", " sufficient selected sufficient replicates pareto \n", - "23 2.75 2.60 20 False \n", - "14 2.62 2.85 20 True \n", - "15 2.45 2.85 20 True \n", - "12 2.52 2.90 20 True \n", - "13 2.70 2.95 20 True \n", - "11 2.90 3.45 20 True \n", + "4 2.20 2.25 20 False \n", + "3 2.20 2.35 20 False \n", + "23 2.40 2.60 20 False \n", + "15 2.53 2.85 20 True \n", + "16 2.50 2.85 20 True \n", + "13 2.50 2.90 20 True \n", + "14 2.80 2.95 20 True \n", + "12 2.90 3.45 20 True \n", "35 3.20 3.50 20 True \n", "38 3.10 3.50 20 True \n", "37 2.90 3.75 20 True \n", "34 3.10 3.80 20 True \n", "36 3.20 3.85 20 True \n", - "16 16.60 16.15 20 True \n", - "19 30.20 28.95 20 True \n", - "17 38.00 36.70 20 True \n", - "21 37.83 35.60 20 False \n", - "22 37.02 37.05 20 True \n", - "18 68.20 66.50 20 True \n", - "20 69.60 66.40 20 True \n", + "17 16.60 16.15 20 True \n", + "20 30.20 28.95 20 True \n", + "18 38.00 36.70 20 True \n", + "22 38.48 35.60 20 False \n", + "19 68.20 66.50 20 True \n", + "21 69.60 66.40 20 True \n", "25 97.60 97.80 20 True \n", "24 97.80 97.95 20 True \n", "0 97.40 97.75 20 True \n", "1 97.40 97.85 20 True \n", - "3 97.60 97.95 20 True \n", - "4 97.60 97.95 20 True \n", + "5 97.60 97.95 20 True \n", + "6 97.60 97.95 20 True \n", "26 97.80 98.10 20 True \n", "27 97.80 98.10 20 True \n", - "8 97.60 97.95 20 True \n", "9 97.60 97.95 20 True \n", "10 97.60 97.95 20 True \n", + "11 97.60 97.95 20 True \n", "31 97.80 98.10 20 True \n", "32 97.80 98.10 20 True \n", "33 97.80 98.10 20 True \n", - "5 97.53 97.45 20 True \n", - "2 97.60 97.85 20 True \n", - "6 97.60 97.95 20 True \n", + "2 97.40 97.85 20 True \n", "7 97.60 97.95 20 True \n", + "8 97.60 97.95 20 True \n", "28 97.80 98.10 20 True \n", "29 97.80 98.10 20 True \n", "30 97.80 98.10 20 True " @@ -2668,10 +2672,10 @@ "from tatc.tradespace import confirm\n", "\n", "selected = [by_key[key] for key in refined.design[refined.pareto]]\n", - "confirmation = confirm(make_study(), selected, refinement.results, OBJECTIVES, replicates=20, tolerance=TOLERANCE)\n", + "confirmation = confirm(make_study(), selected, refinement.results, CRITERIA, replicates=20)\n", "confirmed = confirmation.summary\n", "confirmed[\"description\"] = [describe(values.loc[key]) for key in confirmed.design]\n", - "print(f\"optimism of the selection: {confirmation.optimism(OBJECTIVES)['sufficient']:.2f} percentage points\")\n", + "print(f\"optimism of the selection: {confirmation.optimism()['sufficient']:.2f} percentage points\")\n", "confirmed.sort_values([\"satellites\", \"planes\", \"sufficient\"])[\n", " [\"description\", \"satellites\", \"planes\", \"sufficient selected\", \"sufficient\", \"replicates\", \"pareto\"]\n", "].round(2)" @@ -2682,7 +2686,7 @@ "id": "a3b4c5d6", "metadata": {}, "source": [ - "The selection is optimistic where it chose the best of nearly equal designs. The designs of two to four satellites sample 0.5 to 3.2 percentage points fewer with the new replicates: four satellites in two planes 66.4% rather than 69.6%, and in one plane 66.5% rather than 68.2%. Of the two designs of three satellites in three planes that refinement left nearly as good as three in one plane, one samples 35.6% with the new replicates (rather than 37.8%) and is no longer efficient. The single satellites (but one) and the designs of six to nine satellites instead sample slightly more points with the new replicates (by up to 0.9 and 0.5 points), as the new samples of points happen to be sampled more easily at both ends of the front: common random numbers share this difference between samples among the designs, and it is not an effect of the selection. The mean optimism over the designs (-0.02 points) mixes the two, so compare the designs one by one. All but two of the confirmed designs remain efficient within the tolerance: the shape of the front is confirmed, but its middle is up to 3 points less good than it looked." + "The selection is optimistic where it chose the best of nearly equal designs. The designs of two to four satellites sample 0.5 to 3.2 percentage points fewer with the new replicates: four satellites in two planes 66.4% rather than 69.6%, and in one plane 66.5% rather than 68.2%. The design of three satellites in three planes that refinement left as good as three in one plane samples 35.6% with the new replicates (rather than 38.5%) and is no longer efficient. The single satellites and the designs of six to nine satellites instead sample slightly more points with the new replicates (by up to 0.9 and 0.5 points), as the new samples of points happen to be sampled more easily at both ends of the front: common random numbers share this difference between samples among the designs, and it is not an effect of the selection. The mean optimism over the designs (-0.02 points) mixes the two, so compare the designs one by one. All but four of the confirmed designs remain efficient within the tolerance (three single satellites that refinement left indifferent, about a tolerance below the front, and the three satellites in three planes): the shape of the front is confirmed, but its middle is up to 3 points less good than it looked." ] }, { @@ -2692,7 +2696,7 @@ "source": [ "## Require Reliable Sampling\n", "\n", - "A mean share of points sufficiently sampled does not say how reliably a design achieves it: the share differs between samples of points. Statistics over the replicates other than the mean state how a design is judged, and requirements on them are output constraints. Here, the objective is the share that a design exceeds in 80% of the samples (its 0.2 quantile, `Quantile`), and a design is required to sample at least half of the points sufficiently in at least 80% of the samples (the probability of meeting a threshold, `Probability`, with a `Requirement`). `aggregate` gives the statistics and the violations of the requirements, and `pareto_probability` the probability that each design is efficient among those that meet them." + "A mean share of points sufficiently sampled does not say how reliably a design achieves it: the share differs between samples of points. Statistics over the replicates other than the mean state how a design is judged, and requirements on them are output constraints. Here, the objective is the share that a design exceeds in 80% of the samples (its 0.2 quantile, `Quantile`), and a design is required to sample at least half of the points sufficiently in at least 80% of the samples (the probability of meeting a threshold, `Probability`, with a `Requirement`). `Criteria` collect the objectives, the statistics they name, and the requirements: `aggregate` gives the statistics and the violations of the requirements, and `pareto_probability` the probability that each design is efficient among those that meet them." ] }, { @@ -2701,10 +2705,10 @@ "id": "f9b7d1e3", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T18:31:02.189661Z", - "iopub.status.busy": "2026-11-11T18:31:02.189466Z", - "iopub.status.idle": "2026-11-11T18:31:03.586608Z", - "shell.execute_reply": "2026-11-11T18:31:03.585817Z" + "iopub.execute_input": "2026-11-11T23:53:10.820569Z", + "iopub.status.busy": "2026-11-11T23:53:10.820569Z", + "iopub.status.idle": "2026-11-11T23:53:11.897318Z", + "shell.execute_reply": "2026-11-11T23:53:11.897318Z" } }, "outputs": [ @@ -2823,16 +2827,16 @@ "source": [ "from tatc.tradespace import Probability, Quantile, Requirement, aggregate\n", "\n", - "STATISTICS = {\n", - " \"sufficient p20\": Quantile(\"sufficient\", 0.2),\n", - " \"reliability\": Probability(\"sufficient\", \">=\", 50),\n", - "}\n", - "RELIABLE_OBJECTIVES = {\"satellites\": \"min\", \"planes\": \"min\", \"sufficient p20\": \"max\"}\n", - "REQUIREMENTS = [Requirement(\"reliability\", \">=\", 0.8)]\n", - "\n", - "reliable = pareto_probability(\n", - " refinement.results, RELIABLE_OBJECTIVES, n_resamples=1000, statistics=STATISTICS, requirements=REQUIREMENTS\n", + "RELIABLE = Criteria(\n", + " {\"satellites\": \"min\", \"planes\": \"min\", \"sufficient p20\": \"max\"},\n", + " statistics={\n", + " \"sufficient p20\": Quantile(\"sufficient\", 0.2),\n", + " \"reliability\": Probability(\"sufficient\", \">=\", 50),\n", + " },\n", + " requirements=[Requirement(\"reliability\", \">=\", 0.8)],\n", ")\n", + "\n", + "reliable = pareto_probability(refinement.results, RELIABLE, n_resamples=1000)\n", "reliable[\"description\"] = [describe(values.loc[key]) for key in reliable.design]\n", "print(f\"{reliable.meets_requirements.sum()} of {len(reliable)} designs meet the requirement\")\n", "reliable[reliable.pareto_probability >= 0.1].sort_values([\"satellites\", \"planes\"])[\n", @@ -2850,48 +2854,26 @@ }, { "cell_type": "markdown", - "id": "c0d1e2f3", + "id": "f86b3d37", "metadata": {}, "source": [ - "## Plan for Failures\n", - "\n", - "A design that needs every satellite to work is fragile, and what failures cost depends on how the mission responds to them. A `FailureModel` gives the life of the satellites from their launch, here a bathtub curve of infant mortality, random failures, and wear-out (`Bathtub` of `Weibull` and `Exponential` lives, illustrative), and the probability that a launch fails. Each replicate simulates the mission of a design with failures drawn from its seed (`Deployment.simulate`, with common random numbers: the satellite at the same position of the same plane fails at the same age in every design), and a `RestorationPolicy` responds to them:\n", - "\n", - "* **degrade**: fly the satellites that remain;\n", - "* **produce**: restore each failed satellite by producing a new one (after half a year of procurement, on the production line) and launching it;\n", - "* **spare in orbit**: a spare in each plane, launched with it, takes a failed satellite's place within months (others are produced), and is produced again;\n", - "* **spare on ground**: a spare, produced after the first satellites and stored, is launched at the next slot (others are produced), and is produced again.\n", - "\n", - "The policy is a decision of each design: a fragment of the design space (`policy_space`) decides whether to restore failed satellites, and the spares in orbit (in each plane) and on the ground (here, none or one of each, and none without restoration, which would never use them), and configures the policy of each design (`configure`, from a base policy of half a year of procurement and spares that are produced again). The efficient designs by accuracy, each with each of the five policies, form a design space of both, in which each history gives both the cost of what is produced and launched (the restorations and spares, and the launches that fail) and the phases in which its satellites operate, evaluated as in the previous section: the share of points accurately sampled on average over the mission, and in the worst 10% of the histories, and the cost at 70% confidence.\n", + "## Compare Designs across Scenarios\n", "\n", - "The failures are cheap to simulate, but each phase's share is expensive to evaluate, and most phases repeat the same sets of operating satellites. Each replicate (a sample of points, the expensive part) therefore simulates 20 histories of the failures of its mission (`Deployment.simulate_many`, stratified: a Latin hypercube over the histories in which each satellite's life and each launch draws from its own stratum of its distribution, which estimates means several times more precisely than independent histories), evaluates them together (`evaluate_missions`) with a cache that evaluates each set of satellites once (`PhaseCache`, shared by the histories, policies, and designs of a replicate), and summarizes them (`summarize_missions`): their mean share, and their worst 10% (the risk of the mission), and their cost at 70% confidence. Five replicates of 20 histories measure the risk of each mission with 100 histories, at a fraction of the cost of 100 replicates. Without restoration (degrading), the satellites fail independently, so that the mean share over the failures is computed exactly (`expected_missions`, from the probability that each set of satellites operates), without sampling error; its worst 10% and cost still come from the histories." + "How accurately samples estimate a daily mean depends on the field: samples hours apart estimate the mean of a field that varies slowly (one that decorrelates in 12 hours) better than that of one that varies within the hour (such as rain rates). Which field the mission will serve is not uncertain as the sample of points or the failures are, which the replicates average over: it is a condition under which to compare designs, a scenario. The `scenarios` of a study give fixed values or uncertain parameters of the design space other values: here, the field's decorrelation time (`decorrelation_time`). The study evaluates every design in each field, with the same samples of points, and records the field as its `scenario`; the field of 3 hours, as above, takes its evaluations from the store. Criteria `by` the scenario judge designs in each field, and `robustness` judges them across the fields: the share of the fields in which each design is efficient (its Pareto trace) here, and its regret below:" ] }, { "cell_type": "code", "execution_count": 15, - "id": "d1e2f3a4", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-11T18:31:03.588212Z", - "iopub.status.busy": "2026-11-11T18:31:03.588046Z", - "iopub.status.idle": "2026-11-11T18:31:12.120885Z", - "shell.execute_reply": "2026-11-11T18:31:12.120121Z" - } - }, + "id": "37bd44f4", + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "37% of the satellites fail in 5 years\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "65 designs x 5 replicates x 20 histories in 5 s\n" + "16440 evaluations (3 fields) in 122 s\n", + "efficient designs: {'1 hour': 14, '3 hours': 13, '12 hours': 6}\n" ] }, { @@ -2907,56 +2889,24 @@ " vertical-align: top;\n", " }\n", "\n", - " .dataframe thead tr th {\n", - " text-align: left;\n", - " }\n", - "\n", - " .dataframe thead tr:last-of-type th {\n", + " .dataframe thead th {\n", " text-align: right;\n", " }\n", "\n", "\n", " \n", - " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2968,161 +2918,562 @@ " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionfull constellationaccurateaccurate p10cost p70
policydegradeproducespare in orbitspare on groundspares in orbit and on grounddegradeproducespare in orbitspare on groundspares in orbit and on grounddegradeproducespare in orbitspare on groundspares in orbit and on groundsatellitesplanes1 hour3 hours12 hourspareto trace
basedesign
9b3481aea973800 km, 60 deg FOR, SSO: 1 at 12:003.43.23.94.04.14.00.43.53.73.73.7110.2130.6147.6146.3162.2
fac5d43a19c7800 km, 60 deg FOR, SSO: 2 at 06:0010.07.09.29.69.89.72.17.38.38.68.7128.9153.4170.3170.0184.333b006848799800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.026.234.260.40.67
b85daf65c3a4800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...16.710.914.814.716.014.94.612.212.914.313.3146.2188.2211.1204.4223.3
104e33a3c842800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac...29.316.122.324.424.424.96.118.020.421.021.9170.2218.9237.7235.8249.8
33b006848799800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...33.017.726.128.228.928.50.619.525.125.625.6136.5159.4192.7175.2206.43.01.08.017.095.60.67
c576e2e2dbd1800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:0057.033.147.350.751.751.27.138.544.744.946.8153.9198.1229.3212.4240.1
f216ec70e160800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac...60.432.944.948.048.148.39.537.743.042.443.5161.2201.0247.9216.8260.43.02.040.860.685.80.67
3690f1194419800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:0082.850.768.568.872.569.310.856.261.362.263.1170.4218.34.02.069.085.493.00.67
cb6bd361b577800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.096.696.697.80.67
5529c21520be800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.897.80.67
de505bc89299800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.897.80.67
679ca275c8fc800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.897.80.67
\n", + "" + ], + "text/plain": [ + " description satellites \\\n", + "design \n", + "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 \n", + "b85daf65c3a4 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... 3.0 \n", + "c576e2e2dbd1 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3.0 \n", + "3690f1194419 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4.0 \n", + "cb6bd361b577 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 \n", + "5529c21520be 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", + "de505bc89299 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", + "679ca275c8fc 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", + "\n", + " planes 1 hour 3 hours 12 hours pareto trace \n", + "design \n", + "33b006848799 2.0 26.2 34.2 60.4 0.67 \n", + "b85daf65c3a4 1.0 8.0 17.0 95.6 0.67 \n", + "c576e2e2dbd1 2.0 40.8 60.6 85.8 0.67 \n", + "3690f1194419 2.0 69.0 85.4 93.0 0.67 \n", + "cb6bd361b577 4.0 96.6 96.6 97.8 0.67 \n", + "5529c21520be 3.0 97.8 97.8 97.8 0.67 \n", + "de505bc89299 3.0 97.8 97.8 97.8 0.67 \n", + "679ca275c8fc 3.0 97.8 97.8 97.8 0.67 " + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import time\n", + "\n", + "from tatc.tradespace import robustness\n", + "\n", + "# fields that decorrelate within an hour (such as rain rates), in 3 hours (as above), and in 12 hours\n", + "FIELDS = {\n", + " \"1 hour\": {\"decorrelation_time\": timedelta(hours=1)},\n", + " \"3 hours\": {},\n", + " \"12 hours\": {\"decorrelation_time\": timedelta(hours=12)},\n", + "}\n", + "began = time.perf_counter()\n", + "fields = make_study(scenarios=FIELDS).run(designs)\n", + "print(f\"{len(fields)} evaluations ({len(FIELDS)} fields) in {time.perf_counter() - began:.0f} s\")\n", + "\n", + "# the efficient designs of each field (by accuracy), and the share of the fields in which each design is efficient\n", + "BY_FIELD = Criteria(ACCURACY, by=\"scenario\")\n", + "by_field = aggregate(fields, BY_FIELD)\n", + "by_field[\"pareto\"] = pareto_front(by_field, BY_FIELD)\n", + "print(\"efficient designs:\", by_field[by_field.pareto].scenario.value_counts()[list(FIELDS)].to_dict())\n", + "field_accuracy = by_field.pivot(index=\"design\", columns=\"scenario\", values=\"accurate\")[list(FIELDS)]\n", + "traced = accuracy.set_index(\"design\")[[\"description\", \"satellites\", \"planes\"]].join(field_accuracy)\n", + "traced[\"pareto trace\"] = robustness(fields, ACCURACY).set_index(\"design\")[\"pareto trace\"]\n", + "traced[traced[\"pareto trace\"] > 0.5].sort_values([\"satellites\", \"planes\"]).round(2)" + ] + }, + { + "cell_type": "markdown", + "id": "f51c2632", + "metadata": {}, + "source": [ + "The 10,960 evaluations of the other two fields take about two minutes here. Which designs are efficient depends on the field. For the field that decorrelates in 12 hours, one plane samples well: three satellites in one plane (inclined 75 degrees) sample 96% of the points accurately, and four of the six efficient designs have one plane (the other two, four satellites in two planes, sample 98%). For the fields that vary within hours, the samples must spread over the day: the same three satellites in one plane sample 17% (3 hours) and 8% (1 hour) accurately, against 61% and 41% for three satellites in two sun-synchronous planes. No design is efficient for every field: of the eight efficient for two fields, seven are efficient for the fields of 1 and 3 hours, and the other, three satellites in one plane, for those of 3 and 12 hours.\n", + "\n", + "A design need not be efficient in any field to be a good choice when the field is not known: its regret in a field is how far it falls behind the best design there. With the numbers of satellites and planes as objectives, regret would count mostly satellites and planes (a design matches the cheapest efficient design by dropping some), so here regret is in the share accurately sampled alone, among the designs of at most a number of satellites (a `Requirement`): the points below the best design of each field with as many satellites at most. The design whose largest regret over the fields is least (minimax regret) is the robust choice:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "e87bea8f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanesmax regret1 hour regret3 hours regret12 hours regret
at most
2800 km, 60 deg FOR, Walker 75 deg: 2 x 1 (spac...2.02.011.07.66.411.0
3800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:003.02.09.89.80.49.8
4800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:004.02.05.00.00.05.0
6700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...6.03.00.40.40.20.4
\n", + "
" + ], + "text/plain": [ + " description satellites \\\n", + "at most \n", + "2 800 km, 60 deg FOR, Walker 75 deg: 2 x 1 (spac... 2.0 \n", + "3 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3.0 \n", + "4 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4.0 \n", + "6 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... 6.0 \n", + "\n", + " planes max regret 1 hour regret 3 hours regret 12 hours regret \n", + "at most \n", + "2 2.0 11.0 7.6 6.4 11.0 \n", + "3 2.0 9.8 9.8 0.4 9.8 \n", + "4 2.0 5.0 0.0 0.0 5.0 \n", + "6 3.0 0.4 0.4 0.2 0.4 " + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# the designs of least maximum regret (in points accurately sampled, below the best design of each field), among those\n", + "# of at most a number of satellites\n", + "robust, robust_design = [], {}\n", + "for budget in (2, 3, 4, 6):\n", + " within = Criteria({\"accurate\": \"max\"}, requirements=[Requirement(\"satellites\", \"<=\", budget)])\n", + " regret = robustness(fields, within).set_index(\"design\")\n", + " best = robust_design[budget] = regret[\"max regret\"].idxmin()\n", + " described = traced.loc[best, [\"description\", \"satellites\", \"planes\"]]\n", + " robust.append({\"at most\": budget, **described, **regret.loc[best].drop(\"pareto trace\")})\n", + "pd.DataFrame(robust).set_index(\"at most\").round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "dccc2ff4", + "metadata": {}, + "source": [ + "The robust choice depends on the budget. With four satellites, two sun-synchronous planes of two (crossing at 09:00 and 15:00) are the best for the fields of 1 and 3 hours and fall 5 points behind the best for the field of 12 hours (93% against 98%, by four satellites in two other planes): a mission that does not yet know its field loses little by choosing them. With three satellites, two sun-synchronous planes of two and one fall 10 points behind three satellites in one plane for the field of 12 hours (86% against 96%) and three in three planes for the field of 1 hour (41% against 51%), and less than a point behind the best for 3 hours. Two satellites fall at least 11 points behind somewhere. Six satellites in three Walker planes (at 700 km) fall at most 0.4 points behind the best of any field, though they are efficient in none: a robust choice need not be the best in any scenario. Regrets of a point or two are within the sampling error of the means of five replicates (standard errors of one to four points, as above), so the robust designs of four and six satellites are as good as the best of each field." + ] + }, + { + "cell_type": "markdown", + "id": "c0d1e2f3", + "metadata": {}, + "source": [ + "## Plan for Failures\n", + "\n", + "A design that needs every satellite to work is fragile, and what failures cost depends on how the mission responds to them. A `FailureModel` gives the life of the satellites from their launch, here a bathtub curve of infant mortality, random failures, and wear-out (`Bathtub` of `Weibull` and `Exponential` lives, illustrative), and the probability that a launch fails. Each replicate simulates the mission of a design with failures drawn from its seed (`Deployment.simulate`, with common random numbers: the satellite at the same position of the same plane fails at the same age in every design), and a `RestorationPolicy` responds to them:\n", + "\n", + "* **degrade**: fly the satellites that remain;\n", + "* **produce**: restore each failed satellite by producing a new one (after half a year of procurement, on the production line) and launching it;\n", + "* **spare in orbit**: a spare in each plane, launched with it, takes a failed satellite's place within months (others are produced), and is produced again;\n", + "* **spare on ground**: a spare, produced after the first satellites and stored, is launched at the next slot (others are produced), and is produced again.\n", + "\n", + "The policy is a decision of each design: a fragment of the design space (`policy_space`) decides whether to restore failed satellites, and the spares in orbit (in each plane) and on the ground (here, none or one of each, and none without restoration, which would never use them), and configures the policy of each design (`configure`, from a base policy of half a year of procurement and spares that are produced again). The efficient designs by accuracy, each with each of the five policies, form a design space of both, in which each history gives both the cost of what is produced and launched (the restorations and spares, and the launches that fail) and the phases in which its satellites operate, evaluated as in the previous section: the share of points accurately sampled on average over the mission, and in the worst 10% of the histories, and the cost at 70% confidence.\n", + "\n", + "The failures are cheap to simulate, but each phase's share is expensive to evaluate, and most phases repeat the same sets of operating satellites. Each replicate (a sample of points, the expensive part) therefore simulates 20 histories of the failures of its mission (`Failures` of the study, with `Deployment.simulate_many`, stratified: a Latin hypercube over the histories in which each satellite's life and each launch draws from its own stratum of its distribution, which estimates means several times more precisely than independent histories), evaluates them together (`evaluate_missions`) with a cache that evaluates each set of satellites once (`PhaseCache`, shared by the histories, policies, and designs of a replicate), and summarizes them (`summarize_missions`): their mean share, and their worst 10% (the risk of the mission), and their cost at 70% confidence. Five replicates of 20 histories measure the risk of each mission with 100 histories, at a fraction of the cost of 100 replicates. Without restoration (degrading), the satellites fail independently, so that the mean share over the failures is computed exactly (`expected_missions`, from the probability that each set of satellites operates), without sampling error; its worst 10% and cost still come from the histories." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "d1e2f3a4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-11T23:53:11.897318Z", + "iopub.status.busy": "2026-11-11T23:53:11.897318Z", + "iopub.status.idle": "2026-11-11T23:53:28.438627Z", + "shell.execute_reply": "2026-11-11T23:53:28.438627Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "37% of the satellites fail in 5 years\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "65 designs x 5 replicates x 20 histories in 8 s\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", @@ -3164,28 +3515,8 @@ " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", " \n", @@ -3208,6 +3539,26 @@ " \n", " \n", " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", @@ -3245,8 +3596,8 @@ "3690f1194419 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 \n", "cb6bd361b577 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... \n", "716cb479efda 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", - "679ca275c8fc 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", "5529c21520be 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", + "679ca275c8fc 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", "de505bc89299 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", "\n", " full constellation accurate \\\n", @@ -3262,8 +3613,8 @@ "3690f1194419 82.8 50.7 68.5 68.8 \n", "cb6bd361b577 96.0 75.8 81.2 76.3 \n", "716cb479efda 97.0 64.2 78.0 74.2 \n", - "679ca275c8fc 98.3 79.5 83.0 76.8 \n", "5529c21520be 98.3 79.3 82.8 76.8 \n", + "679ca275c8fc 98.3 79.5 83.0 76.8 \n", "de505bc89299 98.3 79.5 82.9 76.9 \n", "\n", " accurate p10 \\\n", @@ -3279,8 +3630,8 @@ "3690f1194419 72.5 69.3 10.8 \n", "cb6bd361b577 81.5 76.2 60.4 \n", "716cb479efda 79.6 74.3 38.9 \n", - "679ca275c8fc 83.0 76.8 69.0 \n", "5529c21520be 82.8 76.9 66.4 \n", + "679ca275c8fc 83.0 76.8 69.0 \n", "de505bc89299 83.0 76.9 68.0 \n", "\n", " \\\n", @@ -3296,8 +3647,8 @@ "3690f1194419 56.2 61.3 62.2 \n", "cb6bd361b577 73.8 69.8 73.9 \n", "716cb479efda 70.1 67.3 71.5 \n", - "679ca275c8fc 78.7 72.1 78.6 \n", "5529c21520be 78.1 71.6 78.2 \n", + "679ca275c8fc 78.7 72.1 78.6 \n", "de505bc89299 78.7 71.7 78.4 \n", "\n", " cost p70 \\\n", @@ -3313,8 +3664,8 @@ "3690f1194419 63.1 170.4 218.3 246.8 \n", "cb6bd361b577 69.6 246.8 326.4 376.7 \n", "716cb479efda 66.9 209.5 278.8 316.7 \n", - "679ca275c8fc 72.1 253.5 340.0 394.6 \n", "5529c21520be 71.6 253.5 340.0 394.6 \n", + "679ca275c8fc 72.1 253.5 340.0 394.6 \n", "de505bc89299 71.7 253.5 340.0 394.6 \n", "\n", " \n", @@ -3330,12 +3681,12 @@ "3690f1194419 235.4 260.7 \n", "cb6bd361b577 347.0 389.6 \n", "716cb479efda 294.4 329.0 \n", - "679ca275c8fc 355.7 405.7 \n", "5529c21520be 355.7 405.7 \n", + "679ca275c8fc 355.7 405.7 \n", "de505bc89299 355.7 405.7 " ] }, - "execution_count": 15, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -3343,14 +3694,23 @@ "source": [ "import time\n", "\n", - "from tatc.tradespace import Bathtub, Exponential, FailureModel, Integer, Weibull, policy_space\n", + "from tatc.tradespace import (\n", + " Bathtub,\n", + " Exponential,\n", + " FailureModel,\n", + " Failures,\n", + " Integer,\n", + " RestorationPolicy,\n", + " Weibull,\n", + " policy_space,\n", + ")\n", "\n", "# illustrative lives: about 9% fail in their first year, 3% a year at random, and wear-out after about 8 years\n", - "FAILURES = FailureModel(\n", + "FAILURE_MODEL = FailureModel(\n", " life=Bathtub(infant=Weibull(shape=0.5, scale=100), random=Exponential(0.03), wear_out=Weibull(shape=4, scale=9)),\n", " launch=0.05,\n", ")\n", - "print(f\"{1 - FAILURES.life.survival(5):.0%} of the satellites fail in 5 years\")\n", + "print(f\"{1 - FAILURE_MODEL.life.survival(5):.0%} of the satellites fail in 5 years\")\n", "BASE_POLICY = RestorationPolicy(procurement_years=0.5, replenish=True)\n", "POLICY = policy_space(orbit_spares=Integer(0, 1), ground_spares=Integer(0, 1), replenish=True)\n", "\n", @@ -3377,7 +3737,12 @@ " }[orbit, ground]\n", "\n", "\n", - "study = make_study(replicates=5, failures=FAILURES, policy=BASE_POLICY, histories=20, design_space=policy_trade)\n", + "# 20 histories of each replicate, restored by the policy of each design, with the mean share accurately sampled over\n", + "# the mission in the worst 10% of the histories, and the cost at 70% confidence\n", + "FAILURES = Failures(\n", + " FAILURE_MODEL, BASE_POLICY, histories=20, seed=\"failure_seed\", quantiles={\"accurate mean\": 0.1, \"cost\": 0.7}\n", + ")\n", + "study = make_study(replicates=5, failures=FAILURES, design_space=policy_trade)\n", "began = time.perf_counter()\n", "trades = study.run(with_policies)\n", "print(f\"{len(with_policies)} designs x 5 replicates x 20 histories in {time.perf_counter() - began:.0f} s\")\n", @@ -3404,7 +3769,7 @@ "id": "e2f3a4b5", "metadata": {}, "source": [ - "The 6,500 histories (100 of each of the 65 designs and policies) take a few seconds here. The shares accurately sampled over the mission fall short of those of the full constellation under every policy, by the phases of deployment and the failures of launches as well as of satellites (37% of which fail within five years), but for the single satellite, whose shares differ by less than the sampling error of five replicates (the full constellation's are of 20). The response to failures matters most for the designs of several satellites in several planes, and in their worst histories:\n", + "The 6,500 histories (100 of each of the 65 designs and policies) take about ten seconds here. The shares accurately sampled over the mission fall short of those of the full constellation under every policy, by the phases of deployment and the failures of launches as well as of satellites (37% of which fail within five years), but for the single satellite, whose shares differ by less than the sampling error of five replicates (the full constellation's are of 20). The response to failures matters most for the designs of several satellites in several planes, and in their worst histories:\n", "\n", "* **Degrading** is cheapest, but loses 12 to 18 points of the mean against producing replacements for the designs of three to six satellites in two or three planes, and more in their worst 10% of histories (39% against 70% for six satellites in three Walker planes; 1% against 20% for two satellites in two planes, which can lose both). Nine satellites in three planes lose only 3.5 points: a failure leaves eight. The means of degrading are exact (`expected_missions`); those of the other policies are estimates from 100 histories.\n", "* **Producing replacements** restores most of it, at 17 to 34% more cost at 70% confidence than degrading.\n", @@ -3414,14 +3779,14 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 18, "id": "b8c9d0e1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T18:31:12.122682Z", - "iopub.status.busy": "2026-11-11T18:31:12.122431Z", - "iopub.status.idle": "2026-11-11T18:31:12.131848Z", - "shell.execute_reply": "2026-11-11T18:31:12.131188Z" + "iopub.execute_input": "2026-11-11T23:53:28.440633Z", + "iopub.status.busy": "2026-11-11T23:53:28.440633Z", + "iopub.status.idle": "2026-11-11T23:53:28.454498Z", + "shell.execute_reply": "2026-11-11T23:53:28.454498Z" } }, "outputs": [ @@ -3575,94 +3940,350 @@ " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionfull constellationaccurateaccurate p10cost p70
policydegradeproducespare in orbitspare on groundspares in orbit and on grounddegradeproducespare in orbitspare on groundspares in orbit and on grounddegradeproducespare in orbitspare on groundspares in orbit and on ground
base
9b3481aea973800 km, 60 deg FOR, SSO: 1 at 12:003.43.23.94.04.14.00.43.53.73.73.7110.2130.6147.6146.3162.2
fac5d43a19c7800 km, 60 deg FOR, SSO: 2 at 06:0010.07.09.29.69.89.72.17.38.38.68.7128.9153.4170.3170.0184.3
b85daf65c3a4800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...16.710.914.814.716.014.94.612.212.914.313.3146.2188.2211.1204.4223.3
104e33a3c842800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac...29.316.122.324.424.424.96.118.020.421.021.9170.2218.9237.7235.8249.8
33b006848799800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...33.017.726.128.228.928.50.619.525.125.625.6136.5159.4192.7175.2206.4
c576e2e2dbd1800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:0057.033.147.350.751.751.27.138.544.744.946.8153.9198.1229.3212.4240.1
f216ec70e160800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac...60.432.944.948.048.148.39.537.743.042.443.5161.2201.0247.9216.8260.4
3690f1194419800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:0082.850.768.568.872.569.310.856.261.362.263.1170.4218.3246.8235.4260.7209.5278.8316.7294.4329.0
679ca275c8fc800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...98.379.583.076.883.076.869.078.772.178.672.1253.5340.0394.6355.7405.7294.4329.0
5529c21520be405.7
679ca275c8fc800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...98.379.583.076.883.076.869.078.772.178.672.1253.5340.0394.6355.7405.7
de505bc89299800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...98.3278.8
570a452fdb8f700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...spare on ground79.671.5294.4570a452fdb8f700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...spare on ground79.671.5294.4
2b499d154a98800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...produce81.273.8326.4
a37619256b26800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...produce83.078.7340.0
\n", + "
" + ], + "text/plain": [ + " description \\\n", + "design \n", + "2a310c00151b 800 km, 60 deg FOR, SSO: 1 at 12:00 \n", + "bc2076a0d3d8 800 km, 60 deg FOR, SSO: 2 at 06:00 \n", + "bb6574900ac3 800 km, 60 deg FOR, SSO: 1 at 12:00 \n", + "638697713902 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... \n", + "43f50c8bc38a 800 km, 60 deg FOR, SSO: 2 at 06:00 \n", + "ad99c42082ab 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", + "cc2e14e787ff 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", + "eeb7c70a720b 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 \n", + "3a902b976460 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", + "6d54bdbf4648 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 \n", + "1afde0569e34 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 \n", + "e7721a705c31 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 \n", + "46932f795a5a 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", + "6e4564d2ae2c 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", + "570a452fdb8f 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", + "2b499d154a98 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... \n", + "a37619256b26 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", + "\n", + " policy accurate accurate p10 cost p70 \n", + "design \n", + "2a310c00151b degrade 3.2 0.4 110.2 \n", + "bc2076a0d3d8 degrade 7.0 2.1 128.9 \n", + "bb6574900ac3 produce 3.9 3.5 130.6 \n", + "638697713902 degrade 10.9 4.6 146.2 \n", + "43f50c8bc38a produce 9.2 7.3 153.4 \n", + "ad99c42082ab produce 26.1 19.5 159.4 \n", + "cc2e14e787ff spare on ground 28.9 25.6 175.2 \n", + "eeb7c70a720b produce 47.3 38.5 198.1 \n", + "3a902b976460 degrade 64.2 38.9 209.5 \n", + "6d54bdbf4648 spare on ground 51.7 44.9 212.4 \n", + "1afde0569e34 produce 68.5 56.2 218.3 \n", + "e7721a705c31 spare on ground 72.5 62.2 235.4 \n", + "46932f795a5a degrade 79.5 69.0 253.5 \n", + "6e4564d2ae2c produce 78.0 70.1 278.8 \n", + "570a452fdb8f spare on ground 79.6 71.5 294.4 \n", + "2b499d154a98 produce 81.2 73.8 326.4 \n", + "a37619256b26 produce 83.0 78.7 340.0 " + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# the efficient designs and policies, by their cost and their accuracy in the worst 10% of the replicates\n", + "efficient = traded[pareto_front(traded, {\"cost p70\": \"min\", \"accurate p10\": \"max\"})]\n", + "efficient.assign(description=[describe(values.loc[key]) for key in efficient.base]).sort_values(\"cost p70\")[\n", + " [\"description\", \"policy\", \"accurate\", \"accurate p10\", \"cost p70\"]\n", + "].round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "c9d0e1f2", + "metadata": {}, + "source": [ + "The front of cost at 70% confidence against the share accurately sampled in the worst 10% of the histories chooses designs and policies together. Along it, degrading is the cheapest policy of a design and restoring buys robustness: two satellites in two Walker planes keep 20% of the points accurately sampled in their worst histories if they produce replacements (159 million) and 26% with a spare on the ground (175 million); six satellites in three Walker planes keep 39%, 70%, and 72% if they degrade, produce replacements, or keep a spare on the ground, for 210, 279, and 294 million. Nine satellites in three planes degrade gracefully (69% in their worst histories for 254 million), and producing replacements raises them to 79% for 340 million. A spare on the ground is efficient for designs of two to six satellites, but a spare in orbit is not efficient for any design here, as it delays the deployment. The policy that a design deserves depends on the design, which is why the policy is a decision of the design rather than of the study." + ] + }, + { + "cell_type": "markdown", + "id": "135bfcd2", + "metadata": {}, + "source": [ + "## Find What Spreads the Replicates\n", + "\n", + "The replicates of a design differ by its uncertain parameters: here, the sample of points (`points_seed`), the histories of failures (`failure_seed`), and the growth of the cost of development (`cost_growth`, see below). Which of them spreads an objective says what would sharpen it: the spread from the sample of points and from the histories is noise of the estimates, which more points or more histories reduce, and that from the growth of costs is a risk of the mission. `attribute_variance` finds it by evaluating each design again with one parameter drawn as in other replicates and the others held, which works for parameters whose values do not relate to the outcomes in any order, such as seeds. The total share of a parameter is the share of the variance between replicates that it causes, alone or with others (near 0 if it does not matter), with its standard error (`se`, by a bootstrap of the replicates); its first share (`summary(\"first\")`) is the share that knowing it would remove. Here, for the efficient designs and policies of the study of failures, from 20 replicates, 20 more, and 20 with each parameter drawn as in the second 20:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "f0fa7509", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1700 evaluations in 46 s\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
accurate meanaccurate mean p10cost p70accurate mean seaccurate mean p10 secost p70 se
parameter
points_seed92.430.40.06.43.30.0
failure_seed3.667.035.80.76.57.1
cost_growth0.00.081.80.00.019.0
\n", + "
" + ], + "text/plain": [ + " accurate mean accurate mean p10 cost p70 accurate mean se \\\n", + "parameter \n", + "points_seed 92.4 30.4 0.0 6.4 \n", + "failure_seed 3.6 67.0 35.8 0.7 \n", + "cost_growth 0.0 0.0 81.8 0.0 \n", + "\n", + " accurate mean p10 se cost p70 se \n", + "parameter \n", + "points_seed 3.3 0.0 \n", + "failure_seed 6.5 7.1 \n", + "cost_growth 0.0 19.0 " + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import attribute_variance\n", + "\n", + "# the shares (%) of the variance between the replicates of the efficient designs and policies that each uncertain\n", + "# parameter causes, alone or with others, from 20 replicates, 20 more, and 20 with each parameter drawn as in the\n", + "# second 20\n", + "policy_by_key = {design.key: design for design in with_policies}\n", + "began = time.perf_counter()\n", + "attribution = attribute_variance(\n", + " study, # of failures\n", + " [policy_by_key[key] for key in efficient.index],\n", + " [\"accurate mean\", \"accurate mean p10\", \"cost p70\"],\n", + " replicates=20,\n", + ")\n", + "print(f\"{len(attribution.results)} evaluations in {time.perf_counter() - began:.0f} s\")\n", + "attribution.summary().mul(100).round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "7368ea1a", + "metadata": {}, + "source": [ + "The attribution takes 1,700 evaluations (85 of them those of the study above), under a minute here. The sample of points spreads the mean shares accurately sampled (92% of their variance between replicates), and the failures hardly do (4%): the means of degrading are exact, and those of the other policies average 20 histories. The share in the worst 10% of the histories is spread mostly by the failures (67%, and 30% by the points), as a quantile of 20 histories is a noisy estimate. Both are noise of the estimates rather than risks of the missions, and they call for different remedies: more points would sharpen the means, and more histories in each replicate the worst 10%, which is cheap (the 6,500 histories above take about ten seconds). The cost at 70% confidence of a replicate is spread by the growth of the cost of development (82%), a risk of the mission, and by the failures (36%), which cost replacements and spares for the policies that restore satellites; these shares are the least certain (standard errors of 19 and 7 points). The total shares of each objective sum to about 1 within their errors, so the parameters hardly interact." + ] + }, + { + "cell_type": "markdown", + "id": "8c914460", + "metadata": {}, + "source": [ + "The order of designs on the front is settled by their differences, in which the parameters that act alike on two designs cancel (with common random numbers, the designs of a replicate share its parameters). `differences` attributes the variance of the differences between pairs of designs, from the same evaluations: here, between the designs and policies adjacent along the front, by cost at 70% confidence:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "9226eca9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", + " \n", + " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", "
accurate meanaccurate mean p10cost p70accurate mean seaccurate mean p10 secost p70 se
parameter
2b499d154a98800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...produce81.273.8326.4points_seed92.130.40.06.44.50.0
a37619256b26800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...produce83.078.7340.0failure_seed2.973.0105.80.56.54.7
cost_growth0.00.00.00.00.00.0
\n", "
" ], "text/plain": [ - " description \\\n", - "design \n", - "2a310c00151b 800 km, 60 deg FOR, SSO: 1 at 12:00 \n", - "bc2076a0d3d8 800 km, 60 deg FOR, SSO: 2 at 06:00 \n", - "bb6574900ac3 800 km, 60 deg FOR, SSO: 1 at 12:00 \n", - "638697713902 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... \n", - "43f50c8bc38a 800 km, 60 deg FOR, SSO: 2 at 06:00 \n", - "ad99c42082ab 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", - "cc2e14e787ff 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", - "eeb7c70a720b 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 \n", - "3a902b976460 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", - "6d54bdbf4648 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 \n", - "1afde0569e34 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 \n", - "e7721a705c31 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 \n", - "46932f795a5a 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", - "6e4564d2ae2c 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", - "570a452fdb8f 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", - "2b499d154a98 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... \n", - "a37619256b26 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", + " accurate mean accurate mean p10 cost p70 accurate mean se \\\n", + "parameter \n", + "points_seed 92.1 30.4 0.0 6.4 \n", + "failure_seed 2.9 73.0 105.8 0.5 \n", + "cost_growth 0.0 0.0 0.0 0.0 \n", "\n", - " policy accurate accurate p10 cost p70 \n", - "design \n", - "2a310c00151b degrade 3.2 0.4 110.2 \n", - "bc2076a0d3d8 degrade 7.0 2.1 128.9 \n", - "bb6574900ac3 produce 3.9 3.5 130.6 \n", - "638697713902 degrade 10.9 4.6 146.2 \n", - "43f50c8bc38a produce 9.2 7.3 153.4 \n", - "ad99c42082ab produce 26.1 19.5 159.4 \n", - "cc2e14e787ff spare on ground 28.9 25.6 175.2 \n", - "eeb7c70a720b produce 47.3 38.5 198.1 \n", - "3a902b976460 degrade 64.2 38.9 209.5 \n", - "6d54bdbf4648 spare on ground 51.7 44.9 212.4 \n", - "1afde0569e34 produce 68.5 56.2 218.3 \n", - "e7721a705c31 spare on ground 72.5 62.2 235.4 \n", - "46932f795a5a degrade 79.5 69.0 253.5 \n", - "6e4564d2ae2c produce 78.0 70.1 278.8 \n", - "570a452fdb8f spare on ground 79.6 71.5 294.4 \n", - "2b499d154a98 produce 81.2 73.8 326.4 \n", - "a37619256b26 produce 83.0 78.7 340.0 " + " accurate mean p10 se cost p70 se \n", + "parameter \n", + "points_seed 4.5 0.0 \n", + "failure_seed 6.5 4.7 \n", + "cost_growth 0.0 0.0 " ] }, - "execution_count": 16, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# the efficient designs and policies, by their cost and their accuracy in the worst 10% of the replicates\n", - "efficient = traded[pareto_front(traded, {\"cost p70\": \"min\", \"accurate p10\": \"max\"})]\n", - "efficient.assign(description=[describe(values.loc[key]) for key in efficient.base]).sort_values(\"cost p70\")[\n", - " [\"description\", \"policy\", \"accurate\", \"accurate p10\", \"cost p70\"]\n", - "].round(1)" + "# the shares (%) of the variance of the differences between the efficient designs and policies adjacent along the\n", + "# front (by cost), from the same evaluations\n", + "ordered = efficient.sort_values(\"cost p70\").index\n", + "attribution.differences(list(zip(ordered, ordered[1:]))).summary().mul(100).round(1)" ] }, { "cell_type": "markdown", - "id": "c9d0e1f2", + "id": "cfdd26c3", "metadata": {}, "source": [ - "The front of cost at 70% confidence against the share accurately sampled in the worst 10% of the histories chooses designs and policies together. Along it, degrading is the cheapest policy of a design and restoring buys robustness: two satellites in two Walker planes keep 20% of the points accurately sampled in their worst histories if they produce replacements (159 million) and 26% with a spare on the ground (175 million); six satellites in three Walker planes keep 39%, 70%, and 72% if they degrade, produce replacements, or keep a spare on the ground, for 210, 279, and 294 million. Nine satellites in three planes degrade gracefully (69% in their worst histories for 254 million), and producing replacements raises them to 79% for 340 million. A spare on the ground is efficient for designs of two to six satellites, but a spare in orbit is not efficient for any design here, as it delays the deployment. The policy that a design deserves depends on the design, which is why the policy is a decision of the design rather than of the study." + "The growth of the cost of development cancels in every difference: all of these designs fly the same imager, whose development grows alike, so that it is a risk of each mission but not a reason to prefer one of them to another, and the failures alone unsettle the order of their costs (all of the variance of the differences, 106 ± 5%). The shares accurately sampled differ by the parameters that spread them: by the sample of points for the means (92%), and mostly by the histories for the worst 10% (73%, and 30% by the points). More points would settle the order of neighbors by their means, and more histories their order by the worst 10% and by cost." ] }, { @@ -3679,14 +4300,14 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 21, "id": "c2d3e4f5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T18:31:12.133600Z", - "iopub.status.busy": "2026-11-11T18:31:12.133359Z", - "iopub.status.idle": "2026-11-11T18:31:13.861367Z", - "shell.execute_reply": "2026-11-11T18:31:13.860657Z" + "iopub.execute_input": "2026-11-11T23:53:28.454498Z", + "iopub.status.busy": "2026-11-11T23:53:28.454498Z", + "iopub.status.idle": "2026-11-11T23:53:29.777578Z", + "shell.execute_reply": "2026-11-11T23:53:29.777578Z" } }, "outputs": [ @@ -3928,25 +4549,22 @@ "961 0.6 " ] }, - "execution_count": 17, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "BUDGET = 150 # millions of dollars, at 70% confidence\n", - "COST_STATISTICS = {\"cost p70\": Quantile(\"cost\", 0.7)}\n", - "COST_OBJECTIVES = {\"cost p70\": \"min\", \"sufficient\": \"max\"}\n", - "ELEMENTS = [\"cost development\", \"cost production\", \"cost launch\", \"cost operations\"]\n", - "\n", - "costed = pareto_probability(\n", - " refinement.results,\n", - " COST_OBJECTIVES,\n", - " n_resamples=1000,\n", - " statistics=COST_STATISTICS,\n", + "COST = Criteria(\n", + " {\"cost p70\": \"min\", \"sufficient\": \"max\"},\n", + " statistics={\"cost p70\": Quantile(\"cost\", 0.7)},\n", " requirements=[Requirement(\"cost p70\", \"<=\", BUDGET)],\n", " tolerance=TOLERANCE,\n", ")\n", + "ELEMENTS = [\"cost development\", \"cost production\", \"cost launch\", \"cost operations\"]\n", + "\n", + "costed = pareto_probability(refinement.results, COST, n_resamples=1000)\n", "DATED = [\"cost present\", \"cost peak annual\"]\n", "elements = aggregate(refinement.results, [*ELEMENTS, *DATED]).set_index(\"design\")[[*ELEMENTS, *DATED]]\n", "costed = costed.join(values[[\"satellites\", \"planes\"]], on=\"design\").join(elements, on=\"design\")\n", @@ -3978,6 +4596,257 @@ "The growth of the cost of development affects every design alike in a replicate (common random numbers), so it shifts the costs at 70% confidence more for designs whose development costs more, here those of the wider imager. With five replicates of most designs, the 0.7 quantile of their costs is a coarse estimate: an evaluation that costs little more than the cost model (unlike the analysis of sampling) could draw more replicates of the cost alone." ] }, + { + "cell_type": "markdown", + "id": "8f0b0487", + "metadata": {}, + "source": [ + "## Trade Utility Against Cost\n", + "\n", + "Sufficiency and accuracy are objectives above, each in its own units. A stakeholder who values both weighs them, and a utility makes the weights explicit (`Utility`): a single-attribute utility of each metric, from 0 at its worst acceptable value to 1 at its best (here, linear in the share of points sampled sufficiently, `LinearUtility`, and concave in the share sampled accurately, `ExponentialUtility`, as the first points accurately sampled matter most), combined by weights. Two stakeholders weigh the shares differently: one mostly sufficiency (0.7 against 0.3), as a center that counts samples for forecasts might, and the other mostly accuracy (0.3 against 0.7), as one that estimates daily means might. Each design's utility is that of its means: the shares vary between replicates mostly as noise of the sample of points, which the expected utility (the mean of the utility of each replicate, `Mean(utility)`) would penalize as if it were a risk. The figure plots each stakeholder's utility of every design against its cost at 70% confidence (as above), with the front of each ringed:" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "d4a1007a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from tatc.tradespace import ExponentialUtility, LinearUtility, Utility\n", + "\n", + "# the utility of the shares sampled sufficiently (linear) and accurately (concave: the first points matter most), for\n", + "# two stakeholders who weigh them differently\n", + "CURVES = {\"sufficient\": LinearUtility(0, 100), \"accurate\": ExponentialUtility(0, 100, risk=2)}\n", + "STAKEHOLDERS = {\n", + " \"sufficiency\": Utility(CURVES, weights={\"sufficient\": 0.7, \"accurate\": 0.3}),\n", + " \"accuracy\": Utility(CURVES, weights={\"sufficient\": 0.3, \"accurate\": 0.7}),\n", + "}\n", + "means = aggregate(\n", + " refinement.results, {\"sufficient\": \"sufficient\", \"accurate\": \"accurate\", \"cost p70\": Quantile(\"cost\", 0.7)}\n", + ").set_index(\"design\")\n", + "means[\"description\"] = [describe(values.loc[key]) for key in means.index]\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(11, 4.5), sharey=True)\n", + "judged = {}\n", + "for ax, (name, utility) in zip(axes, STAKEHOLDERS.items()):\n", + " judged[name] = means.assign(utility=utility(means))\n", + " judged[name][\"pareto\"] = pareto_front(judged[name], {\"utility\": \"max\", \"cost p70\": \"min\"})\n", + " legend = \"lower right\" if ax is axes[0] else None\n", + " plot_designs(judged[name], \"cost p70\", \"utility\", by=\"planes\", front=\"pareto\", names=planes_name, legend=legend, ax=ax)\n", + " ax.axvline(BUDGET, color=GRAY, lw=1, ls=\"--\")\n", + " ax.set(xlabel=\"Cost at 70% confidence (millions of dollars)\", ylabel=\"Utility\", ylim=(0, 1.02))\n", + " ax.set_title(f\"Weighing {name} most\", fontsize=10)\n", + " style_axes(ax, grid=\"both\")\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "0e08a178", + "metadata": {}, + "source": [ + "The stakeholders' fronts share most of their designs. Those efficient for one stakeholder and not the other:" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "8c84cbf4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "20 designs are efficient for both\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanessufficientaccuratecost p70utility (sufficiency)efficient (sufficiency)utility (accuracy)efficient (accuracy)
design
828c0027d01f800 km, 60 deg FOR, SSO: 1 at 12:00, 2 at 18:003229.257.0156.650.44False0.64True
c576e2e2dbd1800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:003228.860.6156.900.45False0.66True
6ba50f2632cd800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4269.665.4173.730.74True0.80False
3690f1194419800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:004257.685.4173.730.69False0.84True
64cf6542c326800 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...6390.295.8213.530.93False0.96True
\n", + "
" + ], + "text/plain": [ + " description satellites \\\n", + "design \n", + "828c0027d01f 800 km, 60 deg FOR, SSO: 1 at 12:00, 2 at 18:00 3 \n", + "c576e2e2dbd1 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3 \n", + "6ba50f2632cd 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4 \n", + "3690f1194419 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4 \n", + "64cf6542c326 800 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... 6 \n", + "\n", + " planes sufficient accurate cost p70 utility (sufficiency) \\\n", + "design \n", + "828c0027d01f 2 29.2 57.0 156.65 0.44 \n", + "c576e2e2dbd1 2 28.8 60.6 156.90 0.45 \n", + "6ba50f2632cd 2 69.6 65.4 173.73 0.74 \n", + "3690f1194419 2 57.6 85.4 173.73 0.69 \n", + "64cf6542c326 3 90.2 95.8 213.53 0.93 \n", + "\n", + " efficient (sufficiency) utility (accuracy) \\\n", + "design \n", + "828c0027d01f False 0.64 \n", + "c576e2e2dbd1 False 0.66 \n", + "6ba50f2632cd True 0.80 \n", + "3690f1194419 False 0.84 \n", + "64cf6542c326 False 0.96 \n", + "\n", + " efficient (accuracy) \n", + "design \n", + "828c0027d01f True \n", + "c576e2e2dbd1 True \n", + "6ba50f2632cd False \n", + "3690f1194419 True \n", + "64cf6542c326 True " + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# the designs efficient for one stakeholder and not the other\n", + "compared = means[[\"description\", \"satellites\", \"planes\", \"sufficient\", \"accurate\", \"cost p70\"]].copy()\n", + "for name in STAKEHOLDERS:\n", + " compared[f\"utility ({name})\"] = judged[name][\"utility\"]\n", + " compared[f\"efficient ({name})\"] = judged[name][\"pareto\"]\n", + "print(f\"{(compared['efficient (sufficiency)'] & compared['efficient (accuracy)']).sum()} designs are efficient for both\")\n", + "compared[compared[\"efficient (sufficiency)\"] != compared[\"efficient (accuracy)\"]].sort_values(\"cost p70\").round(2)" + ] + }, + { + "cell_type": "markdown", + "id": "6579b63a", + "metadata": {}, + "source": [ + "Within the budget, the stakeholders agree: every design efficient for either of them up to 150 million dollars is efficient for both, as more satellites in more planes buy both shares. Beyond the budget, they part. For 174 million dollars at 70% confidence, the stakeholder of sufficiency prefers four satellites in two Walker planes (70% of the points sufficiently sampled and 65% accurately), and the stakeholder of accuracy four in two sun-synchronous planes crossing at 09:00 and 15:00 (58% and 85%), whose planes spread the samples over the day. The stakeholder of accuracy also finds three satellites in two sun-synchronous planes efficient for 157 million (57 to 61% accurately sampled), and six in three Walker planes for 214 million (96%), which the stakeholder of sufficiency passes over. A utility is a metric of any statistic (such as `Quantile(utility, 0.1)`, the utility that a design exceeds in 90% of the replicates, for risks that the replicates draw) and so an objective of the searches as well; a multiplicative utility (`form=\"multiplicative\"`) makes the shares complements, both of which a design must serve, or substitutes, either of which suffices." + ] + }, { "cell_type": "markdown", "id": "e4f5a6b7", @@ -3992,14 +4861,14 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 24, "id": "f5a6b7c8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T18:31:13.863068Z", - "iopub.status.busy": "2026-11-11T18:31:13.862822Z", - "iopub.status.idle": "2026-11-11T18:31:14.085781Z", - "shell.execute_reply": "2026-11-11T18:31:14.085149Z" + "iopub.execute_input": "2026-11-11T23:53:29.777578Z", + "iopub.status.busy": "2026-11-11T23:53:29.777578Z", + "iopub.status.idle": "2026-11-11T23:53:30.505473Z", + "shell.execute_reply": "2026-11-11T23:53:30.505473Z" } }, "outputs": [ @@ -4159,7 +5028,7 @@ "6bef11e40977 4.5 " ] }, - "execution_count": 18, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -4185,6 +5054,392 @@ "Deployment costs the designs of several planes or launches. Six satellites in two planes sample 98% of the points once deployed, but 87% on average over the mission, as the first plane flies alone for three quarters of a year while the second is produced, and they sample half of the points only 4.5 years after development starts, when the second plane is launched. Four satellites in one plane need two launches (of up to three satellites) half a year apart, and lose 5 points of their 68%; four satellites in two planes lose 5 points of their 70%, and two satellites in two planes 3 points of their 30%. The designs launched at once lose nothing. Over a five-year mission, the loss is the share of the mission before full deployment times the shortfall of the partial constellation: a shorter mission, slower production, or fewer launches a year would weigh deployment more, and could reorder the front." ] }, + { + "cell_type": "markdown", + "id": "6613f6b0", + "metadata": {}, + "source": [ + "Each phase is evaluated over the same day of July, as if the geometry of the satellites and the season were those of that day throughout the mission (quasi-static phases, see `evaluate_phases`). This misses the drift of the relative nodes of planes of different inclinations or altitudes (which precess at different rates), the drift of the local times of planes that are not sun-synchronous, and seasons. Here, the planes of each design share an altitude and an inclination, which keeps their relative geometry, and the shares do not depend on the sun, so the day should represent the mission. Drawing the start of the day for each replicate over a year (the `epoch` of the design space, which `Observations` and the metrics read, as an `Uncertain` parameter) averages the replicates over the drift and the seasons, at the cost of analyzing the satellites again for each day:" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "51ea3119", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanessufficient mean (July)accurate mean (July)sufficient mean (year)accurate mean (year)sufficient mean sem (year)accurate mean sem (year)
design
163120bf9590800 km, 60 deg FOR, SSO: 1 at 18:001.01.03.22.83.23.00.70.6
f7413b1f8466800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...2.01.016.64.016.22.01.00.7
33b006848799800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.027.330.925.828.81.61.6
d5d3fa915ca7800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...3.01.038.011.437.89.80.50.7
1af5f2707be3800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.063.524.561.722.51.80.8
6ba50f2632cd800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.064.359.362.158.01.51.3
6bef11e40977800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.087.171.186.770.30.20.8
\n", + "
" + ], + "text/plain": [ + " description satellites \\\n", + "design \n", + "163120bf9590 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 \n", + "f7413b1f8466 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 \n", + "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 \n", + "d5d3fa915ca7 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 \n", + "1af5f2707be3 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 \n", + "6ba50f2632cd 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 \n", + "6bef11e40977 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 \n", + "\n", + " planes sufficient mean (July) accurate mean (July) \\\n", + "design \n", + "163120bf9590 1.0 3.2 2.8 \n", + "f7413b1f8466 1.0 16.6 4.0 \n", + "33b006848799 2.0 27.3 30.9 \n", + "d5d3fa915ca7 1.0 38.0 11.4 \n", + "1af5f2707be3 1.0 63.5 24.5 \n", + "6ba50f2632cd 2.0 64.3 59.3 \n", + "6bef11e40977 2.0 87.1 71.1 \n", + "\n", + " sufficient mean (year) accurate mean (year) \\\n", + "design \n", + "163120bf9590 3.2 3.0 \n", + "f7413b1f8466 16.2 2.0 \n", + "33b006848799 25.8 28.8 \n", + "d5d3fa915ca7 37.8 9.8 \n", + "1af5f2707be3 61.7 22.5 \n", + "6ba50f2632cd 62.1 58.0 \n", + "6bef11e40977 86.7 70.3 \n", + "\n", + " sufficient mean sem (year) accurate mean sem (year) \n", + "design \n", + "163120bf9590 0.7 0.6 \n", + "f7413b1f8466 1.0 0.7 \n", + "33b006848799 1.6 1.6 \n", + "d5d3fa915ca7 0.5 0.7 \n", + "1af5f2707be3 1.8 0.8 \n", + "6ba50f2632cd 1.5 1.3 \n", + "6bef11e40977 0.2 0.8 " + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# the leading designs, with the day of the analysis drawn for each replicate over a year\n", + "EPOCH = Uncertain(lambda rng: START + timedelta(days=float(rng.uniform(0, 365))))\n", + "epoch_space = DesignSpace(**{**space.children, \"epoch\": EPOCH}, constraints=space.constraints)\n", + "year = make_study(phased=True, design_space=epoch_space, label=\"over a year\").run(\n", + " [epoch_space.design(by_key[key].decisions) for key in leaders.index]\n", + ")\n", + "MEANS = [\"sufficient mean\", \"accurate mean\"]\n", + "over_year = summarize(year, MEANS, design_columns=[]).set_index(\"design\")\n", + "july = aggregate(phased, MEANS).set_index(\"design\")[MEANS]\n", + "leaders[[\"description\", \"satellites\", \"planes\"]].join(july.add_suffix(\" (July)\")).join(\n", + " over_year[[*MEANS, *(f\"{m} sem\" for m in MEANS)]].add_suffix(\" (year)\")\n", + ").sort_values([\"satellites\", \"planes\"]).round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "5e6d3a10", + "metadata": {}, + "source": [ + "Over the year, the means of the leading designs are within 2.2 points of those of the day in July (and within three standard errors of the year's means), most a little lower: the one day represents the mission well here. A constellation of planes at different altitudes or inclinations, metrics that depend on daylight, or a field that varies with the seasons would call for drawing the epoch. The phases also assume that a satellite operates until it fails or is replaced: a design life does not retire a satellite whose replacement is not launched, and a planned replacement whose launch fails is not flown again (see `DeploymentSchedule`)." + ] + }, + { + "cell_type": "markdown", + "id": "27539bda", + "metadata": {}, + "source": [ + "## Stage the Deployment\n", + "\n", + "A deployment need not commit to every plane at once. A stage of a deployment (`Stage`) is a set of planes produced and launched only if a rule decides to, at times during the mission, from what it knows then (a `Decision`: the satellites operating and the history so far) and from the values of the design, such as its uncertain parameters and its scenario. A stage that is not deployed is neither produced, launched, nor paid for, so that a staged deployment is an option: it saves the cost of a stage where the mission does not need it, and loses what deferring the stage costs where it does (as above, the capability of the satellites not yet launched). Whether and how to stage is a decision of each design (here, a value `staging` of the design space), and the `stages` of a `MissionPlan` are a function of the design.\n", + "\n", + "Here, the robust design of four satellites across the fields of the scenarios above (two sun-synchronous planes of two) deploys its second plane at once, never, or only if the field turns out to vary within hours (to decorrelate within 6 hours), as decided at the first launch or a year later. Each staging is evaluated in each field by the phases of its deployment: the mean share of points accurately sampled over the mission, and the present cost:" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "8cbfe502", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
accurate meancost present
scenario1 hour3 hours12 hours1 hour3 hours12 hours
staging
at once62.677.991.0156.4156.4156.4
first plane4.810.073.0118.8118.8118.8
decided at launch62.677.973.0156.4156.4118.8
decided a year later49.762.873.0154.5154.5118.8
\n", + "
" + ], + "text/plain": [ + " accurate mean cost present \\\n", + "scenario 1 hour 3 hours 12 hours 1 hour 3 hours \n", + "staging \n", + "at once 62.6 77.9 91.0 156.4 156.4 \n", + "first plane 4.8 10.0 73.0 118.8 118.8 \n", + "decided at launch 62.6 77.9 73.0 156.4 156.4 \n", + "decided a year later 49.7 62.8 73.0 154.5 154.5 \n", + "\n", + " \n", + "scenario 12 hours \n", + "staging \n", + "at once 156.4 \n", + "first plane 118.8 \n", + "decided at launch 118.8 \n", + "decided a year later 118.8 " + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import dataclasses\n", + "\n", + "from tatc.tradespace import Stage\n", + "\n", + "STAGING = [\"at once\", \"first plane\", \"decided at launch\", \"decided a year later\"]\n", + "staging_space = DesignSpace(**space.children, staging=Categorical(STAGING), constraints=space.constraints)\n", + "\n", + "\n", + "def stages(d):\n", + " \"\"\"The stages of a design's deployment: its second plane deployed with the first (at once), never (first plane),\n", + " or if the field decorrelates within 6 hours, as decided at the first launch or a year later.\"\"\"\n", + " if d.staging == \"at once\":\n", + " return []\n", + " if d.staging == \"first plane\":\n", + " return [Stage(1, 0.0, lambda decision: False)]\n", + " when = 0.0 if d.staging == \"decided at launch\" else 1.0\n", + " return [Stage(1, when, lambda decision: d.decorrelation_time < timedelta(hours=6))]\n", + "\n", + "\n", + "# the robust design of four satellites across the fields, with each staging of its deployment, in each field\n", + "four = by_key[robust_design[4]]\n", + "staged = make_study(\n", + " phased=True,\n", + " scenarios=FIELDS,\n", + " design_space=staging_space,\n", + " plan=dataclasses.replace(PLAN, stages=stages),\n", + " label=\"staged\",\n", + ").run([staging_space.design({**four.decisions, \"staging\": option}) for option in STAGING])\n", + "staged.groupby([\"staging\", \"scenario\"], sort=False)[[\"accurate mean\", \"cost present\"]].mean().unstack(\"scenario\").round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "34aa9033", + "metadata": {}, + "source": [ + "Deciding at the first launch is worth the most. Where the field varies within hours, the second plane is produced and launched as if it were deployed at once (63% and 78% of the points accurately sampled on average over the mission, for 156 million dollars), and where it varies slowly, it is not, which saves 38 million dollars (24%) for 18 points of the mean (73% against 91%): a trade that the rule makes, and that a mission might not. Deciding a year later costs the fields that need the second plane 13 to 15 points of the mean (50% and 63%), as the first plane flies alone for a year more, and saves only 2 million dollars, by discounting the later production. The value of the option is that of knowing the need when it is exercised: the earlier the field is known, the more staging saves at less loss. A rule may decide on anything known by then, such as the satellites still operating (see `Decision`), for a reserve plane launched only if satellites fail." + ] + }, { "cell_type": "markdown", "id": "c5d4e7f6", @@ -4194,19 +5449,19 @@ "\n", "Evaluating every design is affordable here, but not for larger spaces or longer analyses. `screen` evaluates every design with a cheap study, keeps the best (whole fronts, until it keeps at least `keep` of them), and evaluates only those with the full study. A cheap study ranks designs less exactly, so a `tolerance` of an objective keeps designs that are within it of the front of the cheap study.\n", "\n", - "The cheap study must rank designs as the full study would. Here, the screening study analyzes one replicate, rather than five, over a shorter period, with the threshold of sufficient sampling scaled to the period: 12 hours with two observations, or 6 hours with one. The table compares each screening's front with the true front (how many of its efficient designs it keeps, and its hypervolume), and its cost with that of evaluating every design." + "The cheap study must rank designs as the full study would. Here, the screening study analyzes one replicate, rather than five, over a shorter period, with the threshold of sufficient sampling scaled to the period: 12 hours with two observations, or 6 hours with one. The table compares each screening's front with the true front (how many of its efficient designs it keeps, and its hypervolume), and its cost (the satellites analyzed times the days of their analyses) with that of evaluating every design." ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 27, "id": "d6e5f8a7", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T18:31:14.087444Z", - "iopub.status.busy": "2026-11-11T18:31:14.087223Z", - "iopub.status.idle": "2026-11-11T18:31:26.158358Z", - "shell.execute_reply": "2026-11-11T18:31:26.157668Z" + "iopub.execute_input": "2026-11-11T23:53:30.505473Z", + "iopub.status.busy": "2026-11-11T23:53:30.505473Z", + "iopub.status.idle": "2026-11-11T23:54:06.880457Z", + "shell.execute_reply": "2026-11-11T23:54:06.880457Z" } }, "outputs": [ @@ -4305,7 +5560,7 @@ "3 25.1 " ] }, - "execution_count": 19, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -4313,7 +5568,7 @@ "source": [ "from tatc.tradespace import screen\n", "\n", - "full_cost = results.satellite_days.sum()\n", + "full_cost = results.satellites.sum() * DURATION / timedelta(days=1) # satellite-days of analysis\n", "true_front = set(summary.design[summary.pareto])\n", "screenings = []\n", "for hours, keep, tolerance in [(12, 0.05, None), (12, 0.1, 5.0), (6, 0.05, None), (6, 0.2, None)]:\n", @@ -4324,6 +5579,8 @@ " keep=keep,\n", " tolerance=None if tolerance is None else {\"sufficient\": tolerance},\n", " )\n", + " # the satellite-days of the analyses of each stage\n", + " days = screening.results.stage.map({0: hours / 24, 1: DURATION / timedelta(days=1)})\n", " screenings.append(\n", " {\n", " \"screening study\": f\"{hours} h, 1 replicate\",\n", @@ -4332,7 +5589,7 @@ " \"designs kept\": len(screening.designs),\n", " \"efficient designs kept\": f\"{len(true_front & {d.key for d in screening.designs})} of {len(true_front)}\",\n", " \"hypervolume (% of true front)\": 100 * hypervolume(screening.final, OBJECTIVES, REFERENCE) / exact_hypervolume,\n", - " \"cost (% of every design)\": 100 * screening.results.satellite_days.sum() / full_cost,\n", + " \"cost (% of every design)\": 100 * (screening.results.satellites * days).sum() / full_cost,\n", " }\n", " )\n", "pd.DataFrame(screenings).round(1)" @@ -4355,21 +5612,21 @@ "source": [ "## Search with Optimizers\n", "\n", - "Larger design spaces cannot be enumerated or even screened, and an optimizer searches them for efficient designs instead. `optimize_optuna` suggests designs with Optuna's trials, which search the hierarchical design space directly (`DesignSpace.suggest`), and records the violation of the constraint of each infeasible design, which Optuna's samplers use to prefer feasible designs. `optimize_pymoo` searches the unit hypercube that encodes the design space (`DesignSpace.decode`) with a pymoo algorithm. Both evaluate each design once, however often it is proposed, and evaluate the designs proposed together in parallel.\n", + "Larger design spaces cannot be enumerated or even screened, and an optimizer searches them for efficient designs instead. `optimize_optuna` suggests designs with Optuna's trials, which search the hierarchical design space directly (`DesignSpace.suggest`), and records the violation of the constraint of each infeasible design, which Optuna's samplers use to prefer feasible designs. `optimize_pymoo` searches the unit hypercube that encodes the design space (`DesignSpace.decode`) with a pymoo algorithm, which eliminates the proposals of designs proposed or evaluated before: many points of the hypercube decode to the same design (those in the same level of each variable, or that differ only in the variables of a branch not chosen), which pymoo's own elimination of equal points does not see. Both evaluate each design once, however often it is proposed, and evaluate the designs proposed together in parallel. A search chooses its front from one evaluation of each design, which favors designs whose replicates were lucky: its designs and results (a `Search`) are refined and confirmed as above.\n", "\n", "Each search below is given a budget of about 200 proposals, and is compared with a Latin hypercube sample of 200 designs (`DesignSpace.sample`). The designs evaluated (and the analyses of their satellites) are those of the evaluation of every design above, so they are retrieved from the cache." ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 28, "id": "a9b8c1d0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T18:31:26.160062Z", - "iopub.status.busy": "2026-11-11T18:31:26.159842Z", - "iopub.status.idle": "2026-11-11T18:31:27.178938Z", - "shell.execute_reply": "2026-11-11T18:31:27.178266Z" + "iopub.execute_input": "2026-11-11T23:54:06.880457Z", + "iopub.status.busy": "2026-11-11T23:54:06.880457Z", + "iopub.status.idle": "2026-11-11T23:54:08.116915Z", + "shell.execute_reply": "2026-11-11T23:54:08.116915Z" } }, "outputs": [ @@ -4406,8 +5663,8 @@ " \n", " \n", " pymoo (NSGA-II)\n", - " 81.0\n", - " 84.3\n", + " 166.0\n", + " 100.0\n", " \n", " \n", " Latin hypercube sample\n", @@ -4421,11 +5678,11 @@ "text/plain": [ " designs evaluated hypervolume (% of true front)\n", "Optuna (NSGA-II) 143.0 92.1\n", - "pymoo (NSGA-II) 81.0 84.3\n", + "pymoo (NSGA-II) 166.0 100.0\n", "Latin hypercube sample 176.0 79.3" ] }, - "execution_count": 20, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -4434,35 +5691,29 @@ "import optuna\n", "from pymoo.algorithms.moo.nsga2 import NSGA2\n", "\n", - "from tatc.tradespace import optimize_optuna, optimize_pymoo\n", + "from tatc.tradespace import hypervolume_progress, optimize_optuna, optimize_pymoo\n", "\n", "optuna.logging.set_verbosity(optuna.logging.WARNING)\n", "BUDGET = 200\n", "study = make_study()\n", "searches = {}\n", - "_, searches[\"Optuna (NSGA-II)\"] = optimize_optuna(\n", + "searches[\"Optuna (NSGA-II)\"] = optimize_optuna(\n", " study,\n", " OBJECTIVES,\n", " n_trials=BUDGET,\n", " sampler=optuna.samplers.NSGAIISampler(population_size=20, seed=1),\n", " batch_size=20,\n", - ")\n", - "_, searches[\"pymoo (NSGA-II)\"] = optimize_pymoo(study, OBJECTIVES, NSGA2(pop_size=20), (\"n_gen\", BUDGET // 20), seed=1)\n", + ").results\n", + "searches[\"pymoo (NSGA-II)\"] = optimize_pymoo(\n", + " study, OBJECTIVES, NSGA2(pop_size=20), (\"n_gen\", BUDGET // 20), seed=1\n", + ").results\n", "searches[\"Latin hypercube sample\"] = study.run(space.sample(BUDGET, method=\"lhs\", seed=1))\n", "\n", - "\n", - "def get_progress(search_results):\n", - " \"\"\"The hypervolume (% of the true front's) of the designs evaluated, as designs are evaluated.\"\"\"\n", - " means = summarize(search_results, list(OBJECTIVES), design_columns=[]).set_index(\"design\")\n", - " order = search_results.design.drop_duplicates()\n", - " counts = np.arange(10, len(order) + 1, 10)\n", - " return pd.Series(\n", - " [100 * hypervolume(means.reindex(order[:n]).dropna(), OBJECTIVES, REFERENCE) / exact_hypervolume for n in counts],\n", - " index=counts,\n", - " )\n", - "\n", - "\n", - "progress = {name: get_progress(search_results) for name, search_results in searches.items()}\n", + "# the hypervolume (% of the true front's) of the designs evaluated, as designs are evaluated\n", + "progress = {\n", + " name: 100 * hypervolume_progress(search_results, OBJECTIVES, REFERENCE) / exact_hypervolume\n", + " for name, search_results in searches.items()\n", + "}\n", "pd.DataFrame(\n", " {\n", " name: {\n", @@ -4476,20 +5727,20 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 29, "id": "b0c9d2e1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T18:31:27.180650Z", - "iopub.status.busy": "2026-11-11T18:31:27.180366Z", - "iopub.status.idle": "2026-11-11T18:31:27.307537Z", - "shell.execute_reply": "2026-11-11T18:31:27.306838Z" + "iopub.execute_input": "2026-11-11T23:54:08.116915Z", + "iopub.status.busy": "2026-11-11T23:54:08.116915Z", + "iopub.status.idle": "2026-11-11T23:54:08.211848Z", + "shell.execute_reply": "2026-11-11T23:54:08.211848Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -4499,20 +5750,14 @@ } ], "source": [ - "fig, ax = plt.subplots(figsize=(9, 4.2))\n", - "for (name, series), color in zip(progress.items(), (BLUE, ORANGE, AQUA)):\n", - " ax.plot(series.index, series.values, color=color, lw=2, label=name)\n", - " ax.annotate(name, (series.index[-1], series.values[-1]), xytext=(6, 0), textcoords=\"offset points\", va=\"center\", fontsize=8, color=INK)\n", + "from tatc.tradespace import plot_progress\n", + "\n", + "ax = plot_progress(progress)\n", "ax.axhline(100, color=GRAY, lw=1, ls=\"--\")\n", "ax.annotate(\"true front\", (0, 100), xytext=(2, 4), textcoords=\"offset points\", fontsize=8, color=GRAY)\n", - "ax.set(xlabel=\"Designs evaluated\", ylabel=\"Hypervolume (% of true front)\", xlim=(0, None))\n", - "ax.grid(axis=\"y\", color=\"#e6e6e3\", lw=0.8)\n", - "ax.set_axisbelow(True)\n", - "for side in (\"top\", \"right\"):\n", - " ax.spines[side].set_visible(False)\n", - "ax.legend(loc=\"lower right\", fontsize=8, frameon=False)\n", + "ax.set(ylabel=\"Hypervolume (% of true front)\")\n", "ax.set_title(\"Progress of the searches\", fontsize=10)\n", - "fig.tight_layout()\n", + "ax.figure.tight_layout()\n", "plt.show()" ] }, @@ -4521,7 +5766,7 @@ "id": "c1d0e3f2", "metadata": {}, "source": [ - "Both optimizers find more of the hypervolume than a Latin hypercube sample of as many designs. Optuna (NSGA-II, searching the hierarchical space directly) finds 92% of the hypervolume of the true front with 143 designs, 13% of the space. pymoo (NSGA-II, searching the encoded space) finds 84% with 81 designs: its 200 proposals include many that encode the same design or that violate the constraints, which are not evaluated. The sample finds 79% with 176 designs. The searches stop at their budget of proposals, not at convergence: a larger budget, or screening, would bring them closer to the true front. Their results also depend on their seeds, so compare several seeds before relying on one." + "Both optimizers find more of the hypervolume than a Latin hypercube sample of as many designs. Optuna (NSGA-II, searching the hierarchical space directly) finds 92% of the hypervolume of the true front with 143 designs, 13% of the space. pymoo (NSGA-II, searching the encoded space) finds all of it with 166 designs: it proposes no design twice, and its other 34 proposals violate the constraint on the number of satellites (without eliminating duplicates by design, its 200 proposals encoded only 75 designs, which found 88%). The sample finds 79% with 176 designs. The searches stop at their budget of proposals, not at convergence: a larger budget, or screening, would bring Optuna's closer to the true front. Their results also depend on their seeds (over eight seeds, pymoo's search finds 88 to 100% of the hypervolume, 96.5% on average), so compare several seeds before relying on one." ] }, { @@ -4532,14 +5777,18 @@ "## Summary\n", "\n", "* A `DesignSpace` declares a hierarchical trade space, with choices between alternatives (`Choice`), repeated elements such as orbit planes (`Repeat`), bounds that depend on other variables, constraints that measure their violation, and uncertain parameters (`Uncertain`) drawn for each replicate. Building blocks declare common constellation layouts (`walker_space` and `sso_planes_space`) and build their satellites with instruments or entries of the instrument catalog (`build_constellation`).\n", - "* A `Study` evaluates designs in replicates (here, of points of a randomly oriented lattice, `generate_points_rotated_lattice`, which vary less between replicates than random points), in parallel, with a `SatelliteCache` that analyzes each distinct satellite once and a `ResultStore` that keeps its evaluations (by the fingerprint of the study, so that a changed study evaluates its designs again). Every design of a space of about a thousand designs can be evaluated in minutes.\n", + "* An `ObservationStudy` (a `Study` of the observations of `Targets`, with a `MissionPlan` of deployment and costs, and `Failures`) evaluates designs in replicates (here, of points of a randomly oriented lattice, `generate_points_rotated_lattice`, which vary less between replicates than random points), in parallel, with a cache of `Observations` that analyzes each distinct satellite once and a `ResultStore` that keeps its evaluations (by the fingerprint of the study, which describes its targets and the code of TAT-C it uses, so that a changed study evaluates its designs again, and says why). Every design of a space of about a thousand designs can be evaluated in minutes.\n", "* Statistical sufficiency is measured by the sampling error of the statistic that observations estimate (`tatc.analysis.estimate_sampling_error`), which counts of samples overstate when samples cluster in time, as they do in a single plane; revisit statistics and local time coverage explain it.\n", "* The front of the means of the replicates is uncertain: `pareto_probability` finds the designs whose efficiency the replicates settle, and those that are equally good candidates, and `refine` adds replicates only to the latter, with a tolerance of differences that do not matter. `confirm` evaluates the selected designs with new replicates, which removes the optimism of selecting the best of many nearly equal designs.\n", - "* Statistics other than means (such as a `Quantile` or the `Probability` of meeting a threshold) state how reliably a design performs, and `Requirement`s on them are output constraints. Simulated missions (`Deployment.simulate`) draw the failures of satellites and launches from lives whose failure rates vary over the lifecycle (`FailureModel`), and restore them or not (`RestorationPolicy`, by spares in orbit or on the ground, or by producing new ones), for both the cost and the capability of each policy (exactly, without sampling, for missions that do not restore failed satellites: `expected_missions`); the policy is a decision of each design (`policy_space`, configured by `configure`), on the front with the design. `sensitivity` finds the design variables that drive each objective.\n", + "* Statistics other than means (such as a `Quantile` or the `Probability` of meeting a threshold) state how reliably a design performs, and `Requirement`s on them are output constraints. Simulated missions (`Deployment.simulate`) draw the failures of satellites and launches from lives whose failure rates vary over the lifecycle (`FailureModel`), and restore them or not (`RestorationPolicy`, by spares in orbit or on the ground, or by producing new ones), for both the cost and the capability of each policy (exactly, without sampling, for missions that do not restore failed satellites: `expected_missions`); the policy is a decision of each design (`policy_space`, configured by `configure`), on the front with the design. `sensitivity` finds the design variables that drive each objective, and `attribute_variance` the uncertain parameters that spread the replicates of each design (by drawing each again with the others held): here, the sample of points spreads the mean shares and the histories of failures their worst 10%, which says what would sharpen each, and the growth of costs spreads the costs of designs alike, so that it cancels in their differences (`Attribution.differences`) and does not change their order.\n", + "* The `scenarios` of a study compare designs under conditions rather than averaging over them (here, fields of different decorrelation times, a value of the design space): criteria `by` the scenario give the front of each, and `robustness` the share of the scenarios in which each design is efficient (its Pareto trace) and its regret in each, whose least maximum is a robust choice (here, six satellites efficient in no field but never half a point behind the best).\n", "* `screen` evaluates every design with a cheap study and the best with the full one, which finds the front at a fraction of the cost if the cheap study ranks designs as the full one does.\n", - "* A `DeploymentSchedule` plans each design's deployment from rates of production and launch, which dates its costs and divides its mission into phases of the satellites that fly, evaluated with the observations of the full constellation for the mean capability over the mission and the time until a requirement is met.\n", + "* A `Utility` weighs metrics by a stakeholder's preferences (a single-attribute utility of each, combined by weights) into one objective against cost, and is a metric of any statistic (its mean is the expected utility): here, stakeholders who weigh sufficiency or accuracy most agree within the budget and part beyond it.\n", + "* A `DeploymentSchedule` plans each design's deployment from rates of production and launch, which dates its costs and divides its mission into phases of the satellites that fly, evaluated with the observations of the full constellation (over one day, which an epoch drawn for each replicate shows to represent the mission here) for the mean capability over the mission and the time until a requirement is met.\n", + "* A `Stage` of a deployment is produced and launched only if a rule decides to, from what is known then (a `Decision`) and the values of the design: an option whose value the analyses of a study measure (here, deciding at the first launch whether the field needs a second plane saves 38 million dollars where it does not, at no loss where it does, and deciding a year later loses 13 to 15 points of the mean where it does).\n", "* A `CostModel` estimates the life-cycle cost of each deployment from the costs of its satellites, launches, and operations (given by the study), with uncertain growth whose quantiles give the cost at a confidence level, as an objective or a requirement in place of the numbers of satellites and planes.\n", - "* `optimize_optuna` and `optimize_pymoo` search spaces too large to enumerate, and find most of the front with a fraction of the designs.\n", + "* `optimize_optuna` and `optimize_pymoo` search spaces too large to enumerate, and find most of the front with a fraction of the designs (`hypervolume_progress`), pymoo's proposing no design twice (by design, not by point of the encoded space).\n", + "* `plot_designs` and `plot_progress` plot the designs, with the efficient ones ringed, and the progress of searches.\n", "\n", "The sampling error here is that of a model of the field (an exponential correlation in time with a decorrelation time of 3 hours); with a simulation of the field (a nature run), `tatc.analysis.sample_field` and `compare_sampled_means` measure it directly. The costs are illustrative, and the numbers of satellites and planes, proxies of cost in the other sections. The uncertainties are those of the sample of points and the failures of satellites; others (such as the phase of the satellites or the period of the analysis) are further `Uncertain` parameters of the design space." ] @@ -4561,7 +5810,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.14.9" + "version": "3.10.16" } }, "nbformat": 4, From f051666bea8d9c7a7c1094243f45b94bda302615 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Thu, 12 Nov 2026 09:12:22 -0700 Subject: [PATCH 30/52] size mission plans by the values of each design The schedule and cost model of a MissionPlan may be functions of the design, launches limited in mass take the masses of the cost model's satellites, and a launch mass capacity may be a function of each plane (also for the bookings of restorations). --- CHANGELOG.md | 1 + docs/api_reference/tradespace.rst | 4 +- src/tatc/tradespace/cost.py | 4 +- src/tatc/tradespace/deployment.py | 49 ++++++++++++-- src/tatc/tradespace/mission.py | 22 ++++-- src/tatc/tradespace/observations.py | 98 ++++++++++++++++++++++++--- tests/tradespace/test_deployment.py | 34 ++++++++++ tests/tradespace/test_observations.py | 42 ++++++++++++ 8 files changed, 225 insertions(+), 29 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 9617ad2a..d8ac2828 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -26,6 +26,7 @@ Added: - Simulated missions with failures (`Deployment.simulate`, a `MissionHistory` for each replicate, drawn from its seed with common random numbers between designs): lives of satellites whose failure rates vary over the lifecycle (`tradespace.Exponential`, `Weibull`, `Bathtub` of competing causes, and `Piecewise` rates by age, `Lifetime`), failures of launches (`FailureModel`), and a policy that degrades or restores failed satellites (`RestorationPolicy`) by spares in orbit (taking a failed satellite's place after drifting), spares on the ground (launched at the next launch slot), or satellites produced when needed (after procurement, on the production line), optionally replenishing spares and batching restorations in launches. A history gives the phases in which satellites operate (`MissionHistory.phases`), measures of the mission (`MissionHistory.metrics`: failures, restorations, spares used, time to restore, and availability), and, priced by a `CostModel`, the cost of what it produces and launches. Policies are decisions of designs with a fragment of a design space (`policy_space`: whether to restore, spares in orbit and on the ground, and other fields of the policy, without spares that would never be used), and `configure` makes a policy (or a deployment schedule, or another dataclass) from the values of a design. Many histories of a replicate's mission (`Deployment.simulate_many`) share its sample of targets: `evaluate_missions` evaluates them (with their measures and costs) with a cache that evaluates each set of operating satellites once (`PhaseCache`, keyed by the content of the satellites and shared by the histories, policies, and designs of a replicate), and `summarize_missions` gives their means, quantiles (the risk of the mission), and probabilities of meeting requirements, as one record of the replicate. The histories of a replicate are stratified by default (a Latin hypercube over the histories of each satellite's life and each launch, drawn from uniform numbers by `Lifetime.from_uniform`), which estimates the means of missions 3 to 15 times more precisely than independent histories, and means may be estimated with control variates (`summarize_missions(controls=...)`, such as the availability of the mission, whose expected value simulations alone estimate, `Deployment.expected_metrics`). `allocate_histories` recommends the histories of each replicate (and the replicates, for a standard error) from a pilot with independent histories, by the variances between replicates and between histories and their costs (`summarize_missions(spread=True)` gives the standard deviations of the histories). `expected_missions` computes the expected capability and availability of a mission without restoration exactly (the sets of operating satellites by their probabilities, from the survival of each launch group, with planned replacements), without sampling error. Histories may be drawn from stressed failures for importance sampling (`simulate_many(stress=...)`: hazards and launch failures times a factor, each history weighted by its likelihood ratio censored at the end of the mission, `Lifetime.stressed` and `MissionHistory.weight`), which `summarize_missions` weighs in every statistic, with the effective number of histories: the probabilities of rare losses with 30 to 70 times less variance. - Life-cycle costs of deployments for trade studies (`tradespace.CostModel`): the development of each type of satellite, the production of its units on a learning curve (`SatelliteCost`), launches (per launch, or prices per satellite and kg, `LaunchCost`), operations (`OperationsCost`), replacements, and spares in orbit, dated by the deployment for their present value at a discount rate (`CostEstimate.present_value`, metric `cost present`) and annual costs (`CostEstimate.annual`, metric `cost peak annual`), with growth factors for cost risk (such as uncertain parameters, whose quantiles over replicates give the cost at a confidence level). TAT-C does not include cost-estimating relationships: the costs are given by the study. Fingerprints describe dataclasses (such as cost models) by their fields. - Function `tradespace.confirm` (and class `Confirmation`), which evaluates selected designs (such as a front) with new replicates that played no part in their selection, removing the optimism of the selection (the winner's curse, `Confirmation.optimism`). `ResultStore` keys evaluations by the fingerprint of a study (`Study.fingerprint`, a hash of `Study.definition`, see `get_definition`: its seed, use of common random numbers, design space, and build and evaluation functions, with the data frames they are given described by their content, the version of Python, and the source of the modules of TAT-C and resource files they depend on, found from their imports) and keeps each definition, so that a study warns of evaluations of other definitions, which are not reused, naming what differs (`compare_definitions`); `ResultStore.prune` removes them. Changes to TAT-C that a study does not depend on (such as to modules it does not use) keep its results. Namespaces of stores and caches are optional, for what fingerprints cannot see (data that functions read from files, and the code of other modules). `refine` treats designs with fewer than `min_replicates` (5) as uncertain whatever their probability, adds the replicates left to `max_replicates` in a last partial step, and warns if designs remain uncertain without a tolerance. `sensitivity` gives adjusted shares (epsilon squared) by default, without the share that the levels of a variable explain by chance (`adjusted=False` for correlation ratios). + - The schedule and cost model of a `tradespace.MissionPlan` may be functions of the design (`schedule_of`, `cost_model_of`), which size them by its values with relationships of the study's own, such as the costs of a type of satellite from its payload or the capacity of launches to the design's altitude; launches limited in mass take the masses of the satellites from the cost model (`masses_of`, or the plan's `masses`). The `launch_mass_capacity` of a `DeploymentSchedule` may be a function of a plane (`mass_capacity_of`), for planes at different inclinations. - The start of the period of `tradespace.Observations` may be a value of the design (`start_of` and `end_of` give a design's period), such as an uncertain epoch drawn for each replicate over the mission, whose observations are cached apart, so that replicates average over the geometry and seasons of the mission that the one window of quasi-static phases misses (as `evaluate_phases` now states). The schedule of deployments states that a design life does not retire a satellite that is not replaced, and simulations that a planned replacement whose launch fails is not flown again. - Utilities of the metrics of designs (`tradespace.Utility`), for trade spaces of utility against cost: a single-attribute utility of each metric (`LinearUtility`, `ExponentialUtility` of a risk attitude, `PiecewiseUtility`, or any function), combined by weights additively or in Keeney and Raiffa's multiplicative form. A utility is a metric of any statistic (its `Mean` is the expected utility over the replicates, and a utility given as a statistic of `Criteria` is its mean), computed in each replicate, and gives the utility of each row of a data frame (such as a summary of the means of designs). Statistics name the columns they need (`Statistic.columns`). - Staged deployments (`tradespace.Stage`, argument `stages` of `DeploymentSchedule.plan` and `MissionPlan`, which may give the stages of each design): planes that are produced and launched only if a rule decides to, at times during the mission, from what it knows then (`Decision`: the satellites operating, the history so far, and, through the design, its uncertain parameters and scenario), after a lead time and at the next launch slots, and replaced and restored as other planes. A stage that is not deployed is neither produced, launched, nor priced; `MissionHistory.stages` gives when each was deployed, and its metrics the `stages deployed`. Exact expectations of missions without restoration (`expected_missions`) need deployments that are not staged, so that studies of staged deployments sample their histories. diff --git a/docs/api_reference/tradespace.rst b/docs/api_reference/tradespace.rst index 246e440c..8ba0bfcc 100644 --- a/docs/api_reference/tradespace.rst +++ b/docs/api_reference/tradespace.rst @@ -95,7 +95,7 @@ Deployment :no-members: .. autoclass:: tatc.tradespace.DeploymentSchedule - :members: plan, launches_of + :members: plan, launches_of, mass_capacity_of .. autoclass:: tatc.tradespace.Deployment :members: simulate, simulate_many, expected_metrics, planned, phases, begin, end, deployed, units @@ -198,7 +198,7 @@ Observation Studies :members: end, start_of, end_of, cache_of, context_of, __call__ .. autoclass:: tatc.tradespace.MissionPlan - :members: growth_of, stages_of + :members: schedule_of, cost_model_of, masses_of, growth_of, stages_of .. autoclass:: tatc.tradespace.Failures diff --git a/src/tatc/tradespace/cost.py b/src/tatc/tradespace/cost.py index 0930df59..b1f9862f 100644 --- a/src/tatc/tradespace/cost.py +++ b/src/tatc/tradespace/cost.py @@ -8,8 +8,8 @@ restricted or need calibration to an organization's experience: the costs of each type of satellite (such as the satellites of each payload) and of launches and operations are given, as values or functions of a design (such -as a mass-based relationship), in a currency of the user's choice and -constant-year amounts. Cost risk enters as uncertain growth factors (see +as a mass-based relationship, as a `MissionPlan` of each design sizes them), +in a currency of the user's choice and constant-year amounts. Cost risk enters as uncertain growth factors (see `CostModel.estimate`), drawn for each replicate like other uncertain parameters, so that statistics of the cost over replicates (such as a 0.7 `Quantile`) are objectives or requirements. diff --git a/src/tatc/tradespace/deployment.py b/src/tatc/tradespace/deployment.py index a3226c7f..7d01d628 100644 --- a/src/tatc/tradespace/deployment.py +++ b/src/tatc/tradespace/deployment.py @@ -128,6 +128,9 @@ class Deployment: """list[Launch]: The launches (and planned replacements), in order.""" masses: dict[Any, float | None] = field(default_factory=dict) """dict: The mass (kg) of each type of satellite, if given.""" + plane_values: list[Any] = field(default_factory=list) + """list: The values of each plane in the design (see `Plane`), in the + order of `planes`, as given to functions of the schedule of a plane.""" stages: tuple[Stage, ...] = () """tuple[Stage, ...]: The stages deployed only if their rules decide to (whose planes the production and launches above do not include).""" @@ -362,8 +365,11 @@ class DeploymentSchedule: launch_interval (float): The least time between launches. launch_capacity (int | None): The most satellites of a launch, if limited. - launch_mass_capacity (float | None): The most mass (kg) of a launch, - if limited (which requires the masses of the satellites). + launch_mass_capacity (float | Callable | None): The most mass (kg) of + a launch, if limited (which requires the masses of the + satellites): a value, or a function of the index and values of a + plane (as for `order`), such as for planes at different + inclinations, to which a launcher lifts different masses. order (Callable | None): A function of the index and values of a plane (`None` for the planes of a Walker layout) that gives the key by which its type's planes are produced and launched, if @@ -376,7 +382,7 @@ class DeploymentSchedule: production_rate: PerType | None = None launch_interval: float = 0.0 launch_capacity: int | None = None - launch_mass_capacity: float | None = None + launch_mass_capacity: float | Callable[[int, Any], float] | None = None order: Callable[[int, Any], Any] | None = None def __post_init__(self): @@ -397,13 +403,38 @@ def __post_init__(self): if any(value < 0 for value in values): raise ValueError("development_years must not be negative") - def launches_of(self, satellites: int, mass: float | None = None) -> int: + def mass_capacity_of(self, plane: tuple[int, Any] | None = None) -> float | None: + """ + Gets the most mass (kg) of a launch to a plane, if limited. + + Args: + plane (tuple[int, Any] | None): The index and values of the plane, + for a capacity that is a function of the plane. + + Returns: + float | None: the capacity, or `None` if not limited + """ + capacity = self.launch_mass_capacity + if capacity is None or not callable(capacity): + return capacity + if plane is None: + raise ValueError("a launch capacity of each plane needs the plane") + return float(capacity(*plane)) + + def launches_of( + self, + satellites: int, + mass: float | None = None, + plane: tuple[int, Any] | None = None, + ) -> int: """ Gets the launches of a plane of satellites. Args: satellites (int): The number of satellites. mass (float | None): The mass (kg) of each satellite. + plane (tuple[int, Any] | None): The index and values of the plane, + for a capacity in mass that is a function of the plane. Returns: int: the number of launches @@ -411,10 +442,11 @@ def launches_of(self, satellites: int, mass: float | None = None) -> int: count = 1 if self.launch_capacity is not None: count = max(count, math.ceil(satellites / self.launch_capacity)) - if self.launch_mass_capacity is not None: + capacity = self.mass_capacity_of(plane) + if capacity is not None: if mass is None: raise ValueError("a launch capacity in mass requires masses") - per_launch = math.floor(self.launch_mass_capacity / mass) + per_launch = math.floor(capacity / mass) if per_launch < 1: raise ValueError("a satellite exceeds the mass capacity of a launch") count = max(count, math.ceil(satellites / per_launch)) @@ -480,6 +512,7 @@ def plan( size, values = plane.satellites, plane.values index = len(deployment.planes) deployment.planes.append((name, size, spares if size > 0 else 0)) + deployment.plane_values.append(values) if size > 0 and index not in staged: listed.append((index, size + spares, values)) if self.order is not None: @@ -499,7 +532,9 @@ def plan( raise ValueError("a deployment requires satellites (that are not staged)") cadence = -math.inf for ready, index, name, size, mass in sorted(planes, key=lambda p: p[0]): - count = self.launches_of(size, mass) + count = self.launches_of( + size, mass, (index, deployment.plane_values[index]) + ) first = max(ready, cadence) position = 0 for j in range(count): diff --git a/src/tatc/tradespace/mission.py b/src/tatc/tradespace/mission.py index e9e2b133..585d1a58 100644 --- a/src/tatc/tradespace/mission.py +++ b/src/tatc/tradespace/mission.py @@ -590,7 +590,9 @@ def _deploy(self, time: float, stage: Any) -> None: self.line[kind] = ready self.history.production.append(Production(kind, begin, ready, count)) launches = self.schedule.launches_of( - count, self.deployment.masses.get(kind) + count, + self.deployment.masses.get(kind), + self._plane(plane), ) position = 0 for j in range(launches): @@ -638,22 +640,28 @@ def _slot(self, ready: float) -> float: time = booked + interval return time - def _capacity(self, kind: Any) -> float: + def _plane(self, plane: int) -> tuple[int, Any]: + """The index and values of a plane (see `DeploymentSchedule`).""" + values = self.deployment.plane_values + return plane, values[plane] if plane < len(values) else None + + def _capacity(self, plane: int, kind: Any) -> float: capacity = math.inf if self.schedule.launch_capacity is not None: capacity = self.schedule.launch_capacity - if self.schedule.launch_mass_capacity is not None: + mass_capacity = self.schedule.mass_capacity_of(self._plane(plane)) + if mass_capacity is not None: mass = self.deployment.masses.get(kind) if mass is not None: - capacity = min( - capacity, math.floor(self.schedule.launch_mass_capacity / mass) - ) + capacity = min(capacity, math.floor(mass_capacity / mass)) return capacity def _book(self, plane: int, kind: Any, ready: float, item: tuple) -> None: """Books an item on a launch of a plane: an open one, or a new one.""" for booking in self.open.get(plane, []): - if booking.time >= ready and len(booking.items) < self._capacity(kind): + if booking.time >= ready and len(booking.items) < self._capacity( + plane, kind + ): booking.items.append(item) return time = self._slot(ready + self.policy.batch_years) diff --git a/src/tatc/tradespace/observations.py b/src/tatc/tradespace/observations.py index 36e4a6a6..2896732a 100644 --- a/src/tatc/tradespace/observations.py +++ b/src/tatc/tradespace/observations.py @@ -330,9 +330,25 @@ class MissionPlan: `DeploymentSchedule.plan`) and its costs (see `CostModel`), from the values of the design (see `value_of`). + The schedule and the cost model may be functions of the (realized) + design, which size them by its values with relationships of the study's + own (TAT-C includes none, see the module `tatc.tradespace.cost`): for + example, the costs of a type of satellite from the mass of its payload, + or the capacity of launches to the design's altitude:: + + def schedule(d): + return dataclasses.replace(SCHEDULE, launch_mass_capacity=capacity(d.altitude)) + + PLAN = MissionPlan(schedule, COST_MODEL, kind="payload") + + Launches limited in mass take the masses of the satellites from the cost + model (`SatelliteCost.mass`, of each type), unless `masses` are given. + Args: - schedule (DeploymentSchedule): The schedule of the deployment. - cost_model (CostModel | None): The costs, or `None`. + schedule (DeploymentSchedule | Callable): The schedule of the + deployment, or a function of the design that gives it. + cost_model (CostModel | Callable | None): The costs, a function of the + design that gives them, or `None`. kind (Any): The kind of the satellites (for schedules and costs of several kinds), as a value of the design. spares (Any): The spares in orbit in each plane, or a value of the @@ -345,14 +361,71 @@ class MissionPlan: (see `Stage`), or a function of the (realized) design that gives them, such as of a decision whether to stage it and of the values its rules read. + masses (Any): The mass (kg) of the satellites (or of each type, a + mapping), or a value of the design, for launches limited in mass, + or `None` for the masses of the cost model. """ - schedule: DeploymentSchedule - cost_model: CostModel | None = None + schedule: DeploymentSchedule | Callable[[Design], DeploymentSchedule] + cost_model: CostModel | Callable[[Design], CostModel] | None = None kind: Any = None spares: Any = 0 growth: Any = 1.0 stages: Any = () + masses: Any = None + + def schedule_of(self, design: Design) -> DeploymentSchedule: + """ + Gets the schedule of the deployment of a design. + + Args: + design (Design): The (realized) design. + + Returns: + DeploymentSchedule: the schedule + """ + if isinstance(self.schedule, DeploymentSchedule): + return self.schedule + return self.schedule(design) + + def cost_model_of(self, design: Design) -> CostModel | None: + """ + Gets the cost model of a design. + + Args: + design (Design): The (realized) design. + + Returns: + CostModel | None: the cost model, if any + """ + if self.cost_model is None or isinstance(self.cost_model, CostModel): + return self.cost_model + return self.cost_model(design) + + def masses_of(self, design: Design, cost_model: CostModel | None = None) -> Any: + """ + Gets the masses of the satellites of a design, for launches limited in + mass: the given masses (or the value of the design they name), or + those of the types of satellites of its cost model, if any. + + Args: + design (Design): The (realized) design. + cost_model (CostModel | None): The design's cost model. + + Returns: + Any: a mass, a mapping of types to masses, or `None` + """ + if self.masses is not None: + if isinstance(self.masses, (int, float, Mapping)): + return self.masses + return value_of(design, self.masses) + if cost_model is None: + return None + satellites = cost_model.satellites + if isinstance(satellites, Mapping): + masses = {kind: cost.mass for kind, cost in satellites.items()} + return None if all(m is None for m in masses.values()) else masses + return satellites.mass def stages_of(self, design: Design) -> tuple: """ @@ -461,14 +534,17 @@ def __call__(self, satellites: Sequence[Satellite], design: Design) -> dict: if self.plan is not None: policy, spares = self._policy(design) kind = value_of(design, self.plan.kind) - deployment = self.plan.schedule.plan( - layout, kind=kind, spares=spares, stages=self.plan.stages_of(design) + cost_model = self.plan.cost_model_of(design) + deployment = self.plan.schedule_of(design).plan( + layout, + kind=kind, + spares=spares, + masses=self.plan.masses_of(design, cost_model), + stages=self.plan.stages_of(design), ) growth = self.plan.growth_of(design) - if self.plan.cost_model is not None: - record.update( - self.plan.cost_model.estimate(deployment, growth).metrics() - ) + if cost_model is not None: + record.update(cost_model.estimate(deployment, growth).metrics()) metrics = _given_design(self.metrics, design) record.update(metrics(observations)) # the metrics of phases are cached by the observations and, if they @@ -490,7 +566,7 @@ def __call__(self, satellites: Sequence[Satellite], design: Design) -> dict: observations, self._phase_cache, context=context, - cost_model=self.plan.cost_model, + cost_model=cost_model, growth=growth, design=design, ) diff --git a/tests/tradespace/test_deployment.py b/tests/tradespace/test_deployment.py index e2f35b34..8ef7c51d 100644 --- a/tests/tradespace/test_deployment.py +++ b/tests/tradespace/test_deployment.py @@ -14,9 +14,12 @@ from tatc.tradespace import ( DeploymentSchedule, DesignSpace, + Exponential, + FailureModel, Phase, Real, Requirement, + RestorationPolicy, evaluate_phases, sso_planes_space, summarize_phases, @@ -43,6 +46,37 @@ class TestPlan(unittest.TestCase): Unit tests for planned deployments. """ + def test_mass_capacity_by_plane(self): + """A launch capacity in mass may differ by plane (such as by inclination), + for the launches of a deployment and those of its restorations.""" + + def capacity(index, values): + del values # the planes of a Walker constellation have none + return 100.0 if index == 0 else 200.0 + + schedule = DeploymentSchedule(years=5, launch_mass_capacity=capacity) + deployment = schedule.plan(_walker(2, 4), masses=50.0) + launches = { + plane: sum(l.plane == plane for l in deployment.launches) + for plane in (0, 1) + } + self.assertEqual(launches, {0: 2, 1: 1}) + self.assertEqual(deployment.plane_values, [None, None]) + with self.assertRaises(ValueError): + schedule.launches_of(4, 50.0) + self.assertEqual(schedule.launches_of(4, 50.0, (1, None)), 1) + # restorations that wait to share a launch fill it to the plane's capacity + history = deployment.simulate( + FailureModel(life=Exponential(2.0)), + RestorationPolicy(batch_years=1.0), + seed=0, + ) + restorations = [l for l in history.launches if l.purpose == "restoration"] + self.assertTrue(any(l.plane == 1 and l.satellites > 2 for l in restorations)) + self.assertTrue( + all(l.satellites <= (2 if l.plane == 0 else 4) for l in restorations) + ) + def test_production_rate(self): """A production line deploys planes as their satellites are built.""" deployment = DeploymentSchedule(development_years=2, production_rate=8).plan( diff --git a/tests/tradespace/test_observations.py b/tests/tradespace/test_observations.py index 571c23a9..14e2cdb5 100644 --- a/tests/tradespace/test_observations.py +++ b/tests/tradespace/test_observations.py @@ -4,6 +4,7 @@ @author Paul T. Grogan """ +import dataclasses import pickle import tempfile import unittest @@ -25,6 +26,7 @@ FailureModel, Failures, Integer, + LaunchCost, MissionPlan, ObservationStudy, Observations, @@ -343,6 +345,46 @@ def test_epoch(self): ).run(space.enumerate()[:2]) self.assertEqual(set(results.epoch), {START, later}) + def test_sizing(self): + """Plans size the schedule and costs of each design by its values, and + limit launches by the masses of the cost model.""" + designs = [d for d in SPACE.enumerate() if d.layout.per_plane == 2] + + def cost_model(d): + """Satellites that cost more to develop higher (an illustrative relationship).""" + development = 10 * d.altitude / 600e3 + return CostModel( + SatelliteCost(development=development, first_unit=2, mass=100), + launch=LaunchCost(per_launch=1), + ) + + def schedule(d): + """Launches that lift two satellites to 600 km, and one to 700 km.""" + capacity = 250.0 if d.altitude < 650e3 else 150.0 + return dataclasses.replace(SCHEDULE, launch_mass_capacity=capacity) + + def study(plan): + return ObservationStudy( + SPACE, _build, _observations(), _metrics, layout="layout", plan=plan + ) + + results = study(MissionPlan(schedule, cost_model)).run(designs) + by_altitude = results.groupby("altitude")[["cost development", "cost launch"]] + means = by_altitude.mean() + self.assertAlmostEqual( + means.loc[700e3, "cost development"] / means.loc[600e3, "cost development"], + 7 / 6, + ) + # a launch of each plane at 600 km, and of each satellite at 700 km + planes = results.groupby("altitude")["planes"].mean() + self.assertAlmostEqual(means.loc[600e3, "cost launch"], planes[600e3]) + self.assertAlmostEqual(means.loc[700e3, "cost launch"], 2 * planes[700e3]) + # given masses take the place of those of the cost model + light = study(MissionPlan(schedule, cost_model, masses=50.0)).run(designs) + self.assertAlmostEqual( + light.groupby("altitude")["cost launch"].mean()[700e3], planes[700e3] + ) + def test_stages(self): """Plans stage the deployments of designs that decide to.""" space = DesignSpace(**SPACE.children, staged=Categorical([False, True])) From d17e214dd96cc63dbd129fb2bb86dcf5f09fc7f6 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Thu, 12 Nov 2026 09:12:22 -0700 Subject: [PATCH 31/52] judge designs across the scenarios of a study, also in searches Criteria across the scenarios (Across) combine each design's statistics by their worst or weighted mean over the scenarios, in aggregate, pareto_probability (a joint bootstrap of the replicates), and the searches; requirements judge the combined value. The example compares the fronts of the worst and the mean, and searches by the mean. --- CHANGELOG.md | 1 + docs/api_reference/tradespace.rst | 3 + docs/examples/SearchTradeSpace.ipynb | 455 +++++++++++++++++++++++++-- src/tatc/tradespace/__init__.py | 2 + src/tatc/tradespace/criteria.py | 304 +++++++++++++++++- src/tatc/tradespace/optimization.py | 31 +- src/tatc/tradespace/pareto.py | 29 +- src/tatc/tradespace/refinement.py | 3 +- src/tatc/tradespace/scenarios.py | 8 +- tests/tradespace/test_scenarios.py | 214 +++++++++++++ 10 files changed, 989 insertions(+), 61 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index d8ac2828..1cd606e4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -31,6 +31,7 @@ Added: - Utilities of the metrics of designs (`tradespace.Utility`), for trade spaces of utility against cost: a single-attribute utility of each metric (`LinearUtility`, `ExponentialUtility` of a risk attitude, `PiecewiseUtility`, or any function), combined by weights additively or in Keeney and Raiffa's multiplicative form. A utility is a metric of any statistic (its `Mean` is the expected utility over the replicates, and a utility given as a statistic of `Criteria` is its mean), computed in each replicate, and gives the utility of each row of a data frame (such as a summary of the means of designs). Statistics name the columns they need (`Statistic.columns`). - Staged deployments (`tradespace.Stage`, argument `stages` of `DeploymentSchedule.plan` and `MissionPlan`, which may give the stages of each design): planes that are produced and launched only if a rule decides to, at times during the mission, from what it knows then (`Decision`: the satellites operating, the history so far, and, through the design, its uncertain parameters and scenario), after a lead time and at the next launch slots, and replaced and restored as other planes. A stage that is not deployed is neither produced, launched, nor priced; `MissionHistory.stages` gives when each was deployed, and its metrics the `stages deployed`. Exact expectations of missions without restoration (`expected_missions`) need deployments that are not staged, so that studies of staged deployments sample their histories. - Scenarios of studies (argument `scenarios` of `tradespace.Study`): conditions under which designs are compared rather than averaged over, each giving fixed values or uncertain parameters of the design space other values (`Design.realize` takes a `scenario`), so that each design is evaluated in each scenario (recorded as `scenario`, and judged in each with criteria `by` it). Each scenario's evaluations are stored by its values, so that a scenario added later is evaluated alone. Function `tradespace.robustness` gives each design's Pareto trace (the share of scenarios in which it is efficient) and its regret in each scenario (the improvement in every objective it would need to match the scenario's front) and the largest. The metrics of an `ObservationStudy` (and of `PhaseCache`, `evaluate_missions`, and `expected_missions`) are given the realized design if they have a parameter named `design`. + - Criteria across the scenarios of a study (`tradespace.Across`, argument `across` of `Criteria`), which judge each design once by its worst or its (weighted) mean statistics over the scenarios (or the groups of another column), so that searches find designs robust to scenarios; a requirement may be met in every scenario while objectives are means. - Function `tradespace.attribute_variance` (and class `Attribution`), which attributes the variance of metrics between the replicates of each design to its uncertain parameters (or groups of them): the share that each causes, alone or with others, and the share that knowing it would remove, with standard errors, by evaluating designs with one parameter drawn as in other replicates and the others held (which works for seeds, whose values do not order outcomes); `Attribution.summary` pools the shares of several designs, and `Attribution.differences` attributes the variance of the differences between pairs of designs, from the same evaluations (parameters that act alike on both cancel, with common random numbers). `Design.realize` and `Study.run` take a `shift`, which draws named parameters as in other replicates (kept apart in a `ResultStore` as a variant of the replicates), and `DesignSpace.uncertain_paths` lists the uncertain parameters. - Searches with Optuna accept categorical options that depend on earlier decisions (a parameter for each set of options), use TPE with a constant liar in batches by default (which spreads the trials of a batch), and stop after `max_designs` designs evaluated (trials that suggest designs evaluated before are told their objectives without evaluating them again). A design infeasible in some of its replicates violates its feasibility by their share (`Evaluations.infeasibility`), and the first design evaluated in a search is evaluated alone, to check that evaluations give one record each. `Study` records errors of evaluations as infeasible, without storing them, with `errors="record"`. Enumeration walks the items of unordered repetitions in one order only (the same designs, in the same order, four times faster for three sun-synchronous planes), and `DesignSpace.size` counts designs without keeping them. Pareto fronts are found by a vectorized sweep in lexicographic order that compares designs only with the efficient designs before them, and fronts with tolerances by comparing designs only with the efficient designs without tolerances (which dominate every design that any design dominates within the tolerances), in blocks of bounded memory: 20,000 designs in 0.05 s (0.11 s with tolerances) rather than 17 s, and the bootstraps of `pareto_probability` (and so `refine`) about 20 times faster. - Studies of the observations of constellations (`tradespace.ObservationStudy`): the targets of each replicate (`Targets`, fixed or generated from a seed of the design), the observations of each satellite, cached on disk (`Observations`), the metrics of the observations, and, with a `MissionPlan`, the costs of the deployment and the summaries of its phases or of the histories of its `Failures`. Plots of the results of studies (`plot_designs`, `plot_progress`, and `plot_means`, with matplotlib, now in the `tradespace` extra), and the hypervolume of a search as it proceeds (`hypervolume_progress`). diff --git a/docs/api_reference/tradespace.rst b/docs/api_reference/tradespace.rst index 8ba0bfcc..070aaf96 100644 --- a/docs/api_reference/tradespace.rst +++ b/docs/api_reference/tradespace.rst @@ -237,6 +237,9 @@ Criteria, Statistics, and Requirements .. autoclass:: tatc.tradespace.Requirement :members: violation +.. autoclass:: tatc.tradespace.Across + :members: weights_of + Utility ------- diff --git a/docs/examples/SearchTradeSpace.ipynb b/docs/examples/SearchTradeSpace.ipynb index ccc23e7e..c0125b19 100644 --- a/docs/examples/SearchTradeSpace.ipynb +++ b/docs/examples/SearchTradeSpace.ipynb @@ -2872,7 +2872,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "16440 evaluations (3 fields) in 122 s\n", + "16440 evaluations (3 fields) in 139 s\n", "efficient designs: {'1 hour': 14, '3 hours': 13, '12 hours': 6}\n" ] }, @@ -3199,6 +3199,362 @@ "The robust choice depends on the budget. With four satellites, two sun-synchronous planes of two (crossing at 09:00 and 15:00) are the best for the fields of 1 and 3 hours and fall 5 points behind the best for the field of 12 hours (93% against 98%, by four satellites in two other planes): a mission that does not yet know its field loses little by choosing them. With three satellites, two sun-synchronous planes of two and one fall 10 points behind three satellites in one plane for the field of 12 hours (86% against 96%) and three in three planes for the field of 1 hour (41% against 51%), and less than a point behind the best for 3 hours. Two satellites fall at least 11 points behind somewhere. Six satellites in three Walker planes (at 700 km) fall at most 0.4 points behind the best of any field, though they are efficient in none: a robust choice need not be the best in any scenario. Regrets of a point or two are within the sampling error of the means of five replicates (standard errors of one to four points, as above), so the robust designs of four and six satellites are as good as the best of each field." ] }, + { + "cell_type": "markdown", + "id": "4a9c2e17", + "metadata": {}, + "source": [ + "Criteria `across` the fields (`Across`) judge each design once, by its worst or its mean share over the fields, rather than in each field, which is what a search for designs robust to the field needs (see Search with Optimizers below). Here every design is evaluated in every field, so the fronts of both are exact:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "c06b8d53", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "the field in which each design is least accurate: {'1 hour': 1028, '3 hours': 68}\n", + "efficient by the worst: 15, of which 12 in 1 hour\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanes1 hour3 hours12 hoursworstmean
design
9b3481aea973800 km, 60 deg FOR, SSO: 1 at 12:001.01.03.04.227.0TrueFalse
12765c7a29fc800 km, 60 deg FOR, SSO: 1 at 15:001.01.03.03.628.0TrueTrue
24a159fbc4b7800 km, 60 deg FOR, SSO: 2 at 12:002.01.05.69.470.0TrueFalse
c9cacc08010d800 km, 60 deg FOR, SSO: 2 at 15:002.01.04.810.073.0FalseTrue
33b006848799800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.026.234.260.4TrueTrue
d5d3fa915ca7800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...3.01.010.211.467.6TrueFalse
b85daf65c3a4800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...3.01.08.017.095.6FalseTrue
c576e2e2dbd1800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:003.02.040.860.685.8TrueTrue
92ff9cd17e00800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...3.03.050.659.863.6TrueFalse
1af5f2707be3800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.011.226.867.2TrueFalse
104e33a3c842800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac...4.01.09.228.695.0FalseTrue
3690f1194419800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:004.02.069.085.493.0TrueTrue
64cf6542c326800 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...6.03.090.295.897.4TrueFalse
e641bd5c978e700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...6.03.089.896.297.6FalseTrue
6df0f1709edc800 km, 60 deg FOR, Walker 60 deg: 2 x 4 (spac...8.02.070.280.289.2TrueFalse
cb6bd361b577800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.096.696.697.8TrueTrue
5529c21520be800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.897.8TrueTrue
679ca275c8fc800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.897.8TrueTrue
de505bc89299800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.897.8TrueTrue
\n", + "
" + ], + "text/plain": [ + " description satellites \\\n", + "design \n", + "9b3481aea973 800 km, 60 deg FOR, SSO: 1 at 12:00 1.0 \n", + "12765c7a29fc 800 km, 60 deg FOR, SSO: 1 at 15:00 1.0 \n", + "24a159fbc4b7 800 km, 60 deg FOR, SSO: 2 at 12:00 2.0 \n", + "c9cacc08010d 800 km, 60 deg FOR, SSO: 2 at 15:00 2.0 \n", + "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 \n", + "d5d3fa915ca7 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 \n", + "b85daf65c3a4 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... 3.0 \n", + "c576e2e2dbd1 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3.0 \n", + "92ff9cd17e00 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 \n", + "1af5f2707be3 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 \n", + "104e33a3c842 800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac... 4.0 \n", + "3690f1194419 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4.0 \n", + "64cf6542c326 800 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... 6.0 \n", + "e641bd5c978e 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... 6.0 \n", + "6df0f1709edc 800 km, 60 deg FOR, Walker 60 deg: 2 x 4 (spac... 8.0 \n", + "cb6bd361b577 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 \n", + "5529c21520be 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", + "679ca275c8fc 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", + "de505bc89299 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", + "\n", + " planes 1 hour 3 hours 12 hours worst mean \n", + "design \n", + "9b3481aea973 1.0 3.0 4.2 27.0 True False \n", + "12765c7a29fc 1.0 3.0 3.6 28.0 True True \n", + "24a159fbc4b7 1.0 5.6 9.4 70.0 True False \n", + "c9cacc08010d 1.0 4.8 10.0 73.0 False True \n", + "33b006848799 2.0 26.2 34.2 60.4 True True \n", + "d5d3fa915ca7 1.0 10.2 11.4 67.6 True False \n", + "b85daf65c3a4 1.0 8.0 17.0 95.6 False True \n", + "c576e2e2dbd1 2.0 40.8 60.6 85.8 True True \n", + "92ff9cd17e00 3.0 50.6 59.8 63.6 True False \n", + "1af5f2707be3 1.0 11.2 26.8 67.2 True False \n", + "104e33a3c842 1.0 9.2 28.6 95.0 False True \n", + "3690f1194419 2.0 69.0 85.4 93.0 True True \n", + "64cf6542c326 3.0 90.2 95.8 97.4 True False \n", + "e641bd5c978e 3.0 89.8 96.2 97.6 False True \n", + "6df0f1709edc 2.0 70.2 80.2 89.2 True False \n", + "cb6bd361b577 4.0 96.6 96.6 97.8 True True \n", + "5529c21520be 3.0 97.8 97.8 97.8 True True \n", + "679ca275c8fc 3.0 97.8 97.8 97.8 True True \n", + "de505bc89299 3.0 97.8 97.8 97.8 True True " + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import Across\n", + "\n", + "# the efficient designs by their worst and by their mean share accurately sampled over the fields (with equal\n", + "# weights), and those of the field that decorrelates within an hour\n", + "fronts = {}\n", + "for rule in (\"worst\", \"mean\"):\n", + " criteria = Criteria(ACCURACY, across=Across(rule=rule))\n", + " combined = aggregate(fields, criteria)\n", + " fronts[rule] = set(combined.design[pareto_front(combined, criteria)])\n", + "fronts[\"1 hour\"] = set(by_field.design[by_field.pareto & (by_field.scenario == \"1 hour\")])\n", + "print(\"the field in which each design is least accurate:\", field_accuracy.idxmin(axis=1).value_counts().to_dict())\n", + "print(f\"efficient by the worst: {len(fronts['worst'])}, of which {len(fronts['worst'] & fronts['1 hour'])} in 1 hour\")\n", + "compared = traced.loc[sorted(fronts[\"worst\"] | fronts[\"mean\"]), [\"description\", \"satellites\", \"planes\", *FIELDS]]\n", + "compared[\"worst\"] = compared.index.isin(fronts[\"worst\"])\n", + "compared[\"mean\"] = compared.index.isin(fronts[\"mean\"])\n", + "compared.sort_values([\"satellites\", \"planes\", \"mean\"]).round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "93f5a1ce", + "metadata": {}, + "source": [ + "The field that decorrelates within an hour is the hardest for 1,028 of the 1,096 designs (that of 3 hours for the others), so a design's worst share is nearly always its share in that field: 12 of the 15 designs efficient by the worst are efficient in that field, and the worst adds little to it. A worst case suits scenarios that are hardest for different designs; here, the mean and the regret (above) say more. The mean over the fields weighs the field of 12 hours as well, in which one plane samples well: three and four satellites in one plane inclined 75 degrees (96% and 95% in that field) are efficient by the mean, where the worst prefers one plane inclined 45 degrees, about two points better in the field of 1 hour and 28 points worse in that of 12 hours. Eight designs are efficient by both, among them the robust choices of three and four satellites above (in two sun-synchronous planes); the robust choice of six (three Walker planes at 700 km) is efficient by the mean, but not by the worst, by 0.4 points in the field of 1 hour." + ] + }, { "cell_type": "markdown", "id": "c0d1e2f3", @@ -3220,7 +3576,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "id": "d1e2f3a4", "metadata": { "execution": { @@ -3686,7 +4042,7 @@ "de505bc89299 355.7 405.7 " ] }, - "execution_count": 17, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -3779,7 +4135,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "id": "b8c9d0e1", "metadata": { "execution": { @@ -4009,7 +4365,7 @@ "a37619256b26 produce 83.0 78.7 340.0 " ] }, - "execution_count": 18, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -4042,7 +4398,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "id": "f0fa7509", "metadata": {}, "outputs": [ @@ -4137,7 +4493,7 @@ "cost_growth 0.0 19.0 " ] }, - "execution_count": 19, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -4178,7 +4534,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "id": "9226eca9", "metadata": {}, "outputs": [ @@ -4266,7 +4622,7 @@ "cost_growth 0.0 0.0 " ] }, - "execution_count": 20, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -4300,7 +4656,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "id": "c2d3e4f5", "metadata": { "execution": { @@ -4549,7 +4905,7 @@ "961 0.6 " ] }, - "execution_count": 21, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -4608,7 +4964,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 23, "id": "d4a1007a", "metadata": {}, "outputs": [ @@ -4663,7 +5019,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 24, "id": "8c84cbf4", "metadata": {}, "outputs": [ @@ -4824,7 +5180,7 @@ "64cf6542c326 True " ] }, - "execution_count": 23, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -4861,7 +5217,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 25, "id": "f5a6b7c8", "metadata": { "execution": { @@ -5028,7 +5384,7 @@ "6bef11e40977 4.5 " ] }, - "execution_count": 24, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -5064,7 +5420,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 26, "id": "51ea3119", "metadata": {}, "outputs": [ @@ -5243,7 +5599,7 @@ "6bef11e40977 0.2 0.8 " ] }, - "execution_count": 25, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -5285,7 +5641,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 27, "id": "8cbfe502", "metadata": {}, "outputs": [ @@ -5395,7 +5751,7 @@ "decided a year later 118.8 " ] }, - "execution_count": 26, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -5454,7 +5810,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 28, "id": "d6e5f8a7", "metadata": { "execution": { @@ -5560,7 +5916,7 @@ "3 25.1 " ] }, - "execution_count": 27, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -5619,7 +5975,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 29, "id": "a9b8c1d0", "metadata": { "execution": { @@ -5682,7 +6038,7 @@ "Latin hypercube sample 176.0 79.3" ] }, - "execution_count": 28, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" } @@ -5727,7 +6083,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 30, "id": "b0c9d2e1", "metadata": { "execution": { @@ -5769,6 +6125,53 @@ "Both optimizers find more of the hypervolume than a Latin hypercube sample of as many designs. Optuna (NSGA-II, searching the hierarchical space directly) finds 92% of the hypervolume of the true front with 143 designs, 13% of the space. pymoo (NSGA-II, searching the encoded space) finds all of it with 166 designs: it proposes no design twice, and its other 34 proposals violate the constraint on the number of satellites (without eliminating duplicates by design, its 200 proposals encoded only 75 designs, which found 88%). The sample finds 79% with 176 designs. The searches stop at their budget of proposals, not at convergence: a larger budget, or screening, would bring Optuna's closer to the true front. Their results also depend on their seeds (over eight seeds, pymoo's search finds 88 to 100% of the hypervolume, 96.5% on average), so compare several seeds before relying on one." ] }, + { + "cell_type": "markdown", + "id": "7d3e9a41", + "metadata": {}, + "source": [ + "A search for designs robust to the field evaluates each design that it proposes in every field, and judges it by criteria `across` the fields: here pymoo's, by the mean share accurately sampled over the three fields, with as many proposals as above. Its evaluations are those of the comparison of the fields above, retrieved from the store:" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "b52c0f86", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "147 designs evaluated (in 3 fields each): 99.3% of the hypervolume of the true front, and 8 of its 12 designs\n" + ] + } + ], + "source": [ + "# a search for the designs most accurate on average over the fields, against the true front of every design\n", + "FIELD_MEAN = Criteria(ACCURACY, across=Across(rule=\"mean\"))\n", + "ACCURATE_REFERENCE = {\"satellites\": REFERENCE[\"satellites\"], \"planes\": REFERENCE[\"planes\"], \"accurate\": 0}\n", + "field_search = optimize_pymoo(\n", + " make_study(scenarios=FIELDS), FIELD_MEAN, NSGA2(pop_size=20), (\"n_gen\", BUDGET // 20), seed=1\n", + ")\n", + "field_progress = hypervolume_progress(field_search.results, FIELD_MEAN, ACCURATE_REFERENCE)\n", + "true_mean = hypervolume(aggregate(fields, FIELD_MEAN), FIELD_MEAN, ACCURATE_REFERENCE)\n", + "evaluated = set(field_search.results.design)\n", + "print(\n", + " f\"{len(evaluated)} designs evaluated (in {len(FIELDS)} fields each): \"\n", + " f\"{100 * field_progress.iloc[-1] / true_mean:.1f}% of the hypervolume of the true front, \"\n", + " f\"and {len(evaluated & fronts['mean'])} of its {len(fronts['mean'])} designs\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "e81f4d27", + "metadata": {}, + "source": [ + "The search finds 99.3% of the hypervolume of the true front of the mean with 147 designs, and 8 of its 12 designs; each design costs three times as much as in a search of one field, as it is evaluated in each field. Its designs and results refine and confirm its front as for any study, with the same criteria. A search by the worst would search mostly the field of 1 hour here (see Compare Designs across Scenarios)." + ] + }, { "cell_type": "markdown", "id": "d2e1f4a3", @@ -5781,7 +6184,7 @@ "* Statistical sufficiency is measured by the sampling error of the statistic that observations estimate (`tatc.analysis.estimate_sampling_error`), which counts of samples overstate when samples cluster in time, as they do in a single plane; revisit statistics and local time coverage explain it.\n", "* The front of the means of the replicates is uncertain: `pareto_probability` finds the designs whose efficiency the replicates settle, and those that are equally good candidates, and `refine` adds replicates only to the latter, with a tolerance of differences that do not matter. `confirm` evaluates the selected designs with new replicates, which removes the optimism of selecting the best of many nearly equal designs.\n", "* Statistics other than means (such as a `Quantile` or the `Probability` of meeting a threshold) state how reliably a design performs, and `Requirement`s on them are output constraints. Simulated missions (`Deployment.simulate`) draw the failures of satellites and launches from lives whose failure rates vary over the lifecycle (`FailureModel`), and restore them or not (`RestorationPolicy`, by spares in orbit or on the ground, or by producing new ones), for both the cost and the capability of each policy (exactly, without sampling, for missions that do not restore failed satellites: `expected_missions`); the policy is a decision of each design (`policy_space`, configured by `configure`), on the front with the design. `sensitivity` finds the design variables that drive each objective, and `attribute_variance` the uncertain parameters that spread the replicates of each design (by drawing each again with the others held): here, the sample of points spreads the mean shares and the histories of failures their worst 10%, which says what would sharpen each, and the growth of costs spreads the costs of designs alike, so that it cancels in their differences (`Attribution.differences`) and does not change their order.\n", - "* The `scenarios` of a study compare designs under conditions rather than averaging over them (here, fields of different decorrelation times, a value of the design space): criteria `by` the scenario give the front of each, and `robustness` the share of the scenarios in which each design is efficient (its Pareto trace) and its regret in each, whose least maximum is a robust choice (here, six satellites efficient in no field but never half a point behind the best).\n", + "* The `scenarios` of a study compare designs under conditions rather than averaging over them (here, fields of different decorrelation times, a value of the design space): criteria `by` the scenario give the front of each, and `robustness` the share of the scenarios in which each design is efficient (its Pareto trace) and its regret in each, whose least maximum is a robust choice (here, six satellites efficient in no field but never half a point behind the best). Criteria `across` the scenarios (`Across`) judge each design once, by its worst or its mean over them, as a search for robust designs needs: here the worst is mostly the field that varies fastest, and pymoo's search by the mean finds nearly all of the front of the mean.\n", "* `screen` evaluates every design with a cheap study and the best with the full one, which finds the front at a fraction of the cost if the cheap study ranks designs as the full one does.\n", "* A `Utility` weighs metrics by a stakeholder's preferences (a single-attribute utility of each, combined by weights) into one objective against cost, and is a metric of any statistic (its mean is the expected utility): here, stakeholders who weigh sufficiency or accuracy most agree within the budget and part beyond it.\n", "* A `DeploymentSchedule` plans each design's deployment from rates of production and launch, which dates its costs and divides its mission into phases of the satellites that fly, evaluated with the observations of the full constellation (over one day, which an epoch drawn for each replicate shows to represent the mission here) for the mean capability over the mission and the time until a requirement is met.\n", diff --git a/src/tatc/tradespace/__init__.py b/src/tatc/tradespace/__init__.py index b7ded55e..46fe8d9b 100644 --- a/src/tatc/tradespace/__init__.py +++ b/src/tatc/tradespace/__init__.py @@ -73,6 +73,7 @@ policy_space, ) from .criteria import ( + Across, Criteria, Maximum, Mean, @@ -133,6 +134,7 @@ from .values import ChoiceValues, RepeatValues, Scope, Values, configure __all__ = [ + "Across", "Attribution", "Bathtub", "Categorical", diff --git a/src/tatc/tradespace/criteria.py b/src/tatc/tradespace/criteria.py index 8a7bafc1..92fe7ebc 100644 --- a/src/tatc/tradespace/criteria.py +++ b/src/tatc/tradespace/criteria.py @@ -308,6 +308,98 @@ def violation(self, statistic: np.ndarray) -> np.ndarray: return np.where(np.isnan(statistic), np.nan, violation) +_RULES = ("worst", "mean") + + +@dataclass(frozen=True) +class Across: + """ + A rule that combines the statistics of each design across the groups of + a column of the results, such as the scenarios of a study (see `Study`), + so that criteria (see `Criteria`) judge each design once, rather than in + each group (as criteria `by` the column do): each statistic is computed + over the replicates in each group, and then combined across the groups. + + * `"worst"`: a statistic is its worst value in any group: the largest of + an objective to minimize (the smallest of one to maximize), and the + worst of a statistic of requirements for them (the smallest for `">="`), + so that a design meets a requirement only if it does in every group, + as a design robust to the scenarios must. + * `"mean"`: a statistic is its mean over the groups, weighted by their + `weights` (equal if not given), as an expectation over scenarios of + these probabilities. + + `rules` combine some statistics (by name) otherwise than `rule`: for + example, objectives of the mean over scenarios, with a requirement in + every scenario on a statistic of another name:: + + Criteria( + {"accurate": "max", "satellites": "min"}, + statistics={"accurate anywhere": "accurate"}, + requirements=[Requirement("accurate anywhere", ">=", 40)], + across=Across("scenario", "mean", rules={"accurate anywhere": "worst"}), + ) + + The worst of a statistic needs its direction: that of the objective or + the requirements that name it, which must agree. Requirements and + tolerances apply to the combined statistics. A design is judged only if + it has feasible results in every group of the results (in each group of + the criteria's `by`). + + Combining the statistics of the groups (such as the worst of the means) + differs from a statistic of the worst group of each replicate (the mean + of the worst in each replicate), which, for a mean, is more pessimistic. + + Args: + column (str): The column of the groups, such as `"scenario"`. + rule (str): How statistics are combined: `"worst"` or `"mean"`. + weights (Mapping[Any, float] | None): The weights of the mean of the + groups (by value of the column), or `None` for equal weights: + normalized over the groups of the results, each of which must + have one. + rules (Mapping[str, str]): The rules of some statistics (by name), in + place of `rule`. + """ + + column: str = "scenario" + rule: str = "worst" + weights: Mapping[Any, float] | None = None + rules: Mapping[str, str] = field(default_factory=dict) + + def __post_init__(self): + if not isinstance(self.column, str) or not self.column: + raise TypeError("the column must be a name (a non-empty string)") + rules = dict(self.rules) + for rule in [self.rule, *rules.values()]: + if rule not in _RULES: + raise ValueError(f"a rule must be one of {list(_RULES)}, not {rule!r}") + weights = None if self.weights is None else dict(self.weights) + if weights is not None and not all( + np.isfinite(float(w)) and float(w) > 0 for w in weights.values() + ): + raise ValueError("the weights of groups must be positive") + object.__setattr__(self, "rules", rules) + object.__setattr__(self, "weights", weights) + + def weights_of(self, groups: Sequence[Any]) -> np.ndarray: + """ + Gets the weights of the mean of groups, normalized. + + Args: + groups (Sequence[Any]): The groups (values of the column). + + Returns: + numpy.ndarray: the weight of each group, which sum to 1 + """ + if self.weights is None: + return np.full(len(groups), 1.0 / max(len(groups), 1)) + missing = [group for group in groups if group not in self.weights] + if missing: + raise ValueError(f"groups of {self.column!r} without weights: {missing}") + weights = np.array([float(self.weights[group]) for group in groups]) + return weights / weights.sum() + + Tolerance = float | str """A tolerance of an objective: a value in its units, or a share of its value (a string of a percentage, such as `"5%"`).""" @@ -357,6 +449,11 @@ class Criteria: them is as good in every objective and better in at least one, by more than the tolerances (see `pareto_front`). + Designs evaluated in several groups of a column (such as the scenarios + of a study, see `Study`) are judged in each group with criteria `by` the + column, or once with criteria `across` it (see `Across`), which combine + their statistics across the groups: their worst, or their mean. + The functions that judge designs (`aggregate`, `pareto_front`, `pareto_ranks`, `hypervolume`, `pareto_probability`, `refine`, `confirm`, `screen`, and the searches of `optimize_optuna` and @@ -377,6 +474,9 @@ class Criteria: by (Sequence[str] | str): The columns that group the records of an evaluation (such as a sensor), in each group of which designs are judged separately. + across (Across | None): The rule that combines the statistics of + each design across the groups of a column (such as the + scenarios), if any. """ objectives: Mapping[str, str] @@ -384,6 +484,7 @@ class Criteria: requirements: Sequence[Requirement] = () tolerance: Mapping[str, Tolerance] = field(default_factory=dict) by: Sequence[str] | str = () + across: Across | None = None def __post_init__(self): if not isinstance(self.objectives, Mapping): @@ -415,6 +516,17 @@ def __post_init__(self): object.__setattr__(self, "requirements", requirements) object.__setattr__(self, "tolerance", tolerance) object.__setattr__(self, "by", by) + if self.across is not None: + if not isinstance(self.across, Across): + raise TypeError("across must be an Across (or None)") + if self.across.column in by: + raise ValueError( + f"criteria cannot both group and combine {self.across.column!r}" + ) + unknown = sorted(set(self.across.rules) - set(self.names)) + if unknown: + raise ValueError(f"rules of names that are not statistics: {unknown}") + _combiners(self) # checks that each statistic has a worst, if needed @property def names(self) -> list[str]: @@ -500,12 +612,16 @@ def _groups(frame: pd.DataFrame, by: Sequence[str]) -> Iterator[tuple[tuple, Any def _get_matrices( - group: pd.DataFrame, columns: Sequence[str] + group: pd.DataFrame, + columns: Sequence[str], + designs: pd.Index | None = None, + replicates: pd.Index | None = None, ) -> tuple[pd.Index, pd.Index, dict[str, np.ndarray]]: """ Gets the values of metrics of each design (rows) in each replicate (columns) of the results of a group, which must have one record per - evaluation (a design in a replicate). + evaluation (a design in a replicate): of the designs and replicates of + the group, or of those given (`NaN` without a record). """ missing = [column for column in columns if column not in group.columns] if missing: @@ -522,11 +638,13 @@ def _get_matrices( raise ValueError( "the results have several records of an evaluation (a design in a " + "replicate): give the columns that separate them as `by` (of the " - + "criteria)" + + "criteria), or combine their groups `across` (see Across)" + (f", such as {varying}" if varying else "") ) - designs = pd.Index(group["design"].drop_duplicates()) - replicates = pd.Index(sorted(group["replicate"].unique())) + if designs is None: + designs = pd.Index(group["design"].drop_duplicates()) + if replicates is None: + replicates = pd.Index(sorted(group["replicate"].unique())) matrices = {} for column in columns: table = group.pivot(index="design", columns="replicate", values=column) @@ -559,6 +677,153 @@ def _evaluate( return values, violation +def _combiners(criteria: Criteria) -> dict[str, str]: + """ + Gets how each statistic of criteria is combined across the groups of + their `across` (see `Across`): by its largest (`"max"`) or smallest + (`"min"`) value, its worst, or by its `"mean"`. + """ + across = criteria.across + worst: dict[str, set[str]] = {} + for name, direction in criteria.objectives.items(): + worst.setdefault(name, set()).add("max" if direction == "min" else "min") + for requirement in criteria.requirements: + sense = "min" if requirement.operator in (">=", ">") else "max" + worst.setdefault(requirement.name, set()).add(sense) + combiners = {} + for name in criteria.names: + if across.rules.get(name, across.rule) == "mean": + combiners[name] = "mean" + elif name not in worst: + raise ValueError( + f"statistic {name!r} has no worst across {across.column!r}: it is " + + "neither an objective nor required (combine it by its mean, " + + "see Across)" + ) + elif len(worst[name]) > 1: + raise ValueError( + f"the objective and requirements of statistic {name!r} disagree on " + + "its worst: give it another name (in the statistics) for each" + ) + else: + combiners[name] = next(iter(worst[name])) + return combiners + + +def _across_groups(results: pd.DataFrame, across: Across | None) -> list | None: + """ + Gets the groups of results (values of a column, in order) across which + criteria combine statistics, if any. + """ + if across is None: + return None + if across.column not in results.columns: + raise ValueError( + f"the results have no column {across.column!r} to combine across " + + "(such as the scenarios of a study, see Study)" + ) + return list(pd.unique(results[across.column])) + + +class _Statistics: + """ + The statistics of the designs of the feasible results of a group (of the + criteria's `by`), over every replicate or some of them (see `evaluate`), + from the values of their metrics in each replicate: in each group of a + column, combined across the groups (see `Across`), if any. Designs + without results in every group are left out. + + Args: + results (pandas.DataFrame): The feasible results of a group. + statistics (Mapping[str, Statistic]): The statistics, by name. + requirements (Sequence[Requirement]): The requirements. + across (Across | None): The rule that combines the groups of a + column, if any. + combiners (Mapping[str, str] | None): How each statistic is combined + (see `_combiners`), with a rule. + groups (Sequence | None): The groups of the column (of every result), + with a rule. + """ + + def __init__( + self, + results: pd.DataFrame, + statistics: Mapping[str, Statistic], + requirements: Sequence[Requirement] = (), + across: Across | None = None, + combiners: Mapping[str, str] | None = None, + groups: Sequence | None = None, + ): + self.statistics, self.requirements = statistics, requirements + self.combiners = combiners + metrics = sorted( + { + column + for statistic in statistics.values() + for column in statistic.columns + } + ) + if across is None: + self.designs, self.replicates, matrices = _get_matrices(results, metrics) + self.matrices = [matrices] + self.counts = ( + results.groupby("design")["replicate"] + .nunique() + .reindex(self.designs) + .to_numpy() + ) + return + self.weights = ( + across.weights_of(groups) if "mean" in combiners.values() else None + ) + parts = [ + results[(results[across.column] == group).to_numpy()] for group in groups + ] + complete = set.intersection(*(set(part["design"]) for part in parts)) + designs = results["design"].drop_duplicates() + self.designs = pd.Index(designs[designs.isin(complete)]) + self.replicates = pd.Index(sorted(results["replicate"].unique())) + self.matrices = [ + _get_matrices(part, metrics, self.designs, self.replicates)[2] + for part in parts + ] + self.counts = ( + results.groupby(["design", across.column])["replicate"] + .nunique() + .groupby(level="design") + .min() + .reindex(self.designs) + .to_numpy() + ) + + def evaluate( + self, columns: np.ndarray | None = None + ) -> tuple[dict[str, np.ndarray], np.ndarray]: + """ + Computes the statistics of each design (of the replicates `columns` + of the matrices, or all) and the total violation of the requirements. + """ + if self.combiners is None: + return _evaluate( + self.statistics, self.requirements, self.matrices[0], columns + ) + parts = [_evaluate(self.statistics, (), m, columns)[0] for m in self.matrices] + values = {} + for name in self.statistics: + stacked = np.vstack([part[name] for part in parts]) + how = self.combiners[name] + if how == "max": + values[name] = stacked.max(axis=0) + elif how == "min": + values[name] = stacked.min(axis=0) + else: + values[name] = self.weights @ stacked + violation = np.zeros(len(self.designs)) + for requirement in self.requirements: + violation = violation + requirement.violation(values[requirement.name]) + return values, violation + + def _design_columns(results: pd.DataFrame, excluded: set[str]) -> list[str]: """ Gets the columns of the values of designs: those (other than `excluded`) @@ -587,10 +852,13 @@ def aggregate( With criteria (see `Criteria`), the statistics that they name, in each group of their `by`, and the `violation` of their requirements (the sum of the violations, see `Requirement`, 0 if the design meets them all) - and whether the design meets them (`meets_requirements`). + and whether the design meets them (`meets_requirements`). Criteria + `across` a column combine the statistics of each design across its + groups (see `Across`), of which `replicates` is the fewest of any group. The results must have one record per evaluation (a design in a - replicate) in each group. + replicate) in each group (and in each group of the column of the + criteria's `across`). Args: results (pandas.DataFrame): The results. @@ -607,6 +875,7 @@ def aggregate( pandas.DataFrame: a row per design (and group) """ criteria = statistics if isinstance(statistics, Criteria) else None + across, combiners = None, None if criteria is not None: if by: raise ValueError("criteria group records by their own `by`") @@ -615,6 +884,8 @@ def aggregate( criteria.requirements, criteria.by, ) + across = criteria.across + combiners = None if across is None else _combiners(criteria) else: if not isinstance(statistics, Mapping): statistics = {name: name for name in statistics} @@ -628,14 +899,21 @@ def aggregate( metrics = sorted( {column for statistic in resolved.values() for column in statistic.columns} ) + combined = [] if across is None else [across.column] + groups = _across_groups(results, across) if design_columns is None: - design_columns = _design_columns(feasible, {*_STATUS_COLUMNS, *metrics, *by}) - design_columns = [c for c in design_columns if c not in resolved and c not in by] + design_columns = _design_columns( + feasible, {*_STATUS_COLUMNS, *metrics, *by, *combined} + ) + design_columns = [ + c for c in design_columns if c not in resolved and c not in (*by, *combined) + ] frames = [] for key, positions in _groups(feasible, by): group = feasible.iloc[positions] - designs, _, matrices = _get_matrices(group, metrics) - values, violation = _evaluate(resolved, requirements, matrices) + table = _Statistics(group, resolved, requirements, across, combiners, groups) + designs = table.designs + values, violation = table.evaluate() frame = pd.DataFrame({"design": designs}) for name, value in zip(by, key): frame[name] = value @@ -644,9 +922,7 @@ def aggregate( frame[column] = first.loc[designs, column].to_numpy() for name, value in values.items(): frame[name] = value - frame["replicates"] = ( - group.groupby("design")["replicate"].nunique().reindex(designs).to_numpy() - ) + frame["replicates"] = table.counts if criteria is not None: frame["violation"] = violation frame["meets_requirements"] = violation == 0 diff --git a/src/tatc/tradespace/optimization.py b/src/tatc/tradespace/optimization.py index 5e94d064..0874c066 100644 --- a/src/tatc/tradespace/optimization.py +++ b/src/tatc/tradespace/optimization.py @@ -12,6 +12,11 @@ output constraints, whose violations the optimizers minimize along with those of the constraints of the design space. The tolerances of the criteria do not apply to searches. + +A search of a study with several scenarios (see `Study`) evaluates each +design in every scenario, and judges it by criteria `across` the scenarios +(see `Across`): by its worst or its mean over them, such as for designs +robust to scenarios that cannot be told apart in advance. Each design is evaluated once, however often an optimizer proposes it, and designs proposed together are evaluated together, in parallel if the study is (see `Study`). @@ -35,11 +40,12 @@ from .criteria import ( Criteria, + _across_groups, _as_criteria, - _evaluate, - _get_matrices, + _combiners, _resolve, _signs, + _Statistics, ) from .space import Design, Infeasible from .study import Study @@ -85,6 +91,8 @@ def __init__(self, study: Study, criteria: Criteria | Mapping[str, str]): "searches need one record per evaluation: give criteria without `by`" ) self._statistics = _resolve(self.criteria) + across = self.criteria.across + self._combiners = None if across is None else _combiners(self.criteria) self.values: dict[str, tuple[float, ...] | None] = {} """dict: The objectives of each evaluated design (by key), or `None` if it is infeasible.""" @@ -139,7 +147,16 @@ def _run(self, designs: list[Design]) -> None: self.designs.update((design.key, design) for design in designs) records = self.study.run(designs) self._records.append(records) - if records.groupby(["design", "replicate"]).size().max() > 1: + across = self.criteria.across + groups = _across_groups(records, across) + keys = ["design", "replicate", *([] if across is None else [across.column])] + if records.groupby(keys).size().max() > 1: + if across is None and "scenario" in records.columns: + raise ValueError( + "a study with several scenarios gives a record per scenario: " + + "give criteria `across` the scenarios (see Across), or " + + "search a study with one scenario" + ) raise ValueError( "objectives need one record per evaluation: make the " + "study's evaluate function return a mapping of metrics" @@ -152,9 +169,11 @@ def _run(self, designs: list[Design]) -> None: self.values[key] = self.violations[key] = None feasible = records[~records["design"].isin(infeasible)] if len(feasible) > 0: - keys, _, matrices = _get_matrices(feasible, self.criteria.metrics) - values, _ = _evaluate(self._statistics, [], matrices) - for i, key in enumerate(keys): + table = _Statistics( + feasible, self._statistics, (), across, self._combiners, groups + ) + values, _ = table.evaluate() + for i, key in enumerate(table.designs): self.values[key] = tuple( float(values[name][i]) for name in self.criteria.objectives ) diff --git a/src/tatc/tradespace/pareto.py b/src/tatc/tradespace/pareto.py index a071685f..321b8bde 100644 --- a/src/tatc/tradespace/pareto.py +++ b/src/tatc/tradespace/pareto.py @@ -23,14 +23,15 @@ from .criteria import ( Criteria, Requirement, + _across_groups, _as_criteria, - aggregate, - _evaluate, - _get_matrices, + _combiners, _get_tolerances, _groups, _resolve, _signs, + _Statistics, + aggregate, ) @@ -381,7 +382,9 @@ def pareto_probability( understates the uncertainty. Designs may have different replicates (as after `refine`): replicates are drawn from all of them, and each design's statistics are those of its drawn replicates (or of all of its - replicates, if none is drawn). + replicates, if none is drawn). With criteria `across` the scenarios of a + study (see `Across`), a drawn replicate is drawn in every scenario, in + which it has the same uncertain parameters. Args: results (pandas.DataFrame): The results of a study (see @@ -410,13 +413,17 @@ def pareto_probability( signs = _signs(criteria) tolerances = _get_tolerances(criteria.objectives, criteria.tolerance) feasible = results[results["feasible"]] if "feasible" in results else results - metrics = criteria.metrics + combiners = None if criteria.across is None else _combiners(criteria) + groups = _across_groups(results, criteria.across) rng = np.random.default_rng(seed) frames = [] for key, positions in _groups(feasible, criteria.by): group = feasible.iloc[positions] - designs, replicates, matrices = _get_matrices(group, metrics) - values, violation = _evaluate(resolved, requirements, matrices) + table = _Statistics( + group, resolved, requirements, criteria.across, combiners, groups + ) + designs, replicates = table.designs, table.replicates + values, violation = table.evaluate() def front(values, violation): costs = np.column_stack( @@ -435,9 +442,7 @@ def front(values, violation): squares = {name: np.zeros(len(designs)) for name in criteria.objectives} for _ in range(n_resamples): drawn = rng.integers(0, len(replicates), len(replicates)) - sample, sample_violation = _evaluate( - resolved, requirements, matrices, drawn - ) + sample, sample_violation = table.evaluate(drawn) # designs without a drawn replicate keep the statistics of all of theirs for name in sample: missing = np.isnan(sample[name]) & ~np.isnan(values[name]) @@ -459,9 +464,7 @@ def front(values, violation): mean = sums[name] / n_resamples variance = np.maximum(squares[name] / n_resamples - mean**2, 0.0) frame[f"{name} se"] = np.sqrt(variance) - frame["replicates"] = ( - group.groupby("design")["replicate"].nunique().reindex(designs).to_numpy() - ) + frame["replicates"] = table.counts frame["meets_requirements"] = meets frame["pareto"] = efficient frame["pareto_probability"] = counts / n_resamples diff --git a/src/tatc/tradespace/refinement.py b/src/tatc/tradespace/refinement.py index 2ee467d3..4f96f5b7 100644 --- a/src/tatc/tradespace/refinement.py +++ b/src/tatc/tradespace/refinement.py @@ -160,7 +160,8 @@ def refine( indifferent, or `None` to refine uncertain designs until `max_replicates`. budget (int | None): The most evaluations to add (a design in a - replicate), if limited. + replicate, which a study with scenarios evaluates in each), if + limited. n_resamples (int): The number of resamples of each bootstrap. seed (int): The seed of the bootstraps. diff --git a/src/tatc/tradespace/scenarios.py b/src/tatc/tradespace/scenarios.py index 5e25e48e..c7602586 100644 --- a/src/tatc/tradespace/scenarios.py +++ b/src/tatc/tradespace/scenarios.py @@ -95,9 +95,15 @@ def robustness( Raises: ValueError: if the results have no scenarios, or the criteria group - records by other columns. + records by other columns or combine them across scenarios (see + `Across`, by which searches find robust designs). """ criteria = _as_criteria(criteria) + if criteria.across is not None: + raise ValueError( + "robustness judges designs in each scenario: give criteria without " + + "`across`" + ) if criteria.by not in ((), (scenario,)): raise ValueError( f"criteria judge designs by the scenario ({scenario!r}) alone: " diff --git a/tests/tradespace/test_scenarios.py b/tests/tradespace/test_scenarios.py index 3dee00be..8f8f2f8d 100644 --- a/tests/tradespace/test_scenarios.py +++ b/tests/tradespace/test_scenarios.py @@ -4,6 +4,7 @@ @author Paul T. Grogan """ +import importlib.util import math import tempfile import unittest @@ -14,8 +15,10 @@ import pandas as pd from tatc.tradespace import ( + Across, Criteria, DesignSpace, + Evaluations, Fixed, Integer, Requirement, @@ -24,9 +27,16 @@ Uncertain, aggregate, attribute_variance, + optimize_optuna, + optimize_pymoo, + pareto_front, + pareto_probability, robustness, ) +HAS_OPTUNA = importlib.util.find_spec("optuna") is not None +HAS_PYMOO = importlib.util.find_spec("pymoo") is not None + SPACE = DesignSpace(x=Integer(1, 3), level=Fixed(1.0), noise=Uncertain.uniform(0, 1)) SCENARIOS = {"low": {}, "high": {"level": 3.0}, "pinned": {"noise": 0.5}} @@ -251,6 +261,8 @@ def test_invalid(self): robustness(RESULTS, Criteria(OBJECTIVES, by="other")) r = robustness(RESULTS, Criteria(OBJECTIVES, by="scenario")) self.assertEqual(len(r), 3) + with self.assertRaises(ValueError): + robustness(RESULTS, Criteria(OBJECTIVES, across=Across())) def test_study(self): """The robustness of the designs of a study in scenarios.""" @@ -261,5 +273,207 @@ def test_study(self): self.assertEqual(len(r), 3) +class TestAcross(unittest.TestCase): + """ + Unit tests for criteria that combine statistics across scenarios. + """ + + def _summary(self, criteria, results=RESULTS): + summary = aggregate(results, criteria) + summary["pareto"] = pareto_front(summary, criteria) + return summary.set_index("design") + + def test_worst(self): + """Each objective is its worst over the scenarios, and designs are + judged once.""" + summary = self._summary(Criteria(OBJECTIVES, across=Across())) + self.assertEqual(list(summary.index), ["A", "B", "C"]) + self.assertNotIn("scenario", summary.columns) + np.testing.assert_allclose(summary.perf, [6, 8, 7]) + np.testing.assert_allclose(summary.cost, [5, 3, 4]) + np.testing.assert_array_equal(summary.replicates, [1, 1, 1]) + self.assertEqual(list(summary.pareto), [False, True, False]) + + def test_mean(self): + """Each objective is its mean over the scenarios, weighted by their + weights (normalized over the scenarios of the results).""" + summary = self._summary(Criteria(OBJECTIVES, across=Across(rule="mean"))) + np.testing.assert_allclose(summary.perf, [8, 8.5, 8]) + weighted = Across(rule="mean", weights={"s1": 3, "s2": 1, "s3": 2}) + summary = self._summary(Criteria(OBJECTIVES, across=weighted)) + np.testing.assert_allclose(summary.perf, [9, 8.25, 7.5]) + self.assertEqual(list(summary.pareto), [True, True, False]) + unweighted = Across("scenario", "mean", {"s1": 1}) + with self.assertRaises(ValueError): + aggregate(RESULTS, Criteria(OBJECTIVES, across=unweighted)) + + def test_requirements(self): + """A requirement is met by the combined statistic: in every scenario, + by the worst; a statistic of another name may be combined otherwise + than the objectives.""" + required = [Requirement("perf", ">=", 7)] + criteria = Criteria(OBJECTIVES, requirements=required, across=Across()) + summary = self._summary(criteria) + self.assertEqual(list(summary.meets_requirements), [False, True, True]) + criteria = Criteria( + OBJECTIVES, + statistics={"perf floor": "perf"}, + requirements=[Requirement("perf floor", ">=", 7)], + across=Across(rule="mean", rules={"perf floor": "worst"}), + ) + summary = self._summary(criteria) + np.testing.assert_allclose(summary.perf, [8, 8.5, 8]) + np.testing.assert_allclose(summary["perf floor"], [6, 8, 7]) + self.assertEqual(list(summary.meets_requirements), [False, True, True]) + self.assertAlmostEqual(summary.loc["A", "violation"], 1 / 7) + # the worst of a requirement to stay at most a value is its largest + below = Criteria( + {"perf": "max"}, + statistics={"spent": "cost"}, + requirements=[Requirement("spent", "<=", 4)], + across=Across(), + ) + summary = self._summary(below) + self.assertEqual(list(summary.meets_requirements), [False, True, True]) + + def test_incomplete(self): + """Designs without feasible results in every scenario are not judged.""" + more = _results( + [("D", "s1", 20, 1), ("E", "s1", 20, 1), ("E", "s2", None, None)] + ) + results = pd.concat([RESULTS, more], ignore_index=True) + summary = self._summary(Criteria(OBJECTIVES, across=Across()), results) + self.assertEqual(list(summary.index), ["A", "B", "C"]) + + def test_agrees_with_scenarios(self): + """The worst and the mean of the statistics in a study's scenarios.""" + results = Study( + SPACE, lambda d: d, _evaluate, replicates=3, scenarios=SCENARIOS + ).run() + objectives = {"y": "max", "cost": "min"} + by_scenario = aggregate(results, Criteria(objectives, by="scenario")) + y = by_scenario.pivot(index="design", columns="scenario", values="y") + for rule, expected in (("worst", y.min(axis=1)), ("mean", y.mean(axis=1))): + criteria = Criteria(objectives, across=Across(rule=rule)) + summary = aggregate(results, criteria).set_index("design") + np.testing.assert_allclose(summary.y, expected.loc[summary.index]) + probability = pareto_probability( + results, Criteria(objectives, across=Across()), n_resamples=20 + ).set_index("design") + np.testing.assert_allclose(probability.y, y.min(axis=1).loc[probability.index]) + np.testing.assert_array_equal(probability.replicates, 3) + self.assertTrue(probability.pareto.all()) + + def test_resamples_share_replicates(self): + """A bootstrap draws each replicate in every scenario at once.""" + rows = [ + { + "design": "A", + "replicate": r, + "scenario": s, + "feasible": True, + "perf": v, + } + for r in range(6) + for s, v in (("s1", float(r)), ("s2", 10.0 - r)) + ] + results = pd.DataFrame(rows) + mean = Criteria({"perf": "max"}, across=Across(rule="mean")) + probability = pareto_probability(results, mean, n_resamples=50) + self.assertAlmostEqual(probability["perf"].iloc[0], 5.0) + self.assertAlmostEqual(probability["perf se"].iloc[0], 0.0) + worst = Criteria({"perf": "max"}, across=Across()) + probability = pareto_probability(results, worst, n_resamples=50) + self.assertGreater(probability["perf se"].iloc[0], 0.0) + + def test_invalid(self): + """Rules, weights, and the statistics combined by their worst are + checked.""" + with self.assertRaises(ValueError): + Across(rule="best") + with self.assertRaises(ValueError): + Across(rules={"perf": "best"}) + with self.assertRaises(ValueError): + Across(rule="mean", weights={"s1": 0}) + with self.assertRaises(TypeError): + Across(column="") + with self.assertRaises(TypeError): + Criteria(OBJECTIVES, across="scenario") + with self.assertRaises(ValueError): + Criteria(OBJECTIVES, by="scenario", across=Across()) + with self.assertRaises(ValueError): + Criteria(OBJECTIVES, across=Across(rules={"other": "mean"})) + # a statistic without a direction has no worst, unless combined by its mean + with self.assertRaises(ValueError): + Criteria(OBJECTIVES, statistics={"extra": "perf"}, across=Across()) + Criteria( + OBJECTIVES, + statistics={"extra": "perf"}, + across=Across(rules={"extra": "mean"}), + ) + # an objective and a requirement that disagree on its worst + with self.assertRaises(ValueError): + Criteria( + OBJECTIVES, + requirements=[Requirement("perf", "<=", 9)], + across=Across(), + ) + with self.assertRaises(ValueError): + aggregate( + RESULTS.drop(columns="scenario"), Criteria(OBJECTIVES, across=Across()) + ) + + +def _scenario_study(): + return Study(SPACE, lambda d: d, _evaluate, replicates=2, scenarios=SCENARIOS) + + +class TestSearchAcross(unittest.TestCase): + """ + Unit tests for searches across scenarios. + """ + + def test_evaluations(self): + """A search judges each design across the scenarios, as aggregate does.""" + criteria = Criteria({"y": "max", "cost": "min"}, across=Across()) + evaluations = Evaluations(_scenario_study(), criteria) + designs = SPACE.enumerate() + values = evaluations.evaluate(designs) + summary = aggregate(evaluations.results, criteria).set_index("design") + for design, (y, cost) in zip(designs, values): + self.assertAlmostEqual(y, summary.loc[design.key, "y"]) + self.assertAlmostEqual(cost, summary.loc[design.key, "cost"]) + self.assertEqual(len(evaluations.results), 3 * 2 * len(SCENARIOS)) + + def test_needs_across(self): + """A search of a study with several scenarios needs criteria across them.""" + evaluations = Evaluations(_scenario_study(), {"y": "max", "cost": "min"}) + with self.assertRaisesRegex(ValueError, "across"): + evaluations.evaluate(SPACE.enumerate()[:1]) + # a study with one scenario has one record per evaluation + one = Study(SPACE, lambda d: d, _evaluate, scenarios={"high": {"level": 3.0}}) + Evaluations(one, {"y": "max", "cost": "min"}).evaluate(SPACE.enumerate()) + + @unittest.skipUnless(HAS_PYMOO, "requires pymoo") + def test_pymoo(self): + """pymoo searches across the scenarios.""" + # pylint: disable-next=import-outside-toplevel + from pymoo.algorithms.moo.nsga2 import NSGA2 + + criteria = Criteria({"y": "max", "cost": "min"}, across=Across(rule="mean")) + search = optimize_pymoo( + _scenario_study(), criteria, NSGA2(pop_size=4), ("n_gen", 2), seed=1 + ) + self.assertEqual(set(search.results.scenario), set(SCENARIOS)) + self.assertGreater(len(search.designs), 0) + + @unittest.skipUnless(HAS_OPTUNA, "requires optuna") + def test_optuna(self): + """Optuna searches across the scenarios.""" + criteria = Criteria({"y": "max", "cost": "min"}, across=Across()) + search = optimize_optuna(_scenario_study(), criteria, n_trials=6) + self.assertEqual(set(search.results.scenario), set(SCENARIOS)) + + if __name__ == "__main__": unittest.main() From 8c5771ffb862cbd06db69e2346d48ecf27fd5716 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Thu, 12 Nov 2026 09:12:23 -0700 Subject: [PATCH 32/52] let the rules of stages read the capability of the satellites at a decision Decision.capability gives the study's metrics of the satellites operating at a decision, from the Capability that the evaluations of an ObservationStudy give each deployment (Deployment.capability), with the cache of its phases (which now also caches the phases of studies without failures). The example adds a staging that measures the first plane. --- CHANGELOG.md | 2 +- docs/api_reference/tradespace.rst | 7 +- docs/examples/SearchTradeSpace.ipynb | 34 +++-- src/tatc/tradespace/__init__.py | 2 + src/tatc/tradespace/deployment.py | 29 ++-- src/tatc/tradespace/mission.py | 201 +++++++++++++++++++++++--- src/tatc/tradespace/observations.py | 24 +-- tests/tradespace/test_observations.py | 42 ++++++ tests/tradespace/test_stages.py | 99 +++++++++++++ 9 files changed, 393 insertions(+), 47 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 1cd606e4..6ee45acf 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -29,7 +29,7 @@ Added: - The schedule and cost model of a `tradespace.MissionPlan` may be functions of the design (`schedule_of`, `cost_model_of`), which size them by its values with relationships of the study's own, such as the costs of a type of satellite from its payload or the capacity of launches to the design's altitude; launches limited in mass take the masses of the satellites from the cost model (`masses_of`, or the plan's `masses`). The `launch_mass_capacity` of a `DeploymentSchedule` may be a function of a plane (`mass_capacity_of`), for planes at different inclinations. - The start of the period of `tradespace.Observations` may be a value of the design (`start_of` and `end_of` give a design's period), such as an uncertain epoch drawn for each replicate over the mission, whose observations are cached apart, so that replicates average over the geometry and seasons of the mission that the one window of quasi-static phases misses (as `evaluate_phases` now states). The schedule of deployments states that a design life does not retire a satellite that is not replaced, and simulations that a planned replacement whose launch fails is not flown again. - Utilities of the metrics of designs (`tradespace.Utility`), for trade spaces of utility against cost: a single-attribute utility of each metric (`LinearUtility`, `ExponentialUtility` of a risk attitude, `PiecewiseUtility`, or any function), combined by weights additively or in Keeney and Raiffa's multiplicative form. A utility is a metric of any statistic (its `Mean` is the expected utility over the replicates, and a utility given as a statistic of `Criteria` is its mean), computed in each replicate, and gives the utility of each row of a data frame (such as a summary of the means of designs). Statistics name the columns they need (`Statistic.columns`). - - Staged deployments (`tradespace.Stage`, argument `stages` of `DeploymentSchedule.plan` and `MissionPlan`, which may give the stages of each design): planes that are produced and launched only if a rule decides to, at times during the mission, from what it knows then (`Decision`: the satellites operating, the history so far, and, through the design, its uncertain parameters and scenario), after a lead time and at the next launch slots, and replaced and restored as other planes. A stage that is not deployed is neither produced, launched, nor priced; `MissionHistory.stages` gives when each was deployed, and its metrics the `stages deployed`. Exact expectations of missions without restoration (`expected_missions`) need deployments that are not staged, so that studies of staged deployments sample their histories. + - Staged deployments (`tradespace.Stage`, argument `stages` of `DeploymentSchedule.plan` and `MissionPlan`, which may give the stages of each design): planes that are produced and launched only if a rule decides to, at times during the mission, from what it knows then (`Decision`: the satellites operating, the history so far, and, through the design, its uncertain parameters and scenario), after a lead time and at the next launch slots, and replaced and restored as other planes. Rules may also read the capability of the satellites operating at a decision (`Decision.capability`, the study's metrics of their observations, as of a phase), which the evaluations of an `ObservationStudy` give each deployment (`Deployment.capability`, a `tradespace.Capability` of its satellites, observations, and cached phases, which also caches the phases of studies without failures), such as for a plane deployed only if those in orbit fall short. A stage that is not deployed is neither produced, launched, nor priced; `MissionHistory.stages` gives when each was deployed, and its metrics the `stages deployed`. Exact expectations of missions without restoration (`expected_missions`) need deployments that are not staged, so that studies of staged deployments sample their histories. - Scenarios of studies (argument `scenarios` of `tradespace.Study`): conditions under which designs are compared rather than averaged over, each giving fixed values or uncertain parameters of the design space other values (`Design.realize` takes a `scenario`), so that each design is evaluated in each scenario (recorded as `scenario`, and judged in each with criteria `by` it). Each scenario's evaluations are stored by its values, so that a scenario added later is evaluated alone. Function `tradespace.robustness` gives each design's Pareto trace (the share of scenarios in which it is efficient) and its regret in each scenario (the improvement in every objective it would need to match the scenario's front) and the largest. The metrics of an `ObservationStudy` (and of `PhaseCache`, `evaluate_missions`, and `expected_missions`) are given the realized design if they have a parameter named `design`. - Criteria across the scenarios of a study (`tradespace.Across`, argument `across` of `Criteria`), which judge each design once by its worst or its (weighted) mean statistics over the scenarios (or the groups of another column), so that searches find designs robust to scenarios; a requirement may be met in every scenario while objectives are means. - Function `tradespace.attribute_variance` (and class `Attribution`), which attributes the variance of metrics between the replicates of each design to its uncertain parameters (or groups of them): the share that each causes, alone or with others, and the share that knowing it would remove, with standard errors, by evaluating designs with one parameter drawn as in other replicates and the others held (which works for seeds, whose values do not order outcomes); `Attribution.summary` pools the shares of several designs, and `Attribution.differences` attributes the variance of the differences between pairs of designs, from the same evaluations (parameters that act alike on both cancel, with common random numbers). `Design.realize` and `Study.run` take a `shift`, which draws named parameters as in other replicates (kept apart in a `ResultStore` as a variant of the replicates), and `DesignSpace.uncertain_paths` lists the uncertain parameters. diff --git a/docs/api_reference/tradespace.rst b/docs/api_reference/tradespace.rst index 070aaf96..1988618b 100644 --- a/docs/api_reference/tradespace.rst +++ b/docs/api_reference/tradespace.rst @@ -98,7 +98,7 @@ Deployment :members: plan, launches_of, mass_capacity_of .. autoclass:: tatc.tradespace.Deployment - :members: simulate, simulate_many, expected_metrics, planned, phases, begin, end, deployed, units + :members: simulate, simulate_many, expected_metrics, planned, phases, begin, end, deployed, units, stages, capability .. autoclass:: tatc.tradespace.Launch @@ -107,6 +107,7 @@ Deployment .. autoclass:: tatc.tradespace.Stage .. autoclass:: tatc.tradespace.Decision + :members: time, stage, operating, history, deployed, capability Failures and Missions --------------------- @@ -149,6 +150,10 @@ Failures and Missions .. autoclass:: tatc.tradespace.PhaseCache :members: evaluate, clear +.. autoclass:: tatc.tradespace.Capability + :members: at + :special-members: __call__ + .. autofunction:: tatc.tradespace.evaluate_missions .. autofunction:: tatc.tradespace.summarize_missions diff --git a/docs/examples/SearchTradeSpace.ipynb b/docs/examples/SearchTradeSpace.ipynb index c0125b19..2141e912 100644 --- a/docs/examples/SearchTradeSpace.ipynb +++ b/docs/examples/SearchTradeSpace.ipynb @@ -2872,7 +2872,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "16440 evaluations (3 fields) in 139 s\n", + "16440 evaluations (3 fields) in 133 s\n", "efficient designs: {'1 hour': 14, '3 hours': 13, '12 hours': 6}\n" ] }, @@ -3598,7 +3598,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "65 designs x 5 replicates x 20 histories in 8 s\n" + "65 designs x 5 replicates x 20 histories in 9 s\n" ] }, { @@ -4406,7 +4406,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "1700 evaluations in 46 s\n" + "1700 evaluations in 47 s\n" ] }, { @@ -5634,9 +5634,9 @@ "source": [ "## Stage the Deployment\n", "\n", - "A deployment need not commit to every plane at once. A stage of a deployment (`Stage`) is a set of planes produced and launched only if a rule decides to, at times during the mission, from what it knows then (a `Decision`: the satellites operating and the history so far) and from the values of the design, such as its uncertain parameters and its scenario. A stage that is not deployed is neither produced, launched, nor paid for, so that a staged deployment is an option: it saves the cost of a stage where the mission does not need it, and loses what deferring the stage costs where it does (as above, the capability of the satellites not yet launched). Whether and how to stage is a decision of each design (here, a value `staging` of the design space), and the `stages` of a `MissionPlan` are a function of the design.\n", + "A deployment need not commit to every plane at once. A stage of a deployment (`Stage`) is a set of planes produced and launched only if a rule decides to, at times during the mission, from what it knows then (a `Decision`: the satellites operating, what they achieve, and the history so far) and from the values of the design, such as its uncertain parameters and its scenario. A stage that is not deployed is neither produced, launched, nor paid for, so that a staged deployment is an option: it saves the cost of a stage where the mission does not need it, and loses what deferring the stage costs where it does (as above, the capability of the satellites not yet launched). Whether and how to stage is a decision of each design (here, a value `staging` of the design space), and the `stages` of a `MissionPlan` are a function of the design.\n", "\n", - "Here, the robust design of four satellites across the fields of the scenarios above (two sun-synchronous planes of two) deploys its second plane at once, never, or only if the field turns out to vary within hours (to decorrelate within 6 hours), as decided at the first launch or a year later. Each staging is evaluated in each field by the phases of its deployment: the mean share of points accurately sampled over the mission, and the present cost:" + "Here, the robust design of four satellites across the fields of the scenarios above (two sun-synchronous planes of two) deploys its second plane at once, never, or only if the field turns out to vary within hours (to decorrelate within 6 hours), as decided at the first launch or a year later. These rules read the field from the scenario, which a mission does not know; the last rule reads what the first plane achieves once it is launched (`Decision.capability`, by the study's metrics), and deploys the second plane if the first samples fewer than half the points accurately. Each staging is evaluated in each field by the phases of its deployment: the mean share of points accurately sampled over the mission, and the present cost:" ] }, { @@ -5729,6 +5729,15 @@ " 154.5\n", " 118.8\n", " \n", + " \n", + " measured at launch\n", + " 62.6\n", + " 77.9\n", + " 73.0\n", + " 156.4\n", + " 156.4\n", + " 118.8\n", + " \n", " \n", "\n", "" @@ -5741,6 +5750,7 @@ "first plane 4.8 10.0 73.0 118.8 118.8 \n", "decided at launch 62.6 77.9 73.0 156.4 156.4 \n", "decided a year later 49.7 62.8 73.0 154.5 154.5 \n", + "measured at launch 62.6 77.9 73.0 156.4 156.4 \n", "\n", " \n", "scenario 12 hours \n", @@ -5748,7 +5758,8 @@ "at once 156.4 \n", "first plane 118.8 \n", "decided at launch 118.8 \n", - "decided a year later 118.8 " + "decided a year later 118.8 \n", + "measured at launch 118.8 " ] }, "execution_count": 27, @@ -5761,17 +5772,20 @@ "\n", "from tatc.tradespace import Stage\n", "\n", - "STAGING = [\"at once\", \"first plane\", \"decided at launch\", \"decided a year later\"]\n", + "STAGING = [\"at once\", \"first plane\", \"decided at launch\", \"decided a year later\", \"measured at launch\"]\n", "staging_space = DesignSpace(**space.children, staging=Categorical(STAGING), constraints=space.constraints)\n", "\n", "\n", "def stages(d):\n", " \"\"\"The stages of a design's deployment: its second plane deployed with the first (at once), never (first plane),\n", - " or if the field decorrelates within 6 hours, as decided at the first launch or a year later.\"\"\"\n", + " or if the field decorrelates within 6 hours, as decided at the first launch or a year later, or if the first plane\n", + " accurately samples fewer than half the points, as measured at the first launch.\"\"\"\n", " if d.staging == \"at once\":\n", " return []\n", " if d.staging == \"first plane\":\n", " return [Stage(1, 0.0, lambda decision: False)]\n", + " if d.staging == \"measured at launch\":\n", + " return [Stage(1, 0.0, lambda decision: decision.capability[\"accurate\"] < 50)]\n", " when = 0.0 if d.staging == \"decided at launch\" else 1.0\n", " return [Stage(1, when, lambda decision: d.decorrelation_time < timedelta(hours=6))]\n", "\n", @@ -5793,7 +5807,7 @@ "id": "34aa9033", "metadata": {}, "source": [ - "Deciding at the first launch is worth the most. Where the field varies within hours, the second plane is produced and launched as if it were deployed at once (63% and 78% of the points accurately sampled on average over the mission, for 156 million dollars), and where it varies slowly, it is not, which saves 38 million dollars (24%) for 18 points of the mean (73% against 91%): a trade that the rule makes, and that a mission might not. Deciding a year later costs the fields that need the second plane 13 to 15 points of the mean (50% and 63%), as the first plane flies alone for a year more, and saves only 2 million dollars, by discounting the later production. The value of the option is that of knowing the need when it is exercised: the earlier the field is known, the more staging saves at less loss. A rule may decide on anything known by then, such as the satellites still operating (see `Decision`), for a reserve plane launched only if satellites fail." + "Deciding at the first launch is worth the most. Where the field varies within hours, the second plane is produced and launched as if it were deployed at once (63% and 78% of the points accurately sampled on average over the mission, for 156 million dollars), and where it varies slowly, it is not, which saves 38 million dollars (24%) for 18 points of the mean (73% against 91%): a trade that the rule makes, and that a mission might not. Deciding a year later costs the fields that need the second plane 13 to 15 points of the mean (50% and 63%), as the first plane flies alone for a year more, and saves only 2 million dollars, by discounting the later production. The value of the option is that of knowing the need when it is exercised: the earlier the field is known, the more staging saves at less loss. The rule that measures makes the same choices as the rule that reads the field, in every field: the first plane alone accurately samples 5% and 10% of the points where the field varies within hours, so that the second plane is deployed, and 73% where it varies over 12 hours, so that it is not. A mission knows what its satellites achieve, not the field, so this is a rule it could follow; a measurement takes time, though (the rule reads at once the capability that the study computes), and one that waits a year to measure loses what deciding a year later loses above. A rule may also read the satellites still operating (see `Decision`), for a reserve plane launched only if satellites fail, or their capability, for one launched only if those in orbit fall short." ] }, { @@ -6188,7 +6202,7 @@ "* `screen` evaluates every design with a cheap study and the best with the full one, which finds the front at a fraction of the cost if the cheap study ranks designs as the full one does.\n", "* A `Utility` weighs metrics by a stakeholder's preferences (a single-attribute utility of each, combined by weights) into one objective against cost, and is a metric of any statistic (its mean is the expected utility): here, stakeholders who weigh sufficiency or accuracy most agree within the budget and part beyond it.\n", "* A `DeploymentSchedule` plans each design's deployment from rates of production and launch, which dates its costs and divides its mission into phases of the satellites that fly, evaluated with the observations of the full constellation (over one day, which an epoch drawn for each replicate shows to represent the mission here) for the mean capability over the mission and the time until a requirement is met.\n", - "* A `Stage` of a deployment is produced and launched only if a rule decides to, from what is known then (a `Decision`) and the values of the design: an option whose value the analyses of a study measure (here, deciding at the first launch whether the field needs a second plane saves 38 million dollars where it does not, at no loss where it does, and deciding a year later loses 13 to 15 points of the mean where it does).\n", + "* A `Stage` of a deployment is produced and launched only if a rule decides to, from what is known then (a `Decision`) and the values of the design: an option whose value the analyses of a study measure (here, deciding at the first launch whether the field needs a second plane saves 38 million dollars where it does not, at no loss where it does, and deciding a year later loses 13 to 15 points of the mean where it does). A rule may read what the satellites in orbit achieve (`Decision.capability`): here, a second plane deployed if the first accurately samples fewer than half the points makes the same choices without knowing the field.\n", "* A `CostModel` estimates the life-cycle cost of each deployment from the costs of its satellites, launches, and operations (given by the study), with uncertain growth whose quantiles give the cost at a confidence level, as an objective or a requirement in place of the numbers of satellites and planes.\n", "* `optimize_optuna` and `optimize_pymoo` search spaces too large to enumerate, and find most of the front with a fraction of the designs (`hypervolume_progress`), pymoo's proposing no design twice (by design, not by point of the encoded space).\n", "* `plot_designs` and `plot_progress` plot the designs, with the efficient ones ringed, and the progress of searches.\n", diff --git a/src/tatc/tradespace/__init__.py b/src/tatc/tradespace/__init__.py index 46fe8d9b..f7cc4748 100644 --- a/src/tatc/tradespace/__init__.py +++ b/src/tatc/tradespace/__init__.py @@ -55,6 +55,7 @@ summarize_missions, ) from .mission import ( + Capability, Decision, MissionHistory, Phase, @@ -137,6 +138,7 @@ "Across", "Attribution", "Bathtub", + "Capability", "Categorical", "Choice", "ChoiceValues", diff --git a/src/tatc/tradespace/deployment.py b/src/tatc/tradespace/deployment.py index 7d01d628..92ff9233 100644 --- a/src/tatc/tradespace/deployment.py +++ b/src/tatc/tradespace/deployment.py @@ -23,8 +23,9 @@ A deployment may be staged (see `Stage`): planes that are produced and launched only if a rule decides to, at times during the mission, from what -it knows then (see `Decision`), such as a second plane that is launched only -if the mission turns out to need it. Whether and how to stage a deployment +it knows then (see `Decision`, which includes the capability of the +satellites in orbit), such as a second plane that is launched only if the +mission turns out to need it. Whether and how to stage a deployment is a decision of a design, whose flexibility (the cost saved where a stage is not needed, against the capability lost by deferring it where it is) the analyses of a study compare with deployments that are not staged. @@ -45,7 +46,7 @@ from .failures import FailureModel, RestorationPolicy from .histories import _simulate_many from .histories import expected_metrics as _expected_metrics -from .mission import Decision, MissionHistory, Phase, _Simulation +from .mission import Capability, Decision, MissionHistory, Phase, _Simulation from .values import Values @@ -68,7 +69,12 @@ class Stage: parameter or a value of a scenario, known by the time of the decision) reads them from the design, as stages made for each design (see `MissionPlan`) can: for example, `Stage([1], 1.0, lambda decision: - design.decorrelation_time < timedelta(hours=6))`. + design.decorrelation_time < timedelta(hours=6))`. A rule may instead + read what the satellites in orbit achieve (see `Decision.capability`), + as a mission that does not know such values measures them: for example, + `Stage([1], 1.0, lambda decision: decision.capability["accurate"] < + 50)`, which deploys the plane if the satellites operating then sample + fewer than half the points accurately. Args: planes (Sequence[int] | int): The planes of the stage (their indices, @@ -134,7 +140,12 @@ class Deployment: stages: tuple[Stage, ...] = () """tuple[Stage, ...]: The stages deployed only if their rules decide to (whose planes the production and launches above do not include).""" - _planned: MissionHistory | None = field(default=None, repr=False, compare=False) + capability: Capability | None = field(default=None, repr=False, compare=False) + """Capability | None: The capability of the satellites, which the rules + of stages may read at their decisions (see `Decision.capability`) in + every simulation of the deployment, as the evaluations of an + `ObservationStudy` with a `MissionPlan` give it.""" + _planned: tuple | None = field(default=None, repr=False, compare=False) @property def begin(self) -> float: @@ -207,14 +218,14 @@ def simulate( def planned(self) -> MissionHistory: """ Gets the history of the mission without failures (see `simulate`), - simulated once. + simulated once (for its capability). Returns: MissionHistory: the history """ - if self._planned is None: - self._planned = self.simulate() - return self._planned + if self._planned is None or self._planned[0] is not self.capability: + self._planned = (self.capability, self.simulate()) + return self._planned[1] def simulate_many( self, diff --git a/src/tatc/tradespace/mission.py b/src/tatc/tradespace/mission.py index 585d1a58..c0e33656 100644 --- a/src/tatc/tradespace/mission.py +++ b/src/tatc/tradespace/mission.py @@ -12,9 +12,9 @@ import heapq import itertools import math -from collections.abc import Callable, Mapping, Sequence +from collections.abc import Callable, Iterable, Mapping, Sequence from dataclasses import dataclass, field, replace -from functools import partial +from functools import cached_property, partial from typing import TYPE_CHECKING, Any import numpy as np @@ -225,7 +225,10 @@ def metrics(self) -> dict[str, float]: class Decision: """ What the rule of a stage of a deployment knows when it decides whether to - deploy the stage (see `Stage`). + deploy the stage (see `Stage`): the satellites operating and the history + so far, and the capability of the satellites operating (see + `capability`), such as for a stage deployed only if the satellites in + orbit fall short of a requirement. """ time: float @@ -240,6 +243,32 @@ class Decision: have ended.""" deployed: tuple[int, ...] """tuple[int, ...]: The stages deployed so far.""" + _measure: Callable[[], dict[str, float]] | None = field( + default=None, repr=False, compare=False + ) + + @cached_property + def capability(self) -> dict[str, float]: + """dict[str, float]: The metrics of the satellites operating at the + decision, as of a phase in which they operate (see `Capability`): + the capability of the satellites in orbit then, evaluated only if a + rule reads it. It is the capability that the evaluation computes, + as if the mission measured it exactly and at once: a rule that + decides from an estimate adds its error (such as from an uncertain + parameter of the design), and one that waits for a measurement + decides later. + + Raises: + ValueError: if the deployment has no capability (see + `Deployment.capability`, which the evaluations of an + `ObservationStudy` with a `MissionPlan` give).""" + if self._measure is None: + raise ValueError( + "the capability of the satellites at a decision needs a " + + "deployment with a capability (see Deployment.capability), " + + "as the evaluations of an ObservationStudy with a plan give" + ) + return dict(self._measure()) @dataclass @@ -444,12 +473,23 @@ def _on_decide(self, time: float, index: int) -> None: return # deployed at an earlier decision stage = self.deployment.stages[index] if stage.rule is not None: + operating = [ + position + for position, slot in self.slots.items() + if slot["up"] is not None + ] + capability = self.deployment.capability decision = Decision( time - self.deployment.begin, index, - sum(slot["up"] is not None for slot in self.slots.values()), + len(operating), self.history, tuple(sorted(self.decided)), + ( + None + if capability is None + else partial(capability.at, self.deployment.planes, operating) + ), ) if not stage.rule(decision): return @@ -769,12 +809,7 @@ def _evaluate_phases( for phase in phases: names = frozenset(phase.satellites) if names not in evaluated: - - def subset(names: frozenset = names) -> pd.DataFrame: - if "satellite" in observations.columns: - return observations[observations["satellite"].isin(names)] - return observations.iloc[0:0] - + subset = partial(_subset, observations, names) evaluated[names] = dict(metric(subset, names)) rows.append( { @@ -788,6 +823,13 @@ def subset(names: frozenset = names) -> pd.DataFrame: return pd.DataFrame(rows) +def _subset(observations: pd.DataFrame, names: frozenset) -> pd.DataFrame: + """The observations of the satellites of names (none if not by satellite).""" + if "satellite" in observations.columns: + return observations[observations["satellite"].isin(names)] + return observations.iloc[0:0] + + def _given_design(metric: Callable, design: Any) -> Callable: """ Gets a metric of observations alone: the metric, given the design if it @@ -870,16 +912,27 @@ def evaluate( metric = _given_design(self.metric, design) def cached(subset: Callable[[], pd.DataFrame], names: frozenset) -> dict: - key = (context, frozenset(keys[name] for name in names)) - if key in self._memory: - self.hits += 1 - else: - self.misses += 1 - self._memory[key] = dict(metric(subset())) - return self._memory[key] + return self._metrics( + (context, frozenset(keys[name] for name in names)), subset, metric + ) return _evaluate_phases(phases, observations, cached) + def _metrics( + self, + key: tuple, + subset: Callable[[], pd.DataFrame], + metric: Callable[[pd.DataFrame], Mapping[str, float]], + ) -> dict: + """The metrics of a set of satellites (keyed by the context and the + keys of the satellites), from the memory if they are in it.""" + if key in self._memory: + self.hits += 1 + else: + self.misses += 1 + self._memory[key] = dict(metric(subset())) + return self._memory[key] + def clear(self) -> None: """ Clears the cache and its statistics. @@ -892,3 +945,117 @@ def __repr__(self) -> str: f"PhaseCache({len(self._memory)} results, " + f"{self.hits} hits, {self.misses} misses)" ) + + +class Capability: + """ + The capability of the satellites that operate together at a time of a + mission: the metrics of their observations, as of a phase in which they + operate (over the study's representative period, see + `evaluate_phases`), which the rules of stages read at their decisions + (see `Decision.capability` and `Deployment.capability`). The + evaluations of an `ObservationStudy` with a `MissionPlan` give their + deployments the capability of their satellites, with the cache of their + phases: the satellites operating at a decision are those of a phase of + the mission, which the evaluation evaluates anyway. + + Args: + satellites (Sequence[Satellite | str]): The satellites (or their + names), in the order of the planes (see `MissionHistory.phases`). + observations (pandas.DataFrame): The observations of every + satellite, with their names (`satellite`). + metric (Callable | PhaseCache): A function of the observations of + satellites (which may be empty) that gives their metrics, or a + cache of one (which keys satellites by their content, or by the + names given for them). + context (Any): A hashable identifier of the observations, for a + cache (see `PhaseCache`). + design (Design | None): The (realized) design of the mission, for a + metric with a parameter named `design`. + """ + + def __init__( + self, + satellites: Sequence[Satellite | str], + observations: pd.DataFrame, + metric: Callable[..., Mapping[str, float]] | PhaseCache, + context: Any = None, + design: Any = None, + ): + # pylint: disable=too-many-arguments,too-many-positional-arguments + self.satellites = list(satellites) + """list: The satellites (or their names), in the order of the planes.""" + self.observations = observations + """pandas.DataFrame: The observations of every satellite.""" + self.metric = metric + """Callable | PhaseCache: The metric, or a cache of one.""" + self.context = context + """Any: The identifier of the observations, for a cache.""" + self.design = design + """Design | None: The (realized) design of the mission.""" + self._names = _names(self.satellites) + + @cached_property + def _keys(self) -> dict[str, str]: + """The keys of the satellites in a cache, by name.""" + return { + name: ( + get_satellite_key(satellite) + if isinstance(satellite, Satellite) + else name + ) + for name, satellite in zip(self._names, self.satellites) + } + + def __call__(self, names: Iterable[str]) -> dict[str, float]: + """ + Gets the metrics of satellites that operate together. + + Args: + names (Iterable[str]): The names of the satellites. + + Returns: + dict[str, float]: the metrics + """ + names = frozenset(names) + unknown = names - set(self._names) + if unknown: + raise ValueError(f"satellites that are not given: {sorted(unknown)}") + subset = partial(_subset, self.observations, names) + metric = ( + self.metric.metric if isinstance(self.metric, PhaseCache) else self.metric + ) + metric = _given_design(metric, self.design) + if isinstance(self.metric, PhaseCache): + key = (self.context, frozenset(self._keys[name] for name in names)) + # pylint: disable-next=protected-access + return dict(self.metric._metrics(key, subset, metric)) + return dict(metric(subset())) + + def at( + self, + planes: Sequence[tuple[Any, int, int]], + positions: Iterable[tuple[int, int]], + ) -> dict[str, float]: + """ + Gets the metrics of the satellites at positions of the planes of a + deployment (see `Deployment.planes`). + + Args: + planes (Sequence[tuple[Any, int, int]]): The planes: the type of + their satellites, and the number of satellites and of spares. + positions (Iterable[tuple[int, int]]): The plane and position of + each satellite. + + Returns: + dict[str, float]: the metrics + """ + offsets = np.cumsum([0] + [built for _, built, _ in planes]) + if len(self._names) != offsets[-1]: + raise ValueError( + f"expected {offsets[-1]} satellites for the planes, " + + f"not {len(self._names)}" + ) + return self( + self._names[offsets[plane] + position] for plane, position in positions + ) diff --git a/src/tatc/tradespace/observations.py b/src/tatc/tradespace/observations.py index 2896732a..ca7edfa5 100644 --- a/src/tatc/tradespace/observations.py +++ b/src/tatc/tradespace/observations.py @@ -31,7 +31,7 @@ from .deployment import DeploymentSchedule from .failures import FailureModel, RestorationPolicy from .histories import evaluate_missions, expected_missions, summarize_missions -from .mission import PhaseCache, _given_design, evaluate_phases, summarize_phases +from .mission import Capability, PhaseCache, _given_design, summarize_phases from .space import Design, DesignSpace, _scenario_of from .study import Study, _takes_design from .values import configure @@ -360,7 +360,9 @@ def schedule(d): stages (Sequence[Stage] | Callable): The stages of the deployment (see `Stage`), or a function of the (realized) design that gives them, such as of a decision whether to stage it and of the values - its rules read. + its rules read. Their rules may also read the capability of the + satellites operating at a decision, by the study's metrics (see + `Decision.capability`). masses (Any): The mass (kg) of the satellites (or of each type, a mapping), or a value of the design, for launches limited in mass, or `None` for the masses of the cost model. @@ -531,6 +533,11 @@ def __call__(self, satellites: Sequence[Satellite], design: Design) -> dict: layout = value_of(design, self.layout) if layout is not None: record["planes"] = count_planes(layout) + # the metrics of phases are cached by the observations and, if they + # are given the design, by its scenario + context = self.observations.context_of(design) + if _takes_design(self.metrics): + context = (context, _scenario_of(design)) if self.plan is not None: policy, spares = self._policy(design) kind = value_of(design, self.plan.kind) @@ -542,16 +549,15 @@ def __call__(self, satellites: Sequence[Satellite], design: Design) -> dict: masses=self.plan.masses_of(design, cost_model), stages=self.plan.stages_of(design), ) + # the capability that the rules of stages read at their decisions + deployment.capability = Capability( + satellites, observations, self._phase_cache, context, design + ) growth = self.plan.growth_of(design) if cost_model is not None: record.update(cost_model.estimate(deployment, growth).metrics()) metrics = _given_design(self.metrics, design) record.update(metrics(observations)) - # the metrics of phases are cached by the observations and, if they - # are given the design, by its scenario - context = self.observations.context_of(design) - if _takes_design(self.metrics): - context = (context, _scenario_of(design)) if self.failures is not None: histories = deployment.simulate_many( self.failures.model, @@ -601,8 +607,8 @@ def __call__(self, satellites: Sequence[Satellite], design: Design) -> dict: } ) elif self.phases is not None: - capability = evaluate_phases( - deployment.phases(satellites), observations, metrics + capability = self._phase_cache.evaluate( + deployment.phases(satellites), observations, satellites, context, design ) record.update(summarize_phases(capability, requirements=self.phases)) return record diff --git a/tests/tradespace/test_observations.py b/tests/tradespace/test_observations.py index 14e2cdb5..95843f1e 100644 --- a/tests/tradespace/test_observations.py +++ b/tests/tradespace/test_observations.py @@ -421,6 +421,48 @@ def stages(design): self.assertTrue(degraded.feasible.all()) self.assertTrue(any("stages deployed" in column for column in degraded)) + def test_capability_rules(self): + """Rules of stages read the capability of the satellites operating at a + decision, by the study's metrics, in phases and in histories.""" + stagings = ["delayed", "measured", "never", "never measured"] + space = DesignSpace(**SPACE.children, staging=Categorical(stagings)) + + def stages(design): + """A second plane deployed at the first launch, if a rule decides to.""" + rules = { + "delayed": None, + "measured": lambda decision: decision.capability["observed"] <= 100, + "never": lambda decision: False, + "never measured": lambda decision: decision.capability["observed"] < 0, + } + return [Stage(1, 0.0, rules[design.staging])] + + designs = [ + d + for d in space.enumerate() + if d.layout.planes == 2 and d.layout.per_plane == 1 + ] + plan = MissionPlan(SCHEDULE, COSTS, stages=stages) + options = {"layout": "layout", "plan": plan, "replicates": 2} + failures = Failures( + FAILURES, RestorationPolicy(restore=False), histories=4, seed="failure_seed" + ) + for summary in ({"phases": True}, {"failures": failures}): + with self.subTest(summary=list(summary)): + results = ObservationStudy( + space, _build, _observations(), _metrics, **options, **summary + ).run(designs) + means = results.groupby("staging")[["observed mean", "cost"]].mean() + pd.testing.assert_series_equal( + means.loc["measured"], means.loc["delayed"], check_names=False + ) + pd.testing.assert_series_equal( + means.loc["never measured"], means.loc["never"], check_names=False + ) + self.assertLess( + means.loc["never", "cost"], means.loc["delayed", "cost"] + ) + def test_invalid(self): """Failures and phases need a plan, and a plan needs a layout.""" observations = _observations() diff --git a/tests/tradespace/test_stages.py b/tests/tradespace/test_stages.py index 50aff598..24967797 100644 --- a/tests/tradespace/test_stages.py +++ b/tests/tradespace/test_stages.py @@ -6,12 +6,16 @@ import unittest +import pandas as pd + from tatc.tradespace import ( + Capability, CostModel, DeploymentSchedule, DesignSpace, Exponential, FailureModel, + PhaseCache, RestorationPolicy, SatelliteCost, Stage, @@ -31,6 +35,16 @@ def _layout(): return LAYOUT.enumerate()[0].layout +NAMES = [f"s{i}" for i in range(6)] +# an observation of each satellite, so that the metric counts those operating +OBSERVATIONS = pd.DataFrame({"satellite": NAMES}) + + +def _count(observations): + """The number of satellites that observe.""" + return {"observing": float(observations.satellite.nunique())} + + def _launches(history, plane): return [ (launch.time, launch.purpose) @@ -114,6 +128,91 @@ def test_contingency(self): again = deployment.simulate_many(failures, policy, seed=1, histories=20) self.assertEqual([h.stages for h in again], [h.stages for h in histories]) + def test_capability(self): + """Rules read the capability of the satellites operating at a decision.""" + seen = [] + + def rule(decision): + seen.append((decision.time, decision.operating, decision.capability)) + return decision.capability["observing"] < 4 + + deployment = SCHEDULE.plan(_layout(), stages=[Stage(2, [0.0, 0.5], rule)]) + deployment.capability = Capability(NAMES, OBSERVATIONS, _count) + history = deployment.simulate() + # the first plane alone at the first launch (the second is launched later) + self.assertEqual(seen, [(0.0, 2, {"observing": 2.0})]) + self.assertEqual(history.stages, [deployment.begin]) + # the planned history (of the availability) reads it too + self.assertEqual(history.metrics()["stages deployed"], 1.0) + self.assertEqual(deployment.planned().stages, [deployment.begin]) + later = SCHEDULE.plan(_layout(), stages=[Stage(2, 0.5, rule)]) + later.capability = deployment.capability + self.assertEqual(later.simulate().stages, [None]) + # without a capability, a rule cannot read it + unmeasured = SCHEDULE.plan(_layout(), stages=[Stage(2, 0.0, rule)]) + with self.assertRaisesRegex(ValueError, "capability"): + unmeasured.simulate() + + def test_capability_of_failures(self): + """The capability at a decision follows failures, as rules on them do.""" + failures = FailureModel(life=Exponential(0.1)) + policy = RestorationPolicy(restore=False) + by_count = SCHEDULE.plan( + _layout(), + stages=[Stage(2, [0.5, 1.0, 1.5, 2.0], lambda d: d.operating < 4)], + ) + measured = SCHEDULE.plan( + _layout(), + stages=[ + Stage( + 2, + [0.5, 1.0, 1.5, 2.0], + lambda d: d.capability["observing"] < 4, + ) + ], + ) + cache = PhaseCache(_count) + measured.capability = Capability( + NAMES, OBSERVATIONS, cache, context="replicate" + ) + expected = by_count.simulate_many(failures, policy, seed=1, histories=20) + histories = measured.simulate_many(failures, policy, seed=1, histories=20) + self.assertEqual([h.stages for h in histories], [h.stages for h in expected]) + self.assertTrue(any(h.stages[0] is not None for h in histories)) + # each set of satellites read at a decision is evaluated once + self.assertGreater(cache.hits, 0) + + def test_capability_reads(self): + """A capability evaluates sets of satellites by name, or by position, only + when read.""" + calls = [] + + def metric(observations): + calls.append(len(observations)) + return _count(observations) + + capability = Capability(NAMES, OBSERVATIONS, metric) + self.assertEqual(capability(["s0", "s3"]), {"observing": 2.0}) + planes = SCHEDULE.plan(_layout()).planes + self.assertEqual(capability.at(planes, [(1, 0), (2, 1)]), {"observing": 2.0}) + self.assertEqual(capability(set()), {"observing": 0.0}) + self.assertEqual(calls, [2, 2, 0]) + # a rule that does not read it does not evaluate it + deployment = SCHEDULE.plan(_layout(), stages=[Stage(2, 0.0, lambda d: True)]) + deployment.capability = capability + deployment.simulate() + self.assertEqual(len(calls), 3) + with self.assertRaises(ValueError): + capability(["s9"]) + with self.assertRaises(ValueError): + Capability(NAMES[:4], OBSERVATIONS, metric).at(planes, [(0, 0)]) + # a cache keys satellites given by name by their names + cache = PhaseCache(_count) + cached = Capability(NAMES, OBSERVATIONS, cache) + cached(["s0", "s1"]) + cached(["s1", "s0"]) + self.assertEqual((cache.hits, cache.misses), (1, 1)) + def test_lead_and_launches(self): """A lead time delays production, and launch capacity splits launches.""" schedule = DeploymentSchedule( From 83df9f15e7246539638cc3b7b378de1a56968a25 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Thu, 12 Nov 2026 11:44:13 -0700 Subject: [PATCH 33/52] make the trade space easier to understand and use The functions that judge designs (pareto_front, pareto_ranks, hypervolume, sensitivity, main_effects) raise if given results with several rows of a design, and aggregate reads a mapping as objectives, as everywhere else, with named statistics in its own argument. The steps after an evaluation (refine, confirm, screen, attribute_variance) take the study, its criteria or metrics, and then results or designs (as designs, keys, or rows of a summary, which DesignSpace.designs_of rebuilds), and their outcomes give results, a summary, and designs. DesignSpace.extend, DesignSpace.design with overrides, and Study.replace make variants of a space, design, and study, which share a store, which warns only of the same study run with other code. Columns follow one convention (se, mission, histories, pareto_trace, max_regret), an ObservationStudy reports when its plan deploys, and the package exports the names of a study (others from their modules). The API reference is split by step and the example into five notebooks sharing trade_space_example.py. --- CHANGELOG.md | 5 +- docs/api_reference/index.rst | 2 +- docs/api_reference/tradespace.rst | 384 -- docs/api_reference/tradespace/define.rst | 79 + docs/api_reference/tradespace/evaluate.rst | 63 + docs/api_reference/tradespace/index.rst | 136 + docs/api_reference/tradespace/judge.rst | 99 + docs/api_reference/tradespace/missions.rst | 133 + docs/api_reference/tradespace/search.rst | 60 + docs/examples/CompareScenarios.ipynb | 869 ++++ docs/examples/PlanMissions.ipynb | 1815 +++++++ docs/examples/RankUncertainDesigns.ipynb | 1878 +++++++ docs/examples/SearchTradeSpace.ipynb | 5349 +------------------- docs/examples/TradeCostAndUtility.ipynb | 660 +++ docs/examples/index.rst | 9 +- docs/examples/trade_space_example.py | 174 + src/tatc/tradespace/__init__.py | 258 +- src/tatc/tradespace/attribution.py | 11 +- src/tatc/tradespace/confirmation.py | 68 +- src/tatc/tradespace/criteria.py | 231 +- src/tatc/tradespace/fingerprint.py | 20 + src/tatc/tradespace/histories.py | 32 +- src/tatc/tradespace/mission.py | 4 +- src/tatc/tradespace/observations.py | 372 +- src/tatc/tradespace/optimization.py | 40 +- src/tatc/tradespace/pareto.py | 79 +- src/tatc/tradespace/refinement.py | 63 +- src/tatc/tradespace/scenarios.py | 12 +- src/tatc/tradespace/screening.py | 85 +- src/tatc/tradespace/sensitivity.py | 26 +- src/tatc/tradespace/space.py | 203 +- src/tatc/tradespace/store.py | 9 +- src/tatc/tradespace/study.py | 128 +- tests/tradespace/test_attribution.py | 46 +- tests/tradespace/test_cache.py | 2 +- tests/tradespace/test_confirmation.py | 24 +- tests/tradespace/test_constellations.py | 12 +- tests/tradespace/test_cost.py | 4 +- tests/tradespace/test_criteria.py | 34 +- tests/tradespace/test_deployment.py | 6 +- tests/tradespace/test_failures.py | 55 +- tests/tradespace/test_fingerprint.py | 2 + tests/tradespace/test_observations.py | 32 +- tests/tradespace/test_optimization.py | 9 +- tests/tradespace/test_pareto.py | 52 + tests/tradespace/test_refinement.py | 61 +- tests/tradespace/test_scenarios.py | 20 +- tests/tradespace/test_screening.py | 38 +- tests/tradespace/test_sensitivity.py | 10 + tests/tradespace/test_space.py | 64 + tests/tradespace/test_stages.py | 5 +- tests/tradespace/test_store.py | 41 +- tests/tradespace/test_study.py | 28 +- tests/tradespace/test_utility.py | 2 +- 54 files changed, 7757 insertions(+), 6146 deletions(-) delete mode 100644 docs/api_reference/tradespace.rst create mode 100644 docs/api_reference/tradespace/define.rst create mode 100644 docs/api_reference/tradespace/evaluate.rst create mode 100644 docs/api_reference/tradespace/index.rst create mode 100644 docs/api_reference/tradespace/judge.rst create mode 100644 docs/api_reference/tradespace/missions.rst create mode 100644 docs/api_reference/tradespace/search.rst create mode 100644 docs/examples/CompareScenarios.ipynb create mode 100644 docs/examples/PlanMissions.ipynb create mode 100644 docs/examples/RankUncertainDesigns.ipynb create mode 100644 docs/examples/TradeCostAndUtility.ipynb create mode 100644 docs/examples/trade_space_example.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 6ee45acf..52c6aade 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -25,7 +25,7 @@ Added: - Deployment of constellations (`tradespace.DeploymentSchedule`): from the rates and durations of a study (the mission and design life, the development of each type of satellite, its production on a line at a production rate, and launches at a cadence and capacity, in number or mass, optionally in an order of planes), each design's deployment (`DeploymentSchedule.plan`, a `Deployment` of its `Production`, `Launch`es, and replacements), so that a design of more satellites and planes takes longer to deploy. Its launches divide the mission into phases of constant sets of operating satellites (`Deployment.phases`), evaluated over the study's representative period from the observations of the full constellation (`evaluate_phases`) and combined over the mission (`summarize_phases`: the time-weighted mean of each metric and the time until it first meets a requirement). - Simulated missions with failures (`Deployment.simulate`, a `MissionHistory` for each replicate, drawn from its seed with common random numbers between designs): lives of satellites whose failure rates vary over the lifecycle (`tradespace.Exponential`, `Weibull`, `Bathtub` of competing causes, and `Piecewise` rates by age, `Lifetime`), failures of launches (`FailureModel`), and a policy that degrades or restores failed satellites (`RestorationPolicy`) by spares in orbit (taking a failed satellite's place after drifting), spares on the ground (launched at the next launch slot), or satellites produced when needed (after procurement, on the production line), optionally replenishing spares and batching restorations in launches. A history gives the phases in which satellites operate (`MissionHistory.phases`), measures of the mission (`MissionHistory.metrics`: failures, restorations, spares used, time to restore, and availability), and, priced by a `CostModel`, the cost of what it produces and launches. Policies are decisions of designs with a fragment of a design space (`policy_space`: whether to restore, spares in orbit and on the ground, and other fields of the policy, without spares that would never be used), and `configure` makes a policy (or a deployment schedule, or another dataclass) from the values of a design. Many histories of a replicate's mission (`Deployment.simulate_many`) share its sample of targets: `evaluate_missions` evaluates them (with their measures and costs) with a cache that evaluates each set of operating satellites once (`PhaseCache`, keyed by the content of the satellites and shared by the histories, policies, and designs of a replicate), and `summarize_missions` gives their means, quantiles (the risk of the mission), and probabilities of meeting requirements, as one record of the replicate. The histories of a replicate are stratified by default (a Latin hypercube over the histories of each satellite's life and each launch, drawn from uniform numbers by `Lifetime.from_uniform`), which estimates the means of missions 3 to 15 times more precisely than independent histories, and means may be estimated with control variates (`summarize_missions(controls=...)`, such as the availability of the mission, whose expected value simulations alone estimate, `Deployment.expected_metrics`). `allocate_histories` recommends the histories of each replicate (and the replicates, for a standard error) from a pilot with independent histories, by the variances between replicates and between histories and their costs (`summarize_missions(spread=True)` gives the standard deviations of the histories). `expected_missions` computes the expected capability and availability of a mission without restoration exactly (the sets of operating satellites by their probabilities, from the survival of each launch group, with planned replacements), without sampling error. Histories may be drawn from stressed failures for importance sampling (`simulate_many(stress=...)`: hazards and launch failures times a factor, each history weighted by its likelihood ratio censored at the end of the mission, `Lifetime.stressed` and `MissionHistory.weight`), which `summarize_missions` weighs in every statistic, with the effective number of histories: the probabilities of rare losses with 30 to 70 times less variance. - Life-cycle costs of deployments for trade studies (`tradespace.CostModel`): the development of each type of satellite, the production of its units on a learning curve (`SatelliteCost`), launches (per launch, or prices per satellite and kg, `LaunchCost`), operations (`OperationsCost`), replacements, and spares in orbit, dated by the deployment for their present value at a discount rate (`CostEstimate.present_value`, metric `cost present`) and annual costs (`CostEstimate.annual`, metric `cost peak annual`), with growth factors for cost risk (such as uncertain parameters, whose quantiles over replicates give the cost at a confidence level). TAT-C does not include cost-estimating relationships: the costs are given by the study. Fingerprints describe dataclasses (such as cost models) by their fields. - - Function `tradespace.confirm` (and class `Confirmation`), which evaluates selected designs (such as a front) with new replicates that played no part in their selection, removing the optimism of the selection (the winner's curse, `Confirmation.optimism`). `ResultStore` keys evaluations by the fingerprint of a study (`Study.fingerprint`, a hash of `Study.definition`, see `get_definition`: its seed, use of common random numbers, design space, and build and evaluation functions, with the data frames they are given described by their content, the version of Python, and the source of the modules of TAT-C and resource files they depend on, found from their imports) and keeps each definition, so that a study warns of evaluations of other definitions, which are not reused, naming what differs (`compare_definitions`); `ResultStore.prune` removes them. Changes to TAT-C that a study does not depend on (such as to modules it does not use) keep its results. Namespaces of stores and caches are optional, for what fingerprints cannot see (data that functions read from files, and the code of other modules). `refine` treats designs with fewer than `min_replicates` (5) as uncertain whatever their probability, adds the replicates left to `max_replicates` in a last partial step, and warns if designs remain uncertain without a tolerance. `sensitivity` gives adjusted shares (epsilon squared) by default, without the share that the levels of a variable explain by chance (`adjusted=False` for correlation ratios). + - Function `tradespace.confirm` (and class `Confirmation`), which evaluates selected designs (such as a front) with new replicates that played no part in their selection, removing the optimism of the selection (the winner's curse, `Confirmation.optimism`). `ResultStore` keys evaluations by the fingerprint of a study (`Study.fingerprint`, a hash of `Study.definition`, see `get_definition`: its seed, use of common random numbers, design space, and build and evaluation functions, with the data frames they are given described by their content, the version of Python, and the source of the modules of TAT-C and resource files they depend on, found from their imports) and keeps each definition, so that variants of a study share a store without mixing their evaluations, and a study warns of evaluations of the same study with other code (of its functions, of TAT-C, or of Python), which are not reused, naming what differs (`fingerprint.compare_definitions`); `ResultStore.prune` removes them. Changes to TAT-C that a study does not depend on (such as to modules it does not use) keep its results. Namespaces of stores and caches are optional, for what fingerprints cannot see (data that functions read from files, and the code of other modules). `refine` treats designs with fewer than `min_replicates` (5) as uncertain whatever their probability, adds the replicates left to `max_replicates` in a last partial step, and warns if designs remain uncertain without a tolerance. `sensitivity` gives adjusted shares (epsilon squared) by default, without the share that the levels of a variable explain by chance (`adjusted=False` for correlation ratios). - The schedule and cost model of a `tradespace.MissionPlan` may be functions of the design (`schedule_of`, `cost_model_of`), which size them by its values with relationships of the study's own, such as the costs of a type of satellite from its payload or the capacity of launches to the design's altitude; launches limited in mass take the masses of the satellites from the cost model (`masses_of`, or the plan's `masses`). The `launch_mass_capacity` of a `DeploymentSchedule` may be a function of a plane (`mass_capacity_of`), for planes at different inclinations. - The start of the period of `tradespace.Observations` may be a value of the design (`start_of` and `end_of` give a design's period), such as an uncertain epoch drawn for each replicate over the mission, whose observations are cached apart, so that replicates average over the geometry and seasons of the mission that the one window of quasi-static phases misses (as `evaluate_phases` now states). The schedule of deployments states that a design life does not retire a satellite that is not replaced, and simulations that a planned replacement whose launch fails is not flown again. - Utilities of the metrics of designs (`tradespace.Utility`), for trade spaces of utility against cost: a single-attribute utility of each metric (`LinearUtility`, `ExponentialUtility` of a risk attitude, `PiecewiseUtility`, or any function), combined by weights additively or in Keeney and Raiffa's multiplicative form. A utility is a metric of any statistic (its `Mean` is the expected utility over the replicates, and a utility given as a statistic of `Criteria` is its mean), computed in each replicate, and gives the utility of each row of a data frame (such as a summary of the means of designs). Statistics name the columns they need (`Statistic.columns`). @@ -35,7 +35,8 @@ Added: - Function `tradespace.attribute_variance` (and class `Attribution`), which attributes the variance of metrics between the replicates of each design to its uncertain parameters (or groups of them): the share that each causes, alone or with others, and the share that knowing it would remove, with standard errors, by evaluating designs with one parameter drawn as in other replicates and the others held (which works for seeds, whose values do not order outcomes); `Attribution.summary` pools the shares of several designs, and `Attribution.differences` attributes the variance of the differences between pairs of designs, from the same evaluations (parameters that act alike on both cancel, with common random numbers). `Design.realize` and `Study.run` take a `shift`, which draws named parameters as in other replicates (kept apart in a `ResultStore` as a variant of the replicates), and `DesignSpace.uncertain_paths` lists the uncertain parameters. - Searches with Optuna accept categorical options that depend on earlier decisions (a parameter for each set of options), use TPE with a constant liar in batches by default (which spreads the trials of a batch), and stop after `max_designs` designs evaluated (trials that suggest designs evaluated before are told their objectives without evaluating them again). A design infeasible in some of its replicates violates its feasibility by their share (`Evaluations.infeasibility`), and the first design evaluated in a search is evaluated alone, to check that evaluations give one record each. `Study` records errors of evaluations as infeasible, without storing them, with `errors="record"`. Enumeration walks the items of unordered repetitions in one order only (the same designs, in the same order, four times faster for three sun-synchronous planes), and `DesignSpace.size` counts designs without keeping them. Pareto fronts are found by a vectorized sweep in lexicographic order that compares designs only with the efficient designs before them, and fronts with tolerances by comparing designs only with the efficient designs without tolerances (which dominate every design that any design dominates within the tolerances), in blocks of bounded memory: 20,000 designs in 0.05 s (0.11 s with tolerances) rather than 17 s, and the bootstraps of `pareto_probability` (and so `refine`) about 20 times faster. - Studies of the observations of constellations (`tradespace.ObservationStudy`): the targets of each replicate (`Targets`, fixed or generated from a seed of the design), the observations of each satellite, cached on disk (`Observations`), the metrics of the observations, and, with a `MissionPlan`, the costs of the deployment and the summaries of its phases or of the histories of its `Failures`. Plots of the results of studies (`plot_designs`, `plot_progress`, and `plot_means`, with matplotlib, now in the `tradespace` extra), and the hypervolume of a search as it proceeds (`hypervolume_progress`). - - Example `SearchTradeSpace`, which searches a hierarchical trade space of constellations for the designs that sample points sufficiently: by evaluating every design, ranking them with the uncertainty of their replicates, screening, and searching with Optuna and pymoo. + - The steps of trade studies share their arguments and outcomes: `tradespace.refine(study, criteria, results)`, `confirm(study, criteria, results)` (by default, the front of the results), `screen(studies, criteria, designs)` (with criteria for each stage, in place of a `tolerance` of its own), and `attribute_variance(study, metrics, designs)` take designs as `Design` objects, their keys, or rows of a summary or of results, and `Refinement`, `Confirmation`, `Screening`, and `Search` give their `results`, the `summary` of their designs, and the `designs`. `DesignSpace.designs_of` rebuilds designs from rows of their values, which summaries keep (also those of `pareto_probability`, `confirm`, and `screen`), and `DesignSpace.extend`, `DesignSpace.design(design, **overrides)`, and `Study.replace` make variants of design spaces, designs, and studies. `aggregate` takes criteria, a mapping of objectives, or metrics (as the other functions do), and other `statistics` by name; `pareto_front`, `pareto_ranks`, `hypervolume`, `sensitivity`, and `main_effects` raise an error given the results of a study (a row per replicate) rather than a summary. Studies with a mission plan record the years by which it is `deployed`, and the parts of observation studies that refer to values of designs are typed as a `Reference`. Columns: ` se` (rather than `sem`), ` mission` for the mean over the phases of a mission, ` histories p` and ` histories std` for statistics over the histories of failures, and `pareto_trace` and `max_regret`. Package `tradespace` exports the functions and classes of trade studies; the parts from which they are made (such as `PhaseCache`, `Layout`, `configure`, and the fingerprints) are imported from its modules. + - Example `SearchTradeSpace`, which searches a hierarchical trade space of constellations for the designs that sample points sufficiently: by evaluating every design, finding what drives the objectives, screening, and searching with Optuna and pymoo; and examples that take its trade further, importing its design space and study (`trade_space_example.py`): `RankUncertainDesigns` (the probability of efficiency, refinement, confirmation, and requirements on statistics), `CompareScenarios` (fronts, regret, and searches across scenarios), `TradeCostAndUtility`, and `PlanMissions` (deployment, staging, failures, and the attribution of variance). - The `RunOSSEMonsoon` example declares its constellation trade as a design space, caches the looks of each satellite, evaluates its replicates in parallel, and finds its Pareto-efficient designs. Changed: diff --git a/docs/api_reference/index.rst b/docs/api_reference/index.rst index ec928186..11655392 100644 --- a/docs/api_reference/index.rst +++ b/docs/api_reference/index.rst @@ -11,6 +11,6 @@ The following provide documentation on the Python API to TAT-C. catalog generation/index analysis/index - tradespace + tradespace/index preprocess/index utils/index diff --git a/docs/api_reference/tradespace.rst b/docs/api_reference/tradespace.rst deleted file mode 100644 index 1988618b..00000000 --- a/docs/api_reference/tradespace.rst +++ /dev/null @@ -1,384 +0,0 @@ -Trade Space -=========== - -.. automodule:: tatc.tradespace - -Design Spaces -------------- - -.. autoclass:: tatc.tradespace.DesignSpace - :members: enumerate, size, sample, design, suggest, unit_paths, uncertain_paths, encode, decode - -.. autoclass:: tatc.tradespace.Variable - :members: domain - -.. autoclass:: tatc.tradespace.Real - -.. autoclass:: tatc.tradespace.Integer - -.. autoclass:: tatc.tradespace.Categorical - -.. autoclass:: tatc.tradespace.Fixed - -.. autoclass:: tatc.tradespace.Derived - -.. autoclass:: tatc.tradespace.Uncertain - :members: uniform, normal, choice, seed - -.. autoclass:: tatc.tradespace.Choice - -.. autoclass:: tatc.tradespace.Repeat - -.. autoexception:: tatc.tradespace.Infeasible - -Designs -------- - -.. autoclass:: tatc.tradespace.Design - :members: flat, realize, values - -.. autoclass:: tatc.tradespace.Values - -.. autoclass:: tatc.tradespace.ChoiceValues - :members: choice, value - -.. autoclass:: tatc.tradespace.RepeatValues - :members: count - -.. autoclass:: tatc.tradespace.Scope - -.. autofunction:: tatc.tradespace.configure - -Constellations --------------- - -.. automodule:: tatc.tradespace.constellations - :no-members: - -.. autofunction:: tatc.tradespace.walker_space - -.. autofunction:: tatc.tradespace.sso_planes_space - -.. autofunction:: tatc.tradespace.planes_space - -.. autofunction:: tatc.tradespace.build_constellation - -.. autofunction:: tatc.tradespace.count_satellites - -.. autofunction:: tatc.tradespace.count_planes - -.. autofunction:: tatc.tradespace.plane_sizes - -.. autoclass:: tatc.tradespace.Layout - :members: planes, orbits, names, satellites, build - -.. autoclass:: tatc.tradespace.Plane - -.. autofunction:: tatc.tradespace.layout_of - -.. autoclass:: tatc.tradespace.constellations.WalkerLayout - -.. autoclass:: tatc.tradespace.constellations.SSOPlanesLayout - -.. autoclass:: tatc.tradespace.constellations.PlanesLayout - -.. autoclass:: tatc.tradespace.constellations.Layouts - -.. autofunction:: tatc.tradespace.hours_to_time - -.. autofunction:: tatc.tradespace.remove_failures - -Deployment ----------- - -.. automodule:: tatc.tradespace.deployment - :no-members: - -.. autoclass:: tatc.tradespace.DeploymentSchedule - :members: plan, launches_of, mass_capacity_of - -.. autoclass:: tatc.tradespace.Deployment - :members: simulate, simulate_many, expected_metrics, planned, phases, begin, end, deployed, units, stages, capability - -.. autoclass:: tatc.tradespace.Launch - -.. autoclass:: tatc.tradespace.Production - -.. autoclass:: tatc.tradespace.Stage - -.. autoclass:: tatc.tradespace.Decision - :members: time, stage, operating, history, deployed, capability - -Failures and Missions ---------------------- - -.. automodule:: tatc.tradespace.failures - :no-members: - -.. autoclass:: tatc.tradespace.FailureModel - :members: life_of - -.. autoclass:: tatc.tradespace.Lifetime - :members: survival, hazard, cumulative_hazard, sample, from_uniform, dimensions, stressed - -.. autoclass:: tatc.tradespace.Exponential - -.. autoclass:: tatc.tradespace.Weibull - -.. autoclass:: tatc.tradespace.Bathtub - -.. autoclass:: tatc.tradespace.Piecewise - -.. autoclass:: tatc.tradespace.RestorationPolicy - :members: ground_spares_of - -.. autofunction:: tatc.tradespace.policy_space - -.. automodule:: tatc.tradespace.mission - :no-members: - -.. autoclass:: tatc.tradespace.MissionHistory - :members: phases, metrics, in_orbit - -.. autoclass:: tatc.tradespace.Phase - :members: duration - -.. autofunction:: tatc.tradespace.evaluate_phases - -.. autofunction:: tatc.tradespace.summarize_phases - -.. autoclass:: tatc.tradespace.PhaseCache - :members: evaluate, clear - -.. autoclass:: tatc.tradespace.Capability - :members: at - :special-members: __call__ - -.. autofunction:: tatc.tradespace.evaluate_missions - -.. autofunction:: tatc.tradespace.summarize_missions - -.. autofunction:: tatc.tradespace.allocate_histories - -.. autofunction:: tatc.tradespace.expected_missions - -Costs ------ - -.. automodule:: tatc.tradespace.cost - :no-members: - -.. autoclass:: tatc.tradespace.CostModel - :members: estimate, discount - -.. autoclass:: tatc.tradespace.SatelliteCost - :members: production - -.. autoclass:: tatc.tradespace.LaunchCost - -.. autoclass:: tatc.tradespace.OperationsCost - -.. autoclass:: tatc.tradespace.CostEstimate - :members: total, present_value, annual, metrics - -Trade Studies -------------- - -.. autoclass:: tatc.tradespace.Study - :members: run, workers, definition, fingerprint - -Observation Studies -------------------- - -.. automodule:: tatc.tradespace.observations - :no-members: - -.. autoclass:: tatc.tradespace.ObservationStudy - :members: satellites_of, targets_of, observations_of - -.. autoclass:: tatc.tradespace.Targets - :members: of, seed_of - -.. autoclass:: tatc.tradespace.Observations - :members: end, start_of, end_of, cache_of, context_of, __call__ - -.. autoclass:: tatc.tradespace.MissionPlan - :members: schedule_of, cost_model_of, masses_of, growth_of, stages_of - -.. autoclass:: tatc.tradespace.Failures - -.. autofunction:: tatc.tradespace.value_of - -Criteria, Statistics, and Requirements --------------------------------------- - -.. automodule:: tatc.tradespace.criteria - :no-members: - -.. autoclass:: tatc.tradespace.Criteria - :members: names, metrics, statistic - -.. autofunction:: tatc.tradespace.aggregate - -.. autofunction:: tatc.tradespace.summarize - -.. autoclass:: tatc.tradespace.Statistic - :members: reduce, columns, values_of - -.. autoclass:: tatc.tradespace.Mean - -.. autoclass:: tatc.tradespace.StandardDeviation - -.. autoclass:: tatc.tradespace.StandardError - -.. autoclass:: tatc.tradespace.Minimum - -.. autoclass:: tatc.tradespace.Maximum - -.. autoclass:: tatc.tradespace.Quantile - -.. autoclass:: tatc.tradespace.Probability - -.. autoclass:: tatc.tradespace.Requirement - :members: violation - -.. autoclass:: tatc.tradespace.Across - :members: weights_of - -Utility -------- - -.. automodule:: tatc.tradespace.utility - :no-members: - -.. autoclass:: tatc.tradespace.Utility - :members: columns, scaling, evaluate, __call__ - -.. autoclass:: tatc.tradespace.LinearUtility - -.. autoclass:: tatc.tradespace.ExponentialUtility - -.. autoclass:: tatc.tradespace.PiecewiseUtility - -Stores of Results ------------------ - -.. autoclass:: tatc.tradespace.ResultStore - :members: get, put, define, definition, contexts, prune, clear - -Fingerprints ------------- - -.. automodule:: tatc.tradespace.fingerprint - :no-members: - -.. autofunction:: tatc.tradespace.get_fingerprint - -.. autofunction:: tatc.tradespace.get_definition - -.. autofunction:: tatc.tradespace.compare_definitions - -Caches ------- - -.. automodule:: tatc.tradespace.cache - :no-members: - -.. autoclass:: tatc.tradespace.SatelliteCache - :members: get, prune, clear, __call__ - -.. autofunction:: tatc.tradespace.get_satellite_key - -Pareto Efficiency ------------------ - -.. autofunction:: tatc.tradespace.pareto_front - -.. autofunction:: tatc.tradespace.pareto_ranks - -.. autofunction:: tatc.tradespace.hypervolume - -.. autofunction:: tatc.tradespace.hypervolume_progress - -.. autofunction:: tatc.tradespace.pareto_probability - -Adaptive Replication --------------------- - -.. autofunction:: tatc.tradespace.refine - -.. autoclass:: tatc.tradespace.Refinement - :members: uncertain, indifferent - -Confirmation ------------- - -.. autofunction:: tatc.tradespace.confirm - -.. autoclass:: tatc.tradespace.Confirmation - :members: optimism - -Sensitivity ------------ - -.. autofunction:: tatc.tradespace.sensitivity - -.. autofunction:: tatc.tradespace.main_effects - -Scenarios ---------- - -.. automodule:: tatc.tradespace.scenarios - :no-members: - -.. autofunction:: tatc.tradespace.robustness - -Attribution of Variance ------------------------ - -.. automodule:: tatc.tradespace.attribution - :no-members: - -.. autofunction:: tatc.tradespace.attribute_variance - -.. autoclass:: tatc.tradespace.Attribution - :members: summary, differences - -Screening ---------- - -.. autofunction:: tatc.tradespace.screen - -.. autoclass:: tatc.tradespace.Screening - :members: final - -Optimizers ----------- - -.. automodule:: tatc.tradespace.optimization - :no-members: - -.. autofunction:: tatc.tradespace.optimize_optuna - -.. autofunction:: tatc.tradespace.optimize_pymoo - -.. autofunction:: tatc.tradespace.make_pymoo_problem - -.. autoclass:: tatc.tradespace.Search - -.. autoclass:: tatc.tradespace.Evaluations - :members: evaluate, results, worst, designs - -Plots ------ - -.. automodule:: tatc.tradespace.plotting - :no-members: - -.. autofunction:: tatc.tradespace.plot_designs - -.. autofunction:: tatc.tradespace.plot_progress - -.. autofunction:: tatc.tradespace.plot_means - -.. autofunction:: tatc.tradespace.style_axes diff --git a/docs/api_reference/tradespace/define.rst b/docs/api_reference/tradespace/define.rst new file mode 100644 index 00000000..2719b850 --- /dev/null +++ b/docs/api_reference/tradespace/define.rst @@ -0,0 +1,79 @@ +============== +Design Spaces +============== + +.. automodule:: tatc.tradespace.space + :no-members: + +Design Spaces and Designs +========================= + +.. autoclass:: tatc.tradespace.DesignSpace + :members: enumerate, size, sample, design, designs_of, extend, suggest, unit_paths, uncertain_paths, encode, decode + +.. autoclass:: tatc.tradespace.Design + :members: flat, realize, values + +Variables and Values +==================== + +.. autoclass:: tatc.tradespace.Real + +.. autoclass:: tatc.tradespace.Integer + +.. autoclass:: tatc.tradespace.Categorical + +.. autoclass:: tatc.tradespace.Fixed + +.. autoclass:: tatc.tradespace.Derived + +.. autoclass:: tatc.tradespace.Uncertain + :members: uniform, normal, choice, seed + +.. autoclass:: tatc.tradespace.Choice + +.. autoclass:: tatc.tradespace.Repeat + +.. autoexception:: tatc.tradespace.Infeasible + +.. autoclass:: tatc.tradespace.nodes.Variable + :members: domain + +Building Blocks of Constellations +================================= + +Fragments of design spaces of common layouts of constellations, and of the +policies that restore their failures, whose values a study builds into +satellites (see :doc:`missions` for the layouts themselves). + +.. autofunction:: tatc.tradespace.walker_space + +.. autofunction:: tatc.tradespace.sso_planes_space + +.. autofunction:: tatc.tradespace.planes_space + +.. autofunction:: tatc.tradespace.policy_space + +.. autofunction:: tatc.tradespace.build_constellation + +.. autofunction:: tatc.tradespace.count_satellites + +.. autofunction:: tatc.tradespace.count_planes + +Views of Values +=============== + +The callables of a design space (bounds, derived values, and constraints) +and the values of designs are views of the values decided so far. + +.. autoclass:: tatc.tradespace.values.Values + +.. autoclass:: tatc.tradespace.values.ChoiceValues + :members: choice, value + +.. autoclass:: tatc.tradespace.values.RepeatValues + :members: count + +.. autoclass:: tatc.tradespace.values.Scope + +.. autofunction:: tatc.tradespace.values.configure diff --git a/docs/api_reference/tradespace/evaluate.rst b/docs/api_reference/tradespace/evaluate.rst new file mode 100644 index 00000000..8e1b203c --- /dev/null +++ b/docs/api_reference/tradespace/evaluate.rst @@ -0,0 +1,63 @@ +======= +Studies +======= + +Trade Studies +============= + +.. autoclass:: tatc.tradespace.Study + :members: run, replace, workers, definition, fingerprint + +Observation Studies +=================== + +.. automodule:: tatc.tradespace.observations + :no-members: + +.. autoclass:: tatc.tradespace.ObservationStudy + :members: satellites_of, targets_of, observations_of + +.. autoclass:: tatc.tradespace.Observations + :members: end, start_of, end_of, cache_of, context_of, __call__ + +.. autoclass:: tatc.tradespace.Targets + :members: of, seed_of + +.. autoclass:: tatc.tradespace.MissionPlan + :members: schedule_of, cost_model_of, masses_of, growth_of, stages_of + +.. autoclass:: tatc.tradespace.Failures + +.. autodata:: tatc.tradespace.observations.Reference + :annotation: + +.. autofunction:: tatc.tradespace.observations.value_of + +Stores of Results +================= + +.. autoclass:: tatc.tradespace.ResultStore + :members: get, put, define, definition, contexts, prune, clear + +Caches of Satellites +==================== + +.. automodule:: tatc.tradespace.cache + :no-members: + +.. autoclass:: tatc.tradespace.SatelliteCache + :members: get, prune, clear, __call__ + +.. autofunction:: tatc.tradespace.cache.get_satellite_key + +Fingerprints +============ + +.. automodule:: tatc.tradespace.fingerprint + :no-members: + +.. autofunction:: tatc.tradespace.fingerprint.get_fingerprint + +.. autofunction:: tatc.tradespace.fingerprint.get_definition + +.. autofunction:: tatc.tradespace.fingerprint.compare_definitions diff --git a/docs/api_reference/tradespace/index.rst b/docs/api_reference/tradespace/index.rst new file mode 100644 index 00000000..bc9c1fae --- /dev/null +++ b/docs/api_reference/tradespace/index.rst @@ -0,0 +1,136 @@ +=========== +Trade Space +=========== + +.. automodule:: tatc.tradespace + :no-members: + +The examples :doc:`../../examples/SearchTradeSpace` and the notebooks that +follow it show each step on a study of the observations of constellations. + +Steps of a Trade Study +====================== + +A trade study takes a few steps, each of which takes the outcome of the one +before:: + + from tatc.tradespace import ( + Criteria, DesignSpace, Integer, ResultStore, Study, Uncertain, + aggregate, confirm, pareto_front, refine, + ) + + space = DesignSpace(planes=Integer(1, 4), per_plane=Integer(1, 4), seed=Uncertain.seed()) + study = Study(space, build, evaluate, replicates=5, store=ResultStore("results.sqlite")) + results = study.run() # a row per design and replicate + + criteria = Criteria({"satellites": "min", "coverage": "max"}) + summary = aggregate(results, criteria) # a row per design + front = summary[pareto_front(summary, criteria)] + + refinement = refine(study, criteria, results) # replicates where efficiency is uncertain + confirmation = confirm(study, criteria, refinement.results) # the front, with new replicates + +1. **Define** a design space (:doc:`define`): design variables, choices and + repetitions, constraints, and uncertain parameters, which each replicate + of a design draws. +2. **Evaluate** designs with a study (:doc:`evaluate`): a function builds + each realized design and another evaluates it, in parallel, with a store + of the evaluations. An `ObservationStudy` evaluates the observations of + constellations, and their deployment, costs, and failures + (:doc:`missions`). +3. **Judge** designs by criteria (:doc:`judge`): objectives and + requirements on statistics of their replicates, summarized with a row per + design, and their Pareto efficiency. +4. **Settle** the uncertainty of the replicates, or **search** spaces too + large to enumerate (:doc:`search`). Each of these steps takes a study and + criteria, and returns its `results`, the `summary` of its designs, and the + `designs` themselves, for the next step. + +Results and Summaries +===================== + +A study gives **results**: a row per evaluation (a design in a replicate, +and a scenario), with the key of the design (`design`), the `replicate`, the +values of the design by path (see `Design.flat`), whether it is `feasible`, +and its metrics. A **summary** has a row per design (and per group of the +criteria's `by`): statistics over its replicates, the number of +`replicates`, and the values of the design. Functions take one or the +other: + +.. list-table:: + :header-rows: 1 + + * - Take results (a row per replicate) + - Take summaries (a row per design) + * - `aggregate`, `summarize`, `pareto_probability`, + `hypervolume_progress`, `robustness`, `refine`, `confirm`, + `attribute_variance`, `plot_means` + - `pareto_front`, `pareto_ranks`, `hypervolume`, `sensitivity`, + `main_effects`, `plot_designs` + +The functions of summaries raise an error if a design has several rows, as +in the results of a study: summarize them first. + +Columns +------- + +Columns named after a metric or a statistic take a suffix after a space, +and columns that TAT-C defines are named in snake case: + +* statistics over the replicates of a design: named by the criteria (such + as `"cost p70"` for `Quantile("cost", 0.7)`), the means of metrics by + their names, and ` std` and ` se` (by `summarize`, and the + standard error of each objective by `pareto_probability`). +* statistics within a replicate, over the mission of a design (see + `ObservationStudy`): ` mission` (the mean over the phases of the + mission), ` time` (when the phases first meet a requirement), and, + over the histories of its failures, ` histories p`, + ` histories std`, and `P()`. +* columns of judgments: `violation`, `meets_requirements`, `pareto`, + `pareto_rank`, `pareto_probability`, `requirements_probability`, + `pareto_trace`, `max_regret`, and the ` regret` of each scenario. + +Designs and Their Variants +========================== + +Results keep the values of designs, from which `DesignSpace.designs_of` +rebuilds them, so that the steps of a study take designs as `Design` +objects, their keys, or rows of a summary or of results:: + + confirmation = confirm(study, criteria, results, summary[summary.pareto]) + +A variant of a design space adds or replaces children +(`DesignSpace.extend`), and its designs take the decisions of a design of +the other (`DesignSpace.design`). A variant of a study replaces some of its +arguments (`Study.replace`):: + + policies = space.extend(policy=policy_space(orbit_spares=Integer(0, 1))) + designs = [policies.design(d, policy=p) for d in front_designs for p in policy_designs] + results = study.replace(space=policies, replicates=20).run(designs) + +The parts of an `ObservationStudy` (such as its targets and mission plan) +refer to values of designs by a `Reference` (see +:py:data:`tatc.tradespace.observations.Reference`): a name or path of a +value, or a function of the realized design. + +Stores of Results +================= + +A `ResultStore` keeps the evaluations of studies, keyed by the fingerprint +of each study's definition (see `Study.fingerprint`), so that a study that is +run again takes its evaluations from the store, and variants of a study +(other settings, design spaces, or scenarios) share a store without mixing +their evaluations. A namespace of the store identifies only what +fingerprints cannot see (such as data that the functions read from files). A +study warns if the store has evaluations of the same study with other code +(of its functions, of TAT-C, or of Python), which it does not reuse +(`ResultStore.prune` removes them). + +.. toctree:: + :maxdepth: 1 + + define + evaluate + judge + search + missions diff --git a/docs/api_reference/tradespace/judge.rst b/docs/api_reference/tradespace/judge.rst new file mode 100644 index 00000000..a6ef05bc --- /dev/null +++ b/docs/api_reference/tradespace/judge.rst @@ -0,0 +1,99 @@ +======================= +Criteria and Summaries +======================= + +Criteria, Statistics, and Requirements +====================================== + +.. automodule:: tatc.tradespace.criteria + :no-members: + +.. autoclass:: tatc.tradespace.Criteria + :members: names, metrics, statistic + +.. autofunction:: tatc.tradespace.aggregate + +.. autofunction:: tatc.tradespace.summarize + +.. autoclass:: tatc.tradespace.Mean + +.. autoclass:: tatc.tradespace.StandardDeviation + +.. autoclass:: tatc.tradespace.StandardError + +.. autoclass:: tatc.tradespace.Minimum + +.. autoclass:: tatc.tradespace.Maximum + +.. autoclass:: tatc.tradespace.Quantile + +.. autoclass:: tatc.tradespace.Probability + +.. autoclass:: tatc.tradespace.criteria.Statistic + :members: reduce, columns, values_of + +.. autoclass:: tatc.tradespace.Requirement + :members: violation + +.. autoclass:: tatc.tradespace.Across + :members: weights_of + +Pareto Efficiency +================= + +.. automodule:: tatc.tradespace.pareto + :no-members: + +.. autofunction:: tatc.tradespace.pareto_front + +.. autofunction:: tatc.tradespace.pareto_ranks + +.. autofunction:: tatc.tradespace.pareto_probability + +.. autofunction:: tatc.tradespace.hypervolume + +.. autofunction:: tatc.tradespace.hypervolume_progress + +Scenarios +========= + +.. automodule:: tatc.tradespace.scenarios + :no-members: + +.. autofunction:: tatc.tradespace.robustness + +Sensitivity +=========== + +.. autofunction:: tatc.tradespace.sensitivity + +.. autofunction:: tatc.tradespace.main_effects + +Utility +======= + +.. automodule:: tatc.tradespace.utility + :no-members: + +.. autoclass:: tatc.tradespace.Utility + :members: columns, scaling, evaluate, __call__ + +.. autoclass:: tatc.tradespace.LinearUtility + +.. autoclass:: tatc.tradespace.ExponentialUtility + +.. autoclass:: tatc.tradespace.PiecewiseUtility + +Plots +===== + +.. automodule:: tatc.tradespace.plotting + :no-members: + +.. autofunction:: tatc.tradespace.plot_designs + +.. autofunction:: tatc.tradespace.plot_means + +.. autofunction:: tatc.tradespace.plot_progress + +.. autofunction:: tatc.tradespace.style_axes diff --git a/docs/api_reference/tradespace/missions.rst b/docs/api_reference/tradespace/missions.rst new file mode 100644 index 00000000..07f901f4 --- /dev/null +++ b/docs/api_reference/tradespace/missions.rst @@ -0,0 +1,133 @@ +=========================== +Constellations and Missions +=========================== + +The parts of observation studies (see `ObservationStudy`): the layouts of +constellations, their deployment, the failures of their satellites, the +phases and histories of their missions, and their costs. Studies use them +through a `MissionPlan` and `Failures`; the rest are for analyses of their +own. + +Constellations +============== + +.. automodule:: tatc.tradespace.constellations + :no-members: + +.. autoclass:: tatc.tradespace.constellations.Layout + :members: planes, orbits, names, satellites, build + +.. autoclass:: tatc.tradespace.constellations.Plane + +.. autofunction:: tatc.tradespace.constellations.layout_of + +.. autoclass:: tatc.tradespace.constellations.WalkerLayout + +.. autoclass:: tatc.tradespace.constellations.SSOPlanesLayout + +.. autoclass:: tatc.tradespace.constellations.PlanesLayout + +.. autoclass:: tatc.tradespace.constellations.Layouts + +.. autofunction:: tatc.tradespace.constellations.plane_sizes + +.. autofunction:: tatc.tradespace.constellations.hours_to_time + +.. autofunction:: tatc.tradespace.constellations.remove_failures + +Deployment +========== + +.. automodule:: tatc.tradespace.deployment + :no-members: + +.. autoclass:: tatc.tradespace.DeploymentSchedule + :members: plan, launches_of, mass_capacity_of + +.. autoclass:: tatc.tradespace.Stage + +.. autoclass:: tatc.tradespace.deployment.Deployment + :members: simulate, simulate_many, expected_metrics, planned, phases, begin, end, deployed, units, stages, capability + +.. autoclass:: tatc.tradespace.deployment.Launch + +.. autoclass:: tatc.tradespace.deployment.Production + +.. autoclass:: tatc.tradespace.mission.Decision + :members: time, stage, operating, history, deployed, capability + +Failures +======== + +.. automodule:: tatc.tradespace.failures + :no-members: + +.. autoclass:: tatc.tradespace.FailureModel + :members: life_of + +.. autoclass:: tatc.tradespace.failures.Lifetime + :members: survival, hazard, cumulative_hazard, sample, from_uniform, dimensions, stressed + +.. autoclass:: tatc.tradespace.Exponential + +.. autoclass:: tatc.tradespace.Weibull + +.. autoclass:: tatc.tradespace.Bathtub + +.. autoclass:: tatc.tradespace.Piecewise + +.. autoclass:: tatc.tradespace.RestorationPolicy + :members: ground_spares_of + +Missions +======== + +.. automodule:: tatc.tradespace.mission + :no-members: + +.. autoclass:: tatc.tradespace.mission.MissionHistory + :members: phases, metrics, in_orbit + +.. autoclass:: tatc.tradespace.mission.Phase + :members: duration + +.. autofunction:: tatc.tradespace.mission.evaluate_phases + +.. autofunction:: tatc.tradespace.mission.summarize_phases + +.. autoclass:: tatc.tradespace.mission.PhaseCache + :members: evaluate, clear + +.. autoclass:: tatc.tradespace.mission.Capability + :members: at + :special-members: __call__ + +.. automodule:: tatc.tradespace.histories + :no-members: + +.. autofunction:: tatc.tradespace.histories.evaluate_missions + +.. autofunction:: tatc.tradespace.histories.summarize_missions + +.. autofunction:: tatc.tradespace.histories.allocate_histories + +.. autofunction:: tatc.tradespace.histories.expected_missions + +Costs +===== + +.. automodule:: tatc.tradespace.cost + :no-members: + +.. autoclass:: tatc.tradespace.CostModel + :members: estimate, discount + +.. autoclass:: tatc.tradespace.SatelliteCost + :members: production + +.. autoclass:: tatc.tradespace.LaunchCost + +.. autoclass:: tatc.tradespace.OperationsCost + +.. autoclass:: tatc.tradespace.cost.CostEstimate + :members: total, present_value, annual, metrics diff --git a/docs/api_reference/tradespace/search.rst b/docs/api_reference/tradespace/search.rst new file mode 100644 index 00000000..3bcf05d6 --- /dev/null +++ b/docs/api_reference/tradespace/search.rst @@ -0,0 +1,60 @@ +======================== +Refinement and Searches +======================== + +Each of these steps takes a study and criteria (or metrics), and returns its +`results`, the `summary` of its designs, and the `designs` themselves, which +the next step takes. + +Adaptive Replication +==================== + +.. autofunction:: tatc.tradespace.refine + +.. autoclass:: tatc.tradespace.refinement.Refinement + :members: results, summary, history, designs, uncertain, indifferent + +Confirmation +============ + +.. autofunction:: tatc.tradespace.confirm + +.. autoclass:: tatc.tradespace.confirmation.Confirmation + :members: results, summary, criteria, designs, optimism + +Screening +========= + +.. autofunction:: tatc.tradespace.screen + +.. autoclass:: tatc.tradespace.screening.Screening + :members: results, summary, summaries, designs + +Attribution of Variance +======================= + +.. automodule:: tatc.tradespace.attribution + :no-members: + +.. autofunction:: tatc.tradespace.attribute_variance + +.. autoclass:: tatc.tradespace.attribution.Attribution + :members: summary, differences + +Optimizers +========== + +.. automodule:: tatc.tradespace.optimization + :no-members: + +.. autofunction:: tatc.tradespace.optimize_optuna + +.. autofunction:: tatc.tradespace.optimize_pymoo + +.. autoclass:: tatc.tradespace.optimization.Search + :members: results, summary, designs, state + +.. autofunction:: tatc.tradespace.optimization.make_pymoo_problem + +.. autoclass:: tatc.tradespace.optimization.Evaluations + :members: evaluate, results, worst, designs, search diff --git a/docs/examples/CompareScenarios.ipynb b/docs/examples/CompareScenarios.ipynb new file mode 100644 index 00000000..a4dbb032 --- /dev/null +++ b/docs/examples/CompareScenarios.ipynb @@ -0,0 +1,869 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "f99e557a", + "metadata": {}, + "source": [ + "# Compare Designs across Scenarios\n", + "\n", + "This example demonstrates how to compare designs under conditions that are not known in advance (scenarios) with the `tatc.tradespace` module: the front of each scenario, the share of the scenarios in which each design is efficient, the regret of each design, criteria that judge designs across the scenarios, and a search for designs robust to them.\n", + "\n", + "It continues the example `SearchTradeSpace`, whose design space and study it imports from `trade_space_example.py` (beside the notebooks). The evaluations of every design are taken from the study's store if `SearchTradeSpace` was run before (or are evaluated again, in a few minutes). Its objectives here are the numbers of satellites and of planes and the share of points accurately sampled (whose daily mean is estimated within half the field's standard deviation)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "30b9fb03", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-12T17:18:24.143529Z", + "iopub.status.busy": "2026-11-12T17:18:24.143529Z", + "iopub.status.idle": "2026-11-12T17:18:26.859265Z", + "shell.execute_reply": "2026-11-12T17:18:26.859265Z" + } + }, + "outputs": [], + "source": [ + "import time\n", + "from datetime import timedelta\n", + "\n", + "import pandas as pd\n", + "\n", + "from trade_space_example import ACCURACY, REFERENCE, describe, designs, study\n", + "from tatc.tradespace import pareto_front, summarize\n", + "\n", + "# the evaluations of every design, and the designs efficient by accuracy\n", + "results = study.run(designs)\n", + "accuracy = summarize(results, [\"satellites\", \"planes\", \"sufficient\", \"accurate\"])\n", + "accuracy[\"description\"] = accuracy.apply(describe, axis=1)\n", + "accuracy[\"pareto\"] = pareto_front(accuracy, ACCURACY)" + ] + }, + { + "cell_type": "markdown", + "id": "f275da1c", + "metadata": {}, + "source": [ + "## Compare Designs across Scenarios\n", + "\n", + "How accurately samples estimate a daily mean depends on the field: samples hours apart estimate the mean of a field that varies slowly (one that decorrelates in 12 hours) better than that of one that varies within the hour (such as rain rates). Which field the mission will serve is not uncertain as the sample of points or the failures are, which the replicates average over: it is a condition under which to compare designs, a scenario. The `scenarios` of a study give fixed values or uncertain parameters of the design space other values: here, the field's decorrelation time (`decorrelation_time`). The study evaluates every design in each field, with the same samples of points, and records the field as its `scenario`; the field of 3 hours, that of `SearchTradeSpace`, takes its evaluations from the store. Criteria `by` the scenario judge designs in each field, and `robustness` judges them across the fields: the share of the fields in which each design is efficient (its Pareto trace) here, and its regret below:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "209d04e1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-12T17:18:26.859265Z", + "iopub.status.busy": "2026-11-12T17:18:26.859265Z", + "iopub.status.idle": "2026-11-12T17:21:01.727173Z", + "shell.execute_reply": "2026-11-12T17:21:01.726172Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "16440 evaluations (3 fields) in 155 s\n", + "efficient designs: {'1 hour': 14, '3 hours': 13, '12 hours': 6}\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanes1 hour3 hours12 hourspareto_trace
design
33b006848799800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.026.234.260.40.67
b85daf65c3a4800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...3.01.08.017.095.60.67
c576e2e2dbd1800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:003.02.040.860.685.80.67
3690f1194419800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:004.02.069.085.493.00.67
cb6bd361b577800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.096.696.697.80.67
5529c21520be800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.897.80.67
de505bc89299800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.897.80.67
679ca275c8fc800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.897.80.67
\n", + "
" + ], + "text/plain": [ + " description satellites \\\n", + "design \n", + "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 \n", + "b85daf65c3a4 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... 3.0 \n", + "c576e2e2dbd1 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3.0 \n", + "3690f1194419 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4.0 \n", + "cb6bd361b577 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 \n", + "5529c21520be 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", + "de505bc89299 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", + "679ca275c8fc 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", + "\n", + " planes 1 hour 3 hours 12 hours pareto_trace \n", + "design \n", + "33b006848799 2.0 26.2 34.2 60.4 0.67 \n", + "b85daf65c3a4 1.0 8.0 17.0 95.6 0.67 \n", + "c576e2e2dbd1 2.0 40.8 60.6 85.8 0.67 \n", + "3690f1194419 2.0 69.0 85.4 93.0 0.67 \n", + "cb6bd361b577 4.0 96.6 96.6 97.8 0.67 \n", + "5529c21520be 3.0 97.8 97.8 97.8 0.67 \n", + "de505bc89299 3.0 97.8 97.8 97.8 0.67 \n", + "679ca275c8fc 3.0 97.8 97.8 97.8 0.67 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import Criteria, aggregate, robustness\n", + "\n", + "# fields that decorrelate within an hour (such as rain rates), in 3 hours (as in SearchTradeSpace), and in 12 hours\n", + "FIELDS = {\n", + " \"1 hour\": {\"decorrelation_time\": timedelta(hours=1)},\n", + " \"3 hours\": {},\n", + " \"12 hours\": {\"decorrelation_time\": timedelta(hours=12)},\n", + "}\n", + "began = time.perf_counter()\n", + "fields = study.replace(scenarios=FIELDS).run(designs)\n", + "print(f\"{len(fields)} evaluations ({len(FIELDS)} fields) in {time.perf_counter() - began:.0f} s\")\n", + "\n", + "# the efficient designs of each field (by accuracy), and the share of the fields in which each design is efficient\n", + "BY_FIELD = Criteria(ACCURACY, by=\"scenario\")\n", + "by_field = aggregate(fields, BY_FIELD)\n", + "by_field[\"pareto\"] = pareto_front(by_field, BY_FIELD)\n", + "print(\"efficient designs:\", by_field[by_field.pareto].scenario.value_counts()[list(FIELDS)].to_dict())\n", + "field_accuracy = by_field.pivot(index=\"design\", columns=\"scenario\", values=\"accurate\")[list(FIELDS)]\n", + "traced = accuracy.set_index(\"design\")[[\"description\", \"satellites\", \"planes\"]].join(field_accuracy)\n", + "traced[\"pareto_trace\"] = robustness(fields, ACCURACY).set_index(\"design\")[\"pareto_trace\"]\n", + "traced[traced[\"pareto_trace\"] > 0.5].sort_values([\"satellites\", \"planes\"]).round(2)" + ] + }, + { + "cell_type": "markdown", + "id": "6ef8bf46", + "metadata": {}, + "source": [ + "The 10,960 evaluations of the other two fields take about two minutes here. Which designs are efficient depends on the field. For the field that decorrelates in 12 hours, one plane samples well: three satellites in one plane (inclined 75 degrees) sample 96% of the points accurately, and four of the six efficient designs have one plane (the other two, four satellites in two planes, sample 98%). For the fields that vary within hours, the samples must spread over the day: the same three satellites in one plane sample 17% (3 hours) and 8% (1 hour) accurately, against 61% and 41% for three satellites in two sun-synchronous planes. No design is efficient for every field: of the eight efficient for two fields, seven are efficient for the fields of 1 and 3 hours, and the other, three satellites in one plane, for those of 3 and 12 hours.\n", + "\n", + "A design need not be efficient in any field to be a good choice when the field is not known: its regret in a field is how far it falls behind the best design there. With the numbers of satellites and planes as objectives, regret would count mostly satellites and planes (a design matches the cheapest efficient design by dropping some), so here regret is in the share accurately sampled alone, among the designs of at most a number of satellites (a `Requirement`): the points below the best design of each field with as many satellites at most. The design whose largest regret over the fields is least (minimax regret) is the robust choice:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "881decea", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-12T17:21:01.729172Z", + "iopub.status.busy": "2026-11-12T17:21:01.729172Z", + "iopub.status.idle": "2026-11-12T17:21:02.159338Z", + "shell.execute_reply": "2026-11-12T17:21:02.159338Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanesmax_regret1 hour regret3 hours regret12 hours regret
at most
2800 km, 60 deg FOR, Walker 75 deg: 2 x 1 (spac...2.02.011.07.66.411.0
3800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:003.02.09.89.80.49.8
4800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:004.02.05.00.00.05.0
6700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...6.03.00.40.40.20.4
\n", + "
" + ], + "text/plain": [ + " description satellites \\\n", + "at most \n", + "2 800 km, 60 deg FOR, Walker 75 deg: 2 x 1 (spac... 2.0 \n", + "3 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3.0 \n", + "4 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4.0 \n", + "6 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... 6.0 \n", + "\n", + " planes max_regret 1 hour regret 3 hours regret 12 hours regret \n", + "at most \n", + "2 2.0 11.0 7.6 6.4 11.0 \n", + "3 2.0 9.8 9.8 0.4 9.8 \n", + "4 2.0 5.0 0.0 0.0 5.0 \n", + "6 3.0 0.4 0.4 0.2 0.4 " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import Requirement\n", + "\n", + "# the designs of least maximum regret (in points accurately sampled, below the best design of each field), among those\n", + "# of at most a number of satellites\n", + "robust, robust_design = [], {}\n", + "for budget in (2, 3, 4, 6):\n", + " within = Criteria({\"accurate\": \"max\"}, requirements=[Requirement(\"satellites\", \"<=\", budget)])\n", + " regret = robustness(fields, within).set_index(\"design\")\n", + " best = robust_design[budget] = regret[\"max_regret\"].idxmin()\n", + " described = traced.loc[best, [\"description\", \"satellites\", \"planes\"]]\n", + " robust.append({\"at most\": budget, **described, **regret.loc[best].drop(\"pareto_trace\")})\n", + "pd.DataFrame(robust).set_index(\"at most\").round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "d814d0a8", + "metadata": {}, + "source": [ + "The robust choice depends on the budget. With four satellites, two sun-synchronous planes of two (crossing at 09:00 and 15:00) are the best for the fields of 1 and 3 hours and fall 5 points behind the best for the field of 12 hours (93% against 98%, by four satellites in two other planes): a mission that does not yet know its field loses little by choosing them. With three satellites, two sun-synchronous planes of two and one fall 10 points behind three satellites in one plane for the field of 12 hours (86% against 96%) and three in three planes for the field of 1 hour (41% against 51%), and less than a point behind the best for 3 hours. Two satellites fall at least 11 points behind somewhere. Six satellites in three Walker planes (at 700 km) fall at most 0.4 points behind the best of any field, though they are efficient in none: a robust choice need not be the best in any scenario. Regrets of a point or two are within the sampling error of the means of five replicates (standard errors of one to four points, see `SearchTradeSpace`), so the robust designs of four and six satellites are as good as the best of each field." + ] + }, + { + "cell_type": "markdown", + "id": "d8b216ed", + "metadata": {}, + "source": [ + "Criteria `across` the fields (`Across`) judge each design once, by its worst or its mean share over the fields, rather than in each field, which is what a search for designs robust to the field needs (see below). Here every design is evaluated in every field, so the fronts of both are exact:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a26f4db4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-12T17:21:02.159338Z", + "iopub.status.busy": "2026-11-12T17:21:02.159338Z", + "iopub.status.idle": "2026-11-12T17:21:02.328481Z", + "shell.execute_reply": "2026-11-12T17:21:02.328481Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "the field in which each design is least accurate: {'1 hour': 1028, '3 hours': 68}\n", + "efficient by the worst: 15, of which 12 in 1 hour\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanes1 hour3 hours12 hoursworstmean
design
9b3481aea973800 km, 60 deg FOR, SSO: 1 at 12:001.01.03.04.227.0TrueFalse
12765c7a29fc800 km, 60 deg FOR, SSO: 1 at 15:001.01.03.03.628.0TrueTrue
24a159fbc4b7800 km, 60 deg FOR, SSO: 2 at 12:002.01.05.69.470.0TrueFalse
c9cacc08010d800 km, 60 deg FOR, SSO: 2 at 15:002.01.04.810.073.0FalseTrue
33b006848799800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.026.234.260.4TrueTrue
d5d3fa915ca7800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...3.01.010.211.467.6TrueFalse
b85daf65c3a4800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...3.01.08.017.095.6FalseTrue
c576e2e2dbd1800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:003.02.040.860.685.8TrueTrue
92ff9cd17e00800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...3.03.050.659.863.6TrueFalse
1af5f2707be3800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.011.226.867.2TrueFalse
104e33a3c842800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac...4.01.09.228.695.0FalseTrue
3690f1194419800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:004.02.069.085.493.0TrueTrue
64cf6542c326800 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...6.03.090.295.897.4TrueFalse
e641bd5c978e700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...6.03.089.896.297.6FalseTrue
6df0f1709edc800 km, 60 deg FOR, Walker 60 deg: 2 x 4 (spac...8.02.070.280.289.2TrueFalse
cb6bd361b577800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.096.696.697.8TrueTrue
5529c21520be800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.897.8TrueTrue
679ca275c8fc800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.897.8TrueTrue
de505bc89299800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.897.8TrueTrue
\n", + "
" + ], + "text/plain": [ + " description satellites \\\n", + "design \n", + "9b3481aea973 800 km, 60 deg FOR, SSO: 1 at 12:00 1.0 \n", + "12765c7a29fc 800 km, 60 deg FOR, SSO: 1 at 15:00 1.0 \n", + "24a159fbc4b7 800 km, 60 deg FOR, SSO: 2 at 12:00 2.0 \n", + "c9cacc08010d 800 km, 60 deg FOR, SSO: 2 at 15:00 2.0 \n", + "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 \n", + "d5d3fa915ca7 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 \n", + "b85daf65c3a4 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... 3.0 \n", + "c576e2e2dbd1 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3.0 \n", + "92ff9cd17e00 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 \n", + "1af5f2707be3 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 \n", + "104e33a3c842 800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac... 4.0 \n", + "3690f1194419 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4.0 \n", + "64cf6542c326 800 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... 6.0 \n", + "e641bd5c978e 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... 6.0 \n", + "6df0f1709edc 800 km, 60 deg FOR, Walker 60 deg: 2 x 4 (spac... 8.0 \n", + "cb6bd361b577 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 \n", + "5529c21520be 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", + "679ca275c8fc 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", + "de505bc89299 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", + "\n", + " planes 1 hour 3 hours 12 hours worst mean \n", + "design \n", + "9b3481aea973 1.0 3.0 4.2 27.0 True False \n", + "12765c7a29fc 1.0 3.0 3.6 28.0 True True \n", + "24a159fbc4b7 1.0 5.6 9.4 70.0 True False \n", + "c9cacc08010d 1.0 4.8 10.0 73.0 False True \n", + "33b006848799 2.0 26.2 34.2 60.4 True True \n", + "d5d3fa915ca7 1.0 10.2 11.4 67.6 True False \n", + "b85daf65c3a4 1.0 8.0 17.0 95.6 False True \n", + "c576e2e2dbd1 2.0 40.8 60.6 85.8 True True \n", + "92ff9cd17e00 3.0 50.6 59.8 63.6 True False \n", + "1af5f2707be3 1.0 11.2 26.8 67.2 True False \n", + "104e33a3c842 1.0 9.2 28.6 95.0 False True \n", + "3690f1194419 2.0 69.0 85.4 93.0 True True \n", + "64cf6542c326 3.0 90.2 95.8 97.4 True False \n", + "e641bd5c978e 3.0 89.8 96.2 97.6 False True \n", + "6df0f1709edc 2.0 70.2 80.2 89.2 True False \n", + "cb6bd361b577 4.0 96.6 96.6 97.8 True True \n", + "5529c21520be 3.0 97.8 97.8 97.8 True True \n", + "679ca275c8fc 3.0 97.8 97.8 97.8 True True \n", + "de505bc89299 3.0 97.8 97.8 97.8 True True " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import Across\n", + "\n", + "# the efficient designs by their worst and by their mean share accurately sampled over the fields (with equal\n", + "# weights), and those of the field that decorrelates within an hour\n", + "fronts = {}\n", + "for rule in (\"worst\", \"mean\"):\n", + " criteria = Criteria(ACCURACY, across=Across(rule=rule))\n", + " combined = aggregate(fields, criteria)\n", + " fronts[rule] = set(combined.design[pareto_front(combined, criteria)])\n", + "fronts[\"1 hour\"] = set(by_field.design[by_field.pareto & (by_field.scenario == \"1 hour\")])\n", + "print(\"the field in which each design is least accurate:\", field_accuracy.idxmin(axis=1).value_counts().to_dict())\n", + "print(f\"efficient by the worst: {len(fronts['worst'])}, of which {len(fronts['worst'] & fronts['1 hour'])} in 1 hour\")\n", + "compared = traced.loc[sorted(fronts[\"worst\"] | fronts[\"mean\"]), [\"description\", \"satellites\", \"planes\", *FIELDS]]\n", + "compared[\"worst\"] = compared.index.isin(fronts[\"worst\"])\n", + "compared[\"mean\"] = compared.index.isin(fronts[\"mean\"])\n", + "compared.sort_values([\"satellites\", \"planes\", \"mean\"]).round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "701f624a", + "metadata": {}, + "source": [ + "The field that decorrelates within an hour is the hardest for 1,028 of the 1,096 designs (that of 3 hours for the others), so a design's worst share is nearly always its share in that field: 12 of the 15 designs efficient by the worst are efficient in that field, and the worst adds little to it. A worst case suits scenarios that are hardest for different designs; here, the mean and the regret (above) say more. The mean over the fields weighs the field of 12 hours as well, in which one plane samples well: three and four satellites in one plane inclined 75 degrees (96% and 95% in that field) are efficient by the mean, where the worst prefers one plane inclined 45 degrees, about two points better in the field of 1 hour and 28 points worse in that of 12 hours. Eight designs are efficient by both, among them the robust choices of three and four satellites above (in two sun-synchronous planes); the robust choice of six (three Walker planes at 700 km) is efficient by the mean, but not by the worst, by 0.4 points in the field of 1 hour." + ] + }, + { + "cell_type": "markdown", + "id": "1c07a5c4", + "metadata": {}, + "source": [ + "## Search for Robust Designs" + ] + }, + { + "cell_type": "markdown", + "id": "d82e00b3", + "metadata": {}, + "source": [ + "A search for designs robust to the field evaluates each design that it proposes in every field, and judges it by criteria `across` the fields: here pymoo's, by the mean share accurately sampled over the three fields, with as many proposals as above. Its evaluations are those of the comparison of the fields above, retrieved from the store:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "5d5e9a37", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-12T17:21:02.328481Z", + "iopub.status.busy": "2026-11-12T17:21:02.328481Z", + "iopub.status.idle": "2026-11-12T17:21:04.338094Z", + "shell.execute_reply": "2026-11-12T17:21:04.337622Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "147 designs evaluated (in 3 fields each): 99.3% of the hypervolume of the true front, and 8 of its 12 designs\n" + ] + } + ], + "source": [ + "from pymoo.algorithms.moo.nsga2 import NSGA2\n", + "\n", + "from tatc.tradespace import hypervolume, hypervolume_progress, optimize_pymoo\n", + "\n", + "BUDGET = 200 # proposals of the search, as in SearchTradeSpace\n", + "# a search for the designs most accurate on average over the fields, against the true front of every design\n", + "FIELD_MEAN = Criteria(ACCURACY, across=Across(rule=\"mean\"))\n", + "ACCURATE_REFERENCE = {\"satellites\": REFERENCE[\"satellites\"], \"planes\": REFERENCE[\"planes\"], \"accurate\": 0}\n", + "field_search = optimize_pymoo(\n", + " study.replace(scenarios=FIELDS), FIELD_MEAN, NSGA2(pop_size=20), (\"n_gen\", BUDGET // 20), seed=1\n", + ")\n", + "field_progress = hypervolume_progress(field_search.results, FIELD_MEAN, ACCURATE_REFERENCE)\n", + "true_mean = hypervolume(aggregate(fields, FIELD_MEAN), FIELD_MEAN, ACCURATE_REFERENCE)\n", + "evaluated = set(field_search.results.design)\n", + "print(\n", + " f\"{len(evaluated)} designs evaluated (in {len(FIELDS)} fields each): \"\n", + " f\"{100 * field_progress.iloc[-1] / true_mean:.1f}% of the hypervolume of the true front, \"\n", + " f\"and {len(evaluated & fronts['mean'])} of its {len(fronts['mean'])} designs\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "70bf569f", + "metadata": {}, + "source": [ + "The search finds 99.3% of the hypervolume of the true front of the mean with 147 designs, and 8 of its 12 designs; each design costs three times as much as in a search of one field, as it is evaluated in each field. Its designs and results refine and confirm its front as for any study, with the same criteria. A search by the worst would search mostly the field of 1 hour here (see above)." + ] + }, + { + "cell_type": "markdown", + "id": "2235c5f8", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "* The `scenarios` of a study compare designs under conditions rather than averaging over them (here, fields of different decorrelation times, a value of the design space): each design is evaluated in each scenario, with the same replicates, and the evaluations of each scenario are kept apart in the store.\n", + "* Criteria `by` the scenario give the front of each, and `robustness` the share of the scenarios in which each design is efficient (its Pareto trace) and its regret in each, whose least maximum is a robust choice (here, six satellites efficient in no field but never half a point behind the best).\n", + "* Criteria `across` the scenarios (`Across`) judge each design once, by its worst or its mean over them, as a search for robust designs needs: here the worst is mostly the field that varies fastest, and pymoo's search by the mean finds nearly all of the front of the mean." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/PlanMissions.ipynb b/docs/examples/PlanMissions.ipynb new file mode 100644 index 00000000..ff5a44d3 --- /dev/null +++ b/docs/examples/PlanMissions.ipynb @@ -0,0 +1,1815 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e7977fc4", + "metadata": {}, + "source": [ + "# Plan Missions\n", + "\n", + "This example demonstrates how to account for the deployment and the failures of constellations in a trade study with the `tatc.tradespace` module: the phases of each design's deployment, staged deployments that rules decide on during the mission, simulated failures of satellites and launches restored by policies that are decisions of each design, and the attribution of the spread of the replicates to their uncertain parameters.\n", + "\n", + "It continues the example `SearchTradeSpace`, whose design space and study it imports from `trade_space_example.py` (beside the notebooks). The evaluations of every design are taken from the study's store if `SearchTradeSpace` was run before (or are evaluated again, in a few minutes)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "1e32ed92", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-12T17:21:41.323187Z", + "iopub.status.busy": "2026-11-12T17:21:41.323187Z", + "iopub.status.idle": "2026-11-12T17:21:46.509314Z", + "shell.execute_reply": "2026-11-12T17:21:46.508316Z" + } + }, + "outputs": [], + "source": [ + "import time\n", + "from datetime import timedelta\n", + "\n", + "import pandas as pd\n", + "\n", + "from trade_space_example import ACCURACY, OBJECTIVES, PLAN, START, describe, designs, space, study\n", + "from tatc.tradespace import pareto_front, summarize\n", + "\n", + "# the evaluations of every design, the efficient designs (by sufficiency), and the efficient designs by accuracy\n", + "results = study.run(designs)\n", + "summary = summarize(results, [\"satellites\", \"planes\", \"sufficient\", \"accurate\"])\n", + "summary[\"description\"] = summary.apply(describe, axis=1)\n", + "front = summary[pareto_front(summary, OBJECTIVES)].sort_values([\"satellites\", \"planes\"])\n", + "accuracy = summary[pareto_front(summary, ACCURACY)]" + ] + }, + { + "cell_type": "markdown", + "id": "63cac933", + "metadata": {}, + "source": [ + "## Account for Deployment\n", + "\n", + "The shares of points sampled so far are those of each design's full constellation, as if its satellites flew for the whole mission. They are launched over months to years, during which fewer satellites sample the points. The launches of each design's deployment divide its mission into phases, in each of which a set of its satellites flies (`Deployment.phases`); each phase is evaluated over the same representative day with the observations of its satellites (`evaluate_phases`, which filters the observations of the full constellation, from the cache), and the phases are combined over the mission (`summarize_phases`): the mean of each share weighted by the duration of the phases, over the five years from the first launch (`sufficient mission`), and the time from the start of development until half of the points are sampled sufficiently (`sufficient time`, infinite if never).\n", + "\n", + "The phased study (a variant of the study with the phases, `study.replace`) evaluates the efficient designs of `SearchTradeSpace` (the most sufficient of each number of satellites and planes), with the years by which each is `deployed`." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3451a5b5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-12T17:21:46.513316Z", + "iopub.status.busy": "2026-11-12T17:21:46.513316Z", + "iopub.status.idle": "2026-11-12T17:22:04.704273Z", + "shell.execute_reply": "2026-11-12T17:22:04.704273Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanesdeployedsufficientsufficient missionlostsufficient time
design
163120bf9590800 km, 60 deg FOR, SSO: 1 at 18:001.01.03.23.23.20.0inf
f7413b1f8466800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...2.01.03.516.616.60.0inf
33b006848799800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.03.830.227.32.9inf
d5d3fa915ca7800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...3.01.03.838.038.00.0inf
1af5f2707be3800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.04.568.263.54.74.5
6ba50f2632cd800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.04.069.664.35.34.0
6bef11e40977800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.04.597.887.110.74.5
\n", + "
" + ], + "text/plain": [ + " description satellites \\\n", + "design \n", + "163120bf9590 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 \n", + "f7413b1f8466 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 \n", + "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 \n", + "d5d3fa915ca7 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 \n", + "1af5f2707be3 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 \n", + "6ba50f2632cd 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 \n", + "6bef11e40977 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 \n", + "\n", + " planes deployed sufficient sufficient mission lost \\\n", + "design \n", + "163120bf9590 1.0 3.2 3.2 3.2 0.0 \n", + "f7413b1f8466 1.0 3.5 16.6 16.6 0.0 \n", + "33b006848799 2.0 3.8 30.2 27.3 2.9 \n", + "d5d3fa915ca7 1.0 3.8 38.0 38.0 0.0 \n", + "1af5f2707be3 1.0 4.5 68.2 63.5 4.7 \n", + "6ba50f2632cd 2.0 4.0 69.6 64.3 5.3 \n", + "6bef11e40977 2.0 4.5 97.8 87.1 10.7 \n", + "\n", + " sufficient time \n", + "design \n", + "163120bf9590 inf \n", + "f7413b1f8466 inf \n", + "33b006848799 inf \n", + "d5d3fa915ca7 inf \n", + "1af5f2707be3 4.5 \n", + "6ba50f2632cd 4.0 \n", + "6bef11e40977 4.5 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import Requirement, aggregate\n", + "\n", + "# a study of the phases of each design's deployment, and of the years until half of the points are sampled sufficiently\n", + "phased_study = study.replace(phases=[Requirement(\"sufficient\", \">=\", 50)])\n", + "PHASED = [\"sufficient\", \"sufficient mission\", \"sufficient time\", \"deployed\"]\n", + "leaders = front.sort_values(\"sufficient\", ascending=False).drop_duplicates([\"satellites\", \"planes\"])\n", + "phased = phased_study.run(leaders)\n", + "deployed = aggregate(phased, PHASED, design_columns=[]).set_index(\"design\")[PHASED]\n", + "leaders = leaders.set_index(\"design\")[[\"description\", \"satellites\", \"planes\"]].join(deployed)\n", + "leaders[\"lost\"] = leaders[\"sufficient\"] - leaders[\"sufficient mission\"]\n", + "leaders.sort_values([\"satellites\", \"planes\"])[\n", + " [\"description\", \"satellites\", \"planes\", \"deployed\", \"sufficient\", \"sufficient mission\", \"lost\", \"sufficient time\"]\n", + "].round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "f6b53a96", + "metadata": {}, + "source": [ + "Deployment costs the designs of several planes or launches. Six satellites in two planes sample 98% of the points once deployed, but 87% on average over the mission, as the first plane flies alone for three quarters of a year while the second is produced, and they sample half of the points only 4.5 years after development starts, when the second plane is launched. Four satellites in one plane need two launches (of up to three satellites) half a year apart, and lose 5 points of their 68%; four satellites in two planes lose 5 points of their 70%, and two satellites in two planes 3 points of their 30%. The designs launched at once lose nothing. Over a five-year mission, the loss is the share of the mission before full deployment times the shortfall of the partial constellation: a shorter mission, slower production, or fewer launches a year would weigh deployment more, and could reorder the front." + ] + }, + { + "cell_type": "markdown", + "id": "c84d572c", + "metadata": {}, + "source": [ + "Each phase is evaluated over the same day of July, as if the geometry of the satellites and the season were those of that day throughout the mission (quasi-static phases, see `evaluate_phases`). This misses the drift of the relative nodes of planes of different inclinations or altitudes (which precess at different rates), the drift of the local times of planes that are not sun-synchronous, and seasons. Here, the planes of each design share an altitude and an inclination, which keeps their relative geometry, and the shares do not depend on the sun, so the day should represent the mission. Drawing the start of the day for each replicate over a year (the `epoch` of the design space, which `Observations` and the metrics read, as an `Uncertain` parameter of a design space that extends the other, `DesignSpace.extend`) averages the replicates over the drift and the seasons, at the cost of analyzing the satellites again for each day:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9a399192", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-12T17:22:04.704273Z", + "iopub.status.busy": "2026-11-12T17:22:04.704273Z", + "iopub.status.idle": "2026-11-12T17:22:06.223072Z", + "shell.execute_reply": "2026-11-12T17:22:06.221072Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanessufficient mission (July)accurate mission (July)sufficient mission (year)accurate mission (year)sufficient mission se (year)accurate mission se (year)
design
163120bf9590800 km, 60 deg FOR, SSO: 1 at 18:001.01.03.22.83.23.00.70.6
f7413b1f8466800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...2.01.016.64.016.22.01.00.7
33b006848799800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.027.330.925.828.81.61.6
d5d3fa915ca7800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...3.01.038.011.437.89.80.50.7
1af5f2707be3800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.063.524.561.722.51.80.8
6ba50f2632cd800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.064.359.362.158.01.51.3
6bef11e40977800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.087.171.186.770.30.20.8
\n", + "
" + ], + "text/plain": [ + " description satellites \\\n", + "design \n", + "163120bf9590 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 \n", + "f7413b1f8466 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 \n", + "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 \n", + "d5d3fa915ca7 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 \n", + "1af5f2707be3 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 \n", + "6ba50f2632cd 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 \n", + "6bef11e40977 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 \n", + "\n", + " planes sufficient mission (July) accurate mission (July) \\\n", + "design \n", + "163120bf9590 1.0 3.2 2.8 \n", + "f7413b1f8466 1.0 16.6 4.0 \n", + "33b006848799 2.0 27.3 30.9 \n", + "d5d3fa915ca7 1.0 38.0 11.4 \n", + "1af5f2707be3 1.0 63.5 24.5 \n", + "6ba50f2632cd 2.0 64.3 59.3 \n", + "6bef11e40977 2.0 87.1 71.1 \n", + "\n", + " sufficient mission (year) accurate mission (year) \\\n", + "design \n", + "163120bf9590 3.2 3.0 \n", + "f7413b1f8466 16.2 2.0 \n", + "33b006848799 25.8 28.8 \n", + "d5d3fa915ca7 37.8 9.8 \n", + "1af5f2707be3 61.7 22.5 \n", + "6ba50f2632cd 62.1 58.0 \n", + "6bef11e40977 86.7 70.3 \n", + "\n", + " sufficient mission se (year) accurate mission se (year) \n", + "design \n", + "163120bf9590 0.7 0.6 \n", + "f7413b1f8466 1.0 0.7 \n", + "33b006848799 1.6 1.6 \n", + "d5d3fa915ca7 0.5 0.7 \n", + "1af5f2707be3 1.8 0.8 \n", + "6ba50f2632cd 1.5 1.3 \n", + "6bef11e40977 0.2 0.8 " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import Uncertain\n", + "\n", + "# the leading designs, with the day of the analysis drawn for each replicate over a year\n", + "EPOCH = Uncertain(lambda rng: START + timedelta(days=float(rng.uniform(0, 365))))\n", + "epoch_space = space.extend(epoch=EPOCH)\n", + "year = phased_study.replace(space=epoch_space).run(epoch_space.designs_of(front, leaders.index))\n", + "MEANS = [\"sufficient mission\", \"accurate mission\"]\n", + "over_year = summarize(year, MEANS).set_index(\"design\")\n", + "july = aggregate(phased, MEANS).set_index(\"design\")[MEANS]\n", + "leaders[[\"description\", \"satellites\", \"planes\"]].join(july.add_suffix(\" (July)\")).join(\n", + " over_year[[*MEANS, *(f\"{m} se\" for m in MEANS)]].add_suffix(\" (year)\")\n", + ").sort_values([\"satellites\", \"planes\"]).round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "c99a6486", + "metadata": {}, + "source": [ + "Over the year, the means of the leading designs are within 2.2 points of those of the day in July (and within three standard errors of the year's means), most a little lower: the one day represents the mission well here. A constellation of planes at different altitudes or inclinations, metrics that depend on daylight, or a field that varies with the seasons would call for drawing the epoch. The phases also assume that a satellite operates until it fails or is replaced: a design life does not retire a satellite whose replacement is not launched, and a planned replacement whose launch fails is not flown again (see `DeploymentSchedule`)." + ] + }, + { + "cell_type": "markdown", + "id": "8579c533", + "metadata": {}, + "source": [ + "## Stage the Deployment\n", + "\n", + "A deployment need not commit to every plane at once. A stage of a deployment (`Stage`) is a set of planes produced and launched only if a rule decides to, at times during the mission, from what it knows then (a `Decision`: the satellites operating, what they achieve, and the history so far) and from the values of the design, such as its uncertain parameters and its scenario. A stage that is not deployed is neither produced, launched, nor paid for, so that a staged deployment is an option: it saves the cost of a stage where the mission does not need it, and loses what deferring the stage costs where it does (as above, the capability of the satellites not yet launched). Whether and how to stage is a decision of each design (here, a value `staging` of the design space), and the `stages` of a `MissionPlan` are a function of the design.\n", + "\n", + "Here, the design of four satellites most robust to the field whose daily mean is estimated (see `CompareScenarios`: two sun-synchronous planes of two) deploys its second plane at once, never, or only if the field turns out to vary within hours (to decorrelate within 6 hours), as decided at the first launch or a year later. These rules read the field from the scenario, which a mission does not know; the last rule reads what the first plane achieves once it is launched (`Decision.capability`, by the study's metrics), and deploys the second plane if the first samples fewer than half the points accurately. Each staging is evaluated in each field by the phases of its deployment: the mean share of points accurately sampled over the mission, and the present cost:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "7463c0ff", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-12T17:22:06.227071Z", + "iopub.status.busy": "2026-11-12T17:22:06.227071Z", + "iopub.status.idle": "2026-11-12T17:22:07.662228Z", + "shell.execute_reply": "2026-11-12T17:22:07.661222Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
accurate missioncost present
scenario1 hour3 hours12 hours1 hour3 hours12 hours
staging
at once62.677.991.0156.4156.4156.4
first plane4.810.073.0118.8118.8118.8
decided at launch62.677.973.0156.4156.4118.8
decided a year later49.762.873.0154.5154.5118.8
measured at launch62.677.973.0156.4156.4118.8
\n", + "
" + ], + "text/plain": [ + " accurate mission cost present \\\n", + "scenario 1 hour 3 hours 12 hours 1 hour 3 hours \n", + "staging \n", + "at once 62.6 77.9 91.0 156.4 156.4 \n", + "first plane 4.8 10.0 73.0 118.8 118.8 \n", + "decided at launch 62.6 77.9 73.0 156.4 156.4 \n", + "decided a year later 49.7 62.8 73.0 154.5 154.5 \n", + "measured at launch 62.6 77.9 73.0 156.4 156.4 \n", + "\n", + " \n", + "scenario 12 hours \n", + "staging \n", + "at once 156.4 \n", + "first plane 118.8 \n", + "decided at launch 118.8 \n", + "decided a year later 118.8 \n", + "measured at launch 118.8 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import dataclasses\n", + "\n", + "from tatc.tradespace import Categorical, Stage\n", + "\n", + "# the fields of CompareScenarios: decorrelating within an hour, in 3 hours, and in 12 hours\n", + "FIELDS = {\n", + " \"1 hour\": {\"decorrelation_time\": timedelta(hours=1)},\n", + " \"3 hours\": {},\n", + " \"12 hours\": {\"decorrelation_time\": timedelta(hours=12)},\n", + "}\n", + "STAGING = [\"at once\", \"first plane\", \"decided at launch\", \"decided a year later\", \"measured at launch\"]\n", + "staging_space = space.extend(staging=Categorical(STAGING))\n", + "\n", + "\n", + "def stages(d):\n", + " \"\"\"The stages of a design's deployment: its second plane deployed with the first (at once), never (first plane),\n", + " or if the field decorrelates within 6 hours, as decided at the first launch or a year later, or if the first plane\n", + " accurately samples fewer than half the points, as measured at the first launch.\"\"\"\n", + " if d.staging == \"at once\":\n", + " return []\n", + " if d.staging == \"first plane\":\n", + " return [Stage(1, 0.0, lambda decision: False)]\n", + " if d.staging == \"measured at launch\":\n", + " return [Stage(1, 0.0, lambda decision: decision.capability[\"accurate\"] < 50)]\n", + " when = 0.0 if d.staging == \"decided at launch\" else 1.0\n", + " return [Stage(1, when, lambda decision: d.decorrelation_time < timedelta(hours=6))]\n", + "\n", + "\n", + "# the design of four satellites most robust to the field (see CompareScenarios), with each staging of its deployment, in\n", + "# each field\n", + "(four,) = space.designs_of(summary[summary.description == \"800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00\"])\n", + "staged = phased_study.replace(\n", + " space=staging_space, plan=dataclasses.replace(PLAN, stages=stages), scenarios=FIELDS\n", + ").run([staging_space.design(four, staging=option) for option in STAGING])\n", + "staged.groupby([\"staging\", \"scenario\"], sort=False)[[\"accurate mission\", \"cost present\"]].mean().unstack(\"scenario\").round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "502d3883", + "metadata": {}, + "source": [ + "Deciding at the first launch is worth the most. Where the field varies within hours, the second plane is produced and launched as if it were deployed at once (63% and 78% of the points accurately sampled on average over the mission, for 156 million dollars), and where it varies slowly, it is not, which saves 38 million dollars (24%) for 18 points of the mean (73% against 91%): a trade that the rule makes, and that a mission might not. Deciding a year later costs the fields that need the second plane 13 to 15 points of the mean (50% and 63%), as the first plane flies alone for a year more, and saves only 2 million dollars, by discounting the later production. The value of the option is that of knowing the need when it is exercised: the earlier the field is known, the more staging saves at less loss. The rule that measures makes the same choices as the rule that reads the field, in every field: the first plane alone accurately samples 5% and 10% of the points where the field varies within hours, so that the second plane is deployed, and 73% where it varies over 12 hours, so that it is not. A mission knows what its satellites achieve, not the field, so this is a rule it could follow; a measurement takes time, though (the rule reads at once the capability that the study computes), and one that waits a year to measure loses what deciding a year later loses above. A rule may also read the satellites still operating (see `Decision`), for a reserve plane launched only if satellites fail, or their capability, for one launched only if those in orbit fall short." + ] + }, + { + "cell_type": "markdown", + "id": "b8848349", + "metadata": {}, + "source": [ + "## Plan for Failures\n", + "\n", + "A design that needs every satellite to work is fragile, and what failures cost depends on how the mission responds to them. A `FailureModel` gives the life of the satellites from their launch, here a bathtub curve of infant mortality, random failures, and wear-out (`Bathtub` of `Weibull` and `Exponential` lives, illustrative), and the probability that a launch fails. Each replicate simulates the mission of a design with failures drawn from its seed (`Deployment.simulate`, with common random numbers: the satellite at the same position of the same plane fails at the same age in every design), and a `RestorationPolicy` responds to them:\n", + "\n", + "* **degrade**: fly the satellites that remain;\n", + "* **produce**: restore each failed satellite by producing a new one (after half a year of procurement, on the production line) and launching it;\n", + "* **spare in orbit**: a spare in each plane, launched with it, takes a failed satellite's place within months (others are produced), and is produced again;\n", + "* **spare on ground**: a spare, produced after the first satellites and stored, is launched at the next slot (others are produced), and is produced again.\n", + "\n", + "The policy is a decision of each design: a fragment of the design space (`policy_space`) decides whether to restore failed satellites, and the spares in orbit (in each plane) and on the ground (here, none or one of each, and none without restoration, which would never use them), and configures the policy of each design (from a base policy of half a year of procurement and spares that are produced again). The efficient designs by accuracy, each with each of the five policies, form a design space of both (one that extends the other with the policy, `DesignSpace.extend`), in which each history gives both the cost of what is produced and launched (the restorations and spares, and the launches that fail) and the phases in which its satellites operate, evaluated as in the previous section: the share of points accurately sampled on average over the mission, and in the worst 10% of the histories, and the cost at 70% confidence.\n", + "\n", + "The failures are cheap to simulate, but each phase's share is expensive to evaluate, and most phases repeat the same sets of operating satellites. Each replicate (a sample of points, the expensive part) therefore simulates 20 histories of the failures of its mission (`Failures` of the study, with `Deployment.simulate_many`, stratified: a Latin hypercube over the histories in which each satellite's life and each launch draws from its own stratum of its distribution, which estimates means several times more precisely than independent histories), evaluates them together (`evaluate_missions`) with a cache that evaluates each set of satellites once (`PhaseCache`, shared by the histories, policies, and designs of a replicate), and summarizes them (`summarize_missions`): their mean share, and their worst 10% (the risk of the mission), and their cost at 70% confidence. Five replicates of 20 histories measure the risk of each mission with 100 histories, at a fraction of the cost of 100 replicates. Without restoration (degrading), the satellites fail independently, so that the mean share over the failures is computed exactly (`expected_missions`, from the probability that each set of satellites operates), without sampling error; its worst 10% and cost still come from the histories." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "75613a88", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-12T17:22:07.664250Z", + "iopub.status.busy": "2026-11-12T17:22:07.664250Z", + "iopub.status.idle": "2026-11-12T17:22:23.155533Z", + "shell.execute_reply": "2026-11-12T17:22:23.155533Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "37% of the satellites fail in 5 years\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "65 designs x 5 replicates x 20 histories in 10 s\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionfull constellationaccurateaccurate p10cost p70
policydegradeproducespare in orbitspare on groundspares in orbit and on grounddegradeproducespare in orbitspare on groundspares in orbit and on grounddegradeproducespare in orbitspare on groundspares in orbit and on ground
base
9b3481aea973800 km, 60 deg FOR, SSO: 1 at 12:003.43.23.94.04.14.00.43.53.73.73.7110.2130.6147.6146.3162.2
fac5d43a19c7800 km, 60 deg FOR, SSO: 2 at 06:0010.07.09.29.69.89.72.17.38.38.68.7128.9153.4170.3170.0184.3
b85daf65c3a4800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...16.710.914.814.716.014.94.612.212.914.313.3146.2188.2211.1204.4223.3
104e33a3c842800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac...29.316.122.324.424.424.96.118.020.421.021.9170.2218.9237.7235.8249.8
33b006848799800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...33.017.726.128.228.928.50.619.525.125.625.6136.5159.4192.7175.2206.4
c576e2e2dbd1800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:0057.033.147.350.751.751.27.138.544.744.946.8153.9198.1229.3212.4240.1
f216ec70e160800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac...60.432.944.948.048.148.39.537.743.042.443.5161.2201.0247.9216.8260.4
3690f1194419800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:0082.850.768.568.872.569.310.856.261.362.263.1170.4218.3246.8235.4260.7
cb6bd361b577800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...96.075.881.276.381.576.260.473.869.873.969.6246.8326.4376.7347.0389.6
716cb479efda700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...97.064.278.074.279.674.338.970.167.371.566.9209.5278.8316.7294.4329.0
5529c21520be800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...98.379.382.876.882.876.966.478.171.678.271.6253.5340.0394.6355.7405.7
679ca275c8fc800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...98.379.583.076.883.076.869.078.772.178.672.1253.5340.0394.6355.7405.7
de505bc89299800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...98.379.582.976.983.076.968.078.771.778.471.7253.5340.0394.6355.7405.7
\n", + "
" + ], + "text/plain": [ + " description \\\n", + "policy \n", + "base \n", + "9b3481aea973 800 km, 60 deg FOR, SSO: 1 at 12:00 \n", + "fac5d43a19c7 800 km, 60 deg FOR, SSO: 2 at 06:00 \n", + "b85daf65c3a4 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... \n", + "104e33a3c842 800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac... \n", + "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", + "c576e2e2dbd1 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 \n", + "f216ec70e160 800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac... \n", + "3690f1194419 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 \n", + "cb6bd361b577 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... \n", + "716cb479efda 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", + "5529c21520be 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", + "679ca275c8fc 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", + "de505bc89299 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", + "\n", + " full constellation accurate \\\n", + "policy degrade produce spare in orbit \n", + "base \n", + "9b3481aea973 3.4 3.2 3.9 4.0 \n", + "fac5d43a19c7 10.0 7.0 9.2 9.6 \n", + "b85daf65c3a4 16.7 10.9 14.8 14.7 \n", + "104e33a3c842 29.3 16.1 22.3 24.4 \n", + "33b006848799 33.0 17.7 26.1 28.2 \n", + "c576e2e2dbd1 57.0 33.1 47.3 50.7 \n", + "f216ec70e160 60.4 32.9 44.9 48.0 \n", + "3690f1194419 82.8 50.7 68.5 68.8 \n", + "cb6bd361b577 96.0 75.8 81.2 76.3 \n", + "716cb479efda 97.0 64.2 78.0 74.2 \n", + "5529c21520be 98.3 79.3 82.8 76.8 \n", + "679ca275c8fc 98.3 79.5 83.0 76.8 \n", + "de505bc89299 98.3 79.5 82.9 76.9 \n", + "\n", + " accurate p10 \\\n", + "policy spare on ground spares in orbit and on ground degrade \n", + "base \n", + "9b3481aea973 4.1 4.0 0.4 \n", + "fac5d43a19c7 9.8 9.7 2.1 \n", + "b85daf65c3a4 16.0 14.9 4.6 \n", + "104e33a3c842 24.4 24.9 6.1 \n", + "33b006848799 28.9 28.5 0.6 \n", + "c576e2e2dbd1 51.7 51.2 7.1 \n", + "f216ec70e160 48.1 48.3 9.5 \n", + "3690f1194419 72.5 69.3 10.8 \n", + "cb6bd361b577 81.5 76.2 60.4 \n", + "716cb479efda 79.6 74.3 38.9 \n", + "5529c21520be 82.8 76.9 66.4 \n", + "679ca275c8fc 83.0 76.8 69.0 \n", + "de505bc89299 83.0 76.9 68.0 \n", + "\n", + " \\\n", + "policy produce spare in orbit spare on ground \n", + "base \n", + "9b3481aea973 3.5 3.7 3.7 \n", + "fac5d43a19c7 7.3 8.3 8.6 \n", + "b85daf65c3a4 12.2 12.9 14.3 \n", + "104e33a3c842 18.0 20.4 21.0 \n", + "33b006848799 19.5 25.1 25.6 \n", + "c576e2e2dbd1 38.5 44.7 44.9 \n", + "f216ec70e160 37.7 43.0 42.4 \n", + "3690f1194419 56.2 61.3 62.2 \n", + "cb6bd361b577 73.8 69.8 73.9 \n", + "716cb479efda 70.1 67.3 71.5 \n", + "5529c21520be 78.1 71.6 78.2 \n", + "679ca275c8fc 78.7 72.1 78.6 \n", + "de505bc89299 78.7 71.7 78.4 \n", + "\n", + " cost p70 \\\n", + "policy spares in orbit and on ground degrade produce spare in orbit \n", + "base \n", + "9b3481aea973 3.7 110.2 130.6 147.6 \n", + "fac5d43a19c7 8.7 128.9 153.4 170.3 \n", + "b85daf65c3a4 13.3 146.2 188.2 211.1 \n", + "104e33a3c842 21.9 170.2 218.9 237.7 \n", + "33b006848799 25.6 136.5 159.4 192.7 \n", + "c576e2e2dbd1 46.8 153.9 198.1 229.3 \n", + "f216ec70e160 43.5 161.2 201.0 247.9 \n", + "3690f1194419 63.1 170.4 218.3 246.8 \n", + "cb6bd361b577 69.6 246.8 326.4 376.7 \n", + "716cb479efda 66.9 209.5 278.8 316.7 \n", + "5529c21520be 71.6 253.5 340.0 394.6 \n", + "679ca275c8fc 72.1 253.5 340.0 394.6 \n", + "de505bc89299 71.7 253.5 340.0 394.6 \n", + "\n", + " \n", + "policy spare on ground spares in orbit and on ground \n", + "base \n", + "9b3481aea973 146.3 162.2 \n", + "fac5d43a19c7 170.0 184.3 \n", + "b85daf65c3a4 204.4 223.3 \n", + "104e33a3c842 235.8 249.8 \n", + "33b006848799 175.2 206.4 \n", + "c576e2e2dbd1 212.4 240.1 \n", + "f216ec70e160 216.8 260.4 \n", + "3690f1194419 235.4 260.7 \n", + "cb6bd361b577 347.0 389.6 \n", + "716cb479efda 294.4 329.0 \n", + "5529c21520be 355.7 405.7 \n", + "679ca275c8fc 355.7 405.7 \n", + "de505bc89299 355.7 405.7 " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import (\n", + " Bathtub,\n", + " Exponential,\n", + " FailureModel,\n", + " Failures,\n", + " Integer,\n", + " RestorationPolicy,\n", + " Weibull,\n", + " policy_space,\n", + ")\n", + "\n", + "# illustrative lives: about 9% fail in their first year, 3% a year at random, and wear-out after about 8 years\n", + "FAILURE_MODEL = FailureModel(\n", + " life=Bathtub(infant=Weibull(shape=0.5, scale=100), random=Exponential(0.03), wear_out=Weibull(shape=4, scale=9)),\n", + " launch=0.05,\n", + ")\n", + "print(f\"{1 - FAILURE_MODEL.life.survival(5):.0%} of the satellites fail in 5 years\")\n", + "BASE_POLICY = RestorationPolicy(procurement_years=0.5, replenish=True)\n", + "POLICY = policy_space(orbit_spares=Integer(0, 1), ground_spares=Integer(0, 1), replenish=True)\n", + "\n", + "# the design space with a policy, and the efficient designs by accuracy with each policy\n", + "policy_trade = space.extend(policy=POLICY)\n", + "with_policies, base_of = [], {}\n", + "for base in space.designs_of(accuracy):\n", + " for policy in POLICY.enumerate():\n", + " design = policy_trade.design(base, policy=policy)\n", + " with_policies.append(design)\n", + " base_of[design.key] = base.key\n", + "\n", + "\n", + "def describe_policy(row):\n", + " \"\"\"A short description of a policy.\"\"\"\n", + " if not row[\"policy.restore\"]:\n", + " return \"degrade\"\n", + " orbit, ground = row[\"policy.orbit_spares\"] > 0, row[\"policy.ground_spares\"] > 0\n", + " return {\n", + " (False, False): \"produce\",\n", + " (True, False): \"spare in orbit\",\n", + " (False, True): \"spare on ground\",\n", + " (True, True): \"spares in orbit and on ground\",\n", + " }[orbit, ground]\n", + "\n", + "\n", + "# 20 histories of each replicate, restored by the policy of each design, with the mean share accurately sampled over\n", + "# the mission in the worst 10% of the histories, and the cost at 70% confidence (over the histories)\n", + "FAILURES = Failures(\n", + " FAILURE_MODEL, BASE_POLICY, histories=20, seed=\"failure_seed\", quantiles={\"accurate mission\": 0.1, \"cost\": 0.7}\n", + ")\n", + "failures_study = study.replace(space=policy_trade, failures=FAILURES)\n", + "began = time.perf_counter()\n", + "trades = failures_study.run(with_policies)\n", + "print(f\"{len(with_policies)} designs x 5 replicates x 20 histories in {time.perf_counter() - began:.0f} s\")\n", + "# the means over the replicates of the histories' mean share, worst 10%, and cost at 70% confidence\n", + "ROBUST = {\"accurate\": \"accurate mission\", \"accurate p10\": \"accurate mission histories p10\", \"cost p70\": \"cost histories p70\"}\n", + "traded = aggregate(trades, statistics=ROBUST).set_index(\"design\")\n", + "traded[\"policy\"] = traded.apply(describe_policy, axis=1)\n", + "traded[\"base\"] = [base_of[key] for key in traded.index]\n", + "traded = traded[[*ROBUST, \"policy\", \"base\"]]\n", + "\n", + "# the shares of the full constellations, without deployment or failures, for comparison\n", + "nominal = study.replace(replicates=20).run(accuracy)\n", + "full = aggregate(nominal, [\"accurate\"]).set_index(\"design\")[\"accurate\"]\n", + "descriptions = accuracy.set_index(\"design\")[\"description\"]\n", + "ORDER = [\"degrade\", \"produce\", \"spare in orbit\", \"spare on ground\", \"spares in orbit and on ground\"]\n", + "table = traded.pivot(index=\"base\", columns=\"policy\", values=list(ROBUST))\n", + "table = table[[(metric, policy) for metric in ROBUST for policy in ORDER]]\n", + "table.insert(0, (\"full constellation\", \"\"), full.reindex(table.index))\n", + "table.insert(0, (\"description\", \"\"), descriptions.reindex(table.index))\n", + "table.sort_values((\"full constellation\", \"\")).round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "d52db10b", + "metadata": {}, + "source": [ + "The 6,500 histories (100 of each of the 65 designs and policies) take about ten seconds here. The shares accurately sampled over the mission fall short of those of the full constellation under every policy, by the phases of deployment and the failures of launches as well as of satellites (37% of which fail within five years), but for the single satellite, whose shares differ by less than the sampling error of five replicates (the full constellation's are of 20). The response to failures matters most for the designs of several satellites in several planes, and in their worst histories:\n", + "\n", + "* **Degrading** is cheapest, but loses 12 to 18 points of the mean against producing replacements for the designs of three to six satellites in two or three planes, and more in their worst 10% of histories (39% against 70% for six satellites in three Walker planes; 1% against 20% for two satellites in two planes, which can lose both). Nine satellites in three planes lose only 3.5 points: a failure leaves eight. The means of degrading are exact (`expected_missions`); those of the other policies are estimates from 100 histories.\n", + "* **Producing replacements** restores most of it, at 17 to 34% more cost at 70% confidence than degrading.\n", + "* **Spares** cost 28 to 56% more than degrading (up to 62% for spares both in orbit and on the ground), and pay off in the worst histories of the small designs of several planes: two satellites in two planes keep about 25% in their worst histories with a spare, against 20% by producing replacements. A spare on the ground costs less than a spare in each plane for the designs of several planes, and restores as well or better.\n", + "* **A spare in orbit can hurt**: for six to nine satellites in three or four planes, the spares delay the deployment (each plane waits for its spare to be produced, and a fourth satellite in a plane of three takes a second launch), so that they sample less on average (74% against 78% for six satellites, 76% against 81% for eight, 77% against 83% for nine) at a higher cost. Spares in orbit and on the ground together cost the most, and sample about as much as a spare on the ground alone, or less." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "20cc9f3e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-12T17:22:23.155533Z", + "iopub.status.busy": "2026-11-12T17:22:23.155533Z", + "iopub.status.idle": "2026-11-12T17:22:23.171508Z", + "shell.execute_reply": "2026-11-12T17:22:23.171508Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionpolicyaccurateaccurate p10cost p70
design
2a310c00151b800 km, 60 deg FOR, SSO: 1 at 12:00degrade3.20.4110.2
bc2076a0d3d8800 km, 60 deg FOR, SSO: 2 at 06:00degrade7.02.1128.9
bb6574900ac3800 km, 60 deg FOR, SSO: 1 at 12:00produce3.93.5130.6
638697713902800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...degrade10.94.6146.2
43f50c8bc38a800 km, 60 deg FOR, SSO: 2 at 06:00produce9.27.3153.4
ad99c42082ab800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...produce26.119.5159.4
cc2e14e787ff800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...spare on ground28.925.6175.2
eeb7c70a720b800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00produce47.338.5198.1
3a902b976460700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...degrade64.238.9209.5
6d54bdbf4648800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00spare on ground51.744.9212.4
1afde0569e34800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00produce68.556.2218.3
e7721a705c31800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00spare on ground72.562.2235.4
46932f795a5a800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...degrade79.569.0253.5
6e4564d2ae2c700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...produce78.070.1278.8
570a452fdb8f700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...spare on ground79.671.5294.4
2b499d154a98800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...produce81.273.8326.4
a37619256b26800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...produce83.078.7340.0
\n", + "
" + ], + "text/plain": [ + " description \\\n", + "design \n", + "2a310c00151b 800 km, 60 deg FOR, SSO: 1 at 12:00 \n", + "bc2076a0d3d8 800 km, 60 deg FOR, SSO: 2 at 06:00 \n", + "bb6574900ac3 800 km, 60 deg FOR, SSO: 1 at 12:00 \n", + "638697713902 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... \n", + "43f50c8bc38a 800 km, 60 deg FOR, SSO: 2 at 06:00 \n", + "ad99c42082ab 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", + "cc2e14e787ff 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", + "eeb7c70a720b 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 \n", + "3a902b976460 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", + "6d54bdbf4648 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 \n", + "1afde0569e34 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 \n", + "e7721a705c31 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 \n", + "46932f795a5a 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", + "6e4564d2ae2c 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", + "570a452fdb8f 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", + "2b499d154a98 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... \n", + "a37619256b26 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", + "\n", + " policy accurate accurate p10 cost p70 \n", + "design \n", + "2a310c00151b degrade 3.2 0.4 110.2 \n", + "bc2076a0d3d8 degrade 7.0 2.1 128.9 \n", + "bb6574900ac3 produce 3.9 3.5 130.6 \n", + "638697713902 degrade 10.9 4.6 146.2 \n", + "43f50c8bc38a produce 9.2 7.3 153.4 \n", + "ad99c42082ab produce 26.1 19.5 159.4 \n", + "cc2e14e787ff spare on ground 28.9 25.6 175.2 \n", + "eeb7c70a720b produce 47.3 38.5 198.1 \n", + "3a902b976460 degrade 64.2 38.9 209.5 \n", + "6d54bdbf4648 spare on ground 51.7 44.9 212.4 \n", + "1afde0569e34 produce 68.5 56.2 218.3 \n", + "e7721a705c31 spare on ground 72.5 62.2 235.4 \n", + "46932f795a5a degrade 79.5 69.0 253.5 \n", + "6e4564d2ae2c produce 78.0 70.1 278.8 \n", + "570a452fdb8f spare on ground 79.6 71.5 294.4 \n", + "2b499d154a98 produce 81.2 73.8 326.4 \n", + "a37619256b26 produce 83.0 78.7 340.0 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# the efficient designs and policies, by their cost and their accuracy in the worst 10% of the histories\n", + "efficient = traded[pareto_front(traded, {\"cost p70\": \"min\", \"accurate p10\": \"max\"})]\n", + "efficient.assign(description=descriptions.reindex(efficient.base).to_numpy()).sort_values(\"cost p70\")[\n", + " [\"description\", \"policy\", \"accurate\", \"accurate p10\", \"cost p70\"]\n", + "].round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "30d0967a", + "metadata": {}, + "source": [ + "The front of cost at 70% confidence against the share accurately sampled in the worst 10% of the histories chooses designs and policies together. Along it, degrading is the cheapest policy of a design and restoring buys robustness: two satellites in two Walker planes keep 20% of the points accurately sampled in their worst histories if they produce replacements (159 million) and 26% with a spare on the ground (175 million); six satellites in three Walker planes keep 39%, 70%, and 72% if they degrade, produce replacements, or keep a spare on the ground, for 210, 279, and 294 million. Nine satellites in three planes degrade gracefully (69% in their worst histories for 254 million), and producing replacements raises them to 79% for 340 million. A spare on the ground is efficient for designs of two to six satellites, but a spare in orbit is not efficient for any design here, as it delays the deployment. The policy that a design deserves depends on the design, which is why the policy is a decision of the design rather than of the study." + ] + }, + { + "cell_type": "markdown", + "id": "06e6d4fc", + "metadata": {}, + "source": [ + "## Find What Spreads the Replicates\n", + "\n", + "The replicates of a design differ by its uncertain parameters: here, the sample of points (`points_seed`), the histories of failures (`failure_seed`), and the growth of the cost of development (`cost_growth`, see `TradeCostAndUtility`). Which of them spreads an objective says what would sharpen it: the spread from the sample of points and from the histories is noise of the estimates, which more points or more histories reduce, and that from the growth of costs is a risk of the mission. `attribute_variance` finds it by evaluating each design again with one parameter drawn as in other replicates and the others held, which works for parameters whose values do not relate to the outcomes in any order, such as seeds. The total share of a parameter is the share of the variance between replicates that it causes, alone or with others (near 0 if it does not matter), with its standard error (`se`, by a bootstrap of the replicates); its first share (`summary(\"first\")`) is the share that knowing it would remove. Here, for the efficient designs and policies of the study of failures, from 20 replicates, 20 more, and 20 with each parameter drawn as in the second 20:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "1b38f451", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-12T17:22:23.171508Z", + "iopub.status.busy": "2026-11-12T17:22:23.171508Z", + "iopub.status.idle": "2026-11-12T17:23:12.742254Z", + "shell.execute_reply": "2026-11-12T17:23:12.741355Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1700 evaluations in 50 s\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
accurate missionaccurate mission histories p10cost histories p70accurate mission seaccurate mission histories p10 secost histories p70 se
parameter
points_seed92.430.40.06.43.30.0
failure_seed3.667.035.80.76.57.1
cost_growth0.00.081.80.00.019.0
\n", + "
" + ], + "text/plain": [ + " accurate mission accurate mission histories p10 \\\n", + "parameter \n", + "points_seed 92.4 30.4 \n", + "failure_seed 3.6 67.0 \n", + "cost_growth 0.0 0.0 \n", + "\n", + " cost histories p70 accurate mission se \\\n", + "parameter \n", + "points_seed 0.0 6.4 \n", + "failure_seed 35.8 0.7 \n", + "cost_growth 81.8 0.0 \n", + "\n", + " accurate mission histories p10 se cost histories p70 se \n", + "parameter \n", + "points_seed 3.3 0.0 \n", + "failure_seed 6.5 7.1 \n", + "cost_growth 0.0 19.0 " + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import attribute_variance\n", + "\n", + "# the shares (%) of the variance between the replicates of the efficient designs and policies that each uncertain\n", + "# parameter causes, alone or with others, from 20 replicates, 20 more, and 20 with each parameter drawn as in the\n", + "# second 20\n", + "began = time.perf_counter()\n", + "attribution = attribute_variance(\n", + " failures_study, list(ROBUST.values()), policy_trade.designs_of(trades, efficient.index), replicates=20\n", + ")\n", + "print(f\"{len(attribution.results)} evaluations in {time.perf_counter() - began:.0f} s\")\n", + "attribution.summary().mul(100).round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "d87e67ee", + "metadata": {}, + "source": [ + "The attribution takes 1,700 evaluations (85 of them those of the study above), under a minute here. The sample of points spreads the mean shares accurately sampled (92% of their variance between replicates), and the failures hardly do (4%): the means of degrading are exact, and those of the other policies average 20 histories. The share in the worst 10% of the histories is spread mostly by the failures (67%, and 30% by the points), as a quantile of 20 histories is a noisy estimate. Both are noise of the estimates rather than risks of the missions, and they call for different remedies: more points would sharpen the means, and more histories in each replicate the worst 10%, which is cheap (the 6,500 histories above take about ten seconds). The cost at 70% confidence of a replicate is spread by the growth of the cost of development (82%), a risk of the mission, and by the failures (36%), which cost replacements and spares for the policies that restore satellites; these shares are the least certain (standard errors of 19 and 7 points). The total shares of each objective sum to about 1 within their errors, so the parameters hardly interact." + ] + }, + { + "cell_type": "markdown", + "id": "58faf51f", + "metadata": {}, + "source": [ + "The order of designs on the front is settled by their differences, in which the parameters that act alike on two designs cancel (with common random numbers, the designs of a replicate share its parameters). `differences` attributes the variance of the differences between pairs of designs, from the same evaluations: here, between the designs and policies adjacent along the front, by cost at 70% confidence:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "f396b1dc", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-12T17:23:12.742254Z", + "iopub.status.busy": "2026-11-12T17:23:12.742254Z", + "iopub.status.idle": "2026-11-12T17:23:13.026475Z", + "shell.execute_reply": "2026-11-12T17:23:13.026475Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
accurate missionaccurate mission histories p10cost histories p70accurate mission seaccurate mission histories p10 secost histories p70 se
parameter
points_seed92.130.40.06.44.50.0
failure_seed2.973.0105.80.56.54.7
cost_growth0.00.00.00.00.00.0
\n", + "
" + ], + "text/plain": [ + " accurate mission accurate mission histories p10 \\\n", + "parameter \n", + "points_seed 92.1 30.4 \n", + "failure_seed 2.9 73.0 \n", + "cost_growth 0.0 0.0 \n", + "\n", + " cost histories p70 accurate mission se \\\n", + "parameter \n", + "points_seed 0.0 6.4 \n", + "failure_seed 105.8 0.5 \n", + "cost_growth 0.0 0.0 \n", + "\n", + " accurate mission histories p10 se cost histories p70 se \n", + "parameter \n", + "points_seed 4.5 0.0 \n", + "failure_seed 6.5 4.7 \n", + "cost_growth 0.0 0.0 " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# the shares (%) of the variance of the differences between the efficient designs and policies adjacent along the\n", + "# front (by cost), from the same evaluations\n", + "ordered = efficient.sort_values(\"cost p70\").index\n", + "attribution.differences(list(zip(ordered, ordered[1:]))).summary().mul(100).round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "049b3f94", + "metadata": {}, + "source": [ + "The growth of the cost of development cancels in every difference: all of these designs fly the same imager, whose development grows alike, so that it is a risk of each mission but not a reason to prefer one of them to another, and the failures alone unsettle the order of their costs (all of the variance of the differences, 106 ± 5%). The shares accurately sampled differ by the parameters that spread them: by the sample of points for the means (92%), and mostly by the histories for the worst 10% (73%, and 30% by the points). More points would settle the order of neighbors by their means, and more histories their order by the worst 10% and by cost." + ] + }, + { + "cell_type": "markdown", + "id": "5a85b602", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "* A `DeploymentSchedule` plans each design's deployment from rates of production and launch, which divides its mission into phases of the satellites that fly, evaluated with the observations of the full constellation (over one day, which an epoch drawn for each replicate shows to represent the mission here) for the mean capability over the mission and the time until a requirement is met.\n", + "* A `Stage` of a deployment is produced and launched only if a rule decides to, from what is known then (a `Decision`) and the values of the design: an option whose value the analyses of a study measure (here, deciding at the first launch whether the field needs a second plane saves 38 million dollars where it does not, at no loss where it does, and deciding a year later loses 13 to 15 points of the mean where it does). A rule may read what the satellites in orbit achieve (`Decision.capability`): here, a second plane deployed if the first accurately samples fewer than half the points makes the same choices without knowing the field.\n", + "* Simulated missions draw the failures of satellites and launches from lives whose failure rates vary over the lifecycle (`FailureModel`), and restore them or not (`RestorationPolicy`, by spares in orbit or on the ground, or by producing new ones), for both the cost and the capability of each policy (exactly, without sampling, for missions that do not restore failed satellites); the policy is a decision of each design (`policy_space`), on the front with the design.\n", + "* `attribute_variance` finds the uncertain parameters that spread the replicates of each design (by drawing each again with the others held): here, the sample of points spreads the mean shares and the histories of failures their worst 10%, which says what would sharpen each, and the growth of costs spreads the costs of designs alike, so that it cancels in their differences (`Attribution.differences`) and does not change their order." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/RankUncertainDesigns.ipynb b/docs/examples/RankUncertainDesigns.ipynb new file mode 100644 index 00000000..7b13c9c6 --- /dev/null +++ b/docs/examples/RankUncertainDesigns.ipynb @@ -0,0 +1,1878 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5f89aadc", + "metadata": {}, + "source": [ + "# Rank Uncertain Designs\n", + "\n", + "This example demonstrates how to rank designs whose objectives are uncertain with the `tatc.tradespace` module: the probability that each design is Pareto-efficient given the uncertainty of its replicates, replicates added only where they settle it, new replicates that confirm the selected designs, and statistics other than means that state how reliably a design performs.\n", + "\n", + "It continues the example `SearchTradeSpace`, whose design space and study it imports from `trade_space_example.py` (beside the notebooks). The evaluations of every design are taken from the study's store if `SearchTradeSpace` was run before (or are evaluated again, in a few minutes). Its objectives are the numbers of satellites and of planes and the share of points sufficiently sampled (at least four times a day), estimated from five replicates (samples of points) of each design." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "1b487226", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-12T17:17:26.254890Z", + "iopub.status.busy": "2026-11-12T17:17:26.254890Z", + "iopub.status.idle": "2026-11-12T17:17:29.338186Z", + "shell.execute_reply": "2026-11-12T17:17:29.338186Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5480 evaluations: 1096 designs x 5 replicates\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "from trade_space_example import OBJECTIVES, describe, designs, study\n", + "\n", + "# the evaluations of every design\n", + "results = study.run(designs)\n", + "print(f\"{len(results)} evaluations: {len(designs)} designs x {study.replicates} replicates\")" + ] + }, + { + "cell_type": "markdown", + "id": "a64b6506", + "metadata": {}, + "source": [ + "## Rank Designs with the Uncertainty of Replicates\n", + "\n", + "The means of five replicates are uncertain, and so is the front of the means: a design just behind another in the means may be ahead of it in other samples of points. `pareto_probability` estimates the probability that each design is efficient by a bootstrap: it resamples the replicates (the same replicates for every design, which keeps the correlation between designs of common random numbers) and counts how often each design is on the front of the resampled means." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f030cd39", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-12T17:17:29.340647Z", + "iopub.status.busy": "2026-11-12T17:17:29.340647Z", + "iopub.status.idle": "2026-11-12T17:17:30.653695Z", + "shell.execute_reply": "2026-11-12T17:17:30.653695Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanessufficientparetopareto_probability
1017800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac...1.01.02.8False0.38
776700 km, 60 deg FOR, SSO: 1 at 12:001.01.03.0False0.20
1048800 km, 60 deg FOR, SSO: 1 at 09:001.01.03.0False0.12
1050800 km, 60 deg FOR, SSO: 1 at 12:001.01.03.0False0.10
1052800 km, 60 deg FOR, SSO: 1 at 15:001.01.03.0False0.12
1054800 km, 60 deg FOR, SSO: 1 at 18:001.01.03.2True0.54
960800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...2.01.016.6True0.98
963800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.030.2True1.00
961800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...3.01.038.0True1.00
972800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...3.03.037.6False0.32
971800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...3.03.037.8False0.29
962800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.068.2True1.00
965800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.069.6True0.92
1026800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.6False0.32
1025800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.8True1.00
\n", + "
" + ], + "text/plain": [ + " description satellites planes \\\n", + "1017 800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac... 1.0 1.0 \n", + "776 700 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", + "1048 800 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", + "1050 800 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", + "1052 800 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", + "1054 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", + "960 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 1.0 \n", + "963 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", + "961 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 1.0 \n", + "972 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", + "971 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", + "962 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", + "965 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", + "1026 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "1025 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "\n", + " sufficient pareto pareto_probability \n", + "1017 2.8 False 0.38 \n", + "776 3.0 False 0.20 \n", + "1048 3.0 False 0.12 \n", + "1050 3.0 False 0.10 \n", + "1052 3.0 False 0.12 \n", + "1054 3.2 True 0.54 \n", + "960 16.6 True 0.98 \n", + "963 30.2 True 1.00 \n", + "961 38.0 True 1.00 \n", + "972 37.6 False 0.32 \n", + "971 37.8 False 0.29 \n", + "962 68.2 True 1.00 \n", + "965 69.6 True 0.92 \n", + "1026 97.6 False 0.32 \n", + "1025 97.8 True 1.00 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import pareto_probability\n", + "\n", + "probability = pareto_probability(results, OBJECTIVES, n_resamples=1000)\n", + "probability[\"description\"] = probability.apply(describe, axis=1)\n", + "candidates = probability[probability.pareto_probability >= 0.1].sort_values([\"satellites\", \"planes\", \"sufficient\"])\n", + "candidates[[\"description\", \"satellites\", \"planes\", \"sufficient\", \"pareto\", \"pareto_probability\"]].round(2)" + ] + }, + { + "cell_type": "markdown", + "id": "9b971b54", + "metadata": {}, + "source": [ + "Four of the seven efficient designs are efficient in every resample: two satellites in two planes, three or four satellites in one plane, and six in two planes; two satellites in one plane (efficient in 98% of the resamples) and four in two planes (92%) nearly so. The single satellite is not settled by five replicates: one in a sun-synchronous orbit crossing the equator at 18:00 (efficient in 54% of the resamples) samples about as many points as one in a Walker orbit inclined 75 degrees (38%) or crossing at other times (10 to 20%). Likewise, three satellites in three planes (29% and 32%) sample about as many points as three in one plane, and six satellites in two planes with another relative spacing (32%) as many as the efficient design. Designs that are efficient with a probability between 0 and 1 are equally good candidates, given the uncertainty of the estimates: more replicates (samples of points) would separate them, or a tolerance of the share (see `pareto_front`) would treat them as ties." + ] + }, + { + "cell_type": "markdown", + "id": "72111ecf", + "metadata": {}, + "source": [ + "## Refine Uncertain Designs\n", + "\n", + "Five replicates settle the efficiency of most designs, but not of all. More replicates of every design would settle them, at the cost of evaluating every design again for each. `refine` instead adds replicates only to the designs whose efficiency is uncertain (efficient in more than 5% and fewer than 95% of the resamples), five at a time, and estimates their probabilities again, until none is uncertain (or a design has 40 replicates). The added replicates are the next ones after each design's own, which keeps common random numbers between the designs refined together.\n", + "\n", + "Some designs differ by less than any number of replicates could separate, such as those that sample nearly every point: a difference of a tenth of a percentage point does not matter to the trade. A tolerance of 1 percentage point of the share, part of the criteria by which designs are judged (`Criteria`), treats designs within it of the front as efficient (see `pareto_front`), so that refinement does not spend replicates on differences that do not matter. A design about one tolerance below the front stays uncertain instead: more replicates settle which side of the tolerance it falls on only slowly, though it does not matter. `refine` stops refining such a design once the standard error of its share is less than half the tolerance (`precision`): it is then `indifferent`. A `budget` would limit the evaluations, refining the least settled designs first." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "628dcbf7", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-12T17:17:30.656445Z", + "iopub.status.busy": "2026-11-12T17:17:30.655442Z", + "iopub.status.idle": "2026-11-12T17:18:02.798337Z", + "shell.execute_reply": "2026-11-12T17:18:02.798337Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "215 evaluations added, 0.6% of those of 40 replicates of every design\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
rounduncertainindifferentrefinedevaluations
0031229145
111611525
221411315
331412210
44141315
55141315
661412210
77131200
\n", + "
" + ], + "text/plain": [ + " round uncertain indifferent refined evaluations\n", + "0 0 31 2 29 145\n", + "1 1 16 11 5 25\n", + "2 2 14 11 3 15\n", + "3 3 14 12 2 10\n", + "4 4 14 13 1 5\n", + "5 5 14 13 1 5\n", + "6 6 14 12 2 10\n", + "7 7 13 12 0 0" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import Criteria, refine\n", + "\n", + "TOLERANCE = {\"sufficient\": 1.0} # percentage points of the share that do not matter\n", + "CRITERIA = Criteria(OBJECTIVES, tolerance=TOLERANCE)\n", + "refinement = refine(study, CRITERIA, results, step=5, max_replicates=40, precision=0.5, n_resamples=1000)\n", + "added = len(refinement.results) - len(results)\n", + "print(f\"{added} evaluations added, {added / (len(designs) * 35):.1%} of those of 40 replicates of every design\")\n", + "refinement.history" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "25bbdcdf", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-12T17:18:02.798337Z", + "iopub.status.busy": "2026-11-12T17:18:02.798337Z", + "iopub.status.idle": "2026-11-12T17:18:02.846133Z", + "shell.execute_reply": "2026-11-12T17:18:02.846133Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanessufficientreplicatesparetopareto_probabilityindifferent
500600 km, 60 deg FOR, SSO: 1 at 09:001.01.01.8010False0.12True
230500 km, 60 deg FOR, SSO: 1 at 15:001.01.01.9010False0.14True
498600 km, 60 deg FOR, SSO: 1 at 06:001.01.01.9010False0.19True
504600 km, 60 deg FOR, SSO: 1 at 15:001.01.02.1010False0.18True
502600 km, 60 deg FOR, SSO: 1 at 12:001.01.02.2010True0.40True
506600 km, 60 deg FOR, SSO: 1 at 18:001.01.02.2010True0.32True
1017800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac...1.01.02.4010True0.57True
774700 km, 60 deg FOR, SSO: 1 at 09:001.01.02.5010True0.76True
780700 km, 60 deg FOR, SSO: 1 at 18:001.01.02.5010True0.79True
778700 km, 60 deg FOR, SSO: 1 at 15:001.01.02.5315True0.70True
776700 km, 60 deg FOR, SSO: 1 at 12:001.01.02.8010True0.95False
772700 km, 60 deg FOR, SSO: 1 at 06:001.01.02.9010True0.98False
1052800 km, 60 deg FOR, SSO: 1 at 15:001.01.02.9010True0.98False
1046800 km, 60 deg FOR, SSO: 1 at 06:001.01.03.1010True0.98False
1054800 km, 60 deg FOR, SSO: 1 at 18:001.01.03.1010True0.99False
1048800 km, 60 deg FOR, SSO: 1 at 09:001.01.03.2010True0.99False
1050800 km, 60 deg FOR, SSO: 1 at 12:001.01.03.2010True0.99False
960800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...2.01.016.605True1.00False
963800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.030.205True1.00False
961800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...3.01.038.005True1.00False
972800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...3.03.037.0240False0.19False
971800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...3.03.038.4825True0.89True
962800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.068.205True1.00False
965800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.069.605True0.96False
1026800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.605True1.00False
1025800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.805True1.00False
479600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.405True0.97False
480600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.405True0.97False
753700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.605True1.00False
754700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.605True1.00False
1027800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.805True1.00False
1028800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.805True1.00False
768700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.605True1.00False
769700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.605True1.00False
770700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.605True1.00False
1043800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.805True1.00False
1044800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.805True1.00False
1045800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.805True1.00False
761700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.096.805False0.39True
487600 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.405True0.97False
762700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.605True1.00False
763700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.605True1.00False
1035800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.805True1.00False
1036800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.805True1.00False
1037800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.805True1.00False
\n", + "
" + ], + "text/plain": [ + " description satellites planes \\\n", + "500 600 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", + "230 500 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", + "498 600 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", + "504 600 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", + "502 600 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", + "506 600 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", + "1017 800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac... 1.0 1.0 \n", + "774 700 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", + "780 700 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", + "778 700 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", + "776 700 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", + "772 700 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", + "1052 800 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", + "1046 800 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", + "1054 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", + "1048 800 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", + "1050 800 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", + "960 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 1.0 \n", + "963 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", + "961 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 1.0 \n", + "972 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", + "971 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", + "962 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", + "965 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", + "1026 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "1025 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "479 600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", + "480 600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", + "753 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", + "754 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", + "1027 800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", + "1028 800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", + "768 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "769 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "770 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "1043 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "1044 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "1045 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "761 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "487 600 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "762 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "763 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "1035 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "1036 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "1037 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "\n", + " sufficient replicates pareto pareto_probability indifferent \n", + "500 1.80 10 False 0.12 True \n", + "230 1.90 10 False 0.14 True \n", + "498 1.90 10 False 0.19 True \n", + "504 2.10 10 False 0.18 True \n", + "502 2.20 10 True 0.40 True \n", + "506 2.20 10 True 0.32 True \n", + "1017 2.40 10 True 0.57 True \n", + "774 2.50 10 True 0.76 True \n", + "780 2.50 10 True 0.79 True \n", + "778 2.53 15 True 0.70 True \n", + "776 2.80 10 True 0.95 False \n", + "772 2.90 10 True 0.98 False \n", + "1052 2.90 10 True 0.98 False \n", + "1046 3.10 10 True 0.98 False \n", + "1054 3.10 10 True 0.99 False \n", + "1048 3.20 10 True 0.99 False \n", + "1050 3.20 10 True 0.99 False \n", + "960 16.60 5 True 1.00 False \n", + "963 30.20 5 True 1.00 False \n", + "961 38.00 5 True 1.00 False \n", + "972 37.02 40 False 0.19 False \n", + "971 38.48 25 True 0.89 True \n", + "962 68.20 5 True 1.00 False \n", + "965 69.60 5 True 0.96 False \n", + "1026 97.60 5 True 1.00 False \n", + "1025 97.80 5 True 1.00 False \n", + "479 97.40 5 True 0.97 False \n", + "480 97.40 5 True 0.97 False \n", + "753 97.60 5 True 1.00 False \n", + "754 97.60 5 True 1.00 False \n", + "1027 97.80 5 True 1.00 False \n", + "1028 97.80 5 True 1.00 False \n", + "768 97.60 5 True 1.00 False \n", + "769 97.60 5 True 1.00 False \n", + "770 97.60 5 True 1.00 False \n", + "1043 97.80 5 True 1.00 False \n", + "1044 97.80 5 True 1.00 False \n", + "1045 97.80 5 True 1.00 False \n", + "761 96.80 5 False 0.39 True \n", + "487 97.40 5 True 0.97 False \n", + "762 97.60 5 True 1.00 False \n", + "763 97.60 5 True 1.00 False \n", + "1035 97.80 5 True 1.00 False \n", + "1036 97.80 5 True 1.00 False \n", + "1037 97.80 5 True 1.00 False " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "refined = refinement.summary\n", + "refined[\"description\"] = refined.apply(describe, axis=1)\n", + "refined[refined.pareto_probability >= 0.1].sort_values([\"satellites\", \"planes\", \"sufficient\"])[\n", + " [\"description\", \"satellites\", \"planes\", \"sufficient\", \"replicates\", \"pareto\", \"pareto_probability\", \"indifferent\"]\n", + "].round(2)" + ] + }, + { + "cell_type": "markdown", + "id": "8c6de013", + "metadata": {}, + "source": [ + "Refinement adds 215 evaluations, 0.6% of those that 40 replicates of every design would take, to the few designs whose efficiency is uncertain. With the tolerance, the designs that sample nearly every point (six to nine satellites, about 98%) are efficient candidates, with probabilities of 0.97 or more, rather than uncertain: they differ by less than matters. The designs that remain uncertain lie about one tolerance below the front, such as single satellites that sample 1.8 to 2.5% of the points against the best single satellite's 3.2%, or nine satellites that sample 96.8% against 97.8%: whether they are within the tolerance of the front is a question that more replicates settle only slowly, and one that does not change the trade. They are indifferent once their shares are known to within half the tolerance (a standard error of 0.5 percentage points), after 10 or 15 replicates of the single satellites (and the first five of the nine satellites); without a precision (`precision=None`), refinement would refine them to the limit of 40 replicates, for 555 evaluations. The shares of three satellites vary more between replicates: three satellites in three planes that sample 38.5% are indifferent after 25 replicates, and those that sample 37.0% remain uncertain with 40. An absolute tolerance suits a share near saturation better than one near zero; a tolerance proportional to the objective would treat both alike." + ] + }, + { + "cell_type": "markdown", + "id": "08774ef2", + "metadata": {}, + "source": [ + "## Confirm the Front\n", + "\n", + "The efficient designs were selected for their means over their replicates, so they are selected in part for the luck of those replicates: among a thousand designs, those that look best are likely to have drawn favorable samples of points (the winner's curse). `confirm` evaluates the selected designs (by default, the front of the results it is given) with new replicates, which played no part in their selection (the same for every design, which keeps common random numbers), and finds the front among them by these replicates. The difference between the means of the replicates that selected the designs and those of the new ones measures the optimism of the selection." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ccdbfb35", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-12T17:18:02.846133Z", + "iopub.status.busy": "2026-11-12T17:18:02.846133Z", + "iopub.status.idle": "2026-11-12T17:18:20.616576Z", + "shell.execute_reply": "2026-11-12T17:18:20.616576Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "optimism of the selection: -0.02 percentage points\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanessufficient selectedsufficientreplicatespareto
4600 km, 60 deg FOR, SSO: 1 at 18:001.01.02.202.2520False
3600 km, 60 deg FOR, SSO: 1 at 12:001.01.02.202.3520False
23800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac...1.01.02.402.6020False
15700 km, 60 deg FOR, SSO: 1 at 15:001.01.02.532.8520True
16700 km, 60 deg FOR, SSO: 1 at 18:001.01.02.502.8520True
13700 km, 60 deg FOR, SSO: 1 at 09:001.01.02.502.9020True
14700 km, 60 deg FOR, SSO: 1 at 12:001.01.02.802.9520True
12700 km, 60 deg FOR, SSO: 1 at 06:001.01.02.903.4520True
35800 km, 60 deg FOR, SSO: 1 at 09:001.01.03.203.5020True
38800 km, 60 deg FOR, SSO: 1 at 18:001.01.03.103.5020True
37800 km, 60 deg FOR, SSO: 1 at 15:001.01.02.903.7520True
34800 km, 60 deg FOR, SSO: 1 at 06:001.01.03.103.8020True
36800 km, 60 deg FOR, SSO: 1 at 12:001.01.03.203.8520True
17800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...2.01.016.6016.1520True
20800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.030.2028.9520True
18800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...3.01.038.0036.7020True
22800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...3.03.038.4835.6020False
19800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.068.2066.5020True
21800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.069.6066.4020True
25800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.6097.8020True
24800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.8097.9520True
0600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.4097.7520True
1600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.4097.8520True
5700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.6097.9520True
6700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.6097.9520True
26800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.8098.1020True
27800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.8098.1020True
9700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.6097.9520True
10700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.6097.9520True
11700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.6097.9520True
31800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.8098.1020True
32800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.8098.1020True
33800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.8098.1020True
2600 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.4097.8520True
7700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.6097.9520True
8700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.6097.9520True
28800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.8098.1020True
29800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.8098.1020True
30800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.8098.1020True
\n", + "
" + ], + "text/plain": [ + " description satellites planes \\\n", + "4 600 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", + "3 600 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", + "23 800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac... 1.0 1.0 \n", + "15 700 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", + "16 700 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", + "13 700 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", + "14 700 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", + "12 700 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", + "35 800 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", + "38 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", + "37 800 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", + "34 800 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", + "36 800 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", + "17 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 1.0 \n", + "20 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", + "18 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 1.0 \n", + "22 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", + "19 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", + "21 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", + "25 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "24 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "0 600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", + "1 600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", + "5 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", + "6 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", + "26 800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", + "27 800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", + "9 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "10 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "11 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "31 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "32 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "33 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "2 600 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "7 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "8 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "28 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "29 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "30 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "\n", + " sufficient selected sufficient replicates pareto \n", + "4 2.20 2.25 20 False \n", + "3 2.20 2.35 20 False \n", + "23 2.40 2.60 20 False \n", + "15 2.53 2.85 20 True \n", + "16 2.50 2.85 20 True \n", + "13 2.50 2.90 20 True \n", + "14 2.80 2.95 20 True \n", + "12 2.90 3.45 20 True \n", + "35 3.20 3.50 20 True \n", + "38 3.10 3.50 20 True \n", + "37 2.90 3.75 20 True \n", + "34 3.10 3.80 20 True \n", + "36 3.20 3.85 20 True \n", + "17 16.60 16.15 20 True \n", + "20 30.20 28.95 20 True \n", + "18 38.00 36.70 20 True \n", + "22 38.48 35.60 20 False \n", + "19 68.20 66.50 20 True \n", + "21 69.60 66.40 20 True \n", + "25 97.60 97.80 20 True \n", + "24 97.80 97.95 20 True \n", + "0 97.40 97.75 20 True \n", + "1 97.40 97.85 20 True \n", + "5 97.60 97.95 20 True \n", + "6 97.60 97.95 20 True \n", + "26 97.80 98.10 20 True \n", + "27 97.80 98.10 20 True \n", + "9 97.60 97.95 20 True \n", + "10 97.60 97.95 20 True \n", + "11 97.60 97.95 20 True \n", + "31 97.80 98.10 20 True \n", + "32 97.80 98.10 20 True \n", + "33 97.80 98.10 20 True \n", + "2 97.40 97.85 20 True \n", + "7 97.60 97.95 20 True \n", + "8 97.60 97.95 20 True \n", + "28 97.80 98.10 20 True \n", + "29 97.80 98.10 20 True \n", + "30 97.80 98.10 20 True " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import confirm\n", + "\n", + "# the front of the refined results, with 20 new replicates\n", + "confirmation = confirm(study, CRITERIA, refinement.results, replicates=20)\n", + "confirmed = confirmation.summary\n", + "confirmed[\"description\"] = confirmed.apply(describe, axis=1)\n", + "print(f\"optimism of the selection: {confirmation.optimism()['sufficient']:.2f} percentage points\")\n", + "confirmed.sort_values([\"satellites\", \"planes\", \"sufficient\"])[\n", + " [\"description\", \"satellites\", \"planes\", \"sufficient selected\", \"sufficient\", \"replicates\", \"pareto\"]\n", + "].round(2)" + ] + }, + { + "cell_type": "markdown", + "id": "e1752ee5", + "metadata": {}, + "source": [ + "The selection is optimistic where it chose the best of nearly equal designs. The designs of two to four satellites sample 0.5 to 3.2 percentage points fewer with the new replicates: four satellites in two planes 66.4% rather than 69.6%, and in one plane 66.5% rather than 68.2%. The design of three satellites in three planes that refinement left as good as three in one plane samples 35.6% with the new replicates (rather than 38.5%) and is no longer efficient. The single satellites and the designs of six to nine satellites instead sample slightly more points with the new replicates (by up to 0.9 and 0.5 points), as the new samples of points happen to be sampled more easily at both ends of the front: common random numbers share this difference between samples among the designs, and it is not an effect of the selection. The mean optimism over the designs (-0.02 points) mixes the two, so compare the designs one by one. All but four of the confirmed designs remain efficient within the tolerance (three single satellites that refinement left indifferent, about a tolerance below the front, and the three satellites in three planes): the shape of the front is confirmed, but its middle is up to 3 points less good than it looked." + ] + }, + { + "cell_type": "markdown", + "id": "6ecb8b65", + "metadata": {}, + "source": [ + "## Require Reliable Sampling\n", + "\n", + "A mean share of points sufficiently sampled does not say how reliably a design achieves it: the share differs between samples of points. Statistics over the replicates other than the mean state how a design is judged, and requirements on them are output constraints. Here, the objective is the share that a design exceeds in 80% of the samples (its 0.2 quantile, `Quantile`), and a design is required to sample at least half of the points sufficiently in at least 80% of the samples (the probability of meeting a threshold, `Probability`, with a `Requirement`). `Criteria` collect the objectives, the statistics they name, and the requirements: `aggregate` gives the statistics and the violations of the requirements, and `pareto_probability` the probability that each design is efficient among those that meet them." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c1a89037", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-12T17:18:20.616576Z", + "iopub.status.busy": "2026-11-12T17:18:20.616576Z", + "iopub.status.idle": "2026-11-12T17:18:21.776713Z", + "shell.execute_reply": "2026-11-12T17:18:21.776713Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "209 of 1096 designs meet the requirement\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanessufficient p20reliabilityreplicatespareto_probabilityrequirements_probability
962800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.065.01.051.001.0
965800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.068.01.050.941.0
1025800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.81.051.001.0
1026800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.01.050.501.0
\n", + "
" + ], + "text/plain": [ + " description satellites planes \\\n", + "962 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", + "965 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", + "1025 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "1026 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "\n", + " sufficient p20 reliability replicates pareto_probability \\\n", + "962 65.0 1.0 5 1.00 \n", + "965 68.0 1.0 5 0.94 \n", + "1025 97.8 1.0 5 1.00 \n", + "1026 97.0 1.0 5 0.50 \n", + "\n", + " requirements_probability \n", + "962 1.0 \n", + "965 1.0 \n", + "1025 1.0 \n", + "1026 1.0 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import Probability, Quantile, Requirement\n", + "\n", + "RELIABLE = Criteria(\n", + " {\"satellites\": \"min\", \"planes\": \"min\", \"sufficient p20\": \"max\"},\n", + " statistics={\n", + " \"sufficient p20\": Quantile(\"sufficient\", 0.2),\n", + " \"reliability\": Probability(\"sufficient\", \">=\", 50),\n", + " },\n", + " requirements=[Requirement(\"reliability\", \">=\", 0.8)],\n", + ")\n", + "\n", + "reliable = pareto_probability(refinement.results, RELIABLE, n_resamples=1000)\n", + "reliable[\"description\"] = reliable.apply(describe, axis=1)\n", + "print(f\"{reliable.meets_requirements.sum()} of {len(reliable)} designs meet the requirement\")\n", + "reliable[reliable.pareto_probability >= 0.1].sort_values([\"satellites\", \"planes\"])[\n", + " [\"description\", \"satellites\", \"planes\", \"sufficient p20\", \"reliability\", \"replicates\", \"pareto_probability\", \"requirements_probability\"]\n", + "].round(2)" + ] + }, + { + "cell_type": "markdown", + "id": "5bb9e691", + "metadata": {}, + "source": [ + "209 of the 1,096 designs meet the requirement of sampling half of the points sufficiently in at least 80% of the samples, and none of them has fewer than four satellites: the best three satellites sample 38% of the points on average. Among those that meet it, four satellites in one plane (inclined 45 degrees) are efficient for sure, sampling at least 65% of the points in 80% of the samples, and so are six satellites in two planes inclined 75 degrees (at least 98%). Four satellites in two planes sample more (at least 68%) and are efficient in 94% of the resamples, and six satellites in two planes with another relative spacing in 50%: these are the alternatives to weigh with other criteria, such as the cost of launching more planes." + ] + }, + { + "cell_type": "markdown", + "id": "29b30022", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "* The front of the means of the replicates is uncertain: `pareto_probability` finds the designs whose efficiency the replicates settle, and those that are equally good candidates.\n", + "* `refine` adds replicates only to the designs whose efficiency is uncertain, with a tolerance of differences that do not matter (part of the `Criteria`), and stops refining designs whose objectives are known to within a share of the tolerance.\n", + "* `confirm` evaluates the selected designs (by default, the front of the results) with new replicates, which removes the optimism of selecting the best of many nearly equal designs.\n", + "* Statistics other than means (such as a `Quantile` or the `Probability` of meeting a threshold) state how reliably a design performs, and `Requirement`s on them are output constraints.\n", + "* Each of these steps takes the study, the criteria, and the results of the step before (or a search's, see `SearchTradeSpace`), and returns its own results and a summary of its designs." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/SearchTradeSpace.ipynb b/docs/examples/SearchTradeSpace.ipynb index 2141e912..04253884 100644 --- a/docs/examples/SearchTradeSpace.ipynb +++ b/docs/examples/SearchTradeSpace.ipynb @@ -2,19 +2,27 @@ "cells": [ { "cell_type": "markdown", - "id": "a1f0c3d2", + "id": "6a7e7267", "metadata": {}, "source": [ "# Search a Trade Space\n", "\n", - "This example demonstrates how to search a trade space of constellation designs for Pareto-efficient designs with the `tatc.tradespace` module: declaring a hierarchical design space, evaluating designs in replicates (in parallel, with a cache of the analysis of each satellite), ranking them with the uncertainty of their replicates, screening them with a cheaper analysis, and searching the space with optimizers (Optuna and pymoo, installed with `pip install tatc[tradespace]`).\n", + "This example demonstrates how to search a trade space of constellation designs for Pareto-efficient designs with the `tatc.tradespace` module: declaring a hierarchical design space, evaluating designs in replicates (in parallel, with a cache of the analysis of each satellite), finding the Pareto-efficient designs and what drives them, screening designs with a cheaper analysis, and searching the space with optimizers (Optuna and pymoo, installed with `pip install tatc[tradespace]`).\n", "\n", "The trade is a sampling problem of a pre-Phase A study: how many satellites, in how many orbit planes (each of which needs its own launch), sample the Earth sufficiently often? A point is **sufficiently sampled** if an imager observes it at least four times in a day, and the objective is the share of points that are. A second objective measures sufficiency by its purpose: a point is **accurately sampled** if the mean of its samples estimates the daily mean of a field that varies within hours (such as convective precipitation) with an error of at most half the field's standard deviation. The points are a random sample of the Earth (a lattice of points in a random orientation), so the share is a statistical estimate: each replicate of a design draws a different sample of points, which is the uncertainty of the estimate." ] }, { "cell_type": "markdown", - "id": "b2e1d4c3", + "id": "30c41ae9", + "metadata": {}, + "source": [ + "The examples that follow take the same trade further: ranking designs with the uncertainty of their replicates (`RankUncertainDesigns`), comparing them across scenarios (`CompareScenarios`), trading their cost and utility (`TradeCostAndUtility`), and planning their deployment and failures (`PlanMissions`). They import the design space and study of this example from `trade_space_example.py`, beside the notebooks." + ] + }, + { + "cell_type": "markdown", + "id": "98da8775", "metadata": {}, "source": [ "## Configure the Analysis\n", @@ -25,13 +33,13 @@ { "cell_type": "code", "execution_count": 1, - "id": "c3d2e5f4", + "id": "a30fa691", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T23:50:28.225118Z", - "iopub.status.busy": "2026-11-11T23:50:28.225118Z", - "iopub.status.idle": "2026-11-11T23:50:29.544504Z", - "shell.execute_reply": "2026-11-11T23:50:29.543784Z" + "iopub.execute_input": "2026-11-12T17:14:49.655581Z", + "iopub.status.busy": "2026-11-12T17:14:49.655581Z", + "iopub.status.idle": "2026-11-12T17:14:50.577261Z", + "shell.execute_reply": "2026-11-12T17:14:50.576251Z" } }, "outputs": [], @@ -56,7 +64,7 @@ }, { "cell_type": "markdown", - "id": "d4e3f6a5", + "id": "2e6e18b3", "metadata": {}, "source": [ "## Define the Design Space\n", @@ -66,7 +74,7 @@ "* a **Walker delta** constellation (`walker_space`), with an inclination, a number of planes, a number of satellites in each plane, and the relative spacing of the satellites between planes (whose upper bound depends on the number of planes), or\n", "* one or two **sun-synchronous** planes (`sso_planes_space`, a `Repeat` of planes), each with its own equator crossing time and number of satellites. The planes are unordered: two planes in either order are the same design. A constraint of the building block requires the planes to have different crossing times (otherwise, they would be the same plane).\n", "\n", - "The points sampled in each replicate are an `Uncertain` parameter (the seed of a random orientation of a lattice of points, `Uncertain.seed`), drawn for each replicate rather than designed, as are the failures of satellites and the growth of the cost of developing the satellites (both used below). The replicates use common random numbers: every design samples the same points in the same replicate, so that differences between designs are not differences between their samples. The points of a replicate are a Fibonacci lattice in a random orientation (`generate_points_rotated_lattice`): each point is as likely to fall anywhere as a random point, but the points cover the Earth evenly rather than clustering by chance, so that the shares of points vary less between replicates than with random points (`generate_points_random`; here, with 1.5 to 4 times less variance), and fewer replicates estimate them as precisely. The decorrelation time of the field whose daily mean is estimated is a `Fixed` value of the design space, which the metrics read from each design, rather than a constant of the metrics, so that scenarios can change it (see below).\n", + "The points sampled in each replicate are an `Uncertain` parameter (the seed of a random orientation of a lattice of points, `Uncertain.seed`), drawn for each replicate rather than designed, as are the failures of satellites and the growth of the cost of developing the satellites (both used in the examples that follow). The replicates use common random numbers: every design samples the same points in the same replicate, so that differences between designs are not differences between their samples. The points of a replicate are a Fibonacci lattice in a random orientation (`generate_points_rotated_lattice`): each point is as likely to fall anywhere as a random point, but the points cover the Earth evenly rather than clustering by chance, so that the shares of points vary less between replicates than with random points (`generate_points_random`; here, with 1.5 to 4 times less variance), and fewer replicates estimate them as precisely. The decorrelation time of the field whose daily mean is estimated is a `Fixed` value of the design space, which the metrics read from each design, rather than a constant of the metrics, so that scenarios can change it (see `CompareScenarios`).\n", "\n", "The constraint on the number of satellites returns the number in excess of the limit (a number that is not positive if the design satisfies it), rather than `True` or `False`, so that optimizers can tell how far an infeasible design is from a feasible one." ] @@ -74,13 +82,13 @@ { "cell_type": "code", "execution_count": 2, - "id": "e5f4a7b6", + "id": "5c9a0153", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T23:50:29.544504Z", - "iopub.status.busy": "2026-11-11T23:50:29.544504Z", - "iopub.status.idle": "2026-11-11T23:50:30.987111Z", - "shell.execute_reply": "2026-11-11T23:50:30.987111Z" + "iopub.execute_input": "2026-11-12T17:14:50.578955Z", + "iopub.status.busy": "2026-11-12T17:14:50.578955Z", + "iopub.status.idle": "2026-11-12T17:14:52.045125Z", + "shell.execute_reply": "2026-11-12T17:14:52.045125Z" } }, "outputs": [ @@ -116,8 +124,8 @@ " points_seed=Uncertain.seed(),\n", " failure_seed=Uncertain.seed(),\n", " cost_growth=Uncertain(lambda rng: float(rng.triangular(0.9, 1.0, 1.6))), # of development, for cost risk\n", - " decorrelation_time=Fixed(DECORRELATION_TIME), # of the field, which scenarios may change (see below)\n", - " epoch=Fixed(START), # the start of the analysis, which may be drawn for each replicate (see below)\n", + " decorrelation_time=Fixed(DECORRELATION_TIME), # of the field, which scenarios may change (see CompareScenarios)\n", + " epoch=Fixed(START), # the start of the analysis, which may be drawn for each replicate (see PlanMissions)\n", " constraints=[lambda d: count_satellites(d.layout) - MAX_SATELLITES],\n", ")\n", "designs = space.enumerate()\n", @@ -126,28 +134,28 @@ }, { "cell_type": "markdown", - "id": "f6a5b8c7", + "id": "aebe3379", "metadata": {}, "source": [ "## Define the Study\n", "\n", - "An `ObservationStudy` evaluates each design in each replicate: it builds the design's satellites (`build`, with `build_constellation`, which builds the satellites of either layout with a payload: here, an imager, but also entries of the instrument catalog), collects their observations of the replicate's targets (`Observations`), and computes the metrics of the observations (`sample`). The targets are the points of a randomly oriented lattice, generated in each replicate from its seed (`Targets`, from the design's uncertain `points_seed`). The observations of each satellite are cached on disk: designs share many satellites (the same orbit and imager, if not the same name), whose observations are computed once, by the parallel worker processes of the study (`n_jobs=-1`, one per processor), and kept between sessions. A `ResultStore` keeps the records of the evaluations in a file, so that running the notebook again (or resuming it after an interruption) takes them from the file rather than evaluating them again. Both are keyed by the definition of the study (its fingerprint), which describes the points by the recipe that generates them and the code of TAT-C that the study uses: a changed study evaluates its designs again, and says why. The kinds of studies below share the file, each in its own namespace.\n", + "An `ObservationStudy` evaluates each design in each replicate: it builds the design's satellites (`build`, with `build_constellation`, which builds the satellites of either layout with a payload: here, an imager, but also entries of the instrument catalog), collects their observations of the replicate's targets (`Observations`), and computes the metrics of the observations (`sample`). The targets are the points of a randomly oriented lattice, generated in each replicate from its seed (`Targets`, from the design's uncertain `points_seed`). The observations of each satellite are cached on disk: designs share many satellites (the same orbit and imager, if not the same name), whose observations are computed once, by the parallel worker processes of the study (`n_jobs=-1`, one per processor), and kept between sessions. A `ResultStore` keeps the records of the evaluations in a file, so that running the notebook again (or resuming it after an interruption) takes them from the file rather than evaluating them again. Both are keyed by the definition of the study (its fingerprint), which describes the points by the recipe that generates them and the code of TAT-C that the study uses: a changed study evaluates its designs again, and a study whose code changed says why. Variants of the study (of other periods, replicates, or scenarios) share the store, whose fingerprints keep their evaluations apart.\n", "\n", - "The metrics are the two objectives: the share of points with at least four samples a day, and the share whose sampling error (`tatc.analysis.estimate_sampling_error`, for an exponential correlation in time with a decorrelation time of 3 hours) is at most half the field's standard deviation. The study also records the numbers of satellites and of orbit planes (of the design's `layout`), and plans the deployment of each design and estimates its life-cycle cost (`MissionPlan`, of a `DeploymentSchedule` and a `CostModel`, used below).\n", + "The metrics are the two objectives: the share of points with at least four samples a day, and the share whose sampling error (`tatc.analysis.estimate_sampling_error`, for an exponential correlation in time with a decorrelation time of 3 hours) is at most half the field's standard deviation. The study also records the numbers of satellites and of orbit planes (of the design's `layout`), and plans the deployment of each design and estimates its life-cycle cost (`MissionPlan`, of a `DeploymentSchedule` and a `CostModel`, used in `TradeCostAndUtility` and `PlanMissions`).\n", "\n", - "`make_study` makes studies of other durations and numbers of replicates, of the phases of deployment, and with failures, as for screening, deployment, and robustness (below)." + "`study.replace` makes variants of the study with some of its arguments replaced, such as a cheaper study of a shorter period for screening (below), or studies of the phases of deployment and of failures (`PlanMissions`)." ] }, { "cell_type": "code", "execution_count": 3, - "id": "a7b6c9d8", + "id": "dc4e503c", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T23:50:30.987111Z", - "iopub.status.busy": "2026-11-11T23:50:30.987111Z", - "iopub.status.idle": "2026-11-11T23:50:31.003116Z", - "shell.execute_reply": "2026-11-11T23:50:31.003116Z" + "iopub.execute_input": "2026-11-12T17:14:52.045125Z", + "iopub.status.busy": "2026-11-12T17:14:52.045125Z", + "iopub.status.idle": "2026-11-12T17:14:52.060818Z", + "shell.execute_reply": "2026-11-12T17:14:52.060818Z" } }, "outputs": [], @@ -165,7 +173,6 @@ " ObservationStudy,\n", " Observations,\n", " OperationsCost,\n", - " Requirement,\n", " ResultStore,\n", " SatelliteCost,\n", " Targets,\n", @@ -215,37 +222,19 @@ " return build_constellation(d.layout, imager, epoch=START, altitude=d.altitude)\n", "\n", "\n", - "def make_study(\n", - " duration=DURATION,\n", - " replicates=N_REPLICATES,\n", - " failures=None,\n", - " phased=False,\n", - " design_space=None,\n", - " scenarios=None,\n", + "# the study of the shares (%) of points sampled sufficiently and accurately over the period by the satellites of each\n", + "# design, and of its deployment and cost (by the mission plan), whose evaluations are kept in a store\n", + "study = ObservationStudy(\n", + " space,\n", + " build,\n", + " Observations(TARGETS, \"epoch\", DURATION, directory=CACHE_DIRECTORY),\n", + " sample,\n", + " layout=\"layout\",\n", " plan=PLAN,\n", - " label=None,\n", - "):\n", - " \"\"\"A study of the shares (%) of points sampled sufficiently and accurately over a duration by the satellites of\n", - " each design (of the design space, or another), and of its cost (by the mission plan), and (if phased) their means\n", - " over the phases of the mission as the satellites are deployed and the time until half of the points are sampled\n", - " sufficiently, or (with failures) their summaries over histories of the mission in which satellites fail (see\n", - " Failures), in scenarios, if any. Studies of other design spaces or plans are stored apart, by a label.\"\"\"\n", - " kind = (\"failures\" if failures else \"phases\" if phased else \"observations\") + (f\" {label}\" if label else \"\")\n", - " return ObservationStudy(\n", - " design_space or space,\n", - " build,\n", - " Observations(TARGETS, \"epoch\", duration, directory=CACHE_DIRECTORY),\n", - " partial(sample, duration=duration),\n", - " layout=\"layout\",\n", - " plan=plan,\n", - " failures=failures,\n", - " phases=[Requirement(\"sufficient\", \">=\", 50)] if phased else None,\n", - " replicates=replicates,\n", - " scenarios=scenarios,\n", - " n_jobs=-1,\n", - " store=ResultStore(CACHE_DIRECTORY / \"results.sqlite\", namespace=f\"{kind} over {duration}\"),\n", - " )\n", - "\n", + " replicates=N_REPLICATES,\n", + " n_jobs=-1,\n", + " store=ResultStore(CACHE_DIRECTORY / \"results.sqlite\"),\n", + ")\n", "\n", "OBJECTIVES = {\"satellites\": \"min\", \"planes\": \"min\", \"sufficient\": \"max\"}\n", "REFERENCE = {\"satellites\": MAX_SATELLITES + 1, \"planes\": 5, \"sufficient\": 0} # worse than every design, for hypervolumes" @@ -253,24 +242,24 @@ }, { "cell_type": "markdown", - "id": "b8c7d0e9", + "id": "a10276fc", "metadata": {}, "source": [ "## Evaluate Every Design\n", "\n", - "The design space is small enough to evaluate every design, which gives the true Pareto front against which the screening and the searches below are compared. `summarize` gives the mean of each objective over the replicates (and its standard deviation and standard error), and `pareto_front` the designs that no other design is as good as in every objective and better than in one." + "The design space is small enough to evaluate every design, which gives the true Pareto front against which the screening and the searches below are compared. `summarize` gives a summary of the designs: a row per design, with its values (from which `DesignSpace.designs_of` rebuilds it) and the mean of each objective over the replicates (and its standard deviation and standard error), and `pareto_front` the designs that no other design is as good as in every objective and better than in one." ] }, { "cell_type": "code", "execution_count": 4, - "id": "c9d8e1f0", + "id": "7ca0697d", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T23:50:31.003116Z", - "iopub.status.busy": "2026-11-11T23:50:31.003116Z", - "iopub.status.idle": "2026-11-11T23:52:17.656647Z", - "shell.execute_reply": "2026-11-11T23:52:17.656647Z" + "iopub.execute_input": "2026-11-12T17:14:52.060818Z", + "iopub.status.busy": "2026-11-12T17:14:52.060818Z", + "iopub.status.idle": "2026-11-12T17:16:33.009809Z", + "shell.execute_reply": "2026-11-12T17:16:33.008808Z" } }, "outputs": [ @@ -306,7 +295,7 @@ " satellites\n", " planes\n", " sufficient\n", - " sufficient sem\n", + " sufficient se\n", " \n", " \n", " \n", @@ -380,14 +369,14 @@ "965 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", "1025 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", "\n", - " sufficient sufficient sem \n", - "1054 3.2 0.9 \n", - "960 16.6 1.2 \n", - "963 30.2 2.2 \n", - "961 38.0 1.2 \n", - "962 68.2 1.8 \n", - "965 69.6 0.8 \n", - "1025 97.8 0.2 " + " sufficient sufficient se \n", + "1054 3.2 0.9 \n", + "960 16.6 1.2 \n", + "963 30.2 2.2 \n", + "961 38.0 1.2 \n", + "962 68.2 1.8 \n", + "965 69.6 0.8 \n", + "1025 97.8 0.2 " ] }, "execution_count": 4, @@ -398,21 +387,18 @@ "source": [ "from tatc.tradespace import hypervolume, pareto_front, summarize\n", "\n", - "results = make_study().run(designs)\n", + "results = study.run(designs)\n", "print(f\"{len(results)} evaluations: {len(designs)} designs x {N_REPLICATES} replicates\")\n", "\n", - "# the values of each design, and the means of its objectives over the replicates\n", - "values = results.drop_duplicates(\"design\").set_index(\"design\").drop(\n", - " columns=[\"replicate\", \"points_seed\", \"failure_seed\", \"cost_growth\", \"seconds\", \"sufficient\", \"accurate\", \"feasible\"]\n", - ")\n", - "values = values.drop(columns=[column for column in values.columns if column.startswith(\"cost\")])\n", - "summary = summarize(results, list(OBJECTIVES), design_columns=[])\n", + "# a row per design: its values and the means of its objectives over the replicates (with their standard deviations and\n", + "# standard errors), and whether it is efficient\n", + "summary = summarize(results, list(OBJECTIVES))\n", "summary[\"pareto\"] = pareto_front(summary, OBJECTIVES)\n", "exact_hypervolume = hypervolume(summary, OBJECTIVES, REFERENCE)\n", "\n", "\n", "def describe(d):\n", - " \"\"\"A short description of a design.\"\"\"\n", + " \"\"\"A short description of a design (a row of its values).\"\"\"\n", " if d.layout == \"walker\":\n", " layout = (\n", " f\"Walker {d['layout.walker.inclination']:.0f} deg: {d['layout.walker.planes']:.0f} x \"\n", @@ -427,21 +413,21 @@ " return f\"{d.altitude / 1e3:.0f} km, {d.field_of_regard} deg FOR, {layout}\"\n", "\n", "\n", - "summary[\"description\"] = [describe(values.loc[key]) for key in summary.design]\n", + "summary[\"description\"] = summary.apply(describe, axis=1)\n", "front = summary[summary.pareto].sort_values([\"satellites\", \"planes\"])\n", - "front[[\"description\", \"satellites\", \"planes\", \"sufficient\", \"sufficient sem\"]].round(1)" + "front[[\"description\", \"satellites\", \"planes\", \"sufficient\", \"sufficient se\"]].round(1)" ] }, { "cell_type": "code", "execution_count": 5, - "id": "d0e9f2a1", + "id": "2b0ec3e0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T23:52:17.658653Z", - "iopub.status.busy": "2026-11-11T23:52:17.658653Z", - "iopub.status.idle": "2026-11-11T23:52:17.892528Z", - "shell.execute_reply": "2026-11-11T23:52:17.892528Z" + "iopub.execute_input": "2026-11-12T17:16:33.011808Z", + "iopub.status.busy": "2026-11-12T17:16:33.011808Z", + "iopub.status.idle": "2026-11-12T17:16:33.227373Z", + "shell.execute_reply": "2026-11-12T17:16:33.226409Z" } }, "outputs": [ @@ -489,7 +475,7 @@ }, { "cell_type": "markdown", - "id": "e1f0a3b2", + "id": "a42a293e", "metadata": {}, "source": [ "Of the 1,096 feasible designs, seven are Pareto-efficient (ringed in the figure). All of them fly at the highest altitude (800 km) with the wider field of regard (60 degrees), which observe the most points per satellite, so the trade is in the number of satellites and planes. One satellite samples only 3% of the points sufficiently (at least four times a day), and the share rises steeply with the number of satellites: two satellites in two planes (30%) sample nearly twice as many points as two in one plane (17%), four satellites sample about two thirds of the points in one plane or two (68% and 70%), and six satellites in two inclined planes sample 98%. No design with more than six satellites is efficient, because six already sample nearly every point. Designs with the same number of satellites differ widely: their layout (inclination, planes, and phasing) matters as much as their number." @@ -497,7 +483,7 @@ }, { "cell_type": "markdown", - "id": "f1a2b3c4", + "id": "ac77e2d7", "metadata": {}, "source": [ "## Measure the Sampling Error\n", @@ -508,13 +494,13 @@ { "cell_type": "code", "execution_count": 6, - "id": "a2b3c4d5", + "id": "e1752a9a", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T23:52:17.892528Z", - "iopub.status.busy": "2026-11-11T23:52:17.892528Z", - "iopub.status.idle": "2026-11-11T23:52:18.066661Z", - "shell.execute_reply": "2026-11-11T23:52:18.065907Z" + "iopub.execute_input": "2026-11-12T17:16:33.229884Z", + "iopub.status.busy": "2026-11-12T17:16:33.229884Z", + "iopub.status.idle": "2026-11-12T17:16:33.304056Z", + "shell.execute_reply": "2026-11-12T17:16:33.303055Z" } }, "outputs": [ @@ -544,7 +530,7 @@ " planes\n", " sufficient\n", " accurate\n", - " accurate sem\n", + " accurate se\n", " \n", " \n", " \n", @@ -685,20 +671,20 @@ "1036 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", "1037 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", "\n", - " sufficient accurate accurate sem \n", - "1050 3.0 4.2 0.6 \n", - "1047 11.6 10.4 0.9 \n", - "963 30.2 34.2 1.8 \n", - "1019 26.2 17.0 1.1 \n", - "1075 28.8 60.6 1.3 \n", - "1001 34.2 61.0 3.8 \n", - "1020 49.2 28.6 2.1 \n", - "1081 57.6 85.4 0.7 \n", - "758 89.0 96.4 0.5 \n", - "1045 97.8 96.6 0.5 \n", - "1035 97.8 97.8 0.2 \n", - "1036 97.8 97.8 0.2 \n", - "1037 97.8 97.8 0.2 " + " sufficient accurate accurate se \n", + "1050 3.0 4.2 0.6 \n", + "1047 11.6 10.4 0.9 \n", + "963 30.2 34.2 1.8 \n", + "1019 26.2 17.0 1.1 \n", + "1075 28.8 60.6 1.3 \n", + "1001 34.2 61.0 3.8 \n", + "1020 49.2 28.6 2.1 \n", + "1081 57.6 85.4 0.7 \n", + "758 89.0 96.4 0.5 \n", + "1045 97.8 96.6 0.5 \n", + "1035 97.8 97.8 0.2 \n", + "1036 97.8 97.8 0.2 \n", + "1037 97.8 97.8 0.2 " ] }, "execution_count": 6, @@ -708,24 +694,24 @@ ], "source": [ "ACCURACY = {\"satellites\": \"min\", \"planes\": \"min\", \"accurate\": \"max\"}\n", - "accuracy = summarize(results, [\"satellites\", \"planes\", \"sufficient\", \"accurate\"], design_columns=[])\n", - "accuracy[\"description\"] = [describe(values.loc[key]) for key in accuracy.design]\n", + "accuracy = summarize(results, [\"satellites\", \"planes\", \"sufficient\", \"accurate\"])\n", + "accuracy[\"description\"] = accuracy.apply(describe, axis=1)\n", "accuracy[\"pareto\"] = pareto_front(accuracy, ACCURACY)\n", "accuracy[accuracy.pareto].sort_values([\"satellites\", \"planes\"])[\n", - " [\"description\", \"satellites\", \"planes\", \"sufficient\", \"accurate\", \"accurate sem\"]\n", + " [\"description\", \"satellites\", \"planes\", \"sufficient\", \"accurate\", \"accurate se\"]\n", "].round(1)" ] }, { "cell_type": "code", "execution_count": 7, - "id": "b3c4d5e6", + "id": "0936a1c2", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T23:52:18.069173Z", - "iopub.status.busy": "2026-11-11T23:52:18.069173Z", - "iopub.status.idle": "2026-11-11T23:52:18.255867Z", - "shell.execute_reply": "2026-11-11T23:52:18.255867Z" + "iopub.execute_input": "2026-11-12T17:16:33.306056Z", + "iopub.status.busy": "2026-11-12T17:16:33.305055Z", + "iopub.status.idle": "2026-11-12T17:16:33.443733Z", + "shell.execute_reply": "2026-11-12T17:16:33.442741Z" } }, "outputs": [ @@ -757,7 +743,7 @@ }, { "cell_type": "markdown", - "id": "c4d5e6f7", + "id": "a5555a08", "metadata": {}, "source": [ "The revisits of two designs of four satellites, those in one plane that sample the most points sufficiently and those that sample the most points accurately, show why they differ in accuracy: the times between their samples (`tatc.analysis.compute_revisit_statistics`), including the longest gap of the day, and the times of day they sample (`tatc.analysis.compute_local_time_coverage`, in eight 3-hour intervals of local time)." @@ -766,13 +752,13 @@ { "cell_type": "code", "execution_count": 8, - "id": "d5e6f7a8", + "id": "481917fb", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T23:52:18.255867Z", - "iopub.status.busy": "2026-11-11T23:52:18.255867Z", - "iopub.status.idle": "2026-11-11T23:52:18.556287Z", - "shell.execute_reply": "2026-11-11T23:52:18.556287Z" + "iopub.execute_input": "2026-11-12T17:16:33.444732Z", + "iopub.status.busy": "2026-11-12T17:16:33.444732Z", + "iopub.status.idle": "2026-11-12T17:16:33.760244Z", + "shell.execute_reply": "2026-11-12T17:16:33.760244Z" } }, "outputs": [ @@ -872,13 +858,12 @@ "# the most sufficiently sampling design of four satellites in one plane, and the most accurately sampling design of four\n", "first = four[four.planes == 1].iloc[0]\n", "second = four.sort_values(\"accurate\", ascending=False).iloc[0]\n", - "by_key = {d.key: d for d in designs}\n", - "study = make_study()\n", "rows = []\n", - "for row in (first, second):\n", + "# the designs of the rows, rebuilt from their values\n", + "for row, design in zip((first, second), space.designs_of(four, [first.design, second.design])):\n", " # the observations of the design's first replicate, and its points\n", - " observations = study.observations_of(by_key[row.design])\n", - " points = study.targets_of(by_key[row.design])\n", + " observations = study.observations_of(design)\n", + " points = study.targets_of(design)\n", " revisits = compute_revisit_statistics(observations, START, START + DURATION, targets=points)\n", " local = compute_local_time_coverage(observations, targets=points)\n", " observed = revisits[revisits.samples > 0]\n", @@ -897,7 +882,7 @@ }, { "cell_type": "markdown", - "id": "e6f7a8b9", + "id": "3d77aa41", "metadata": {}, "source": [ "Counting samples and measuring their sampling error rank designs differently. Satellites in one plane (blue in the figure) sample many points four times a day, but in bursts: consecutive passes of satellites that follow each other in a plane, minutes apart, repeat each other for a field that decorrelates in hours. Four satellites in one Walker plane sample 68% of the points at least four times a day, but only 27% accurately: half of their revisits are 0.4 hours apart, and they leave a gap of 13.8 hours. Four satellites in two sun-synchronous planes sample fewer points four times (58%) but 85% accurately: their samples are 5.9 hours apart, in four of the eight 3-hour intervals of the day. Designs in a single plane remain efficient only as those that need the fewest launches, and sample at most 29% of the points accurately; six satellites in three planes sample 96% of the points accurately, nearly as many as nine (98%)." @@ -905,7 +890,7 @@ }, { "cell_type": "markdown", - "id": "f7a8b9c0", + "id": "31c15e60", "metadata": {}, "source": [ "## Find What Drives the Objectives\n", @@ -916,13 +901,13 @@ { "cell_type": "code", "execution_count": 9, - "id": "a8b9c0d1", + "id": "5206fdbc", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T23:52:18.556287Z", - "iopub.status.busy": "2026-11-11T23:52:18.556287Z", - "iopub.status.idle": "2026-11-11T23:52:18.588823Z", - "shell.execute_reply": "2026-11-11T23:52:18.588160Z" + "iopub.execute_input": "2026-11-12T17:16:33.762237Z", + "iopub.status.busy": "2026-11-12T17:16:33.762237Z", + "iopub.status.idle": "2026-11-12T17:16:33.792018Z", + "shell.execute_reply": "2026-11-12T17:16:33.791025Z" } }, "outputs": [ @@ -1032,7 +1017,7 @@ "source": [ "from tatc.tradespace import sensitivity\n", "\n", - "frame = accuracy.join(values.drop(columns=[\"satellites\", \"planes\"]), on=\"design\")\n", + "# the summary keeps the values of each design\n", "variables = [\n", " \"altitude\",\n", " \"field_of_regard\",\n", @@ -1043,12 +1028,12 @@ " \"layout.walker.relative_spacing\",\n", " \"layout.sso.planes.count\",\n", "]\n", - "sensitivity(frame, variables, [\"sufficient\", \"accurate\"]).round(2)" + "sensitivity(accuracy, variables, [\"sufficient\", \"accurate\"]).round(2)" ] }, { "cell_type": "markdown", - "id": "b9c0d1e2", + "id": "879ef8cd", "metadata": {}, "source": [ "The field of regard explains the most of both objectives (25% of their variance), as it sets the swath of every satellite. The layout matters next, but differently for the two objectives: the number of satellites in each Walker plane explains more of the share of points sufficiently sampled (22%) than of those accurately sampled (18%), and the number of Walker planes the reverse (12% and 29%), as more planes spread the samples in time. The altitude explains little of either objective (3%), although a higher orbit widens the swath: its effect is small next to those of the field of regard and the layout. The inclination explains nothing on average over the Walker designs." @@ -1056,24 +1041,26 @@ }, { "cell_type": "markdown", - "id": "f2a1b4c3", + "id": "8318fcb6", "metadata": {}, "source": [ - "## Rank Designs with the Uncertainty of Replicates\n", + "## Screen Designs with a Cheaper Analysis\n", + "\n", + "Evaluating every design is affordable here, but not for larger spaces or longer analyses. `screen` evaluates every design with a cheap study, keeps the best (whole fronts, until it keeps at least `keep` of them), and evaluates only those with the full study. A cheap study ranks designs less exactly, so criteria of the cheap study with a tolerance of an objective (`Criteria`) keep designs that are within it of the front of the cheap study.\n", "\n", - "The means of five replicates are uncertain, and so is the front of the means: a design just behind another in the means may be ahead of it in other samples of points. `pareto_probability` estimates the probability that each design is efficient by a bootstrap: it resamples the replicates (the same replicates for every design, which keeps the correlation between designs of common random numbers) and counts how often each design is on the front of the resampled means." + "The cheap study must rank designs as the full study would. Here, the screening study analyzes one replicate, rather than five, over a shorter period, with the threshold of sufficient sampling scaled to the period: 12 hours with two observations, or 6 hours with one. The table compares each screening's front with the true front (how many of its efficient designs it keeps, and its hypervolume), and its cost (the satellites analyzed times the days of their analyses) with that of evaluating every design." ] }, { "cell_type": "code", "execution_count": 10, - "id": "a3b2c5d4", + "id": "b50f4cb2", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T23:52:18.588823Z", - "iopub.status.busy": "2026-11-11T23:52:18.588823Z", - "iopub.status.idle": "2026-11-11T23:52:20.032880Z", - "shell.execute_reply": "2026-11-11T23:52:20.032880Z" + "iopub.execute_input": "2026-11-12T17:16:33.795026Z", + "iopub.status.busy": "2026-11-12T17:16:33.794025Z", + "iopub.status.idle": "2026-11-12T17:17:08.843811Z", + "shell.execute_reply": "2026-11-12T17:17:08.843811Z" } }, "outputs": [ @@ -1098,188 +1085,78 @@ " \n", " \n", " \n", - " description\n", - " satellites\n", - " planes\n", - " sufficient\n", - " pareto\n", - " pareto_probability\n", + " screening study\n", + " keep (%)\n", + " tolerance (%)\n", + " designs kept\n", + " efficient designs kept\n", + " hypervolume (% of true front)\n", + " cost (% of every design)\n", " \n", " \n", " \n", " \n", - " 1017\n", - " 800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac...\n", - " 1.0\n", - " 1.0\n", - " 2.8\n", - " False\n", - " 0.38\n", - " \n", - " \n", - " 776\n", - " 700 km, 60 deg FOR, SSO: 1 at 12:00\n", - " 1.0\n", - " 1.0\n", - " 3.0\n", - " False\n", - " 0.20\n", - " \n", - " \n", - " 1048\n", - " 800 km, 60 deg FOR, SSO: 1 at 09:00\n", - " 1.0\n", - " 1.0\n", - " 3.0\n", - " False\n", - " 0.12\n", - " \n", - " \n", - " 1050\n", - " 800 km, 60 deg FOR, SSO: 1 at 12:00\n", - " 1.0\n", - " 1.0\n", - " 3.0\n", - " False\n", - " 0.10\n", - " \n", - " \n", - " 1052\n", - " 800 km, 60 deg FOR, SSO: 1 at 15:00\n", - " 1.0\n", - " 1.0\n", - " 3.0\n", - " False\n", - " 0.12\n", - " \n", - " \n", - " 1054\n", - " 800 km, 60 deg FOR, SSO: 1 at 18:00\n", - " 1.0\n", - " 1.0\n", - " 3.2\n", - " True\n", - " 0.54\n", - " \n", - " \n", - " 960\n", - " 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...\n", - " 2.0\n", - " 1.0\n", - " 16.6\n", - " True\n", - " 0.98\n", - " \n", - " \n", - " 963\n", - " 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...\n", - " 2.0\n", - " 2.0\n", - " 30.2\n", - " True\n", - " 1.00\n", - " \n", - " \n", - " 961\n", - " 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...\n", - " 3.0\n", - " 1.0\n", - " 38.0\n", - " True\n", - " 1.00\n", - " \n", - " \n", - " 972\n", - " 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...\n", - " 3.0\n", - " 3.0\n", - " 37.6\n", - " False\n", - " 0.32\n", - " \n", - " \n", - " 971\n", - " 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...\n", - " 3.0\n", - " 3.0\n", - " 37.8\n", - " False\n", - " 0.29\n", - " \n", - " \n", - " 962\n", - " 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...\n", - " 4.0\n", - " 1.0\n", - " 68.2\n", - " True\n", - " 1.00\n", + " 0\n", + " 12 h, 1 replicate\n", + " 5.0\n", + " NaN\n", + " 74\n", + " 4 of 7\n", + " 98.8\n", + " 16.9\n", " \n", " \n", - " 965\n", - " 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...\n", - " 4.0\n", - " 2.0\n", - " 69.6\n", - " True\n", - " 0.92\n", + " 1\n", + " 12 h, 1 replicate\n", + " 10.0\n", + " 5.0\n", + " 248\n", + " 7 of 7\n", + " 100.0\n", + " 29.2\n", " \n", " \n", - " 1026\n", - " 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...\n", - " 6.0\n", - " 2.0\n", - " 97.6\n", - " False\n", - " 0.32\n", + " 2\n", + " 6 h, 1 replicate\n", + " 5.0\n", + " NaN\n", + " 62\n", + " 1 of 7\n", + " 83.0\n", + " 10.6\n", " \n", " \n", - " 1025\n", - " 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...\n", - " 6.0\n", - " 2.0\n", - " 97.8\n", - " True\n", - " 1.00\n", + " 3\n", + " 6 h, 1 replicate\n", + " 20.0\n", + " NaN\n", + " 231\n", + " 5 of 7\n", + " 96.6\n", + " 25.1\n", " \n", " \n", "\n", "" ], "text/plain": [ - " description satellites planes \\\n", - "1017 800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac... 1.0 1.0 \n", - "776 700 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", - "1048 800 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", - "1050 800 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", - "1052 800 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", - "1054 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", - "960 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 1.0 \n", - "963 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", - "961 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 1.0 \n", - "972 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", - "971 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", - "962 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", - "965 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", - "1026 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", - "1025 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + " screening study keep (%) tolerance (%) designs kept \\\n", + "0 12 h, 1 replicate 5.0 NaN 74 \n", + "1 12 h, 1 replicate 10.0 5.0 248 \n", + "2 6 h, 1 replicate 5.0 NaN 62 \n", + "3 6 h, 1 replicate 20.0 NaN 231 \n", "\n", - " sufficient pareto pareto_probability \n", - "1017 2.8 False 0.38 \n", - "776 3.0 False 0.20 \n", - "1048 3.0 False 0.12 \n", - "1050 3.0 False 0.10 \n", - "1052 3.0 False 0.12 \n", - "1054 3.2 True 0.54 \n", - "960 16.6 True 0.98 \n", - "963 30.2 True 1.00 \n", - "961 38.0 True 1.00 \n", - "972 37.6 False 0.32 \n", - "971 37.8 False 0.29 \n", - "962 68.2 True 1.00 \n", - "965 69.6 True 0.92 \n", - "1026 97.6 False 0.32 \n", - "1025 97.8 True 1.00 " + " efficient designs kept hypervolume (% of true front) \\\n", + "0 4 of 7 98.8 \n", + "1 7 of 7 100.0 \n", + "2 1 of 7 83.0 \n", + "3 5 of 7 96.6 \n", + "\n", + " cost (% of every design) \n", + "0 16.9 \n", + "1 29.2 \n", + "2 10.6 \n", + "3 25.1 " ] }, "execution_count": 10, @@ -1288,54 +1165,76 @@ } ], "source": [ - "from tatc.tradespace import pareto_probability\n", + "from tatc.tradespace import Criteria, screen\n", + "\n", "\n", - "probability = pareto_probability(results, OBJECTIVES, n_resamples=1000)\n", - "probability[\"description\"] = [describe(values.loc[key]) for key in probability.design]\n", - "candidates = probability[probability.pareto_probability >= 0.1].sort_values([\"satellites\", \"planes\", \"sufficient\"])\n", - "candidates[[\"description\", \"satellites\", \"planes\", \"sufficient\", \"pareto\", \"pareto_probability\"]].round(2)" + "def over(duration):\n", + " \"\"\"The study of one replicate over a shorter period, as a cheap analysis.\"\"\"\n", + " return study.replace(\n", + " observations=Observations(TARGETS, \"epoch\", duration, directory=CACHE_DIRECTORY),\n", + " metrics=partial(sample, duration=duration),\n", + " replicates=1,\n", + " )\n", + "\n", + "\n", + "full_cost = results.satellites.sum() * DURATION / timedelta(days=1) # satellite-days of analysis\n", + "true_front = set(summary.design[summary.pareto])\n", + "screenings = []\n", + "for hours, keep, tolerance in [(12, 0.05, None), (12, 0.1, 5.0), (6, 0.05, None), (6, 0.2, None)]:\n", + " # the criteria of the cheap study, with a tolerance of its share, if any, and of the full study\n", + " cheap = OBJECTIVES if tolerance is None else Criteria(OBJECTIVES, tolerance={\"sufficient\": tolerance})\n", + " screening = screen([over(timedelta(hours=hours)), study], [cheap, OBJECTIVES], designs, keep=keep)\n", + " # the satellite-days of the analyses of each stage\n", + " days = screening.results.stage.map({0: hours / 24, 1: DURATION / timedelta(days=1)})\n", + " screenings.append(\n", + " {\n", + " \"screening study\": f\"{hours} h, 1 replicate\",\n", + " \"keep (%)\": 100 * keep,\n", + " \"tolerance (%)\": tolerance,\n", + " \"designs kept\": len(screening.designs),\n", + " \"efficient designs kept\": f\"{len(true_front & {d.key for d in screening.designs})} of {len(true_front)}\",\n", + " \"hypervolume (% of true front)\": 100 * hypervolume(screening.summary, OBJECTIVES, REFERENCE) / exact_hypervolume,\n", + " \"cost (% of every design)\": 100 * (screening.results.satellites * days).sum() / full_cost,\n", + " }\n", + " )\n", + "pd.DataFrame(screenings).round(1)" ] }, { "cell_type": "markdown", - "id": "b4c3d6e5", + "id": "4ef50735", "metadata": {}, "source": [ - "Four of the seven efficient designs are efficient in every resample: two satellites in two planes, three or four satellites in one plane, and six in two planes; two satellites in one plane (efficient in 98% of the resamples) and four in two planes (92%) nearly so. The single satellite is not settled by five replicates: one in a sun-synchronous orbit crossing the equator at 18:00 (efficient in 54% of the resamples) samples about as many points as one in a Walker orbit inclined 75 degrees (38%) or crossing at other times (10 to 20%). Likewise, three satellites in three planes (29% and 32%) sample about as many points as three in one plane, and six satellites in two planes with another relative spacing (32%) as many as the efficient design. Designs that are efficient with a probability between 0 and 1 are equally good candidates, given the uncertainty of the estimates: more replicates (samples of points) would separate them, or a tolerance of the share (see `pareto_front`) would treat them as ties." + "The 12-hour screening study ranks designs nearly as the full study does. Keeping the best 5% of the designs finds a front with 99% of the hypervolume of the true front at 17% of the cost of evaluating every design, although it misses three of the seven efficient designs, whose places designs with nearly the same objectives take. Keeping 10%, with a tolerance of 5 percentage points, keeps every efficient design at 29% of the cost.\n", + "\n", + "The 6-hour screening study is cheaper, but ranks designs differently: one observation of a point in 6 hours separates designs less than four observations in a day do. Keeping 5% of the designs keeps only one of the seven efficient ones (83% of the hypervolume), and keeping 20% still misses two of them (97% of the hypervolume) at 25% of the cost, nearly as much as the 12-hour study that keeps them all. How many designs to keep depends on how well the cheap study ranks designs, which is worth checking on a sample of designs evaluated with both studies before screening a larger space." ] }, { "cell_type": "markdown", - "id": "a4c2e6f8", + "id": "3d127bbc", "metadata": {}, "source": [ - "## Refine Uncertain Designs\n", + "## Search with Optimizers\n", "\n", - "Five replicates settle the efficiency of most designs, but not of all. More replicates of every design would settle them, at the cost of evaluating every design again for each. `refine` instead adds replicates only to the designs whose efficiency is uncertain (efficient in more than 5% and fewer than 95% of the resamples), five at a time, and estimates their probabilities again, until none is uncertain (or a design has 40 replicates). The added replicates are the next ones after each design's own, which keeps common random numbers between the designs refined together.\n", + "Larger design spaces cannot be enumerated or even screened, and an optimizer searches them for efficient designs instead. `optimize_optuna` suggests designs with Optuna's trials, which search the hierarchical design space directly (`DesignSpace.suggest`), and records the violation of the constraint of each infeasible design, which Optuna's samplers use to prefer feasible designs. `optimize_pymoo` searches the unit hypercube that encodes the design space (`DesignSpace.decode`) with a pymoo algorithm, which eliminates the proposals of designs proposed or evaluated before: many points of the hypercube decode to the same design (those in the same level of each variable, or that differ only in the variables of a branch not chosen), which pymoo's own elimination of equal points does not see. Both evaluate each design once, however often it is proposed, and evaluate the designs proposed together in parallel. A search chooses its front from one evaluation of each design, which favors designs whose replicates were lucky: its results (a `Search`) are refined and confirmed as for any study (see `RankUncertainDesigns`).\n", "\n", - "Some designs differ by less than any number of replicates could separate, such as those that sample nearly every point: a difference of a tenth of a percentage point does not matter to the trade. A tolerance of 1 percentage point of the share, part of the criteria by which designs are judged (`Criteria`), treats designs within it of the front as efficient (see `pareto_front`), so that refinement does not spend replicates on differences that do not matter. A design about one tolerance below the front stays uncertain instead: more replicates settle which side of the tolerance it falls on only slowly, though it does not matter. `refine` stops refining such a design once the standard error of its share is less than half the tolerance (`precision`): it is then `indifferent`. A `budget` would limit the evaluations, refining the least settled designs first." + "Each search below is given a budget of about 200 proposals, and is compared with a Latin hypercube sample of 200 designs (`DesignSpace.sample`). The designs evaluated (and the analyses of their satellites) are those of the evaluation of every design above, so they are retrieved from the cache." ] }, { "cell_type": "code", "execution_count": 11, - "id": "b5d3f7a9", + "id": "1bcffde7", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T23:52:20.034888Z", - "iopub.status.busy": "2026-11-11T23:52:20.034888Z", - "iopub.status.idle": "2026-11-11T23:52:49.196732Z", - "shell.execute_reply": "2026-11-11T23:52:49.196732Z" + "iopub.execute_input": "2026-11-12T17:17:08.843811Z", + "iopub.status.busy": "2026-11-12T17:17:08.843811Z", + "iopub.status.idle": "2026-11-12T17:17:10.740726Z", + "shell.execute_reply": "2026-11-12T17:17:10.740726Z" } }, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "215 evaluations added, 0.6% of those of 40 replicates of every design\n" - ] - }, { "data": { "text/html": [ @@ -1357,92 +1256,35 @@ " \n", " \n", " \n", - " round\n", - " uncertain\n", - " indifferent\n", - " refined\n", - " evaluations\n", + " designs evaluated\n", + " hypervolume (% of true front)\n", " \n", " \n", " \n", " \n", - " 0\n", - " 0\n", - " 31\n", - " 2\n", - " 29\n", - " 145\n", - " \n", - " \n", - " 1\n", - " 1\n", - " 16\n", - " 11\n", - " 5\n", - " 25\n", - " \n", - " \n", - " 2\n", - " 2\n", - " 14\n", - " 11\n", - " 3\n", - " 15\n", - " \n", - " \n", - " 3\n", - " 3\n", - " 14\n", - " 12\n", - " 2\n", - " 10\n", - " \n", - " \n", - " 4\n", - " 4\n", - " 14\n", - " 13\n", - " 1\n", - " 5\n", - " \n", - " \n", - " 5\n", - " 5\n", - " 14\n", - " 13\n", - " 1\n", - " 5\n", + " Optuna (NSGA-II)\n", + " 143.0\n", + " 92.1\n", " \n", " \n", - " 6\n", - " 6\n", - " 14\n", - " 12\n", - " 2\n", - " 10\n", + " pymoo (NSGA-II)\n", + " 166.0\n", + " 100.0\n", " \n", " \n", - " 7\n", - " 7\n", - " 13\n", - " 12\n", - " 0\n", - " 0\n", + " Latin hypercube sample\n", + " 176.0\n", + " 79.3\n", " \n", " \n", "\n", "" ], "text/plain": [ - " round uncertain indifferent refined evaluations\n", - "0 0 31 2 29 145\n", - "1 1 16 11 5 25\n", - "2 2 14 11 3 15\n", - "3 3 14 12 2 10\n", - "4 4 14 13 1 5\n", - "5 5 14 13 1 5\n", - "6 6 14 12 2 10\n", - "7 7 13 12 0 0" + " designs evaluated hypervolume (% of true front)\n", + "Optuna (NSGA-II) 143.0 92.1\n", + "pymoo (NSGA-II) 166.0 100.0\n", + "Latin hypercube sample 176.0 79.3" ] }, "execution_count": 11, @@ -1451,4621 +1293,13 @@ } ], "source": [ - "from tatc.tradespace import Criteria, refine\n", - "\n", - "TOLERANCE = {\"sufficient\": 1.0} # percentage points of the share that do not matter\n", - "CRITERIA = Criteria(OBJECTIVES, tolerance=TOLERANCE)\n", - "refinement = refine(\n", - " make_study(), designs, results, CRITERIA, step=5, max_replicates=40, precision=0.5, n_resamples=1000\n", - ")\n", - "added = len(refinement.results) - len(results)\n", - "print(f\"{added} evaluations added, {added / (len(designs) * 35):.1%} of those of 40 replicates of every design\")\n", - "refinement.history" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "c6e4a8b0", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-11T23:52:49.196732Z", - "iopub.status.busy": "2026-11-11T23:52:49.196732Z", - "iopub.status.idle": "2026-11-11T23:52:49.261059Z", - "shell.execute_reply": "2026-11-11T23:52:49.260196Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
descriptionsatellitesplanessufficientreplicatesparetopareto_probabilityindifferent
500600 km, 60 deg FOR, SSO: 1 at 09:001.01.01.8010False0.12True
230500 km, 60 deg FOR, SSO: 1 at 15:001.01.01.9010False0.14True
498600 km, 60 deg FOR, SSO: 1 at 06:001.01.01.9010False0.19True
504600 km, 60 deg FOR, SSO: 1 at 15:001.01.02.1010False0.18True
502600 km, 60 deg FOR, SSO: 1 at 12:001.01.02.2010True0.40True
506600 km, 60 deg FOR, SSO: 1 at 18:001.01.02.2010True0.32True
1017800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac...1.01.02.4010True0.57True
774700 km, 60 deg FOR, SSO: 1 at 09:001.01.02.5010True0.76True
780700 km, 60 deg FOR, SSO: 1 at 18:001.01.02.5010True0.79True
778700 km, 60 deg FOR, SSO: 1 at 15:001.01.02.5315True0.70True
776700 km, 60 deg FOR, SSO: 1 at 12:001.01.02.8010True0.95False
772700 km, 60 deg FOR, SSO: 1 at 06:001.01.02.9010True0.98False
1052800 km, 60 deg FOR, SSO: 1 at 15:001.01.02.9010True0.98False
1046800 km, 60 deg FOR, SSO: 1 at 06:001.01.03.1010True0.98False
1054800 km, 60 deg FOR, SSO: 1 at 18:001.01.03.1010True0.99False
1048800 km, 60 deg FOR, SSO: 1 at 09:001.01.03.2010True0.99False
1050800 km, 60 deg FOR, SSO: 1 at 12:001.01.03.2010True0.99False
960800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...2.01.016.605True1.00False
963800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.030.205True1.00False
961800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...3.01.038.005True1.00False
972800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...3.03.037.0240False0.19False
971800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...3.03.038.4825True0.89True
962800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.068.205True1.00False
965800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.069.605True0.96False
1026800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.605True1.00False
1025800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.805True1.00False
479600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.405True0.97False
480600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.405True0.97False
753700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.605True1.00False
754700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.605True1.00False
1027800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.805True1.00False
1028800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.805True1.00False
768700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.605True1.00False
769700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.605True1.00False
770700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.605True1.00False
1043800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.805True1.00False
1044800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.805True1.00False
1045800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.805True1.00False
761700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.096.805False0.39True
487600 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.405True0.97False
762700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.605True1.00False
763700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.605True1.00False
1035800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.805True1.00False
1036800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.805True1.00False
1037800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.805True1.00False
\n", - "
" - ], - "text/plain": [ - " description satellites planes \\\n", - "500 600 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", - "230 500 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", - "498 600 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", - "504 600 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", - "502 600 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", - "506 600 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", - "1017 800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac... 1.0 1.0 \n", - "774 700 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", - "780 700 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", - "778 700 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", - "776 700 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", - "772 700 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", - "1052 800 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", - "1046 800 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", - "1054 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", - "1048 800 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", - "1050 800 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", - "960 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 1.0 \n", - "963 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", - "961 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 1.0 \n", - "972 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", - "971 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", - "962 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", - "965 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", - "1026 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", - "1025 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", - "479 600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "480 600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "753 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "754 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "1027 800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "1028 800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "768 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "769 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "770 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "1043 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "1044 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "1045 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "761 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "487 600 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "762 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "763 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "1035 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "1036 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "1037 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "\n", - " sufficient replicates pareto pareto_probability indifferent \n", - "500 1.80 10 False 0.12 True \n", - "230 1.90 10 False 0.14 True \n", - "498 1.90 10 False 0.19 True \n", - "504 2.10 10 False 0.18 True \n", - "502 2.20 10 True 0.40 True \n", - "506 2.20 10 True 0.32 True \n", - "1017 2.40 10 True 0.57 True \n", - "774 2.50 10 True 0.76 True \n", - "780 2.50 10 True 0.79 True \n", - "778 2.53 15 True 0.70 True \n", - "776 2.80 10 True 0.95 False \n", - "772 2.90 10 True 0.98 False \n", - "1052 2.90 10 True 0.98 False \n", - "1046 3.10 10 True 0.98 False \n", - "1054 3.10 10 True 0.99 False \n", - "1048 3.20 10 True 0.99 False \n", - "1050 3.20 10 True 0.99 False \n", - "960 16.60 5 True 1.00 False \n", - "963 30.20 5 True 1.00 False \n", - "961 38.00 5 True 1.00 False \n", - "972 37.02 40 False 0.19 False \n", - "971 38.48 25 True 0.89 True \n", - "962 68.20 5 True 1.00 False \n", - "965 69.60 5 True 0.96 False \n", - "1026 97.60 5 True 1.00 False \n", - "1025 97.80 5 True 1.00 False \n", - "479 97.40 5 True 0.97 False \n", - "480 97.40 5 True 0.97 False \n", - "753 97.60 5 True 1.00 False \n", - "754 97.60 5 True 1.00 False \n", - "1027 97.80 5 True 1.00 False \n", - "1028 97.80 5 True 1.00 False \n", - "768 97.60 5 True 1.00 False \n", - "769 97.60 5 True 1.00 False \n", - "770 97.60 5 True 1.00 False \n", - "1043 97.80 5 True 1.00 False \n", - "1044 97.80 5 True 1.00 False \n", - "1045 97.80 5 True 1.00 False \n", - "761 96.80 5 False 0.39 True \n", - "487 97.40 5 True 0.97 False \n", - "762 97.60 5 True 1.00 False \n", - "763 97.60 5 True 1.00 False \n", - "1035 97.80 5 True 1.00 False \n", - "1036 97.80 5 True 1.00 False \n", - "1037 97.80 5 True 1.00 False " - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "refined = refinement.probability\n", - "refined[\"description\"] = [describe(values.loc[key]) for key in refined.design]\n", - "refined[refined.pareto_probability >= 0.1].sort_values([\"satellites\", \"planes\", \"sufficient\"])[\n", - " [\"description\", \"satellites\", \"planes\", \"sufficient\", \"replicates\", \"pareto\", \"pareto_probability\", \"indifferent\"]\n", - "].round(2)" - ] - }, - { - "cell_type": "markdown", - "id": "d7f5b9c1", - "metadata": {}, - "source": [ - "Refinement adds 215 evaluations, 0.6% of those that 40 replicates of every design would take, to the few designs whose efficiency is uncertain. With the tolerance, the designs that sample nearly every point (six to nine satellites, about 98%) are efficient candidates, with probabilities of 0.97 or more, rather than uncertain: they differ by less than matters. The designs that remain uncertain lie about one tolerance below the front, such as single satellites that sample 1.8 to 2.5% of the points against the best single satellite's 3.2%, or nine satellites that sample 96.8% against 97.8%: whether they are within the tolerance of the front is a question that more replicates settle only slowly, and one that does not change the trade. They are indifferent once their shares are known to within half the tolerance (a standard error of 0.5 percentage points), after 10 or 15 replicates of the single satellites (and the first five of the nine satellites); without a precision (`precision=None`), refinement would refine them to the limit of 40 replicates, for 555 evaluations. The shares of three satellites vary more between replicates: three satellites in three planes that sample 38.5% are indifferent after 25 replicates, and those that sample 37.0% remain uncertain with 40. An absolute tolerance suits a share near saturation better than one near zero; a tolerance proportional to the objective would treat both alike." - ] - }, - { - "cell_type": "markdown", - "id": "e1f2a3b4", - "metadata": {}, - "source": [ - "## Confirm the Front\n", - "\n", - "The efficient designs were selected for their means over their replicates, so they are selected in part for the luck of those replicates: among a thousand designs, those that look best are likely to have drawn favorable samples of points (the winner's curse). `confirm` evaluates the selected designs with new replicates, which played no part in their selection (the same for every design, which keeps common random numbers), and finds the front among them by these replicates. The difference between the means of the replicates that selected the designs and those of the new ones measures the optimism of the selection." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "f2a3b4c5", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-11T23:52:49.261059Z", - "iopub.status.busy": "2026-11-11T23:52:49.261059Z", - "iopub.status.idle": "2026-11-11T23:53:10.820066Z", - "shell.execute_reply": "2026-11-11T23:53:10.819684Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "optimism of the selection: -0.02 percentage points\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
descriptionsatellitesplanessufficient selectedsufficientreplicatespareto
4600 km, 60 deg FOR, SSO: 1 at 18:001.01.02.202.2520False
3600 km, 60 deg FOR, SSO: 1 at 12:001.01.02.202.3520False
23800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac...1.01.02.402.6020False
15700 km, 60 deg FOR, SSO: 1 at 15:001.01.02.532.8520True
16700 km, 60 deg FOR, SSO: 1 at 18:001.01.02.502.8520True
13700 km, 60 deg FOR, SSO: 1 at 09:001.01.02.502.9020True
14700 km, 60 deg FOR, SSO: 1 at 12:001.01.02.802.9520True
12700 km, 60 deg FOR, SSO: 1 at 06:001.01.02.903.4520True
35800 km, 60 deg FOR, SSO: 1 at 09:001.01.03.203.5020True
38800 km, 60 deg FOR, SSO: 1 at 18:001.01.03.103.5020True
37800 km, 60 deg FOR, SSO: 1 at 15:001.01.02.903.7520True
34800 km, 60 deg FOR, SSO: 1 at 06:001.01.03.103.8020True
36800 km, 60 deg FOR, SSO: 1 at 12:001.01.03.203.8520True
17800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...2.01.016.6016.1520True
20800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.030.2028.9520True
18800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...3.01.038.0036.7020True
22800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...3.03.038.4835.6020False
19800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.068.2066.5020True
21800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.069.6066.4020True
25800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.6097.8020True
24800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.8097.9520True
0600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.4097.7520True
1600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.4097.8520True
5700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.6097.9520True
6700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.6097.9520True
26800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.8098.1020True
27800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.8098.1020True
9700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.6097.9520True
10700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.6097.9520True
11700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.6097.9520True
31800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.8098.1020True
32800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.8098.1020True
33800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.8098.1020True
2600 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.4097.8520True
7700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.6097.9520True
8700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.6097.9520True
28800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.8098.1020True
29800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.8098.1020True
30800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.8098.1020True
\n", - "
" - ], - "text/plain": [ - " description satellites planes \\\n", - "4 600 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", - "3 600 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", - "23 800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac... 1.0 1.0 \n", - "15 700 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", - "16 700 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", - "13 700 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", - "14 700 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", - "12 700 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", - "35 800 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", - "38 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", - "37 800 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", - "34 800 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", - "36 800 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", - "17 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 1.0 \n", - "20 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", - "18 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 1.0 \n", - "22 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", - "19 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", - "21 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", - "25 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", - "24 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", - "0 600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "1 600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "5 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "6 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "26 800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "27 800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "9 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "10 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "11 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "31 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "32 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "33 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "2 600 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "7 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "8 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "28 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "29 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "30 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "\n", - " sufficient selected sufficient replicates pareto \n", - "4 2.20 2.25 20 False \n", - "3 2.20 2.35 20 False \n", - "23 2.40 2.60 20 False \n", - "15 2.53 2.85 20 True \n", - "16 2.50 2.85 20 True \n", - "13 2.50 2.90 20 True \n", - "14 2.80 2.95 20 True \n", - "12 2.90 3.45 20 True \n", - "35 3.20 3.50 20 True \n", - "38 3.10 3.50 20 True \n", - "37 2.90 3.75 20 True \n", - "34 3.10 3.80 20 True \n", - "36 3.20 3.85 20 True \n", - "17 16.60 16.15 20 True \n", - "20 30.20 28.95 20 True \n", - "18 38.00 36.70 20 True \n", - "22 38.48 35.60 20 False \n", - "19 68.20 66.50 20 True \n", - "21 69.60 66.40 20 True \n", - "25 97.60 97.80 20 True \n", - "24 97.80 97.95 20 True \n", - "0 97.40 97.75 20 True \n", - "1 97.40 97.85 20 True \n", - "5 97.60 97.95 20 True \n", - "6 97.60 97.95 20 True \n", - "26 97.80 98.10 20 True \n", - "27 97.80 98.10 20 True \n", - "9 97.60 97.95 20 True \n", - "10 97.60 97.95 20 True \n", - "11 97.60 97.95 20 True \n", - "31 97.80 98.10 20 True \n", - "32 97.80 98.10 20 True \n", - "33 97.80 98.10 20 True \n", - "2 97.40 97.85 20 True \n", - "7 97.60 97.95 20 True \n", - "8 97.60 97.95 20 True \n", - "28 97.80 98.10 20 True \n", - "29 97.80 98.10 20 True \n", - "30 97.80 98.10 20 True " - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from tatc.tradespace import confirm\n", - "\n", - "selected = [by_key[key] for key in refined.design[refined.pareto]]\n", - "confirmation = confirm(make_study(), selected, refinement.results, CRITERIA, replicates=20)\n", - "confirmed = confirmation.summary\n", - "confirmed[\"description\"] = [describe(values.loc[key]) for key in confirmed.design]\n", - "print(f\"optimism of the selection: {confirmation.optimism()['sufficient']:.2f} percentage points\")\n", - "confirmed.sort_values([\"satellites\", \"planes\", \"sufficient\"])[\n", - " [\"description\", \"satellites\", \"planes\", \"sufficient selected\", \"sufficient\", \"replicates\", \"pareto\"]\n", - "].round(2)" - ] - }, - { - "cell_type": "markdown", - "id": "a3b4c5d6", - "metadata": {}, - "source": [ - "The selection is optimistic where it chose the best of nearly equal designs. The designs of two to four satellites sample 0.5 to 3.2 percentage points fewer with the new replicates: four satellites in two planes 66.4% rather than 69.6%, and in one plane 66.5% rather than 68.2%. The design of three satellites in three planes that refinement left as good as three in one plane samples 35.6% with the new replicates (rather than 38.5%) and is no longer efficient. The single satellites and the designs of six to nine satellites instead sample slightly more points with the new replicates (by up to 0.9 and 0.5 points), as the new samples of points happen to be sampled more easily at both ends of the front: common random numbers share this difference between samples among the designs, and it is not an effect of the selection. The mean optimism over the designs (-0.02 points) mixes the two, so compare the designs one by one. All but four of the confirmed designs remain efficient within the tolerance (three single satellites that refinement left indifferent, about a tolerance below the front, and the three satellites in three planes): the shape of the front is confirmed, but its middle is up to 3 points less good than it looked." - ] - }, - { - "cell_type": "markdown", - "id": "e8a6c0d2", - "metadata": {}, - "source": [ - "## Require Reliable Sampling\n", - "\n", - "A mean share of points sufficiently sampled does not say how reliably a design achieves it: the share differs between samples of points. Statistics over the replicates other than the mean state how a design is judged, and requirements on them are output constraints. Here, the objective is the share that a design exceeds in 80% of the samples (its 0.2 quantile, `Quantile`), and a design is required to sample at least half of the points sufficiently in at least 80% of the samples (the probability of meeting a threshold, `Probability`, with a `Requirement`). `Criteria` collect the objectives, the statistics they name, and the requirements: `aggregate` gives the statistics and the violations of the requirements, and `pareto_probability` the probability that each design is efficient among those that meet them." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "f9b7d1e3", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-11T23:53:10.820569Z", - "iopub.status.busy": "2026-11-11T23:53:10.820569Z", - "iopub.status.idle": "2026-11-11T23:53:11.897318Z", - "shell.execute_reply": "2026-11-11T23:53:11.897318Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "209 of 1096 designs meet the requirement\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
descriptionsatellitesplanessufficient p20reliabilityreplicatespareto_probabilityrequirements_probability
962800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.065.01.051.001.0
965800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.068.01.050.941.0
1025800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.81.051.001.0
1026800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.01.050.501.0
\n", - "
" - ], - "text/plain": [ - " description satellites planes \\\n", - "962 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", - "965 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", - "1025 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", - "1026 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", - "\n", - " sufficient p20 reliability replicates pareto_probability \\\n", - "962 65.0 1.0 5 1.00 \n", - "965 68.0 1.0 5 0.94 \n", - "1025 97.8 1.0 5 1.00 \n", - "1026 97.0 1.0 5 0.50 \n", - "\n", - " requirements_probability \n", - "962 1.0 \n", - "965 1.0 \n", - "1025 1.0 \n", - "1026 1.0 " - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from tatc.tradespace import Probability, Quantile, Requirement, aggregate\n", - "\n", - "RELIABLE = Criteria(\n", - " {\"satellites\": \"min\", \"planes\": \"min\", \"sufficient p20\": \"max\"},\n", - " statistics={\n", - " \"sufficient p20\": Quantile(\"sufficient\", 0.2),\n", - " \"reliability\": Probability(\"sufficient\", \">=\", 50),\n", - " },\n", - " requirements=[Requirement(\"reliability\", \">=\", 0.8)],\n", - ")\n", - "\n", - "reliable = pareto_probability(refinement.results, RELIABLE, n_resamples=1000)\n", - "reliable[\"description\"] = [describe(values.loc[key]) for key in reliable.design]\n", - "print(f\"{reliable.meets_requirements.sum()} of {len(reliable)} designs meet the requirement\")\n", - "reliable[reliable.pareto_probability >= 0.1].sort_values([\"satellites\", \"planes\"])[\n", - " [\"description\", \"satellites\", \"planes\", \"sufficient p20\", \"reliability\", \"replicates\", \"pareto_probability\", \"requirements_probability\"]\n", - "].round(2)" - ] - }, - { - "cell_type": "markdown", - "id": "a0c8e2f4", - "metadata": {}, - "source": [ - "209 of the 1,096 designs meet the requirement of sampling half of the points sufficiently in at least 80% of the samples, and none of them has fewer than four satellites: the best three satellites sample 38% of the points on average. Among those that meet it, four satellites in one plane (inclined 45 degrees) are efficient for sure, sampling at least 65% of the points in 80% of the samples, and so are six satellites in two planes inclined 75 degrees (at least 98%). Four satellites in two planes sample more (at least 68%) and are efficient in 94% of the resamples, and six satellites in two planes with another relative spacing in 50%: these are the alternatives to weigh with other criteria, such as the cost of launching more planes." - ] - }, - { - "cell_type": "markdown", - "id": "f86b3d37", - "metadata": {}, - "source": [ - "## Compare Designs across Scenarios\n", - "\n", - "How accurately samples estimate a daily mean depends on the field: samples hours apart estimate the mean of a field that varies slowly (one that decorrelates in 12 hours) better than that of one that varies within the hour (such as rain rates). Which field the mission will serve is not uncertain as the sample of points or the failures are, which the replicates average over: it is a condition under which to compare designs, a scenario. The `scenarios` of a study give fixed values or uncertain parameters of the design space other values: here, the field's decorrelation time (`decorrelation_time`). The study evaluates every design in each field, with the same samples of points, and records the field as its `scenario`; the field of 3 hours, as above, takes its evaluations from the store. Criteria `by` the scenario judge designs in each field, and `robustness` judges them across the fields: the share of the fields in which each design is efficient (its Pareto trace) here, and its regret below:" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "37bd44f4", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "16440 evaluations (3 fields) in 133 s\n", - "efficient designs: {'1 hour': 14, '3 hours': 13, '12 hours': 6}\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
descriptionsatellitesplanes1 hour3 hours12 hourspareto trace
design
33b006848799800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.026.234.260.40.67
b85daf65c3a4800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...3.01.08.017.095.60.67
c576e2e2dbd1800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:003.02.040.860.685.80.67
3690f1194419800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:004.02.069.085.493.00.67
cb6bd361b577800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.096.696.697.80.67
5529c21520be800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.897.80.67
de505bc89299800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.897.80.67
679ca275c8fc800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.897.80.67
\n", - "
" - ], - "text/plain": [ - " description satellites \\\n", - "design \n", - "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 \n", - "b85daf65c3a4 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... 3.0 \n", - "c576e2e2dbd1 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3.0 \n", - "3690f1194419 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4.0 \n", - "cb6bd361b577 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 \n", - "5529c21520be 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", - "de505bc89299 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", - "679ca275c8fc 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", - "\n", - " planes 1 hour 3 hours 12 hours pareto trace \n", - "design \n", - "33b006848799 2.0 26.2 34.2 60.4 0.67 \n", - "b85daf65c3a4 1.0 8.0 17.0 95.6 0.67 \n", - "c576e2e2dbd1 2.0 40.8 60.6 85.8 0.67 \n", - "3690f1194419 2.0 69.0 85.4 93.0 0.67 \n", - "cb6bd361b577 4.0 96.6 96.6 97.8 0.67 \n", - "5529c21520be 3.0 97.8 97.8 97.8 0.67 \n", - "de505bc89299 3.0 97.8 97.8 97.8 0.67 \n", - "679ca275c8fc 3.0 97.8 97.8 97.8 0.67 " - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import time\n", - "\n", - "from tatc.tradespace import robustness\n", - "\n", - "# fields that decorrelate within an hour (such as rain rates), in 3 hours (as above), and in 12 hours\n", - "FIELDS = {\n", - " \"1 hour\": {\"decorrelation_time\": timedelta(hours=1)},\n", - " \"3 hours\": {},\n", - " \"12 hours\": {\"decorrelation_time\": timedelta(hours=12)},\n", - "}\n", - "began = time.perf_counter()\n", - "fields = make_study(scenarios=FIELDS).run(designs)\n", - "print(f\"{len(fields)} evaluations ({len(FIELDS)} fields) in {time.perf_counter() - began:.0f} s\")\n", - "\n", - "# the efficient designs of each field (by accuracy), and the share of the fields in which each design is efficient\n", - "BY_FIELD = Criteria(ACCURACY, by=\"scenario\")\n", - "by_field = aggregate(fields, BY_FIELD)\n", - "by_field[\"pareto\"] = pareto_front(by_field, BY_FIELD)\n", - "print(\"efficient designs:\", by_field[by_field.pareto].scenario.value_counts()[list(FIELDS)].to_dict())\n", - "field_accuracy = by_field.pivot(index=\"design\", columns=\"scenario\", values=\"accurate\")[list(FIELDS)]\n", - "traced = accuracy.set_index(\"design\")[[\"description\", \"satellites\", \"planes\"]].join(field_accuracy)\n", - "traced[\"pareto trace\"] = robustness(fields, ACCURACY).set_index(\"design\")[\"pareto trace\"]\n", - "traced[traced[\"pareto trace\"] > 0.5].sort_values([\"satellites\", \"planes\"]).round(2)" - ] - }, - { - "cell_type": "markdown", - "id": "f51c2632", - "metadata": {}, - "source": [ - "The 10,960 evaluations of the other two fields take about two minutes here. Which designs are efficient depends on the field. For the field that decorrelates in 12 hours, one plane samples well: three satellites in one plane (inclined 75 degrees) sample 96% of the points accurately, and four of the six efficient designs have one plane (the other two, four satellites in two planes, sample 98%). For the fields that vary within hours, the samples must spread over the day: the same three satellites in one plane sample 17% (3 hours) and 8% (1 hour) accurately, against 61% and 41% for three satellites in two sun-synchronous planes. No design is efficient for every field: of the eight efficient for two fields, seven are efficient for the fields of 1 and 3 hours, and the other, three satellites in one plane, for those of 3 and 12 hours.\n", - "\n", - "A design need not be efficient in any field to be a good choice when the field is not known: its regret in a field is how far it falls behind the best design there. With the numbers of satellites and planes as objectives, regret would count mostly satellites and planes (a design matches the cheapest efficient design by dropping some), so here regret is in the share accurately sampled alone, among the designs of at most a number of satellites (a `Requirement`): the points below the best design of each field with as many satellites at most. The design whose largest regret over the fields is least (minimax regret) is the robust choice:" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "e87bea8f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
descriptionsatellitesplanesmax regret1 hour regret3 hours regret12 hours regret
at most
2800 km, 60 deg FOR, Walker 75 deg: 2 x 1 (spac...2.02.011.07.66.411.0
3800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:003.02.09.89.80.49.8
4800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:004.02.05.00.00.05.0
6700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...6.03.00.40.40.20.4
\n", - "
" - ], - "text/plain": [ - " description satellites \\\n", - "at most \n", - "2 800 km, 60 deg FOR, Walker 75 deg: 2 x 1 (spac... 2.0 \n", - "3 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3.0 \n", - "4 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4.0 \n", - "6 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... 6.0 \n", - "\n", - " planes max regret 1 hour regret 3 hours regret 12 hours regret \n", - "at most \n", - "2 2.0 11.0 7.6 6.4 11.0 \n", - "3 2.0 9.8 9.8 0.4 9.8 \n", - "4 2.0 5.0 0.0 0.0 5.0 \n", - "6 3.0 0.4 0.4 0.2 0.4 " - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# the designs of least maximum regret (in points accurately sampled, below the best design of each field), among those\n", - "# of at most a number of satellites\n", - "robust, robust_design = [], {}\n", - "for budget in (2, 3, 4, 6):\n", - " within = Criteria({\"accurate\": \"max\"}, requirements=[Requirement(\"satellites\", \"<=\", budget)])\n", - " regret = robustness(fields, within).set_index(\"design\")\n", - " best = robust_design[budget] = regret[\"max regret\"].idxmin()\n", - " described = traced.loc[best, [\"description\", \"satellites\", \"planes\"]]\n", - " robust.append({\"at most\": budget, **described, **regret.loc[best].drop(\"pareto trace\")})\n", - "pd.DataFrame(robust).set_index(\"at most\").round(1)" - ] - }, - { - "cell_type": "markdown", - "id": "dccc2ff4", - "metadata": {}, - "source": [ - "The robust choice depends on the budget. With four satellites, two sun-synchronous planes of two (crossing at 09:00 and 15:00) are the best for the fields of 1 and 3 hours and fall 5 points behind the best for the field of 12 hours (93% against 98%, by four satellites in two other planes): a mission that does not yet know its field loses little by choosing them. With three satellites, two sun-synchronous planes of two and one fall 10 points behind three satellites in one plane for the field of 12 hours (86% against 96%) and three in three planes for the field of 1 hour (41% against 51%), and less than a point behind the best for 3 hours. Two satellites fall at least 11 points behind somewhere. Six satellites in three Walker planes (at 700 km) fall at most 0.4 points behind the best of any field, though they are efficient in none: a robust choice need not be the best in any scenario. Regrets of a point or two are within the sampling error of the means of five replicates (standard errors of one to four points, as above), so the robust designs of four and six satellites are as good as the best of each field." - ] - }, - { - "cell_type": "markdown", - "id": "4a9c2e17", - "metadata": {}, - "source": [ - "Criteria `across` the fields (`Across`) judge each design once, by its worst or its mean share over the fields, rather than in each field, which is what a search for designs robust to the field needs (see Search with Optimizers below). Here every design is evaluated in every field, so the fronts of both are exact:" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "c06b8d53", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "the field in which each design is least accurate: {'1 hour': 1028, '3 hours': 68}\n", - "efficient by the worst: 15, of which 12 in 1 hour\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
descriptionsatellitesplanes1 hour3 hours12 hoursworstmean
design
9b3481aea973800 km, 60 deg FOR, SSO: 1 at 12:001.01.03.04.227.0TrueFalse
12765c7a29fc800 km, 60 deg FOR, SSO: 1 at 15:001.01.03.03.628.0TrueTrue
24a159fbc4b7800 km, 60 deg FOR, SSO: 2 at 12:002.01.05.69.470.0TrueFalse
c9cacc08010d800 km, 60 deg FOR, SSO: 2 at 15:002.01.04.810.073.0FalseTrue
33b006848799800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.026.234.260.4TrueTrue
d5d3fa915ca7800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...3.01.010.211.467.6TrueFalse
b85daf65c3a4800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...3.01.08.017.095.6FalseTrue
c576e2e2dbd1800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:003.02.040.860.685.8TrueTrue
92ff9cd17e00800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...3.03.050.659.863.6TrueFalse
1af5f2707be3800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.011.226.867.2TrueFalse
104e33a3c842800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac...4.01.09.228.695.0FalseTrue
3690f1194419800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:004.02.069.085.493.0TrueTrue
64cf6542c326800 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...6.03.090.295.897.4TrueFalse
e641bd5c978e700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...6.03.089.896.297.6FalseTrue
6df0f1709edc800 km, 60 deg FOR, Walker 60 deg: 2 x 4 (spac...8.02.070.280.289.2TrueFalse
cb6bd361b577800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.096.696.697.8TrueTrue
5529c21520be800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.897.8TrueTrue
679ca275c8fc800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.897.8TrueTrue
de505bc89299800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.897.8TrueTrue
\n", - "
" - ], - "text/plain": [ - " description satellites \\\n", - "design \n", - "9b3481aea973 800 km, 60 deg FOR, SSO: 1 at 12:00 1.0 \n", - "12765c7a29fc 800 km, 60 deg FOR, SSO: 1 at 15:00 1.0 \n", - "24a159fbc4b7 800 km, 60 deg FOR, SSO: 2 at 12:00 2.0 \n", - "c9cacc08010d 800 km, 60 deg FOR, SSO: 2 at 15:00 2.0 \n", - "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 \n", - "d5d3fa915ca7 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 \n", - "b85daf65c3a4 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... 3.0 \n", - "c576e2e2dbd1 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3.0 \n", - "92ff9cd17e00 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 \n", - "1af5f2707be3 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 \n", - "104e33a3c842 800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac... 4.0 \n", - "3690f1194419 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4.0 \n", - "64cf6542c326 800 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... 6.0 \n", - "e641bd5c978e 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... 6.0 \n", - "6df0f1709edc 800 km, 60 deg FOR, Walker 60 deg: 2 x 4 (spac... 8.0 \n", - "cb6bd361b577 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 \n", - "5529c21520be 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", - "679ca275c8fc 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", - "de505bc89299 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", - "\n", - " planes 1 hour 3 hours 12 hours worst mean \n", - "design \n", - "9b3481aea973 1.0 3.0 4.2 27.0 True False \n", - "12765c7a29fc 1.0 3.0 3.6 28.0 True True \n", - "24a159fbc4b7 1.0 5.6 9.4 70.0 True False \n", - "c9cacc08010d 1.0 4.8 10.0 73.0 False True \n", - "33b006848799 2.0 26.2 34.2 60.4 True True \n", - "d5d3fa915ca7 1.0 10.2 11.4 67.6 True False \n", - "b85daf65c3a4 1.0 8.0 17.0 95.6 False True \n", - "c576e2e2dbd1 2.0 40.8 60.6 85.8 True True \n", - "92ff9cd17e00 3.0 50.6 59.8 63.6 True False \n", - "1af5f2707be3 1.0 11.2 26.8 67.2 True False \n", - "104e33a3c842 1.0 9.2 28.6 95.0 False True \n", - "3690f1194419 2.0 69.0 85.4 93.0 True True \n", - "64cf6542c326 3.0 90.2 95.8 97.4 True False \n", - "e641bd5c978e 3.0 89.8 96.2 97.6 False True \n", - "6df0f1709edc 2.0 70.2 80.2 89.2 True False \n", - "cb6bd361b577 4.0 96.6 96.6 97.8 True True \n", - "5529c21520be 3.0 97.8 97.8 97.8 True True \n", - "679ca275c8fc 3.0 97.8 97.8 97.8 True True \n", - "de505bc89299 3.0 97.8 97.8 97.8 True True " - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from tatc.tradespace import Across\n", - "\n", - "# the efficient designs by their worst and by their mean share accurately sampled over the fields (with equal\n", - "# weights), and those of the field that decorrelates within an hour\n", - "fronts = {}\n", - "for rule in (\"worst\", \"mean\"):\n", - " criteria = Criteria(ACCURACY, across=Across(rule=rule))\n", - " combined = aggregate(fields, criteria)\n", - " fronts[rule] = set(combined.design[pareto_front(combined, criteria)])\n", - "fronts[\"1 hour\"] = set(by_field.design[by_field.pareto & (by_field.scenario == \"1 hour\")])\n", - "print(\"the field in which each design is least accurate:\", field_accuracy.idxmin(axis=1).value_counts().to_dict())\n", - "print(f\"efficient by the worst: {len(fronts['worst'])}, of which {len(fronts['worst'] & fronts['1 hour'])} in 1 hour\")\n", - "compared = traced.loc[sorted(fronts[\"worst\"] | fronts[\"mean\"]), [\"description\", \"satellites\", \"planes\", *FIELDS]]\n", - "compared[\"worst\"] = compared.index.isin(fronts[\"worst\"])\n", - "compared[\"mean\"] = compared.index.isin(fronts[\"mean\"])\n", - "compared.sort_values([\"satellites\", \"planes\", \"mean\"]).round(1)" - ] - }, - { - "cell_type": "markdown", - "id": "93f5a1ce", - "metadata": {}, - "source": [ - "The field that decorrelates within an hour is the hardest for 1,028 of the 1,096 designs (that of 3 hours for the others), so a design's worst share is nearly always its share in that field: 12 of the 15 designs efficient by the worst are efficient in that field, and the worst adds little to it. A worst case suits scenarios that are hardest for different designs; here, the mean and the regret (above) say more. The mean over the fields weighs the field of 12 hours as well, in which one plane samples well: three and four satellites in one plane inclined 75 degrees (96% and 95% in that field) are efficient by the mean, where the worst prefers one plane inclined 45 degrees, about two points better in the field of 1 hour and 28 points worse in that of 12 hours. Eight designs are efficient by both, among them the robust choices of three and four satellites above (in two sun-synchronous planes); the robust choice of six (three Walker planes at 700 km) is efficient by the mean, but not by the worst, by 0.4 points in the field of 1 hour." - ] - }, - { - "cell_type": "markdown", - "id": "c0d1e2f3", - "metadata": {}, - "source": [ - "## Plan for Failures\n", - "\n", - "A design that needs every satellite to work is fragile, and what failures cost depends on how the mission responds to them. A `FailureModel` gives the life of the satellites from their launch, here a bathtub curve of infant mortality, random failures, and wear-out (`Bathtub` of `Weibull` and `Exponential` lives, illustrative), and the probability that a launch fails. Each replicate simulates the mission of a design with failures drawn from its seed (`Deployment.simulate`, with common random numbers: the satellite at the same position of the same plane fails at the same age in every design), and a `RestorationPolicy` responds to them:\n", - "\n", - "* **degrade**: fly the satellites that remain;\n", - "* **produce**: restore each failed satellite by producing a new one (after half a year of procurement, on the production line) and launching it;\n", - "* **spare in orbit**: a spare in each plane, launched with it, takes a failed satellite's place within months (others are produced), and is produced again;\n", - "* **spare on ground**: a spare, produced after the first satellites and stored, is launched at the next slot (others are produced), and is produced again.\n", - "\n", - "The policy is a decision of each design: a fragment of the design space (`policy_space`) decides whether to restore failed satellites, and the spares in orbit (in each plane) and on the ground (here, none or one of each, and none without restoration, which would never use them), and configures the policy of each design (`configure`, from a base policy of half a year of procurement and spares that are produced again). The efficient designs by accuracy, each with each of the five policies, form a design space of both, in which each history gives both the cost of what is produced and launched (the restorations and spares, and the launches that fail) and the phases in which its satellites operate, evaluated as in the previous section: the share of points accurately sampled on average over the mission, and in the worst 10% of the histories, and the cost at 70% confidence.\n", - "\n", - "The failures are cheap to simulate, but each phase's share is expensive to evaluate, and most phases repeat the same sets of operating satellites. Each replicate (a sample of points, the expensive part) therefore simulates 20 histories of the failures of its mission (`Failures` of the study, with `Deployment.simulate_many`, stratified: a Latin hypercube over the histories in which each satellite's life and each launch draws from its own stratum of its distribution, which estimates means several times more precisely than independent histories), evaluates them together (`evaluate_missions`) with a cache that evaluates each set of satellites once (`PhaseCache`, shared by the histories, policies, and designs of a replicate), and summarizes them (`summarize_missions`): their mean share, and their worst 10% (the risk of the mission), and their cost at 70% confidence. Five replicates of 20 histories measure the risk of each mission with 100 histories, at a fraction of the cost of 100 replicates. Without restoration (degrading), the satellites fail independently, so that the mean share over the failures is computed exactly (`expected_missions`, from the probability that each set of satellites operates), without sampling error; its worst 10% and cost still come from the histories." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "d1e2f3a4", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-11T23:53:11.897318Z", - "iopub.status.busy": "2026-11-11T23:53:11.897318Z", - "iopub.status.idle": "2026-11-11T23:53:28.438627Z", - "shell.execute_reply": "2026-11-11T23:53:28.438627Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "37% of the satellites fail in 5 years\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "65 designs x 5 replicates x 20 histories in 9 s\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
descriptionfull constellationaccurateaccurate p10cost p70
policydegradeproducespare in orbitspare on groundspares in orbit and on grounddegradeproducespare in orbitspare on groundspares in orbit and on grounddegradeproducespare in orbitspare on groundspares in orbit and on ground
base
9b3481aea973800 km, 60 deg FOR, SSO: 1 at 12:003.43.23.94.04.14.00.43.53.73.73.7110.2130.6147.6146.3162.2
fac5d43a19c7800 km, 60 deg FOR, SSO: 2 at 06:0010.07.09.29.69.89.72.17.38.38.68.7128.9153.4170.3170.0184.3
b85daf65c3a4800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...16.710.914.814.716.014.94.612.212.914.313.3146.2188.2211.1204.4223.3
104e33a3c842800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac...29.316.122.324.424.424.96.118.020.421.021.9170.2218.9237.7235.8249.8
33b006848799800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...33.017.726.128.228.928.50.619.525.125.625.6136.5159.4192.7175.2206.4
c576e2e2dbd1800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:0057.033.147.350.751.751.27.138.544.744.946.8153.9198.1229.3212.4240.1
f216ec70e160800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac...60.432.944.948.048.148.39.537.743.042.443.5161.2201.0247.9216.8260.4
3690f1194419800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:0082.850.768.568.872.569.310.856.261.362.263.1170.4218.3246.8235.4260.7
cb6bd361b577800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...96.075.881.276.381.576.260.473.869.873.969.6246.8326.4376.7347.0389.6
716cb479efda700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...97.064.278.074.279.674.338.970.167.371.566.9209.5278.8316.7294.4329.0
5529c21520be800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...98.379.382.876.882.876.966.478.171.678.271.6253.5340.0394.6355.7405.7
679ca275c8fc800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...98.379.583.076.883.076.869.078.772.178.672.1253.5340.0394.6355.7405.7
de505bc89299800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...98.379.582.976.983.076.968.078.771.778.471.7253.5340.0394.6355.7405.7
\n", - "
" - ], - "text/plain": [ - " description \\\n", - "policy \n", - "base \n", - "9b3481aea973 800 km, 60 deg FOR, SSO: 1 at 12:00 \n", - "fac5d43a19c7 800 km, 60 deg FOR, SSO: 2 at 06:00 \n", - "b85daf65c3a4 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... \n", - "104e33a3c842 800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac... \n", - "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", - "c576e2e2dbd1 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 \n", - "f216ec70e160 800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac... \n", - "3690f1194419 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 \n", - "cb6bd361b577 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... \n", - "716cb479efda 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", - "5529c21520be 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", - "679ca275c8fc 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", - "de505bc89299 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", - "\n", - " full constellation accurate \\\n", - "policy degrade produce spare in orbit \n", - "base \n", - "9b3481aea973 3.4 3.2 3.9 4.0 \n", - "fac5d43a19c7 10.0 7.0 9.2 9.6 \n", - "b85daf65c3a4 16.7 10.9 14.8 14.7 \n", - "104e33a3c842 29.3 16.1 22.3 24.4 \n", - "33b006848799 33.0 17.7 26.1 28.2 \n", - "c576e2e2dbd1 57.0 33.1 47.3 50.7 \n", - "f216ec70e160 60.4 32.9 44.9 48.0 \n", - "3690f1194419 82.8 50.7 68.5 68.8 \n", - "cb6bd361b577 96.0 75.8 81.2 76.3 \n", - "716cb479efda 97.0 64.2 78.0 74.2 \n", - "5529c21520be 98.3 79.3 82.8 76.8 \n", - "679ca275c8fc 98.3 79.5 83.0 76.8 \n", - "de505bc89299 98.3 79.5 82.9 76.9 \n", - "\n", - " accurate p10 \\\n", - "policy spare on ground spares in orbit and on ground degrade \n", - "base \n", - "9b3481aea973 4.1 4.0 0.4 \n", - "fac5d43a19c7 9.8 9.7 2.1 \n", - "b85daf65c3a4 16.0 14.9 4.6 \n", - "104e33a3c842 24.4 24.9 6.1 \n", - "33b006848799 28.9 28.5 0.6 \n", - "c576e2e2dbd1 51.7 51.2 7.1 \n", - "f216ec70e160 48.1 48.3 9.5 \n", - "3690f1194419 72.5 69.3 10.8 \n", - "cb6bd361b577 81.5 76.2 60.4 \n", - "716cb479efda 79.6 74.3 38.9 \n", - "5529c21520be 82.8 76.9 66.4 \n", - "679ca275c8fc 83.0 76.8 69.0 \n", - "de505bc89299 83.0 76.9 68.0 \n", - "\n", - " \\\n", - "policy produce spare in orbit spare on ground \n", - "base \n", - "9b3481aea973 3.5 3.7 3.7 \n", - "fac5d43a19c7 7.3 8.3 8.6 \n", - "b85daf65c3a4 12.2 12.9 14.3 \n", - "104e33a3c842 18.0 20.4 21.0 \n", - "33b006848799 19.5 25.1 25.6 \n", - "c576e2e2dbd1 38.5 44.7 44.9 \n", - "f216ec70e160 37.7 43.0 42.4 \n", - "3690f1194419 56.2 61.3 62.2 \n", - "cb6bd361b577 73.8 69.8 73.9 \n", - "716cb479efda 70.1 67.3 71.5 \n", - "5529c21520be 78.1 71.6 78.2 \n", - "679ca275c8fc 78.7 72.1 78.6 \n", - "de505bc89299 78.7 71.7 78.4 \n", - "\n", - " cost p70 \\\n", - "policy spares in orbit and on ground degrade produce spare in orbit \n", - "base \n", - "9b3481aea973 3.7 110.2 130.6 147.6 \n", - "fac5d43a19c7 8.7 128.9 153.4 170.3 \n", - "b85daf65c3a4 13.3 146.2 188.2 211.1 \n", - "104e33a3c842 21.9 170.2 218.9 237.7 \n", - "33b006848799 25.6 136.5 159.4 192.7 \n", - "c576e2e2dbd1 46.8 153.9 198.1 229.3 \n", - "f216ec70e160 43.5 161.2 201.0 247.9 \n", - "3690f1194419 63.1 170.4 218.3 246.8 \n", - "cb6bd361b577 69.6 246.8 326.4 376.7 \n", - "716cb479efda 66.9 209.5 278.8 316.7 \n", - "5529c21520be 71.6 253.5 340.0 394.6 \n", - "679ca275c8fc 72.1 253.5 340.0 394.6 \n", - "de505bc89299 71.7 253.5 340.0 394.6 \n", - "\n", - " \n", - "policy spare on ground spares in orbit and on ground \n", - "base \n", - "9b3481aea973 146.3 162.2 \n", - "fac5d43a19c7 170.0 184.3 \n", - "b85daf65c3a4 204.4 223.3 \n", - "104e33a3c842 235.8 249.8 \n", - "33b006848799 175.2 206.4 \n", - "c576e2e2dbd1 212.4 240.1 \n", - "f216ec70e160 216.8 260.4 \n", - "3690f1194419 235.4 260.7 \n", - "cb6bd361b577 347.0 389.6 \n", - "716cb479efda 294.4 329.0 \n", - "5529c21520be 355.7 405.7 \n", - "679ca275c8fc 355.7 405.7 \n", - "de505bc89299 355.7 405.7 " - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import time\n", - "\n", - "from tatc.tradespace import (\n", - " Bathtub,\n", - " Exponential,\n", - " FailureModel,\n", - " Failures,\n", - " Integer,\n", - " RestorationPolicy,\n", - " Weibull,\n", - " policy_space,\n", - ")\n", - "\n", - "# illustrative lives: about 9% fail in their first year, 3% a year at random, and wear-out after about 8 years\n", - "FAILURE_MODEL = FailureModel(\n", - " life=Bathtub(infant=Weibull(shape=0.5, scale=100), random=Exponential(0.03), wear_out=Weibull(shape=4, scale=9)),\n", - " launch=0.05,\n", - ")\n", - "print(f\"{1 - FAILURE_MODEL.life.survival(5):.0%} of the satellites fail in 5 years\")\n", - "BASE_POLICY = RestorationPolicy(procurement_years=0.5, replenish=True)\n", - "POLICY = policy_space(orbit_spares=Integer(0, 1), ground_spares=Integer(0, 1), replenish=True)\n", - "\n", - "# the design space with a policy, and the efficient designs by accuracy with each policy\n", - "policy_trade = DesignSpace(**space.children, policy=POLICY, constraints=space.constraints)\n", - "with_policies, base_of = [], {}\n", - "for key in accuracy.design[accuracy.pareto]:\n", - " for policy in POLICY.enumerate():\n", - " design = policy_trade.design({**by_key[key].decisions, \"policy\": policy.decisions})\n", - " with_policies.append(design)\n", - " base_of[design.key] = key\n", - "\n", - "\n", - "def describe_policy(row):\n", - " \"\"\"A short description of a policy.\"\"\"\n", - " if not row[\"policy.restore\"]:\n", - " return \"degrade\"\n", - " orbit, ground = row[\"policy.orbit_spares\"] > 0, row[\"policy.ground_spares\"] > 0\n", - " return {\n", - " (False, False): \"produce\",\n", - " (True, False): \"spare in orbit\",\n", - " (False, True): \"spare on ground\",\n", - " (True, True): \"spares in orbit and on ground\",\n", - " }[orbit, ground]\n", - "\n", - "\n", - "# 20 histories of each replicate, restored by the policy of each design, with the mean share accurately sampled over\n", - "# the mission in the worst 10% of the histories, and the cost at 70% confidence\n", - "FAILURES = Failures(\n", - " FAILURE_MODEL, BASE_POLICY, histories=20, seed=\"failure_seed\", quantiles={\"accurate mean\": 0.1, \"cost\": 0.7}\n", - ")\n", - "study = make_study(replicates=5, failures=FAILURES, design_space=policy_trade)\n", - "began = time.perf_counter()\n", - "trades = study.run(with_policies)\n", - "print(f\"{len(with_policies)} designs x 5 replicates x 20 histories in {time.perf_counter() - began:.0f} s\")\n", - "# the means over the replicates of the histories' mean share, worst 10%, and cost at 70% confidence\n", - "ROBUST = {\"accurate\": \"accurate mean\", \"accurate p10\": \"accurate mean p10\", \"cost p70\": \"cost p70\"}\n", - "traded = aggregate(trades, ROBUST).set_index(\"design\")[list(ROBUST)]\n", - "first = trades.drop_duplicates(\"design\").set_index(\"design\")\n", - "traded[\"policy\"] = [describe_policy(first.loc[key]) for key in traded.index]\n", - "traded[\"base\"] = [base_of[key] for key in traded.index]\n", - "\n", - "# the shares of the full constellations, without deployment or failures, for comparison\n", - "nominal = make_study(replicates=20).run([by_key[key] for key in accuracy.design[accuracy.pareto]])\n", - "full = aggregate(nominal, [\"accurate\"]).set_index(\"design\")[\"accurate\"]\n", - "ORDER = [\"degrade\", \"produce\", \"spare in orbit\", \"spare on ground\", \"spares in orbit and on ground\"]\n", - "table = traded.pivot(index=\"base\", columns=\"policy\", values=[\"accurate\", \"accurate p10\", \"cost p70\"])\n", - "table = table[[(metric, policy) for metric in (\"accurate\", \"accurate p10\", \"cost p70\") for policy in ORDER]]\n", - "table.insert(0, (\"full constellation\", \"\"), full.reindex(table.index))\n", - "table.insert(0, (\"description\", \"\"), [describe(values.loc[key]) for key in table.index])\n", - "table.sort_values((\"full constellation\", \"\")).round(1)" - ] - }, - { - "cell_type": "markdown", - "id": "e2f3a4b5", - "metadata": {}, - "source": [ - "The 6,500 histories (100 of each of the 65 designs and policies) take about ten seconds here. The shares accurately sampled over the mission fall short of those of the full constellation under every policy, by the phases of deployment and the failures of launches as well as of satellites (37% of which fail within five years), but for the single satellite, whose shares differ by less than the sampling error of five replicates (the full constellation's are of 20). The response to failures matters most for the designs of several satellites in several planes, and in their worst histories:\n", - "\n", - "* **Degrading** is cheapest, but loses 12 to 18 points of the mean against producing replacements for the designs of three to six satellites in two or three planes, and more in their worst 10% of histories (39% against 70% for six satellites in three Walker planes; 1% against 20% for two satellites in two planes, which can lose both). Nine satellites in three planes lose only 3.5 points: a failure leaves eight. The means of degrading are exact (`expected_missions`); those of the other policies are estimates from 100 histories.\n", - "* **Producing replacements** restores most of it, at 17 to 34% more cost at 70% confidence than degrading.\n", - "* **Spares** cost 28 to 56% more than degrading (up to 62% for spares both in orbit and on the ground), and pay off in the worst histories of the small designs of several planes: two satellites in two planes keep about 25% in their worst histories with a spare, against 20% by producing replacements. A spare on the ground costs less than a spare in each plane for the designs of several planes, and restores as well or better.\n", - "* **A spare in orbit can hurt**: for six to nine satellites in three or four planes, the spares delay the deployment (each plane waits for its spare to be produced, and a fourth satellite in a plane of three takes a second launch), so that they sample less on average (74% against 78% for six satellites, 76% against 81% for eight, 77% against 83% for nine) at a higher cost. Spares in orbit and on the ground together cost the most, and sample about as much as a spare on the ground alone, or less." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "b8c9d0e1", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-11T23:53:28.440633Z", - "iopub.status.busy": "2026-11-11T23:53:28.440633Z", - "iopub.status.idle": "2026-11-11T23:53:28.454498Z", - "shell.execute_reply": "2026-11-11T23:53:28.454498Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
descriptionpolicyaccurateaccurate p10cost p70
design
2a310c00151b800 km, 60 deg FOR, SSO: 1 at 12:00degrade3.20.4110.2
bc2076a0d3d8800 km, 60 deg FOR, SSO: 2 at 06:00degrade7.02.1128.9
bb6574900ac3800 km, 60 deg FOR, SSO: 1 at 12:00produce3.93.5130.6
638697713902800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...degrade10.94.6146.2
43f50c8bc38a800 km, 60 deg FOR, SSO: 2 at 06:00produce9.27.3153.4
ad99c42082ab800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...produce26.119.5159.4
cc2e14e787ff800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...spare on ground28.925.6175.2
eeb7c70a720b800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00produce47.338.5198.1
3a902b976460700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...degrade64.238.9209.5
6d54bdbf4648800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00spare on ground51.744.9212.4
1afde0569e34800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00produce68.556.2218.3
e7721a705c31800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00spare on ground72.562.2235.4
46932f795a5a800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...degrade79.569.0253.5
6e4564d2ae2c700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...produce78.070.1278.8
570a452fdb8f700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...spare on ground79.671.5294.4
2b499d154a98800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...produce81.273.8326.4
a37619256b26800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...produce83.078.7340.0
\n", - "
" - ], - "text/plain": [ - " description \\\n", - "design \n", - "2a310c00151b 800 km, 60 deg FOR, SSO: 1 at 12:00 \n", - "bc2076a0d3d8 800 km, 60 deg FOR, SSO: 2 at 06:00 \n", - "bb6574900ac3 800 km, 60 deg FOR, SSO: 1 at 12:00 \n", - "638697713902 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... \n", - "43f50c8bc38a 800 km, 60 deg FOR, SSO: 2 at 06:00 \n", - "ad99c42082ab 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", - "cc2e14e787ff 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", - "eeb7c70a720b 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 \n", - "3a902b976460 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", - "6d54bdbf4648 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 \n", - "1afde0569e34 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 \n", - "e7721a705c31 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 \n", - "46932f795a5a 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", - "6e4564d2ae2c 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", - "570a452fdb8f 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", - "2b499d154a98 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... \n", - "a37619256b26 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", - "\n", - " policy accurate accurate p10 cost p70 \n", - "design \n", - "2a310c00151b degrade 3.2 0.4 110.2 \n", - "bc2076a0d3d8 degrade 7.0 2.1 128.9 \n", - "bb6574900ac3 produce 3.9 3.5 130.6 \n", - "638697713902 degrade 10.9 4.6 146.2 \n", - "43f50c8bc38a produce 9.2 7.3 153.4 \n", - "ad99c42082ab produce 26.1 19.5 159.4 \n", - "cc2e14e787ff spare on ground 28.9 25.6 175.2 \n", - "eeb7c70a720b produce 47.3 38.5 198.1 \n", - "3a902b976460 degrade 64.2 38.9 209.5 \n", - "6d54bdbf4648 spare on ground 51.7 44.9 212.4 \n", - "1afde0569e34 produce 68.5 56.2 218.3 \n", - "e7721a705c31 spare on ground 72.5 62.2 235.4 \n", - "46932f795a5a degrade 79.5 69.0 253.5 \n", - "6e4564d2ae2c produce 78.0 70.1 278.8 \n", - "570a452fdb8f spare on ground 79.6 71.5 294.4 \n", - "2b499d154a98 produce 81.2 73.8 326.4 \n", - "a37619256b26 produce 83.0 78.7 340.0 " - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# the efficient designs and policies, by their cost and their accuracy in the worst 10% of the replicates\n", - "efficient = traded[pareto_front(traded, {\"cost p70\": \"min\", \"accurate p10\": \"max\"})]\n", - "efficient.assign(description=[describe(values.loc[key]) for key in efficient.base]).sort_values(\"cost p70\")[\n", - " [\"description\", \"policy\", \"accurate\", \"accurate p10\", \"cost p70\"]\n", - "].round(1)" - ] - }, - { - "cell_type": "markdown", - "id": "c9d0e1f2", - "metadata": {}, - "source": [ - "The front of cost at 70% confidence against the share accurately sampled in the worst 10% of the histories chooses designs and policies together. Along it, degrading is the cheapest policy of a design and restoring buys robustness: two satellites in two Walker planes keep 20% of the points accurately sampled in their worst histories if they produce replacements (159 million) and 26% with a spare on the ground (175 million); six satellites in three Walker planes keep 39%, 70%, and 72% if they degrade, produce replacements, or keep a spare on the ground, for 210, 279, and 294 million. Nine satellites in three planes degrade gracefully (69% in their worst histories for 254 million), and producing replacements raises them to 79% for 340 million. A spare on the ground is efficient for designs of two to six satellites, but a spare in orbit is not efficient for any design here, as it delays the deployment. The policy that a design deserves depends on the design, which is why the policy is a decision of the design rather than of the study." - ] - }, - { - "cell_type": "markdown", - "id": "135bfcd2", - "metadata": {}, - "source": [ - "## Find What Spreads the Replicates\n", - "\n", - "The replicates of a design differ by its uncertain parameters: here, the sample of points (`points_seed`), the histories of failures (`failure_seed`), and the growth of the cost of development (`cost_growth`, see below). Which of them spreads an objective says what would sharpen it: the spread from the sample of points and from the histories is noise of the estimates, which more points or more histories reduce, and that from the growth of costs is a risk of the mission. `attribute_variance` finds it by evaluating each design again with one parameter drawn as in other replicates and the others held, which works for parameters whose values do not relate to the outcomes in any order, such as seeds. The total share of a parameter is the share of the variance between replicates that it causes, alone or with others (near 0 if it does not matter), with its standard error (`se`, by a bootstrap of the replicates); its first share (`summary(\"first\")`) is the share that knowing it would remove. Here, for the efficient designs and policies of the study of failures, from 20 replicates, 20 more, and 20 with each parameter drawn as in the second 20:" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "f0fa7509", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1700 evaluations in 47 s\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
accurate meanaccurate mean p10cost p70accurate mean seaccurate mean p10 secost p70 se
parameter
points_seed92.430.40.06.43.30.0
failure_seed3.667.035.80.76.57.1
cost_growth0.00.081.80.00.019.0
\n", - "
" - ], - "text/plain": [ - " accurate mean accurate mean p10 cost p70 accurate mean se \\\n", - "parameter \n", - "points_seed 92.4 30.4 0.0 6.4 \n", - "failure_seed 3.6 67.0 35.8 0.7 \n", - "cost_growth 0.0 0.0 81.8 0.0 \n", - "\n", - " accurate mean p10 se cost p70 se \n", - "parameter \n", - "points_seed 3.3 0.0 \n", - "failure_seed 6.5 7.1 \n", - "cost_growth 0.0 19.0 " - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from tatc.tradespace import attribute_variance\n", - "\n", - "# the shares (%) of the variance between the replicates of the efficient designs and policies that each uncertain\n", - "# parameter causes, alone or with others, from 20 replicates, 20 more, and 20 with each parameter drawn as in the\n", - "# second 20\n", - "policy_by_key = {design.key: design for design in with_policies}\n", - "began = time.perf_counter()\n", - "attribution = attribute_variance(\n", - " study, # of failures\n", - " [policy_by_key[key] for key in efficient.index],\n", - " [\"accurate mean\", \"accurate mean p10\", \"cost p70\"],\n", - " replicates=20,\n", - ")\n", - "print(f\"{len(attribution.results)} evaluations in {time.perf_counter() - began:.0f} s\")\n", - "attribution.summary().mul(100).round(1)" - ] - }, - { - "cell_type": "markdown", - "id": "7368ea1a", - "metadata": {}, - "source": [ - "The attribution takes 1,700 evaluations (85 of them those of the study above), under a minute here. The sample of points spreads the mean shares accurately sampled (92% of their variance between replicates), and the failures hardly do (4%): the means of degrading are exact, and those of the other policies average 20 histories. The share in the worst 10% of the histories is spread mostly by the failures (67%, and 30% by the points), as a quantile of 20 histories is a noisy estimate. Both are noise of the estimates rather than risks of the missions, and they call for different remedies: more points would sharpen the means, and more histories in each replicate the worst 10%, which is cheap (the 6,500 histories above take about ten seconds). The cost at 70% confidence of a replicate is spread by the growth of the cost of development (82%), a risk of the mission, and by the failures (36%), which cost replacements and spares for the policies that restore satellites; these shares are the least certain (standard errors of 19 and 7 points). The total shares of each objective sum to about 1 within their errors, so the parameters hardly interact." - ] - }, - { - "cell_type": "markdown", - "id": "8c914460", - "metadata": {}, - "source": [ - "The order of designs on the front is settled by their differences, in which the parameters that act alike on two designs cancel (with common random numbers, the designs of a replicate share its parameters). `differences` attributes the variance of the differences between pairs of designs, from the same evaluations: here, between the designs and policies adjacent along the front, by cost at 70% confidence:" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "9226eca9", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
accurate meanaccurate mean p10cost p70accurate mean seaccurate mean p10 secost p70 se
parameter
points_seed92.130.40.06.44.50.0
failure_seed2.973.0105.80.56.54.7
cost_growth0.00.00.00.00.00.0
\n", - "
" - ], - "text/plain": [ - " accurate mean accurate mean p10 cost p70 accurate mean se \\\n", - "parameter \n", - "points_seed 92.1 30.4 0.0 6.4 \n", - "failure_seed 2.9 73.0 105.8 0.5 \n", - "cost_growth 0.0 0.0 0.0 0.0 \n", - "\n", - " accurate mean p10 se cost p70 se \n", - "parameter \n", - "points_seed 4.5 0.0 \n", - "failure_seed 6.5 4.7 \n", - "cost_growth 0.0 0.0 " - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# the shares (%) of the variance of the differences between the efficient designs and policies adjacent along the\n", - "# front (by cost), from the same evaluations\n", - "ordered = efficient.sort_values(\"cost p70\").index\n", - "attribution.differences(list(zip(ordered, ordered[1:]))).summary().mul(100).round(1)" - ] - }, - { - "cell_type": "markdown", - "id": "cfdd26c3", - "metadata": {}, - "source": [ - "The growth of the cost of development cancels in every difference: all of these designs fly the same imager, whose development grows alike, so that it is a risk of each mission but not a reason to prefer one of them to another, and the failures alone unsettle the order of their costs (all of the variance of the differences, 106 ± 5%). The shares accurately sampled differ by the parameters that spread them: by the sample of points for the means (92%), and mostly by the histories for the worst 10% (73%, and 30% by the points). More points would settle the order of neighbors by their means, and more histories their order by the worst 10% and by cost." - ] - }, - { - "cell_type": "markdown", - "id": "b1c2d3e4", - "metadata": {}, - "source": [ - "## Trade Cost Against Sufficiency\n", - "\n", - "The numbers of satellites and planes are proxies of cost. A `CostModel` estimates the life-cycle cost of each design from the costs of its satellites (the development of each type, and the production of its units on a learning curve), launches (here, a small launcher for every three satellites of a plane), and operations, given by the study (TAT-C does not include cost-estimating relationships). The costs here are illustrative, in millions of dollars. The evaluation adds the cost and its elements to each record, for the satellites of each design's imager (`kind`): a wider field of regard costs more to develop and build. The deployment of each design (`DeploymentSchedule.plan`) dates the costs, from rates, so that each design's schedule follows from its satellites and planes: development over three years, then the production of the satellites on one line at four a year, plane by plane, each plane launched when its satellites are ready (in launches of up to three satellites, at most one every half year), and operations from each launch to the end of the mission (five years after the first launch). The dated costs give the present value of the cost (`cost present`, discounted at 3% a year) and the cost of the most expensive year (`cost peak annual`), for annual budgets.\n", - "\n", - "The growth of the cost of development is uncertain (an `Uncertain` parameter, from 0.9 to 1.6 times the estimate, most likely 1), drawn for each replicate, so that statistics over the replicates give the cost at a confidence level: here, the 0.7 quantile (`cost p70`), as budgets are often set. A requirement keeps the designs whose cost at 70% confidence is within a budget, and the front trades this cost against the share of points sufficiently sampled. (Cost depends only on the design, so a constraint of the design space could exclude designs over a budget before they are evaluated, with the cost without growth.)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "c2d3e4f5", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-11T23:53:28.454498Z", - "iopub.status.busy": "2026-11-11T23:53:28.454498Z", - "iopub.status.idle": "2026-11-11T23:53:29.777578Z", - "shell.execute_reply": "2026-11-11T23:53:29.777578Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "520 of 1096 designs cost at most 150 at 70% confidence, of which 46 are efficient in at least half of the resamples\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
descriptionsatellitesplanesdeployedcost p70cost developmentcost productioncost launchcost operationscost presentcost peak annualsufficientpareto_probability
635700 km, 30 deg FOR, SSO: 1 at 06:00113.283.644.412.08.017.575.523.51.01.0
910800 km, 30 deg FOR, SSO: 2 at 06:00213.596.944.422.88.020.087.230.82.60.9
826800 km, 30 deg FOR, Walker 45 deg: 2 x 1 (spac...223.8104.744.422.816.019.894.342.36.20.9
824800 km, 30 deg FOR, Walker 45 deg: 1 x 3 (spac...313.8109.644.433.08.022.598.241.07.81.0
835800 km, 30 deg FOR, Walker 45 deg: 3 x 1 (spac...334.2124.844.433.024.021.8112.252.511.21.0
828800 km, 30 deg FOR, Walker 45 deg: 2 x 2 (spac...424.0129.344.442.716.024.5115.950.722.21.0
963800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...223.8139.266.734.216.019.8126.053.730.21.0
845800 km, 30 deg FOR, Walker 45 deg: 4 x 1 (spac...444.8144.344.442.732.023.5129.262.231.00.7
961800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...313.8149.166.749.48.022.5134.457.438.00.6
\n", - "
" - ], - "text/plain": [ - " description satellites planes \\\n", - "635 700 km, 30 deg FOR, SSO: 1 at 06:00 1 1 \n", - "910 800 km, 30 deg FOR, SSO: 2 at 06:00 2 1 \n", - "826 800 km, 30 deg FOR, Walker 45 deg: 2 x 1 (spac... 2 2 \n", - "824 800 km, 30 deg FOR, Walker 45 deg: 1 x 3 (spac... 3 1 \n", - "835 800 km, 30 deg FOR, Walker 45 deg: 3 x 1 (spac... 3 3 \n", - "828 800 km, 30 deg FOR, Walker 45 deg: 2 x 2 (spac... 4 2 \n", - "963 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2 2 \n", - "845 800 km, 30 deg FOR, Walker 45 deg: 4 x 1 (spac... 4 4 \n", - "961 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3 1 \n", - "\n", - " deployed cost p70 cost development cost production cost launch \\\n", - "635 3.2 83.6 44.4 12.0 8.0 \n", - "910 3.5 96.9 44.4 22.8 8.0 \n", - "826 3.8 104.7 44.4 22.8 16.0 \n", - "824 3.8 109.6 44.4 33.0 8.0 \n", - "835 4.2 124.8 44.4 33.0 24.0 \n", - "828 4.0 129.3 44.4 42.7 16.0 \n", - "963 3.8 139.2 66.7 34.2 16.0 \n", - "845 4.8 144.3 44.4 42.7 32.0 \n", - "961 3.8 149.1 66.7 49.4 8.0 \n", - "\n", - " cost operations cost present cost peak annual sufficient \\\n", - "635 17.5 75.5 23.5 1.0 \n", - "910 20.0 87.2 30.8 2.6 \n", - "826 19.8 94.3 42.3 6.2 \n", - "824 22.5 98.2 41.0 7.8 \n", - "835 21.8 112.2 52.5 11.2 \n", - "828 24.5 115.9 50.7 22.2 \n", - "963 19.8 126.0 53.7 30.2 \n", - "845 23.5 129.2 62.2 31.0 \n", - "961 22.5 134.4 57.4 38.0 \n", - "\n", - " pareto_probability \n", - "635 1.0 \n", - "910 0.9 \n", - "826 0.9 \n", - "824 1.0 \n", - "835 1.0 \n", - "828 1.0 \n", - "963 1.0 \n", - "845 0.7 \n", - "961 0.6 " - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "BUDGET = 150 # millions of dollars, at 70% confidence\n", - "COST = Criteria(\n", - " {\"cost p70\": \"min\", \"sufficient\": \"max\"},\n", - " statistics={\"cost p70\": Quantile(\"cost\", 0.7)},\n", - " requirements=[Requirement(\"cost p70\", \"<=\", BUDGET)],\n", - " tolerance=TOLERANCE,\n", - ")\n", - "ELEMENTS = [\"cost development\", \"cost production\", \"cost launch\", \"cost operations\"]\n", - "\n", - "costed = pareto_probability(refinement.results, COST, n_resamples=1000)\n", - "DATED = [\"cost present\", \"cost peak annual\"]\n", - "elements = aggregate(refinement.results, [*ELEMENTS, *DATED]).set_index(\"design\")[[*ELEMENTS, *DATED]]\n", - "costed = costed.join(values[[\"satellites\", \"planes\"]], on=\"design\").join(elements, on=\"design\")\n", - "costed[\"description\"] = [describe(values.loc[key]) for key in costed.design]\n", - "# the years from the start of development to the launch of every plane, from each design's schedule\n", - "costed[\"deployed\"] = [\n", - " SCHEDULE.plan(by_key[key].layout, kind=by_key[key].field_of_regard).deployed for key in costed.design\n", - "]\n", - "efficient = costed[costed.pareto_probability >= 0.5]\n", - "print(\n", - " f\"{costed.meets_requirements.sum()} of {len(costed)} designs cost at most {BUDGET} at 70% confidence, \"\n", - " + f\"of which {len(efficient)} are efficient in at least half of the resamples\"\n", - ")\n", - "# the most sufficient of these at each cost\n", - "efficient.sort_values([\"cost p70\", \"sufficient\"], ascending=[True, False]).drop_duplicates(\"cost p70\")[\n", - " [\"description\", \"satellites\", \"planes\", \"deployed\", \"cost p70\", *ELEMENTS, *DATED, \"sufficient\", \"pareto_probability\"]\n", - "].round(1)" - ] - }, - { - "cell_type": "markdown", - "id": "d3e4f5a6", - "metadata": {}, - "source": [ - "520 of the 1,096 designs cost at most 150 million dollars at 70% confidence. Along the front, money buys sufficiency in steps: one satellite (84 million at 70% confidence, of which 44 million on average develops it) samples 1% of the points sufficiently; a second satellite in its plane, 3%, and in a second plane, 6%; four satellites in two Walker planes (129 million), 22%. The planes now have a price: four satellites in four planes sample more points sufficiently than in two (31% against 22%, as more planes spread the samples in time), at twice the cost of launches (32 million against 16). The wider field of regard joins the front only near the budget, where its development (67 million against 44) is worth its swath: two satellites with the wider imager sample 30% of the points for 139 million, about as many as four with the narrower one in four planes, and three of them 38% for 149 million, the most within the budget. The designs that sample nearly every point (six to nine satellites) cost more than the budget.\n", - "\n", - "Each design's schedule follows from its satellites and planes (`deployed`, years from the start of development to the launch of its last plane): one satellite is launched 3.2 years after development starts; four satellites in two planes take a year to produce, and are deployed after 4.0 years; and four satellites in four planes, after 4.8 years, as each plane takes a launch and launches are half a year apart. Dated, the costs are worth 8 to 9% less at present (at 3% a year), as most are incurred three or more years from now. The most expensive year is the one after development, in which the satellites are produced and the first are launched: four satellites in four planes need 62 million in that year, and one satellite 24 million. A budget of annual funding would limit the satellites produced in a year, which a slower production rate would spread over more years, at the cost of deploying later.\n", - "\n", - "The growth of the cost of development affects every design alike in a replicate (common random numbers), so it shifts the costs at 70% confidence more for designs whose development costs more, here those of the wider imager. With five replicates of most designs, the 0.7 quantile of their costs is a coarse estimate: an evaluation that costs little more than the cost model (unlike the analysis of sampling) could draw more replicates of the cost alone." - ] - }, - { - "cell_type": "markdown", - "id": "8f0b0487", - "metadata": {}, - "source": [ - "## Trade Utility Against Cost\n", - "\n", - "Sufficiency and accuracy are objectives above, each in its own units. A stakeholder who values both weighs them, and a utility makes the weights explicit (`Utility`): a single-attribute utility of each metric, from 0 at its worst acceptable value to 1 at its best (here, linear in the share of points sampled sufficiently, `LinearUtility`, and concave in the share sampled accurately, `ExponentialUtility`, as the first points accurately sampled matter most), combined by weights. Two stakeholders weigh the shares differently: one mostly sufficiency (0.7 against 0.3), as a center that counts samples for forecasts might, and the other mostly accuracy (0.3 against 0.7), as one that estimates daily means might. Each design's utility is that of its means: the shares vary between replicates mostly as noise of the sample of points, which the expected utility (the mean of the utility of each replicate, `Mean(utility)`) would penalize as if it were a risk. The figure plots each stakeholder's utility of every design against its cost at 70% confidence (as above), with the front of each ringed:" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "d4a1007a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from tatc.tradespace import ExponentialUtility, LinearUtility, Utility\n", - "\n", - "# the utility of the shares sampled sufficiently (linear) and accurately (concave: the first points matter most), for\n", - "# two stakeholders who weigh them differently\n", - "CURVES = {\"sufficient\": LinearUtility(0, 100), \"accurate\": ExponentialUtility(0, 100, risk=2)}\n", - "STAKEHOLDERS = {\n", - " \"sufficiency\": Utility(CURVES, weights={\"sufficient\": 0.7, \"accurate\": 0.3}),\n", - " \"accuracy\": Utility(CURVES, weights={\"sufficient\": 0.3, \"accurate\": 0.7}),\n", - "}\n", - "means = aggregate(\n", - " refinement.results, {\"sufficient\": \"sufficient\", \"accurate\": \"accurate\", \"cost p70\": Quantile(\"cost\", 0.7)}\n", - ").set_index(\"design\")\n", - "means[\"description\"] = [describe(values.loc[key]) for key in means.index]\n", - "\n", - "fig, axes = plt.subplots(1, 2, figsize=(11, 4.5), sharey=True)\n", - "judged = {}\n", - "for ax, (name, utility) in zip(axes, STAKEHOLDERS.items()):\n", - " judged[name] = means.assign(utility=utility(means))\n", - " judged[name][\"pareto\"] = pareto_front(judged[name], {\"utility\": \"max\", \"cost p70\": \"min\"})\n", - " legend = \"lower right\" if ax is axes[0] else None\n", - " plot_designs(judged[name], \"cost p70\", \"utility\", by=\"planes\", front=\"pareto\", names=planes_name, legend=legend, ax=ax)\n", - " ax.axvline(BUDGET, color=GRAY, lw=1, ls=\"--\")\n", - " ax.set(xlabel=\"Cost at 70% confidence (millions of dollars)\", ylabel=\"Utility\", ylim=(0, 1.02))\n", - " ax.set_title(f\"Weighing {name} most\", fontsize=10)\n", - " style_axes(ax, grid=\"both\")\n", - "fig.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "0e08a178", - "metadata": {}, - "source": [ - "The stakeholders' fronts share most of their designs. Those efficient for one stakeholder and not the other:" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "8c84cbf4", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "20 designs are efficient for both\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
descriptionsatellitesplanessufficientaccuratecost p70utility (sufficiency)efficient (sufficiency)utility (accuracy)efficient (accuracy)
design
828c0027d01f800 km, 60 deg FOR, SSO: 1 at 12:00, 2 at 18:003229.257.0156.650.44False0.64True
c576e2e2dbd1800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:003228.860.6156.900.45False0.66True
6ba50f2632cd800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4269.665.4173.730.74True0.80False
3690f1194419800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:004257.685.4173.730.69False0.84True
64cf6542c326800 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...6390.295.8213.530.93False0.96True
\n", - "
" - ], - "text/plain": [ - " description satellites \\\n", - "design \n", - "828c0027d01f 800 km, 60 deg FOR, SSO: 1 at 12:00, 2 at 18:00 3 \n", - "c576e2e2dbd1 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3 \n", - "6ba50f2632cd 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4 \n", - "3690f1194419 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4 \n", - "64cf6542c326 800 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... 6 \n", - "\n", - " planes sufficient accurate cost p70 utility (sufficiency) \\\n", - "design \n", - "828c0027d01f 2 29.2 57.0 156.65 0.44 \n", - "c576e2e2dbd1 2 28.8 60.6 156.90 0.45 \n", - "6ba50f2632cd 2 69.6 65.4 173.73 0.74 \n", - "3690f1194419 2 57.6 85.4 173.73 0.69 \n", - "64cf6542c326 3 90.2 95.8 213.53 0.93 \n", - "\n", - " efficient (sufficiency) utility (accuracy) \\\n", - "design \n", - "828c0027d01f False 0.64 \n", - "c576e2e2dbd1 False 0.66 \n", - "6ba50f2632cd True 0.80 \n", - "3690f1194419 False 0.84 \n", - "64cf6542c326 False 0.96 \n", - "\n", - " efficient (accuracy) \n", - "design \n", - "828c0027d01f True \n", - "c576e2e2dbd1 True \n", - "6ba50f2632cd False \n", - "3690f1194419 True \n", - "64cf6542c326 True " - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# the designs efficient for one stakeholder and not the other\n", - "compared = means[[\"description\", \"satellites\", \"planes\", \"sufficient\", \"accurate\", \"cost p70\"]].copy()\n", - "for name in STAKEHOLDERS:\n", - " compared[f\"utility ({name})\"] = judged[name][\"utility\"]\n", - " compared[f\"efficient ({name})\"] = judged[name][\"pareto\"]\n", - "print(f\"{(compared['efficient (sufficiency)'] & compared['efficient (accuracy)']).sum()} designs are efficient for both\")\n", - "compared[compared[\"efficient (sufficiency)\"] != compared[\"efficient (accuracy)\"]].sort_values(\"cost p70\").round(2)" - ] - }, - { - "cell_type": "markdown", - "id": "6579b63a", - "metadata": {}, - "source": [ - "Within the budget, the stakeholders agree: every design efficient for either of them up to 150 million dollars is efficient for both, as more satellites in more planes buy both shares. Beyond the budget, they part. For 174 million dollars at 70% confidence, the stakeholder of sufficiency prefers four satellites in two Walker planes (70% of the points sufficiently sampled and 65% accurately), and the stakeholder of accuracy four in two sun-synchronous planes crossing at 09:00 and 15:00 (58% and 85%), whose planes spread the samples over the day. The stakeholder of accuracy also finds three satellites in two sun-synchronous planes efficient for 157 million (57 to 61% accurately sampled), and six in three Walker planes for 214 million (96%), which the stakeholder of sufficiency passes over. A utility is a metric of any statistic (such as `Quantile(utility, 0.1)`, the utility that a design exceeds in 90% of the replicates, for risks that the replicates draw) and so an objective of the searches as well; a multiplicative utility (`form=\"multiplicative\"`) makes the shares complements, both of which a design must serve, or substitutes, either of which suffices." - ] - }, - { - "cell_type": "markdown", - "id": "e4f5a6b7", - "metadata": {}, - "source": [ - "## Account for Deployment\n", - "\n", - "The shares of points sampled so far are those of each design's full constellation, as if its satellites flew for the whole mission. They are launched over months to years, during which fewer satellites sample the points. The launches of each design's deployment divide its mission into phases, in each of which a set of its satellites flies (`Deployment.phases`); each phase is evaluated over the same representative day with the observations of its satellites (`evaluate_phases`, which filters the observations of the full constellation, from the cache), and the phases are combined over the mission (`summarize_phases`): the mean of each share weighted by the duration of the phases, over the five years from the first launch (`sufficient mean`), and the time from the start of development until half of the points are sampled sufficiently (`sufficient time`, infinite if never).\n", - "\n", - "The phased study evaluates the efficient designs of the first front (the most sufficient of each number of satellites and planes)." - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "f5a6b7c8", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-11T23:53:29.777578Z", - "iopub.status.busy": "2026-11-11T23:53:29.777578Z", - "iopub.status.idle": "2026-11-11T23:53:30.505473Z", - "shell.execute_reply": "2026-11-11T23:53:30.505473Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
descriptionsatellitesplanesdeployedsufficientsufficient meanlostsufficient time
design
163120bf9590800 km, 60 deg FOR, SSO: 1 at 18:001.01.03.23.23.20.0inf
f7413b1f8466800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...2.01.03.516.616.60.0inf
33b006848799800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.03.830.227.32.9inf
d5d3fa915ca7800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...3.01.03.838.038.00.0inf
1af5f2707be3800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.04.568.263.54.74.5
6ba50f2632cd800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.04.069.664.35.34.0
6bef11e40977800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.04.597.887.110.74.5
\n", - "
" - ], - "text/plain": [ - " description satellites \\\n", - "design \n", - "163120bf9590 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 \n", - "f7413b1f8466 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 \n", - "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 \n", - "d5d3fa915ca7 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 \n", - "1af5f2707be3 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 \n", - "6ba50f2632cd 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 \n", - "6bef11e40977 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 \n", - "\n", - " planes deployed sufficient sufficient mean lost \\\n", - "design \n", - "163120bf9590 1.0 3.2 3.2 3.2 0.0 \n", - "f7413b1f8466 1.0 3.5 16.6 16.6 0.0 \n", - "33b006848799 2.0 3.8 30.2 27.3 2.9 \n", - "d5d3fa915ca7 1.0 3.8 38.0 38.0 0.0 \n", - "1af5f2707be3 1.0 4.5 68.2 63.5 4.7 \n", - "6ba50f2632cd 2.0 4.0 69.6 64.3 5.3 \n", - "6bef11e40977 2.0 4.5 97.8 87.1 10.7 \n", - "\n", - " sufficient time \n", - "design \n", - "163120bf9590 inf \n", - "f7413b1f8466 inf \n", - "33b006848799 inf \n", - "d5d3fa915ca7 inf \n", - "1af5f2707be3 4.5 \n", - "6ba50f2632cd 4.0 \n", - "6bef11e40977 4.5 " - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "PHASED = [\"sufficient\", \"sufficient mean\", \"sufficient time\"]\n", - "leaders = front.sort_values(\"sufficient\", ascending=False).drop_duplicates([\"satellites\", \"planes\"])\n", - "phased = make_study(phased=True).run([by_key[key] for key in leaders.design])\n", - "deployed = aggregate(phased, PHASED).set_index(\"design\")[PHASED]\n", - "leaders = leaders.set_index(\"design\")[[\"description\", \"satellites\", \"planes\"]].join(deployed)\n", - "leaders[\"deployed\"] = [SCHEDULE.plan(by_key[key].layout, kind=by_key[key].field_of_regard).deployed for key in leaders.index]\n", - "leaders[\"lost\"] = leaders[\"sufficient\"] - leaders[\"sufficient mean\"]\n", - "leaders.sort_values([\"satellites\", \"planes\"])[\n", - " [\"description\", \"satellites\", \"planes\", \"deployed\", \"sufficient\", \"sufficient mean\", \"lost\", \"sufficient time\"]\n", - "].round(1)" - ] - }, - { - "cell_type": "markdown", - "id": "a6b7c8d9", - "metadata": {}, - "source": [ - "Deployment costs the designs of several planes or launches. Six satellites in two planes sample 98% of the points once deployed, but 87% on average over the mission, as the first plane flies alone for three quarters of a year while the second is produced, and they sample half of the points only 4.5 years after development starts, when the second plane is launched. Four satellites in one plane need two launches (of up to three satellites) half a year apart, and lose 5 points of their 68%; four satellites in two planes lose 5 points of their 70%, and two satellites in two planes 3 points of their 30%. The designs launched at once lose nothing. Over a five-year mission, the loss is the share of the mission before full deployment times the shortfall of the partial constellation: a shorter mission, slower production, or fewer launches a year would weigh deployment more, and could reorder the front." - ] - }, - { - "cell_type": "markdown", - "id": "6613f6b0", - "metadata": {}, - "source": [ - "Each phase is evaluated over the same day of July, as if the geometry of the satellites and the season were those of that day throughout the mission (quasi-static phases, see `evaluate_phases`). This misses the drift of the relative nodes of planes of different inclinations or altitudes (which precess at different rates), the drift of the local times of planes that are not sun-synchronous, and seasons. Here, the planes of each design share an altitude and an inclination, which keeps their relative geometry, and the shares do not depend on the sun, so the day should represent the mission. Drawing the start of the day for each replicate over a year (the `epoch` of the design space, which `Observations` and the metrics read, as an `Uncertain` parameter) averages the replicates over the drift and the seasons, at the cost of analyzing the satellites again for each day:" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "51ea3119", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
descriptionsatellitesplanessufficient mean (July)accurate mean (July)sufficient mean (year)accurate mean (year)sufficient mean sem (year)accurate mean sem (year)
design
163120bf9590800 km, 60 deg FOR, SSO: 1 at 18:001.01.03.22.83.23.00.70.6
f7413b1f8466800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...2.01.016.64.016.22.01.00.7
33b006848799800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.027.330.925.828.81.61.6
d5d3fa915ca7800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...3.01.038.011.437.89.80.50.7
1af5f2707be3800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.063.524.561.722.51.80.8
6ba50f2632cd800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.064.359.362.158.01.51.3
6bef11e40977800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.087.171.186.770.30.20.8
\n", - "
" - ], - "text/plain": [ - " description satellites \\\n", - "design \n", - "163120bf9590 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 \n", - "f7413b1f8466 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 \n", - "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 \n", - "d5d3fa915ca7 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 \n", - "1af5f2707be3 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 \n", - "6ba50f2632cd 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 \n", - "6bef11e40977 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 \n", - "\n", - " planes sufficient mean (July) accurate mean (July) \\\n", - "design \n", - "163120bf9590 1.0 3.2 2.8 \n", - "f7413b1f8466 1.0 16.6 4.0 \n", - "33b006848799 2.0 27.3 30.9 \n", - "d5d3fa915ca7 1.0 38.0 11.4 \n", - "1af5f2707be3 1.0 63.5 24.5 \n", - "6ba50f2632cd 2.0 64.3 59.3 \n", - "6bef11e40977 2.0 87.1 71.1 \n", - "\n", - " sufficient mean (year) accurate mean (year) \\\n", - "design \n", - "163120bf9590 3.2 3.0 \n", - "f7413b1f8466 16.2 2.0 \n", - "33b006848799 25.8 28.8 \n", - "d5d3fa915ca7 37.8 9.8 \n", - "1af5f2707be3 61.7 22.5 \n", - "6ba50f2632cd 62.1 58.0 \n", - "6bef11e40977 86.7 70.3 \n", - "\n", - " sufficient mean sem (year) accurate mean sem (year) \n", - "design \n", - "163120bf9590 0.7 0.6 \n", - "f7413b1f8466 1.0 0.7 \n", - "33b006848799 1.6 1.6 \n", - "d5d3fa915ca7 0.5 0.7 \n", - "1af5f2707be3 1.8 0.8 \n", - "6ba50f2632cd 1.5 1.3 \n", - "6bef11e40977 0.2 0.8 " - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# the leading designs, with the day of the analysis drawn for each replicate over a year\n", - "EPOCH = Uncertain(lambda rng: START + timedelta(days=float(rng.uniform(0, 365))))\n", - "epoch_space = DesignSpace(**{**space.children, \"epoch\": EPOCH}, constraints=space.constraints)\n", - "year = make_study(phased=True, design_space=epoch_space, label=\"over a year\").run(\n", - " [epoch_space.design(by_key[key].decisions) for key in leaders.index]\n", - ")\n", - "MEANS = [\"sufficient mean\", \"accurate mean\"]\n", - "over_year = summarize(year, MEANS, design_columns=[]).set_index(\"design\")\n", - "july = aggregate(phased, MEANS).set_index(\"design\")[MEANS]\n", - "leaders[[\"description\", \"satellites\", \"planes\"]].join(july.add_suffix(\" (July)\")).join(\n", - " over_year[[*MEANS, *(f\"{m} sem\" for m in MEANS)]].add_suffix(\" (year)\")\n", - ").sort_values([\"satellites\", \"planes\"]).round(1)" - ] - }, - { - "cell_type": "markdown", - "id": "5e6d3a10", - "metadata": {}, - "source": [ - "Over the year, the means of the leading designs are within 2.2 points of those of the day in July (and within three standard errors of the year's means), most a little lower: the one day represents the mission well here. A constellation of planes at different altitudes or inclinations, metrics that depend on daylight, or a field that varies with the seasons would call for drawing the epoch. The phases also assume that a satellite operates until it fails or is replaced: a design life does not retire a satellite whose replacement is not launched, and a planned replacement whose launch fails is not flown again (see `DeploymentSchedule`)." - ] - }, - { - "cell_type": "markdown", - "id": "27539bda", - "metadata": {}, - "source": [ - "## Stage the Deployment\n", - "\n", - "A deployment need not commit to every plane at once. A stage of a deployment (`Stage`) is a set of planes produced and launched only if a rule decides to, at times during the mission, from what it knows then (a `Decision`: the satellites operating, what they achieve, and the history so far) and from the values of the design, such as its uncertain parameters and its scenario. A stage that is not deployed is neither produced, launched, nor paid for, so that a staged deployment is an option: it saves the cost of a stage where the mission does not need it, and loses what deferring the stage costs where it does (as above, the capability of the satellites not yet launched). Whether and how to stage is a decision of each design (here, a value `staging` of the design space), and the `stages` of a `MissionPlan` are a function of the design.\n", - "\n", - "Here, the robust design of four satellites across the fields of the scenarios above (two sun-synchronous planes of two) deploys its second plane at once, never, or only if the field turns out to vary within hours (to decorrelate within 6 hours), as decided at the first launch or a year later. These rules read the field from the scenario, which a mission does not know; the last rule reads what the first plane achieves once it is launched (`Decision.capability`, by the study's metrics), and deploys the second plane if the first samples fewer than half the points accurately. Each staging is evaluated in each field by the phases of its deployment: the mean share of points accurately sampled over the mission, and the present cost:" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "8cbfe502", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
accurate meancost present
scenario1 hour3 hours12 hours1 hour3 hours12 hours
staging
at once62.677.991.0156.4156.4156.4
first plane4.810.073.0118.8118.8118.8
decided at launch62.677.973.0156.4156.4118.8
decided a year later49.762.873.0154.5154.5118.8
measured at launch62.677.973.0156.4156.4118.8
\n", - "
" - ], - "text/plain": [ - " accurate mean cost present \\\n", - "scenario 1 hour 3 hours 12 hours 1 hour 3 hours \n", - "staging \n", - "at once 62.6 77.9 91.0 156.4 156.4 \n", - "first plane 4.8 10.0 73.0 118.8 118.8 \n", - "decided at launch 62.6 77.9 73.0 156.4 156.4 \n", - "decided a year later 49.7 62.8 73.0 154.5 154.5 \n", - "measured at launch 62.6 77.9 73.0 156.4 156.4 \n", - "\n", - " \n", - "scenario 12 hours \n", - "staging \n", - "at once 156.4 \n", - "first plane 118.8 \n", - "decided at launch 118.8 \n", - "decided a year later 118.8 \n", - "measured at launch 118.8 " - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import dataclasses\n", - "\n", - "from tatc.tradespace import Stage\n", - "\n", - "STAGING = [\"at once\", \"first plane\", \"decided at launch\", \"decided a year later\", \"measured at launch\"]\n", - "staging_space = DesignSpace(**space.children, staging=Categorical(STAGING), constraints=space.constraints)\n", - "\n", - "\n", - "def stages(d):\n", - " \"\"\"The stages of a design's deployment: its second plane deployed with the first (at once), never (first plane),\n", - " or if the field decorrelates within 6 hours, as decided at the first launch or a year later, or if the first plane\n", - " accurately samples fewer than half the points, as measured at the first launch.\"\"\"\n", - " if d.staging == \"at once\":\n", - " return []\n", - " if d.staging == \"first plane\":\n", - " return [Stage(1, 0.0, lambda decision: False)]\n", - " if d.staging == \"measured at launch\":\n", - " return [Stage(1, 0.0, lambda decision: decision.capability[\"accurate\"] < 50)]\n", - " when = 0.0 if d.staging == \"decided at launch\" else 1.0\n", - " return [Stage(1, when, lambda decision: d.decorrelation_time < timedelta(hours=6))]\n", - "\n", - "\n", - "# the robust design of four satellites across the fields, with each staging of its deployment, in each field\n", - "four = by_key[robust_design[4]]\n", - "staged = make_study(\n", - " phased=True,\n", - " scenarios=FIELDS,\n", - " design_space=staging_space,\n", - " plan=dataclasses.replace(PLAN, stages=stages),\n", - " label=\"staged\",\n", - ").run([staging_space.design({**four.decisions, \"staging\": option}) for option in STAGING])\n", - "staged.groupby([\"staging\", \"scenario\"], sort=False)[[\"accurate mean\", \"cost present\"]].mean().unstack(\"scenario\").round(1)" - ] - }, - { - "cell_type": "markdown", - "id": "34aa9033", - "metadata": {}, - "source": [ - "Deciding at the first launch is worth the most. Where the field varies within hours, the second plane is produced and launched as if it were deployed at once (63% and 78% of the points accurately sampled on average over the mission, for 156 million dollars), and where it varies slowly, it is not, which saves 38 million dollars (24%) for 18 points of the mean (73% against 91%): a trade that the rule makes, and that a mission might not. Deciding a year later costs the fields that need the second plane 13 to 15 points of the mean (50% and 63%), as the first plane flies alone for a year more, and saves only 2 million dollars, by discounting the later production. The value of the option is that of knowing the need when it is exercised: the earlier the field is known, the more staging saves at less loss. The rule that measures makes the same choices as the rule that reads the field, in every field: the first plane alone accurately samples 5% and 10% of the points where the field varies within hours, so that the second plane is deployed, and 73% where it varies over 12 hours, so that it is not. A mission knows what its satellites achieve, not the field, so this is a rule it could follow; a measurement takes time, though (the rule reads at once the capability that the study computes), and one that waits a year to measure loses what deciding a year later loses above. A rule may also read the satellites still operating (see `Decision`), for a reserve plane launched only if satellites fail, or their capability, for one launched only if those in orbit fall short." - ] - }, - { - "cell_type": "markdown", - "id": "c5d4e7f6", - "metadata": {}, - "source": [ - "## Screen Designs with a Cheaper Analysis\n", - "\n", - "Evaluating every design is affordable here, but not for larger spaces or longer analyses. `screen` evaluates every design with a cheap study, keeps the best (whole fronts, until it keeps at least `keep` of them), and evaluates only those with the full study. A cheap study ranks designs less exactly, so a `tolerance` of an objective keeps designs that are within it of the front of the cheap study.\n", - "\n", - "The cheap study must rank designs as the full study would. Here, the screening study analyzes one replicate, rather than five, over a shorter period, with the threshold of sufficient sampling scaled to the period: 12 hours with two observations, or 6 hours with one. The table compares each screening's front with the true front (how many of its efficient designs it keeps, and its hypervolume), and its cost (the satellites analyzed times the days of their analyses) with that of evaluating every design." - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "d6e5f8a7", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-11T23:53:30.505473Z", - "iopub.status.busy": "2026-11-11T23:53:30.505473Z", - "iopub.status.idle": "2026-11-11T23:54:06.880457Z", - "shell.execute_reply": "2026-11-11T23:54:06.880457Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
screening studykeep (%)tolerance (%)designs keptefficient designs kepthypervolume (% of true front)cost (% of every design)
012 h, 1 replicate5.0NaN744 of 798.816.9
112 h, 1 replicate10.05.02487 of 7100.029.2
26 h, 1 replicate5.0NaN621 of 783.010.6
36 h, 1 replicate20.0NaN2315 of 796.625.1
\n", - "
" - ], - "text/plain": [ - " screening study keep (%) tolerance (%) designs kept \\\n", - "0 12 h, 1 replicate 5.0 NaN 74 \n", - "1 12 h, 1 replicate 10.0 5.0 248 \n", - "2 6 h, 1 replicate 5.0 NaN 62 \n", - "3 6 h, 1 replicate 20.0 NaN 231 \n", - "\n", - " efficient designs kept hypervolume (% of true front) \\\n", - "0 4 of 7 98.8 \n", - "1 7 of 7 100.0 \n", - "2 1 of 7 83.0 \n", - "3 5 of 7 96.6 \n", - "\n", - " cost (% of every design) \n", - "0 16.9 \n", - "1 29.2 \n", - "2 10.6 \n", - "3 25.1 " - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from tatc.tradespace import screen\n", - "\n", - "full_cost = results.satellites.sum() * DURATION / timedelta(days=1) # satellite-days of analysis\n", - "true_front = set(summary.design[summary.pareto])\n", - "screenings = []\n", - "for hours, keep, tolerance in [(12, 0.05, None), (12, 0.1, 5.0), (6, 0.05, None), (6, 0.2, None)]:\n", - " screening = screen(\n", - " designs,\n", - " [make_study(timedelta(hours=hours), replicates=1), make_study()],\n", - " OBJECTIVES,\n", - " keep=keep,\n", - " tolerance=None if tolerance is None else {\"sufficient\": tolerance},\n", - " )\n", - " # the satellite-days of the analyses of each stage\n", - " days = screening.results.stage.map({0: hours / 24, 1: DURATION / timedelta(days=1)})\n", - " screenings.append(\n", - " {\n", - " \"screening study\": f\"{hours} h, 1 replicate\",\n", - " \"keep (%)\": 100 * keep,\n", - " \"tolerance (%)\": tolerance,\n", - " \"designs kept\": len(screening.designs),\n", - " \"efficient designs kept\": f\"{len(true_front & {d.key for d in screening.designs})} of {len(true_front)}\",\n", - " \"hypervolume (% of true front)\": 100 * hypervolume(screening.final, OBJECTIVES, REFERENCE) / exact_hypervolume,\n", - " \"cost (% of every design)\": 100 * (screening.results.satellites * days).sum() / full_cost,\n", - " }\n", - " )\n", - "pd.DataFrame(screenings).round(1)" - ] - }, - { - "cell_type": "markdown", - "id": "e7f6a9b8", - "metadata": {}, - "source": [ - "The 12-hour screening study ranks designs nearly as the full study does. Keeping the best 5% of the designs finds a front with 99% of the hypervolume of the true front at 17% of the cost of evaluating every design, although it misses three of the seven efficient designs, whose places designs with nearly the same objectives take. Keeping 10%, with a tolerance of 5 percentage points, keeps every efficient design at 29% of the cost.\n", - "\n", - "The 6-hour screening study is cheaper, but ranks designs differently: one observation of a point in 6 hours separates designs less than four observations in a day do. Keeping 5% of the designs keeps only one of the seven efficient ones (83% of the hypervolume), and keeping 20% still misses two of them (97% of the hypervolume) at 25% of the cost, nearly as much as the 12-hour study that keeps them all. How many designs to keep depends on how well the cheap study ranks designs, which is worth checking on a sample of designs evaluated with both studies before screening a larger space." - ] - }, - { - "cell_type": "markdown", - "id": "f8a7b0c9", - "metadata": {}, - "source": [ - "## Search with Optimizers\n", - "\n", - "Larger design spaces cannot be enumerated or even screened, and an optimizer searches them for efficient designs instead. `optimize_optuna` suggests designs with Optuna's trials, which search the hierarchical design space directly (`DesignSpace.suggest`), and records the violation of the constraint of each infeasible design, which Optuna's samplers use to prefer feasible designs. `optimize_pymoo` searches the unit hypercube that encodes the design space (`DesignSpace.decode`) with a pymoo algorithm, which eliminates the proposals of designs proposed or evaluated before: many points of the hypercube decode to the same design (those in the same level of each variable, or that differ only in the variables of a branch not chosen), which pymoo's own elimination of equal points does not see. Both evaluate each design once, however often it is proposed, and evaluate the designs proposed together in parallel. A search chooses its front from one evaluation of each design, which favors designs whose replicates were lucky: its designs and results (a `Search`) are refined and confirmed as above.\n", - "\n", - "Each search below is given a budget of about 200 proposals, and is compared with a Latin hypercube sample of 200 designs (`DesignSpace.sample`). The designs evaluated (and the analyses of their satellites) are those of the evaluation of every design above, so they are retrieved from the cache." - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "a9b8c1d0", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-11T23:54:06.880457Z", - "iopub.status.busy": "2026-11-11T23:54:06.880457Z", - "iopub.status.idle": "2026-11-11T23:54:08.116915Z", - "shell.execute_reply": "2026-11-11T23:54:08.116915Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
designs evaluatedhypervolume (% of true front)
Optuna (NSGA-II)143.092.1
pymoo (NSGA-II)166.0100.0
Latin hypercube sample176.079.3
\n", - "
" - ], - "text/plain": [ - " designs evaluated hypervolume (% of true front)\n", - "Optuna (NSGA-II) 143.0 92.1\n", - "pymoo (NSGA-II) 166.0 100.0\n", - "Latin hypercube sample 176.0 79.3" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import optuna\n", - "from pymoo.algorithms.moo.nsga2 import NSGA2\n", + "import optuna\n", + "from pymoo.algorithms.moo.nsga2 import NSGA2\n", "\n", "from tatc.tradespace import hypervolume_progress, optimize_optuna, optimize_pymoo\n", "\n", "optuna.logging.set_verbosity(optuna.logging.WARNING)\n", "BUDGET = 200\n", - "study = make_study()\n", "searches = {}\n", "searches[\"Optuna (NSGA-II)\"] = optimize_optuna(\n", " study,\n", @@ -6097,14 +1331,14 @@ }, { "cell_type": "code", - "execution_count": 30, - "id": "b0c9d2e1", + "execution_count": 12, + "id": "562e2055", "metadata": { "execution": { - "iopub.execute_input": "2026-11-11T23:54:08.116915Z", - "iopub.status.busy": "2026-11-11T23:54:08.116915Z", - "iopub.status.idle": "2026-11-11T23:54:08.211848Z", - "shell.execute_reply": "2026-11-11T23:54:08.211848Z" + "iopub.execute_input": "2026-11-12T17:17:10.740726Z", + "iopub.status.busy": "2026-11-12T17:17:10.740726Z", + "iopub.status.idle": "2026-11-12T17:17:10.852067Z", + "shell.execute_reply": "2026-11-12T17:17:10.852067Z" } }, "outputs": [ @@ -6133,7 +1367,7 @@ }, { "cell_type": "markdown", - "id": "c1d0e3f2", + "id": "1e082131", "metadata": {}, "source": [ "Both optimizers find more of the hypervolume than a Latin hypercube sample of as many designs. Optuna (NSGA-II, searching the hierarchical space directly) finds 92% of the hypervolume of the true front with 143 designs, 13% of the space. pymoo (NSGA-II, searching the encoded space) finds all of it with 166 designs: it proposes no design twice, and its other 34 proposals violate the constraint on the number of satellites (without eliminating duplicates by design, its 200 proposals encoded only 75 designs, which found 88%). The sample finds 79% with 176 designs. The searches stop at their budget of proposals, not at convergence: a larger budget, or screening, would bring Optuna's closer to the true front. Their results also depend on their seeds (over eight seeds, pymoo's search finds 88 to 100% of the hypervolume, 96.5% on average), so compare several seeds before relying on one." @@ -6141,73 +1375,20 @@ }, { "cell_type": "markdown", - "id": "7d3e9a41", - "metadata": {}, - "source": [ - "A search for designs robust to the field evaluates each design that it proposes in every field, and judges it by criteria `across` the fields: here pymoo's, by the mean share accurately sampled over the three fields, with as many proposals as above. Its evaluations are those of the comparison of the fields above, retrieved from the store:" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "b52c0f86", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "147 designs evaluated (in 3 fields each): 99.3% of the hypervolume of the true front, and 8 of its 12 designs\n" - ] - } - ], - "source": [ - "# a search for the designs most accurate on average over the fields, against the true front of every design\n", - "FIELD_MEAN = Criteria(ACCURACY, across=Across(rule=\"mean\"))\n", - "ACCURATE_REFERENCE = {\"satellites\": REFERENCE[\"satellites\"], \"planes\": REFERENCE[\"planes\"], \"accurate\": 0}\n", - "field_search = optimize_pymoo(\n", - " make_study(scenarios=FIELDS), FIELD_MEAN, NSGA2(pop_size=20), (\"n_gen\", BUDGET // 20), seed=1\n", - ")\n", - "field_progress = hypervolume_progress(field_search.results, FIELD_MEAN, ACCURATE_REFERENCE)\n", - "true_mean = hypervolume(aggregate(fields, FIELD_MEAN), FIELD_MEAN, ACCURATE_REFERENCE)\n", - "evaluated = set(field_search.results.design)\n", - "print(\n", - " f\"{len(evaluated)} designs evaluated (in {len(FIELDS)} fields each): \"\n", - " f\"{100 * field_progress.iloc[-1] / true_mean:.1f}% of the hypervolume of the true front, \"\n", - " f\"and {len(evaluated & fronts['mean'])} of its {len(fronts['mean'])} designs\"\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "e81f4d27", - "metadata": {}, - "source": [ - "The search finds 99.3% of the hypervolume of the true front of the mean with 147 designs, and 8 of its 12 designs; each design costs three times as much as in a search of one field, as it is evaluated in each field. Its designs and results refine and confirm its front as for any study, with the same criteria. A search by the worst would search mostly the field of 1 hour here (see Compare Designs across Scenarios)." - ] - }, - { - "cell_type": "markdown", - "id": "d2e1f4a3", + "id": "bcc66e31", "metadata": {}, "source": [ "## Summary\n", "\n", "* A `DesignSpace` declares a hierarchical trade space, with choices between alternatives (`Choice`), repeated elements such as orbit planes (`Repeat`), bounds that depend on other variables, constraints that measure their violation, and uncertain parameters (`Uncertain`) drawn for each replicate. Building blocks declare common constellation layouts (`walker_space` and `sso_planes_space`) and build their satellites with instruments or entries of the instrument catalog (`build_constellation`).\n", - "* An `ObservationStudy` (a `Study` of the observations of `Targets`, with a `MissionPlan` of deployment and costs, and `Failures`) evaluates designs in replicates (here, of points of a randomly oriented lattice, `generate_points_rotated_lattice`, which vary less between replicates than random points), in parallel, with a cache of `Observations` that analyzes each distinct satellite once and a `ResultStore` that keeps its evaluations (by the fingerprint of the study, which describes its targets and the code of TAT-C it uses, so that a changed study evaluates its designs again, and says why). Every design of a space of about a thousand designs can be evaluated in minutes.\n", - "* Statistical sufficiency is measured by the sampling error of the statistic that observations estimate (`tatc.analysis.estimate_sampling_error`), which counts of samples overstate when samples cluster in time, as they do in a single plane; revisit statistics and local time coverage explain it.\n", - "* The front of the means of the replicates is uncertain: `pareto_probability` finds the designs whose efficiency the replicates settle, and those that are equally good candidates, and `refine` adds replicates only to the latter, with a tolerance of differences that do not matter. `confirm` evaluates the selected designs with new replicates, which removes the optimism of selecting the best of many nearly equal designs.\n", - "* Statistics other than means (such as a `Quantile` or the `Probability` of meeting a threshold) state how reliably a design performs, and `Requirement`s on them are output constraints. Simulated missions (`Deployment.simulate`) draw the failures of satellites and launches from lives whose failure rates vary over the lifecycle (`FailureModel`), and restore them or not (`RestorationPolicy`, by spares in orbit or on the ground, or by producing new ones), for both the cost and the capability of each policy (exactly, without sampling, for missions that do not restore failed satellites: `expected_missions`); the policy is a decision of each design (`policy_space`, configured by `configure`), on the front with the design. `sensitivity` finds the design variables that drive each objective, and `attribute_variance` the uncertain parameters that spread the replicates of each design (by drawing each again with the others held): here, the sample of points spreads the mean shares and the histories of failures their worst 10%, which says what would sharpen each, and the growth of costs spreads the costs of designs alike, so that it cancels in their differences (`Attribution.differences`) and does not change their order.\n", - "* The `scenarios` of a study compare designs under conditions rather than averaging over them (here, fields of different decorrelation times, a value of the design space): criteria `by` the scenario give the front of each, and `robustness` the share of the scenarios in which each design is efficient (its Pareto trace) and its regret in each, whose least maximum is a robust choice (here, six satellites efficient in no field but never half a point behind the best). Criteria `across` the scenarios (`Across`) judge each design once, by its worst or its mean over them, as a search for robust designs needs: here the worst is mostly the field that varies fastest, and pymoo's search by the mean finds nearly all of the front of the mean.\n", + "* An `ObservationStudy` (a `Study` of the observations of `Targets`, with a `MissionPlan` of deployment and costs) evaluates designs in replicates (here, of points of a randomly oriented lattice, `generate_points_rotated_lattice`, which vary less between replicates than random points), in parallel, with a cache of `Observations` that analyzes each distinct satellite once and a `ResultStore` that keeps its evaluations (by the fingerprint of the study, which describes its targets and the code of TAT-C it uses, so that a changed study evaluates its designs again). Every design of a space of about a thousand designs can be evaluated in minutes, and `Study.replace` makes variants of a study.\n", + "* A summary of the results (`summarize`, or `aggregate`) has a row per design, with its values, for `pareto_front` and `plot_designs`. Statistical sufficiency is measured by the sampling error of the statistic that observations estimate (`tatc.analysis.estimate_sampling_error`), which counts of samples overstate when samples cluster in time, as they do in a single plane; revisit statistics and local time coverage explain it. `sensitivity` finds the design variables that drive each objective.\n", "* `screen` evaluates every design with a cheap study and the best with the full one, which finds the front at a fraction of the cost if the cheap study ranks designs as the full one does.\n", - "* A `Utility` weighs metrics by a stakeholder's preferences (a single-attribute utility of each, combined by weights) into one objective against cost, and is a metric of any statistic (its mean is the expected utility): here, stakeholders who weigh sufficiency or accuracy most agree within the budget and part beyond it.\n", - "* A `DeploymentSchedule` plans each design's deployment from rates of production and launch, which dates its costs and divides its mission into phases of the satellites that fly, evaluated with the observations of the full constellation (over one day, which an epoch drawn for each replicate shows to represent the mission here) for the mean capability over the mission and the time until a requirement is met.\n", - "* A `Stage` of a deployment is produced and launched only if a rule decides to, from what is known then (a `Decision`) and the values of the design: an option whose value the analyses of a study measure (here, deciding at the first launch whether the field needs a second plane saves 38 million dollars where it does not, at no loss where it does, and deciding a year later loses 13 to 15 points of the mean where it does). A rule may read what the satellites in orbit achieve (`Decision.capability`): here, a second plane deployed if the first accurately samples fewer than half the points makes the same choices without knowing the field.\n", - "* A `CostModel` estimates the life-cycle cost of each deployment from the costs of its satellites, launches, and operations (given by the study), with uncertain growth whose quantiles give the cost at a confidence level, as an objective or a requirement in place of the numbers of satellites and planes.\n", - "* `optimize_optuna` and `optimize_pymoo` search spaces too large to enumerate, and find most of the front with a fraction of the designs (`hypervolume_progress`), pymoo's proposing no design twice (by design, not by point of the encoded space).\n", - "* `plot_designs` and `plot_progress` plot the designs, with the efficient ones ringed, and the progress of searches.\n", + "* `optimize_optuna` and `optimize_pymoo` search spaces too large to enumerate, and find most of the front with a fraction of the designs (`hypervolume_progress`), pymoo's proposing no design twice (by design, not by point of the encoded space). `plot_designs` and `plot_progress` plot the designs, with the efficient ones ringed, and the progress of searches.\n", + "\n", + "The examples that follow take the trade further: ranking designs with the uncertainty of their replicates (`RankUncertainDesigns`), comparing them across scenarios (`CompareScenarios`), trading their cost and utility (`TradeCostAndUtility`), and planning their deployment and failures (`PlanMissions`).\n", "\n", - "The sampling error here is that of a model of the field (an exponential correlation in time with a decorrelation time of 3 hours); with a simulation of the field (a nature run), `tatc.analysis.sample_field` and `compare_sampled_means` measure it directly. The costs are illustrative, and the numbers of satellites and planes, proxies of cost in the other sections. The uncertainties are those of the sample of points and the failures of satellites; others (such as the phase of the satellites or the period of the analysis) are further `Uncertain` parameters of the design space." + "The sampling error here is that of a model of the field (an exponential correlation in time with a decorrelation time of 3 hours); with a simulation of the field (a nature run), `tatc.analysis.sample_field` and `compare_sampled_means` measure it directly. The uncertainty here is that of the sample of points; others (such as the phase of the satellites or the period of the analysis) are further `Uncertain` parameters of the design space." ] } ], diff --git a/docs/examples/TradeCostAndUtility.ipynb b/docs/examples/TradeCostAndUtility.ipynb new file mode 100644 index 00000000..f10ed6b4 --- /dev/null +++ b/docs/examples/TradeCostAndUtility.ipynb @@ -0,0 +1,660 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1a498cec", + "metadata": {}, + "source": [ + "# Trade Cost and Utility\n", + "\n", + "This example demonstrates how to trade the life-cycle cost of designs against what they achieve with the `tatc.tradespace` module: costs estimated from a cost model and each design's deployment, with uncertain growth whose quantiles give the cost at a confidence level, a budget as a requirement, and utilities that weigh several objectives by a stakeholder's preferences.\n", + "\n", + "It continues the example `SearchTradeSpace`, whose design space and study it imports from `trade_space_example.py` (beside the notebooks). The evaluations of every design are taken from the study's store if `SearchTradeSpace` was run before (or are evaluated again, in a few minutes). Its replicates are refined where the efficiency of designs is uncertain, as in `RankUncertainDesigns` (from the store, if that example was run before)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "38ec6b1f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-12T17:21:07.465585Z", + "iopub.status.busy": "2026-11-12T17:21:07.465585Z", + "iopub.status.idle": "2026-11-12T17:21:34.293683Z", + "shell.execute_reply": "2026-11-12T17:21:34.292062Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5695 evaluations\n" + ] + } + ], + "source": [ + "from trade_space_example import OBJECTIVES, describe, designs, planes_name, study\n", + "from tatc.tradespace import Criteria, refine\n", + "\n", + "# the evaluations of every design, with replicates added where their efficiency is uncertain (see RankUncertainDesigns)\n", + "results = study.run(designs)\n", + "TOLERANCE = {\"sufficient\": 1.0} # percentage points of the share that do not matter\n", + "CRITERIA = Criteria(OBJECTIVES, tolerance=TOLERANCE)\n", + "refinement = refine(study, CRITERIA, results, step=5, max_replicates=40, precision=0.5, n_resamples=1000)\n", + "print(f\"{len(refinement.results)} evaluations\")" + ] + }, + { + "cell_type": "markdown", + "id": "16b35cc8", + "metadata": {}, + "source": [ + "## Trade Cost Against Sufficiency\n", + "\n", + "The numbers of satellites and planes are proxies of cost. A `CostModel` estimates the life-cycle cost of each design from the costs of its satellites (the development of each type, and the production of its units on a learning curve), launches (here, a small launcher for every three satellites of a plane), and operations, given by the study (TAT-C does not include cost-estimating relationships). The costs here are illustrative, in millions of dollars. The evaluation adds the cost and its elements to each record (and the years by which the design is `deployed`), for the satellites of each design's imager (`kind`): a wider field of regard costs more to develop and build. The deployment of each design (`DeploymentSchedule.plan`) dates the costs, from rates, so that each design's schedule follows from its satellites and planes: development over three years, then the production of the satellites on one line at four a year, plane by plane, each plane launched when its satellites are ready (in launches of up to three satellites, at most one every half year), and operations from each launch to the end of the mission (five years after the first launch). The dated costs give the present value of the cost (`cost present`, discounted at 3% a year) and the cost of the most expensive year (`cost peak annual`), for annual budgets.\n", + "\n", + "The growth of the cost of development is uncertain (an `Uncertain` parameter, from 0.9 to 1.6 times the estimate, most likely 1), drawn for each replicate, so that statistics over the replicates give the cost at a confidence level: here, the 0.7 quantile (`cost p70`), as budgets are often set. A requirement keeps the designs whose cost at 70% confidence is within a budget, and the front trades this cost against the share of points sufficiently sampled. (Cost depends only on the design, so a constraint of the design space could exclude designs over a budget before they are evaluated, with the cost without growth.)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "30e16c98", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-12T17:21:34.297309Z", + "iopub.status.busy": "2026-11-12T17:21:34.296795Z", + "iopub.status.idle": "2026-11-12T17:21:37.440566Z", + "shell.execute_reply": "2026-11-12T17:21:37.438573Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "520 of 1096 designs cost at most 150 at 70% confidence, of which 46 are efficient in at least half of the resamples\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanesdeployedcost p70cost developmentcost productioncost launchcost operationscost presentcost peak annualsufficientpareto_probability
635700 km, 30 deg FOR, SSO: 1 at 06:00113.283.644.412.08.017.575.523.51.01.0
910800 km, 30 deg FOR, SSO: 2 at 06:00213.596.944.422.88.020.087.230.82.60.9
826800 km, 30 deg FOR, Walker 45 deg: 2 x 1 (spac...223.8104.744.422.816.019.894.342.36.20.9
824800 km, 30 deg FOR, Walker 45 deg: 1 x 3 (spac...313.8109.644.433.08.022.598.241.07.81.0
835800 km, 30 deg FOR, Walker 45 deg: 3 x 1 (spac...334.2124.844.433.024.021.8112.252.511.21.0
828800 km, 30 deg FOR, Walker 45 deg: 2 x 2 (spac...424.0129.344.442.716.024.5115.950.722.21.0
963800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...223.8139.266.734.216.019.8126.053.730.21.0
845800 km, 30 deg FOR, Walker 45 deg: 4 x 1 (spac...444.8144.344.442.732.023.5129.262.231.00.7
961800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...313.8149.166.749.48.022.5134.457.438.00.6
\n", + "
" + ], + "text/plain": [ + " description satellites planes \\\n", + "635 700 km, 30 deg FOR, SSO: 1 at 06:00 1 1 \n", + "910 800 km, 30 deg FOR, SSO: 2 at 06:00 2 1 \n", + "826 800 km, 30 deg FOR, Walker 45 deg: 2 x 1 (spac... 2 2 \n", + "824 800 km, 30 deg FOR, Walker 45 deg: 1 x 3 (spac... 3 1 \n", + "835 800 km, 30 deg FOR, Walker 45 deg: 3 x 1 (spac... 3 3 \n", + "828 800 km, 30 deg FOR, Walker 45 deg: 2 x 2 (spac... 4 2 \n", + "963 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2 2 \n", + "845 800 km, 30 deg FOR, Walker 45 deg: 4 x 1 (spac... 4 4 \n", + "961 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3 1 \n", + "\n", + " deployed cost p70 cost development cost production cost launch \\\n", + "635 3.2 83.6 44.4 12.0 8.0 \n", + "910 3.5 96.9 44.4 22.8 8.0 \n", + "826 3.8 104.7 44.4 22.8 16.0 \n", + "824 3.8 109.6 44.4 33.0 8.0 \n", + "835 4.2 124.8 44.4 33.0 24.0 \n", + "828 4.0 129.3 44.4 42.7 16.0 \n", + "963 3.8 139.2 66.7 34.2 16.0 \n", + "845 4.8 144.3 44.4 42.7 32.0 \n", + "961 3.8 149.1 66.7 49.4 8.0 \n", + "\n", + " cost operations cost present cost peak annual sufficient \\\n", + "635 17.5 75.5 23.5 1.0 \n", + "910 20.0 87.2 30.8 2.6 \n", + "826 19.8 94.3 42.3 6.2 \n", + "824 22.5 98.2 41.0 7.8 \n", + "835 21.8 112.2 52.5 11.2 \n", + "828 24.5 115.9 50.7 22.2 \n", + "963 19.8 126.0 53.7 30.2 \n", + "845 23.5 129.2 62.2 31.0 \n", + "961 22.5 134.4 57.4 38.0 \n", + "\n", + " pareto_probability \n", + "635 1.0 \n", + "910 0.9 \n", + "826 0.9 \n", + "824 1.0 \n", + "835 1.0 \n", + "828 1.0 \n", + "963 1.0 \n", + "845 0.7 \n", + "961 0.6 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import Quantile, Requirement, aggregate, pareto_probability\n", + "\n", + "BUDGET = 150 # millions of dollars, at 70% confidence\n", + "COST = Criteria(\n", + " {\"cost p70\": \"min\", \"sufficient\": \"max\"},\n", + " statistics={\"cost p70\": Quantile(\"cost\", 0.7)},\n", + " requirements=[Requirement(\"cost p70\", \"<=\", BUDGET)],\n", + " tolerance=TOLERANCE,\n", + ")\n", + "ELEMENTS = [\"cost development\", \"cost production\", \"cost launch\", \"cost operations\"]\n", + "DATED = [\"cost present\", \"cost peak annual\"]\n", + "\n", + "# the probability that each design is efficient, with its values (such as its satellites and planes, and the years by\n", + "# which it is deployed), and the means of the elements of its cost\n", + "costed = pareto_probability(refinement.results, COST, n_resamples=1000)\n", + "means = aggregate(refinement.results, [*ELEMENTS, *DATED], design_columns=[]).set_index(\"design\")\n", + "costed[[*ELEMENTS, *DATED]] = means.loc[costed.design, [*ELEMENTS, *DATED]].to_numpy()\n", + "costed[\"description\"] = costed.apply(describe, axis=1)\n", + "efficient = costed[costed.pareto_probability >= 0.5]\n", + "print(\n", + " f\"{costed.meets_requirements.sum()} of {len(costed)} designs cost at most {BUDGET} at 70% confidence, \"\n", + " + f\"of which {len(efficient)} are efficient in at least half of the resamples\"\n", + ")\n", + "# the most sufficient of these at each cost\n", + "efficient.sort_values([\"cost p70\", \"sufficient\"], ascending=[True, False]).drop_duplicates(\"cost p70\")[\n", + " [\"description\", \"satellites\", \"planes\", \"deployed\", \"cost p70\", *ELEMENTS, *DATED, \"sufficient\", \"pareto_probability\"]\n", + "].round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "164eba41", + "metadata": {}, + "source": [ + "520 of the 1,096 designs cost at most 150 million dollars at 70% confidence. Along the front, money buys sufficiency in steps: one satellite (84 million at 70% confidence, of which 44 million on average develops it) samples 1% of the points sufficiently; a second satellite in its plane, 3%, and in a second plane, 6%; four satellites in two Walker planes (129 million), 22%. The planes now have a price: four satellites in four planes sample more points sufficiently than in two (31% against 22%, as more planes spread the samples in time), at twice the cost of launches (32 million against 16). The wider field of regard joins the front only near the budget, where its development (67 million against 44) is worth its swath: two satellites with the wider imager sample 30% of the points for 139 million, about as many as four with the narrower one in four planes, and three of them 38% for 149 million, the most within the budget. The designs that sample nearly every point (six to nine satellites) cost more than the budget.\n", + "\n", + "Each design's schedule follows from its satellites and planes (`deployed`, years from the start of development to the launch of its last plane): one satellite is launched 3.2 years after development starts; four satellites in two planes take a year to produce, and are deployed after 4.0 years; and four satellites in four planes, after 4.8 years, as each plane takes a launch and launches are half a year apart. Dated, the costs are worth 8 to 9% less at present (at 3% a year), as most are incurred three or more years from now. The most expensive year is the one after development, in which the satellites are produced and the first are launched: four satellites in four planes need 62 million in that year, and one satellite 24 million. A budget of annual funding would limit the satellites produced in a year, which a slower production rate would spread over more years, at the cost of deploying later.\n", + "\n", + "The growth of the cost of development affects every design alike in a replicate (common random numbers), so it shifts the costs at 70% confidence more for designs whose development costs more, here those of the wider imager. With five replicates of most designs, the 0.7 quantile of their costs is a coarse estimate: an evaluation that costs little more than the cost model (unlike the analysis of sampling) could draw more replicates of the cost alone." + ] + }, + { + "cell_type": "markdown", + "id": "b41fbb9e", + "metadata": {}, + "source": [ + "## Trade Utility Against Cost\n", + "\n", + "Sufficiency and accuracy are objectives of `SearchTradeSpace`, each in its own units. A stakeholder who values both weighs them, and a utility makes the weights explicit (`Utility`): a single-attribute utility of each metric, from 0 at its worst acceptable value to 1 at its best (here, linear in the share of points sampled sufficiently, `LinearUtility`, and concave in the share sampled accurately, `ExponentialUtility`, as the first points accurately sampled matter most), combined by weights. Two stakeholders weigh the shares differently: one mostly sufficiency (0.7 against 0.3), as a center that counts samples for forecasts might, and the other mostly accuracy (0.3 against 0.7), as one that estimates daily means might. Each design's utility is that of its means: the shares vary between replicates mostly as noise of the sample of points, which the expected utility (the mean of the utility of each replicate, `Mean(utility)`) would penalize as if it were a risk. The figure plots each stakeholder's utility of every design against its cost at 70% confidence (as above), with the front of each ringed:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "1d83ea69", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-12T17:21:37.444572Z", + "iopub.status.busy": "2026-11-12T17:21:37.443572Z", + "iopub.status.idle": "2026-11-12T17:21:38.748571Z", + "shell.execute_reply": "2026-11-12T17:21:38.747456Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "from tatc.tradespace import ExponentialUtility, LinearUtility, Utility, pareto_front, plot_designs, style_axes\n", + "from tatc.tradespace.plotting import GRAY\n", + "\n", + "# the utility of the shares sampled sufficiently (linear) and accurately (concave: the first points matter most), for\n", + "# two stakeholders who weigh them differently\n", + "CURVES = {\"sufficient\": LinearUtility(0, 100), \"accurate\": ExponentialUtility(0, 100, risk=2)}\n", + "STAKEHOLDERS = {\n", + " \"sufficiency\": Utility(CURVES, weights={\"sufficient\": 0.7, \"accurate\": 0.3}),\n", + " \"accuracy\": Utility(CURVES, weights={\"sufficient\": 0.3, \"accurate\": 0.7}),\n", + "}\n", + "means = aggregate(\n", + " refinement.results,\n", + " statistics={\"sufficient\": \"sufficient\", \"accurate\": \"accurate\", \"cost p70\": Quantile(\"cost\", 0.7)},\n", + ").set_index(\"design\")\n", + "means[\"description\"] = means.apply(describe, axis=1)\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(11, 4.5), sharey=True)\n", + "judged = {}\n", + "for ax, (name, utility) in zip(axes, STAKEHOLDERS.items()):\n", + " judged[name] = means.assign(utility=utility(means))\n", + " judged[name][\"pareto\"] = pareto_front(judged[name], {\"utility\": \"max\", \"cost p70\": \"min\"})\n", + " legend = \"lower right\" if ax is axes[0] else None\n", + " plot_designs(judged[name], \"cost p70\", \"utility\", by=\"planes\", front=\"pareto\", names=planes_name, legend=legend, ax=ax)\n", + " ax.axvline(BUDGET, color=GRAY, lw=1, ls=\"--\")\n", + " ax.set(xlabel=\"Cost at 70% confidence (millions of dollars)\", ylabel=\"Utility\", ylim=(0, 1.02))\n", + " ax.set_title(f\"Weighing {name} most\", fontsize=10)\n", + " style_axes(ax, grid=\"both\")\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f055925e", + "metadata": {}, + "source": [ + "The stakeholders' fronts share most of their designs. Those efficient for one stakeholder and not the other:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "182b77eb", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-12T17:21:38.751636Z", + "iopub.status.busy": "2026-11-12T17:21:38.751636Z", + "iopub.status.idle": "2026-11-12T17:21:38.772519Z", + "shell.execute_reply": "2026-11-12T17:21:38.771429Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "20 designs are efficient for both\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanessufficientaccuratecost p70utility (sufficiency)efficient (sufficiency)utility (accuracy)efficient (accuracy)
design
828c0027d01f800 km, 60 deg FOR, SSO: 1 at 12:00, 2 at 18:003229.257.0156.650.44False0.64True
c576e2e2dbd1800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:003228.860.6156.900.45False0.66True
6ba50f2632cd800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4269.665.4173.730.74True0.80False
3690f1194419800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:004257.685.4173.730.69False0.84True
64cf6542c326800 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...6390.295.8213.530.93False0.96True
\n", + "
" + ], + "text/plain": [ + " description satellites \\\n", + "design \n", + "828c0027d01f 800 km, 60 deg FOR, SSO: 1 at 12:00, 2 at 18:00 3 \n", + "c576e2e2dbd1 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3 \n", + "6ba50f2632cd 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4 \n", + "3690f1194419 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4 \n", + "64cf6542c326 800 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... 6 \n", + "\n", + " planes sufficient accurate cost p70 utility (sufficiency) \\\n", + "design \n", + "828c0027d01f 2 29.2 57.0 156.65 0.44 \n", + "c576e2e2dbd1 2 28.8 60.6 156.90 0.45 \n", + "6ba50f2632cd 2 69.6 65.4 173.73 0.74 \n", + "3690f1194419 2 57.6 85.4 173.73 0.69 \n", + "64cf6542c326 3 90.2 95.8 213.53 0.93 \n", + "\n", + " efficient (sufficiency) utility (accuracy) \\\n", + "design \n", + "828c0027d01f False 0.64 \n", + "c576e2e2dbd1 False 0.66 \n", + "6ba50f2632cd True 0.80 \n", + "3690f1194419 False 0.84 \n", + "64cf6542c326 False 0.96 \n", + "\n", + " efficient (accuracy) \n", + "design \n", + "828c0027d01f True \n", + "c576e2e2dbd1 True \n", + "6ba50f2632cd False \n", + "3690f1194419 True \n", + "64cf6542c326 True " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# the designs efficient for one stakeholder and not the other\n", + "compared = means[[\"description\", \"satellites\", \"planes\", \"sufficient\", \"accurate\", \"cost p70\"]].copy()\n", + "for name in STAKEHOLDERS:\n", + " compared[f\"utility ({name})\"] = judged[name][\"utility\"]\n", + " compared[f\"efficient ({name})\"] = judged[name][\"pareto\"]\n", + "print(f\"{(compared['efficient (sufficiency)'] & compared['efficient (accuracy)']).sum()} designs are efficient for both\")\n", + "compared[compared[\"efficient (sufficiency)\"] != compared[\"efficient (accuracy)\"]].sort_values(\"cost p70\").round(2)" + ] + }, + { + "cell_type": "markdown", + "id": "eca76b2c", + "metadata": {}, + "source": [ + "Within the budget, the stakeholders agree: every design efficient for either of them up to 150 million dollars is efficient for both, as more satellites in more planes buy both shares. Beyond the budget, they part. For 174 million dollars at 70% confidence, the stakeholder of sufficiency prefers four satellites in two Walker planes (70% of the points sufficiently sampled and 65% accurately), and the stakeholder of accuracy four in two sun-synchronous planes crossing at 09:00 and 15:00 (58% and 85%), whose planes spread the samples over the day. The stakeholder of accuracy also finds three satellites in two sun-synchronous planes efficient for 157 million (57 to 61% accurately sampled), and six in three Walker planes for 214 million (96%), which the stakeholder of sufficiency passes over. A utility is a metric of any statistic (such as `Quantile(utility, 0.1)`, the utility that a design exceeds in 90% of the replicates, for risks that the replicates draw) and so an objective of the searches as well; a multiplicative utility (`form=\"multiplicative\"`) makes the shares complements, both of which a design must serve, or substitutes, either of which suffices." + ] + }, + { + "cell_type": "markdown", + "id": "9e616895", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "* A `CostModel` estimates the life-cycle cost of each deployment from the costs of its satellites, launches, and operations (given by the study, as TAT-C includes no cost-estimating relationships), dated by the deployment that a `DeploymentSchedule` plans from rates of production and launch, with uncertain growth whose quantiles give the cost at a confidence level, as an objective or a requirement in place of the numbers of satellites and planes.\n", + "* A `Utility` weighs metrics by a stakeholder's preferences (a single-attribute utility of each, combined by weights) into one objective against cost, and is a metric of any statistic (its mean is the expected utility): here, stakeholders who weigh sufficiency or accuracy most agree within the budget and part beyond it." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/index.rst b/docs/examples/index.rst index 3d12fad0..2bd4a470 100644 --- a/docs/examples/index.rst +++ b/docs/examples/index.rst @@ -23,11 +23,18 @@ The following provide examples of TAT-C use in a Jupyter notebook environment. RunOSSEMonsoon.ipynb RunOSSEHurricane.ipynb SearchTradeSpace.ipynb + RankUncertainDesigns.ipynb + CompareScenarios.ipynb + TradeCostAndUtility.ipynb + PlanMissions.ipynb Note that running the above examples in a local Python environment requires additional dependencies which can be installed via:: pip install tatc[examples] -using the pip package manager. The trade space example also requires:: +using the pip package manager. The trade space examples also require:: pip install tatc[tradespace] + +The trade space examples after the first (SearchTradeSpace) import its design space and study from +``trade_space_example.py``, beside the notebooks. diff --git a/docs/examples/trade_space_example.py b/docs/examples/trade_space_example.py new file mode 100644 index 00000000..5f67b7ca --- /dev/null +++ b/docs/examples/trade_space_example.py @@ -0,0 +1,174 @@ +""" +The design space and study of the example `SearchTradeSpace`, which the +examples that follow it (`RankUncertainDesigns`, `CompareScenarios`, +`TradeCostAndUtility`, and `PlanMissions`) import. See `SearchTradeSpace` +for what each part means. + +@author: Paul T. Grogan +""" + +import tempfile +from datetime import datetime, timedelta, timezone +from pathlib import Path + +from tatc.analysis import estimate_sampling_error +from tatc.generation import generate_points_rotated_lattice +from tatc.schemas import Instrument +from tatc.tradespace import ( + Categorical, + Choice, + CostModel, + DeploymentSchedule, + DesignSpace, + Fixed, + Integer, + LaunchCost, + MissionPlan, + ObservationStudy, + Observations, + OperationsCost, + Real, + ResultStore, + SatelliteCost, + Targets, + Uncertain, + build_constellation, + count_satellites, + sso_planes_space, + walker_space, +) + +START = datetime(2026, 7, 1, tzinfo=timezone.utc) +DURATION = timedelta(days=1) # the period of the analysis +N_POINTS = 100 # points sampled in each replicate +N_REPLICATES = 5 # replicates (samples of points) of each design +SAMPLES_PER_DAY = ( + 4 # a point is sufficiently sampled if it is observed at least this often +) +MAX_SATELLITES = 10 +DECORRELATION_TIME = timedelta(hours=3) # of the field whose daily mean is estimated +MAX_RELATIVE_ERROR = 0.5 # a point is accurately sampled within this share of the field's standard deviation + +space = DesignSpace( + altitude=Real(500e3, 800e3, step=100e3), + field_of_regard=Categorical([30, 60]), + layout=Choice( + walker=walker_space( + inclination=Real(45, 75, step=15), + planes=Integer(1, 4), + per_plane=Integer(1, 4), + ), + sso=sso_planes_space( + crossing=Real(6, 18, step=3), satellites=Integer(1, 2), count=Integer(1, 2) + ), + ), + points_seed=Uncertain.seed(), + failure_seed=Uncertain.seed(), + cost_growth=Uncertain( + lambda rng: float(rng.triangular(0.9, 1.0, 1.6)) + ), # of development, for cost risk + decorrelation_time=Fixed( + DECORRELATION_TIME + ), # of the field, which scenarios may change + epoch=Fixed( + START + ), # the start of the analysis, which may be drawn for each replicate + constraints=[lambda d: count_satellites(d.layout) - MAX_SATELLITES], +) +designs = space.enumerate() + +# the deployment of each design: 3 years of development, a production line of 4 satellites a year, launches of up to 3 +# satellites at most every half year, and 5 years of operations from the first launch +SCHEDULE = DeploymentSchedule( + years=5, + development_years=3, + production_rate=4, + launch_interval=0.5, + launch_capacity=3, +) +# illustrative costs (millions of dollars), not estimates of any mission: satellites with an imager of each field of +# regard, small launchers, and operations, discounted at 3% a year +COST_MODEL = CostModel( + satellites={ + 30: SatelliteCost(development=40, first_unit=12, learning_rate=0.9, mass=60), + 60: SatelliteCost(development=60, first_unit=18, learning_rate=0.9, mass=90), + }, + launch=LaunchCost(per_launch=8), + operations=OperationsCost(per_year=3, per_satellite_year=0.5), + discount_rate=0.03, +) + +# the deployment and cost of each design: satellites of the kind of its field of regard, with its growth of +# development costs +PLAN = MissionPlan( + SCHEDULE, COST_MODEL, kind="field_of_regard", growth={"development": "cost_growth"} +) +# the points of each replicate: a randomly oriented lattice, generated from the replicate's seed +TARGETS = Targets(generate_points_rotated_lattice, N_POINTS, seed="points_seed") +CACHE_DIRECTORY = Path(tempfile.gettempdir()) / "tatc-search-trade-space" + + +def sample(observations, design, duration=DURATION): + """The shares (%) of points sampled sufficiently and accurately by observations over a duration from the design's + epoch (of the field of the design's decorrelation time).""" + if len(observations) == 0: # no satellites + return {"sufficient": 0.0, "accurate": 0.0} + samples = observations.groupby("target_hash").size() + error = estimate_sampling_error( + observations, design.epoch, design.epoch + duration, design.decorrelation_time + ) + threshold = SAMPLES_PER_DAY * duration / timedelta(days=1) + return { + "sufficient": 100 * (samples >= threshold).sum() / N_POINTS, + "accurate": 100 * (error.relative_error <= MAX_RELATIVE_ERROR).sum() / N_POINTS, + } + + +def build(d): + """The satellites of a design: an imager of its field of regard in each orbit of its layout.""" + imager = Instrument(name="imager", field_of_regard=d.field_of_regard) + return build_constellation(d.layout, imager, epoch=START, altitude=d.altitude) + + +# the study of the shares (%) of points sampled sufficiently and accurately over the period by the satellites of each +# design, and of its deployment and cost (by the mission plan), whose evaluations are kept in a store +study = ObservationStudy( + space, + build, + Observations(TARGETS, "epoch", DURATION, directory=CACHE_DIRECTORY), + sample, + layout="layout", + plan=PLAN, + replicates=N_REPLICATES, + n_jobs=-1, + store=ResultStore(CACHE_DIRECTORY / "results.sqlite"), +) + +OBJECTIVES = {"satellites": "min", "planes": "min", "sufficient": "max"} +ACCURACY = {"satellites": "min", "planes": "min", "accurate": "max"} +REFERENCE = { + "satellites": MAX_SATELLITES + 1, + "planes": 5, + "sufficient": 0, +} # worse than every design, for hypervolumes + + +def describe(d): + """A short description of a design (a row of its values).""" + if d.layout == "walker": + layout = ( + f"Walker {d['layout.walker.inclination']:.0f} deg: {d['layout.walker.planes']:.0f} x " + f"{d['layout.walker.per_plane']:.0f} (spacing {d['layout.walker.relative_spacing']:.0f})" + ) + else: + planes = [ + f"{d[f'layout.sso.planes[{k}].satellites']:.0f} at {d[f'layout.sso.planes[{k}].crossing']:02.0f}:00" + for k in range(int(d["layout.sso.planes.count"])) + ] + layout = "SSO: " + ", ".join(planes) + return f"{d.altitude / 1e3:.0f} km, {d.field_of_regard} deg FOR, {layout}" + + +def planes_name(planes): + """The name of a number of planes.""" + return f"{planes:.0f} plane{'s' if planes > 1 else ''}" diff --git a/src/tatc/tradespace/__init__.py b/src/tatc/tradespace/__init__.py index f7cc4748..0a6043da 100644 --- a/src/tatc/tradespace/__init__.py +++ b/src/tatc/tradespace/__init__.py @@ -1,78 +1,35 @@ """ -Trade space analysis: design spaces of (hierarchical) design variables and -uncertain parameters, building blocks of constellations (their deployment and life-cycle cost, -and capability over the phases of deployment), -trade studies that evaluate their designs (in scenarios, with caches -of analyses by satellite, in parallel), studies of the observations of -constellations (their targets, deployment, costs, failures, and phases), criteria that judge designs by -statistics of their replicates (of metrics or their utility) and requirements on them, Pareto efficiency -(with the uncertainty of replicates), -adaptive replication, confirmation of selected designs with new replicates, -persistent stores of results (keyed by fingerprints of studies), sensitivity analysis -(to design variables, and attribution of variance to uncertain parameters), -screening with analyses of increasing fidelity, -searches with optimizers (Optuna and pymoo, optional dependencies), -and plots of results (matplotlib, an optional dependency). +Trade space analysis of constellations. + +A trade study declares a design space (`DesignSpace`), evaluates its designs +in replicates that draw its uncertain parameters (`Study`, or +`ObservationStudy` for the observations, deployment, costs, and failures of +constellations) into results (a row per replicate), judges designs by +criteria (`Criteria`) on summaries of the results (`aggregate`, a row per +design) and their Pareto efficiency (`pareto_front`), and settles the +uncertainty of its replicates (`refine`, `confirm`), or finds efficient +designs of spaces too large to enumerate (`screen`, `optimize_optuna`, +`optimize_pymoo`). + +This package exports the functions and classes of trade studies. The parts +from which they are made (such as the layouts of constellations, the +simulation of missions, and fingerprints) are in its modules. @author: Paul T. Grogan """ -from .attribution import Attribution, attribute_variance -from .cache import SatelliteCache, get_satellite_key -from .confirmation import Confirmation, confirm -from .cost import ( - CostEstimate, - CostModel, - LaunchCost, - OperationsCost, - SatelliteCost, -) +from .attribution import attribute_variance +from .cache import SatelliteCache +from .confirmation import confirm from .constellations import ( build_constellation, count_planes, count_satellites, - Layout, - Plane, - hours_to_time, - layout_of, - plane_sizes, planes_space, - remove_failures, sso_planes_space, walker_space, ) -from .deployment import ( - Deployment, - DeploymentSchedule, - Launch, - Production, - Stage, -) -from .histories import ( - allocate_histories, - evaluate_missions, - expected_missions, - summarize_missions, -) -from .mission import ( - Capability, - Decision, - MissionHistory, - Phase, - PhaseCache, - evaluate_phases, - summarize_phases, -) -from .failures import ( - Bathtub, - Exponential, - FailureModel, - Lifetime, - Piecewise, - RestorationPolicy, - Weibull, - policy_space, -) +from .cost import CostModel, LaunchCost, OperationsCost, SatelliteCost from .criteria import ( Across, Criteria, @@ -84,38 +41,19 @@ Requirement, StandardDeviation, StandardError, - Statistic, aggregate, summarize, ) -from .optimization import ( - Evaluations, - Search, - make_pymoo_problem, - optimize_optuna, - optimize_pymoo, -) -from .fingerprint import compare_definitions, get_definition, get_fingerprint -from .observations import ( - Failures, - MissionPlan, - ObservationStudy, - Observations, - Targets, - value_of, -) -from .pareto import ( - hypervolume, - hypervolume_progress, - pareto_front, - pareto_probability, - pareto_ranks, +from .deployment import DeploymentSchedule, Stage +from .failures import ( + Bathtub, + Exponential, + FailureModel, + Piecewise, + RestorationPolicy, + Weibull, + policy_space, ) -from .plotting import plot_designs, plot_means, plot_progress, style_axes -from .refinement import Refinement, refine -from .screening import Screening, screen -from .scenarios import robustness -from .sensitivity import main_effects, sensitivity from .nodes import ( Categorical, Choice, @@ -126,126 +64,102 @@ Real, Repeat, Uncertain, - Variable, ) +from .observations import Failures, MissionPlan, ObservationStudy, Observations, Targets +from .optimization import optimize_optuna, optimize_pymoo +from .pareto import ( + hypervolume, + hypervolume_progress, + pareto_front, + pareto_probability, + pareto_ranks, +) +from .plotting import plot_designs, plot_means, plot_progress, style_axes +from .refinement import refine +from .scenarios import robustness +from .screening import screen +from .sensitivity import main_effects, sensitivity from .space import Design, DesignSpace from .store import ResultStore from .study import Study from .utility import ExponentialUtility, LinearUtility, PiecewiseUtility, Utility -from .values import ChoiceValues, RepeatValues, Scope, Values, configure __all__ = [ - "Across", - "Attribution", - "Bathtub", - "Capability", + # design spaces "Categorical", "Choice", - "ChoiceValues", - "Confirmation", - "CostEstimate", - "CostModel", - "Criteria", - "Decision", - "Deployment", - "DeploymentSchedule", "Derived", "Design", "DesignSpace", - "Evaluations", - "Exponential", - "ExponentialUtility", - "FailureModel", - "Failures", "Fixed", "Infeasible", "Integer", - "Launch", + "Real", + "Repeat", + "Uncertain", + "build_constellation", + "count_planes", + "count_satellites", + "planes_space", + "policy_space", + "sso_planes_space", + "walker_space", + # studies + "Bathtub", + "CostModel", + "DeploymentSchedule", + "Exponential", + "FailureModel", + "Failures", "LaunchCost", - "Layout", - "Lifetime", - "LinearUtility", - "Maximum", - "Mean", - "Minimum", - "MissionHistory", "MissionPlan", "ObservationStudy", "Observations", "OperationsCost", - "Phase", - "PhaseCache", "Piecewise", - "PiecewiseUtility", - "Plane", - "Probability", - "Production", - "Quantile", - "Real", - "Refinement", - "Repeat", - "RepeatValues", - "Requirement", "RestorationPolicy", "ResultStore", "SatelliteCache", "SatelliteCost", - "Scope", - "Screening", - "Search", "Stage", - "StandardDeviation", - "StandardError", - "Statistic", "Study", "Targets", - "Uncertain", - "Utility", - "Values", - "Variable", "Weibull", + # criteria and summaries + "Across", + "Criteria", + "ExponentialUtility", + "LinearUtility", + "Maximum", + "Mean", + "Minimum", + "PiecewiseUtility", + "Probability", + "Quantile", + "Requirement", + "StandardDeviation", + "StandardError", + "Utility", "aggregate", - "allocate_histories", - "attribute_variance", - "build_constellation", - "compare_definitions", - "configure", - "confirm", - "count_planes", - "count_satellites", - "evaluate_missions", - "evaluate_phases", - "expected_missions", - "get_definition", - "get_fingerprint", - "get_satellite_key", - "hours_to_time", "hypervolume", "hypervolume_progress", - "layout_of", "main_effects", - "make_pymoo_problem", - "optimize_optuna", - "optimize_pymoo", "pareto_front", "pareto_probability", "pareto_ranks", - "plane_sizes", - "planes_space", + "robustness", + "sensitivity", + "summarize", + # refinement and searches + "attribute_variance", + "confirm", + "optimize_optuna", + "optimize_pymoo", + "refine", + "screen", + # plots "plot_designs", "plot_means", "plot_progress", - "policy_space", - "refine", - "remove_failures", - "robustness", - "screen", - "sensitivity", - "sso_planes_space", "style_axes", - "summarize", - "summarize_missions", - "summarize_phases", - "value_of", - "walker_space", ] diff --git a/src/tatc/tradespace/attribution.py b/src/tatc/tradespace/attribution.py index d83e2fcd..d7905753 100644 --- a/src/tatc/tradespace/attribution.py +++ b/src/tatc/tradespace/attribution.py @@ -16,7 +16,7 @@ import numpy as np import pandas as pd -from .space import Design, DesignSpace, _check_uncertain, _generic +from .space import Design, DesignSpace, _check_uncertain, _designs, _generic from .study import Study _SHARES = ("first", "total") @@ -461,8 +461,9 @@ def _shares( def attribute_variance( study: Study, - designs: Sequence[Design], metrics: Sequence[str], + designs: Sequence[Design] | pd.DataFrame, + *, parameters: Sequence[str] | Mapping[str, Sequence[str]] | None = None, replicates: int | None = None, by: Sequence[str] = (), @@ -520,8 +521,10 @@ def attribute_variance( Args: study (Study): The study that evaluates designs. - designs (Sequence[Design]): The designs. metrics (Sequence[str]): The metrics (columns of the results). + designs (Sequence[Design] | pandas.DataFrame): The designs, or a data + frame of their values (such as rows of a summary that keeps them, + see `DesignSpace.designs_of`). parameters (Sequence[str] | Mapping[str, Sequence[str]] | None): The uncertain parameters to attribute variance to (by their paths, see `DesignSpace.uncertain_paths`), groups of them (by name), or @@ -545,7 +548,7 @@ def attribute_variance( raise ValueError("n_resamples must be at least 2") groups = _groups_of(study.space, parameters) metrics, by = list(metrics), tuple(by) - unique = list({design.key: design for design in designs}.values()) + unique = _designs(study.space, designs) plain = study.run(unique, replicates=range(2 * n)) missing = [column for column in (*metrics, *by) if column not in plain.columns] if missing and plain["feasible"].any(): diff --git a/src/tatc/tradespace/confirmation.py b/src/tatc/tradespace/confirmation.py index e10c6826..25d5489d 100644 --- a/src/tatc/tradespace/confirmation.py +++ b/src/tatc/tradespace/confirmation.py @@ -8,34 +8,41 @@ from __future__ import annotations from collections.abc import Mapping, Sequence -from dataclasses import dataclass +from dataclasses import dataclass, field import numpy as np import pandas as pd from .criteria import Criteria, _as_criteria, aggregate from .pareto import pareto_front -from .space import Design +from .space import Design, _designs from .study import Study @dataclass class Confirmation: """ - The outcome of a confirmation (see `confirm`). + The outcome of a confirmation (see `confirm`): its `results`, the + `summary` of its designs, and the `designs` themselves, as the outcomes of + other steps of a trade study (see `Refinement`). Its results are only + those of the new replicates, which judge the designs without the + optimism of their selection. """ results: pd.DataFrame - """pandas.DataFrame: The results of the new replicates (see `Study.run`).""" + """pandas.DataFrame: The results of the new replicates (see `Study.run`), + which do not include those that selected the designs.""" summary: pd.DataFrame - """pandas.DataFrame: A row per design (and group): the statistics of - the criteria by the new replicates, those of the replicates that - selected the design (` selected`), the number of new - `replicates`, and whether the design meets the requirements - (`meets_requirements`) and is efficient among the confirmed designs that - do (`pareto`), by the new replicates.""" + """pandas.DataFrame: A row per design (and group): the values of the + design, the statistics of the criteria by the new replicates, those of + the replicates that selected the design (` selected`), the + number of new `replicates`, and whether the design meets the + requirements (`meets_requirements`) and is efficient among the confirmed + designs that do (`pareto`), by the new replicates.""" criteria: Criteria """Criteria: The criteria of the confirmation.""" + designs: list[Design] = field(default_factory=list) + """list[Design]: The confirmed designs.""" def optimism(self) -> pd.Series: """ @@ -61,14 +68,15 @@ def optimism(self) -> pd.Series: def confirm( study: Study, - designs: Sequence[Design], - results: pd.DataFrame, criteria: Criteria | Mapping[str, str], + results: pd.DataFrame, + designs: Sequence[Design | str] | pd.DataFrame | None = None, + *, replicates: int | None = None, ) -> Confirmation: """ - Confirms selected designs (such as a Pareto front, or the best designs - of an optimizer) with new replicates. + Confirms selected designs (by default, the Pareto front of the results, + or the best designs of an optimizer) with new replicates. Designs selected for their outcomes in some replicates are selected in part for the luck of those replicates: among many designs, the best @@ -83,24 +91,33 @@ def confirm( Args: study (Study): The study that evaluates designs. - designs (Sequence[Design]): The selected designs. - results (pandas.DataFrame): Every result that informed the selection - (see `Study.run`), such as those of an enumeration, refinement, - or search. criteria (Criteria | Mapping[str, str]): The criteria (see `Criteria`), or the objectives (metrics whose means they are) and their directions (`"min"` or `"max"`). + results (pandas.DataFrame): Every result that informed the selection + (see `Study.run`), such as those of an enumeration, refinement, + or search. + designs (Sequence[Design | str] | pandas.DataFrame | None): The + selected designs (designs, their keys, or a data frame of them, + such as rows of a summary), or `None` for those efficient by + the criteria over every replicate of the results (see + `aggregate` and `pareto_front`). replicates (int | None): The number of new replicates, or `None` for the study's number. Returns: - Confirmation: the new results and the summary of each design + Confirmation: the new results, the summary of each design, and the + designs """ criteria = _as_criteria(criteria) count = study.replicates if replicates is None else replicates if count < 1: raise ValueError("replicates must be at least 1") - designs = list({design.key: design for design in designs}.values()) + if designs is None: + summary = aggregate(results, criteria, design_columns=[]) + summary = summary.dropna(subset=list(criteria.objectives)) + designs = summary[pareto_front(summary, criteria)] + designs = _designs(study.space, designs, results) keys = {design.key for design in designs} start = int(results["replicate"].max()) + 1 if len(results) > 0 else 0 fresh = study.run(designs, replicates=range(start, start + count)) @@ -109,8 +126,10 @@ def confirm( selected = aggregate( results[results["design"].isin(keys)], criteria, design_columns=[] ) - confirmed = aggregate(fresh, criteria, design_columns=[]) - summary = confirmed[[*columns, *names, "replicates", "meets_requirements"]] + confirmed = aggregate(fresh, criteria) + judged = {*columns, *names, "replicates", "violation", "meets_requirements"} + values = [column for column in confirmed.columns if column not in judged] + summary = confirmed[[*columns, *values, *names, "replicates", "meets_requirements"]] summary = summary.merge( selected[[*columns, *names]].rename( columns={name: f"{name} selected" for name in names} @@ -121,6 +140,7 @@ def confirm( summary = summary[ [ *columns, + *values, *(c for name in names for c in (name, f"{name} selected")), "replicates", "meets_requirements", @@ -130,4 +150,6 @@ def confirm( known = summary.dropna(subset=list(criteria.objectives)) summary["pareto"] = False summary.loc[known.index, "pareto"] = pareto_front(known, criteria).to_numpy() - return Confirmation(results=fresh, summary=summary, criteria=criteria) + return Confirmation( + results=fresh, summary=summary, criteria=criteria, designs=designs + ) diff --git a/src/tatc/tradespace/criteria.py b/src/tatc/tradespace/criteria.py index 92fe7ebc..a34068d3 100644 --- a/src/tatc/tradespace/criteria.py +++ b/src/tatc/tradespace/criteria.py @@ -18,7 +18,7 @@ import operator as op from collections.abc import Iterator, Mapping, Sequence -from dataclasses import dataclass, field +from dataclasses import dataclass, field, replace from typing import Any import numpy as np @@ -441,7 +441,16 @@ class Criteria: `Statistic`), the tolerances of the objectives within which differences do not matter, and the columns that group the records of an evaluation (such as a sensor), in each group of which designs are judged - separately. + separately:: + + criteria = Criteria( + {"cost p70": "min", "coverage": "max"}, + statistics={"cost p70": Quantile("cost", 0.7)}, + requirements=[Requirement("cost p70", "<=", 150)], + tolerance={"coverage": 1.0}, + ) + summary = aggregate(results, criteria) + front = summary[pareto_front(summary, criteria)] Objectives and requirements name statistics: those of `statistics`, or otherwise the means of the metrics of their names. A design is @@ -611,6 +620,27 @@ def _groups(frame: pd.DataFrame, by: Sequence[str]) -> Iterator[tuple[tuple, Any yield (key if isinstance(key, tuple) else (key,)), positions +def _check_summary(summary: pd.DataFrame, by: Sequence[str] = ()) -> None: + """ + Checks that a data frame is a summary of designs (a row per design, in + each group of the columns `by`), not the results of a study (a row per + replicate), which the functions of summaries would judge as if each + replicate were a design. + """ + if "design" in summary.columns: + keys = summary[["design", *(c for c in by if c in summary.columns)]] + elif summary.index.name == "design" and not by: + keys = summary.index.to_frame() + else: + return + if keys.duplicated().any(): + raise ValueError( + "the data frame has several rows of a design: summarize the results " + + "of a study (a row per replicate) first, with a row per design (see " + + "aggregate), or judge designs in groups (see Criteria's `by`)" + ) + + def _get_matrices( group: pd.DataFrame, columns: Sequence[str], @@ -836,25 +866,128 @@ def _design_columns(results: pd.DataFrame, excluded: set[str]) -> list[str]: return [column for column in candidates if (constant[column] <= 1).all()] +def _value_columns( + feasible: pd.DataFrame, + statistics: Mapping[str, Statistic], + by: Sequence[str], + across: Across | None, + design_columns: Sequence[str] | None, +) -> list[str]: + """ + Gets the columns of the values of designs that a summary keeps: those + given, or those that are the same in every record of each design (but + the metrics of the statistics, the columns of groups, and status + columns). + """ + combined = [] if across is None else [across.column] + if design_columns is None: + metrics = { + column for statistic in statistics.values() for column in statistic.columns + } + design_columns = _design_columns( + feasible, {*_STATUS_COLUMNS, *metrics, *by, *combined} + ) + return [ + c for c in design_columns if c not in statistics and c not in (*by, *combined) + ] + + +def _with_values( + frame: pd.DataFrame, group: pd.DataFrame, designs: Any, columns: Sequence[str] +) -> None: + """ + Adds the values of designs (columns of the first record of each design of + a group of results) to the rows of a summary of the designs. + """ + first = group.drop_duplicates("design").set_index("design") + for column in columns: + frame[column] = first.loc[designs, column].to_numpy() + + +def _criteria_of( + criteria: Criteria | Mapping[str, str] | Sequence[str] | str, + statistics: Mapping[str, Statistic | str] | None, + by: Sequence[str] | str, +) -> tuple[Criteria | None, dict[str, Statistic], tuple[str, ...]]: + """ + Gets the criteria (if any) of the arguments of `aggregate`, the + statistics to compute (by name), and the columns that group records. + """ + by = (by,) if isinstance(by, str) else tuple(by) + extra = { + name: Mean(value) if isinstance(value, str) or _is_derived(value) else value + for name, value in dict(statistics or {}).items() + } + for name, statistic in extra.items(): + if not isinstance(statistic, Statistic): + raise TypeError(f"statistic {name!r} is not a Statistic") + if isinstance(criteria, Mapping) and not set(criteria.values()) <= {"min", "max"}: + raise ValueError( + "a mapping of criteria gives the directions of objectives ('min' or " + + "'max'): give statistics by name as `statistics`" + ) + if isinstance(criteria, (Criteria, Mapping)): + if by and isinstance(criteria, Criteria): + raise ValueError( + "criteria group records by their own `by`: give it to the criteria" + ) + judged = _as_criteria(criteria) + if by: + judged = replace(judged, by=by) + if extra: + clashes = sorted( + name + for name in extra + if name in judged.names and judged.statistic(name) != extra[name] + ) + if clashes: + raise ValueError( + f"statistics that the criteria name otherwise: {clashes}" + ) + judged = replace(judged, statistics={**judged.statistics, **extra}) + return judged, _resolve(judged), judged.by + metrics = [criteria] if isinstance(criteria, str) else list(criteria) + resolved: dict[str, Statistic] = {name: Mean(name) for name in metrics} + resolved.update(extra) + if not resolved: + raise ValueError( + "give criteria, the metrics whose means to compute, or statistics" + ) + return None, resolved, by + + def aggregate( results: pd.DataFrame, - statistics: Criteria | Mapping[str, Statistic | str] | Sequence[str], + criteria: Criteria | Mapping[str, str] | Sequence[str] | str = (), + *, + statistics: Mapping[str, Statistic | str] | None = None, by: Sequence[str] | str = (), design_columns: Sequence[str] | None = None, ) -> pd.DataFrame: """ - Aggregates the feasible results of a study (see `Study.run`) over the - replicates of each design (and each group of the columns `by`, such as a - sensor): the statistics, by name (a metric given as a string, or in a - list of names, is its mean), the number of `replicates`, and the values - of the design. - - With criteria (see `Criteria`), the statistics that they name, in each - group of their `by`, and the `violation` of their requirements (the sum - of the violations, see `Requirement`, 0 if the design meets them all) - and whether the design meets them (`meets_requirements`). Criteria - `across` a column combine the statistics of each design across its - groups (see `Across`), of which `replicates` is the fewest of any group. + Aggregates the feasible results of a study (see `Study.run`, a row per + replicate) into a summary of its designs (a row per design, and per + group of the columns `by`, such as a sensor): statistics over the + replicates of each design, the number of `replicates`, and the values of + the design (see `Design.flat`), from which `DesignSpace.designs_of` + rebuilds the designs. + + The statistics are those of criteria (see `Criteria`, or a mapping of + objectives to their directions, which are the means of the metrics of + their names), or the means of metrics (a list of their names), and other + `statistics`, by name (a statistic, or a metric given as a string, whose + mean it is):: + + aggregate(results, {"satellites": "min", "sufficient": "max"}) + aggregate(results, ["sufficient", "accurate"]) + aggregate(results, statistics={"cost p70": Quantile("cost", 0.7)}) + + With criteria, the summary also gives the `violation` of their + requirements (the sum of the violations, see `Requirement`, 0 if the + design meets them all) and whether the design meets them + (`meets_requirements`). Criteria `across` a column combine the + statistics of each design across its groups (see `Across`), of which + `replicates` is the fewest of any group. The results must have one record per evaluation (a design in a replicate) in each group (and in each group of the column of the @@ -862,11 +995,13 @@ def aggregate( Args: results (pandas.DataFrame): The results. - statistics (Criteria | Mapping[str, Statistic | str] | Sequence[str]): - Criteria, the statistics by name, or the metrics whose means to - compute. - by (Sequence[str] | str): Other columns that group records of an - evaluation (those of the criteria, with criteria). + criteria (Criteria | Mapping[str, str] | Sequence[str] | str): The + criteria (or objectives and their directions), or the metrics + whose means to compute. + statistics (Mapping[str, Statistic | str] | None): Other statistics, + by name. + by (Sequence[str] | str): The columns that group records of an + evaluation (those of the criteria, if they have any). design_columns (Sequence[str] | None): The columns of the values of designs, or `None` for those that are the same in every replicate of a design (except the metrics). @@ -874,40 +1009,14 @@ def aggregate( Returns: pandas.DataFrame: a row per design (and group) """ - criteria = statistics if isinstance(statistics, Criteria) else None - across, combiners = None, None - if criteria is not None: - if by: - raise ValueError("criteria group records by their own `by`") - resolved, requirements, by = ( - _resolve(criteria), - criteria.requirements, - criteria.by, - ) - across = criteria.across - combiners = None if across is None else _combiners(criteria) - else: - if not isinstance(statistics, Mapping): - statistics = {name: name for name in statistics} - resolved = { - name: Mean(value) if isinstance(value, str) or _is_derived(value) else value - for name, value in statistics.items() - } - requirements = () - by = (by,) if isinstance(by, str) else tuple(by) + judged, resolved, by = _criteria_of(criteria, statistics, by) + across, combiners, requirements = None, None, () + if judged is not None: + requirements, across = judged.requirements, judged.across + combiners = None if across is None else _combiners(judged) feasible = results[results["feasible"]] if "feasible" in results else results - metrics = sorted( - {column for statistic in resolved.values() for column in statistic.columns} - ) - combined = [] if across is None else [across.column] groups = _across_groups(results, across) - if design_columns is None: - design_columns = _design_columns( - feasible, {*_STATUS_COLUMNS, *metrics, *by, *combined} - ) - design_columns = [ - c for c in design_columns if c not in resolved and c not in (*by, *combined) - ] + columns = _value_columns(feasible, resolved, by, across, design_columns) frames = [] for key, positions in _groups(feasible, by): group = feasible.iloc[positions] @@ -917,19 +1026,17 @@ def aggregate( frame = pd.DataFrame({"design": designs}) for name, value in zip(by, key): frame[name] = value - first = group.drop_duplicates("design").set_index("design") - for column in design_columns: - frame[column] = first.loc[designs, column].to_numpy() + _with_values(frame, group, designs, columns) for name, value in values.items(): frame[name] = value frame["replicates"] = table.counts - if criteria is not None: + if judged is not None: frame["violation"] = violation frame["meets_requirements"] = violation == 0 frames.append(frame) if not frames: - judged = ["violation", "meets_requirements"] if criteria is not None else [] - return pd.DataFrame(columns=["design", *by, *resolved, "replicates", *judged]) + status = ["violation", "meets_requirements"] if judged is not None else [] + return pd.DataFrame(columns=["design", *by, *resolved, "replicates", *status]) return pd.concat(frames, ignore_index=True) @@ -943,7 +1050,7 @@ def summarize( Summarizes the metrics of the feasible results of a study over their replicates (see `aggregate`): for each design (and each group of the columns `by`, such as a sensor), the mean of each metric, its standard - deviation (` std`) and standard error (` sem`) between + deviation (` std`) and standard error (` se`) between replicates, and the number of replicates (`replicates`), with the values of the design. @@ -963,5 +1070,7 @@ def summarize( for metric in metrics: statistics[metric] = Mean(metric) statistics[f"{metric} std"] = StandardDeviation(metric) - statistics[f"{metric} sem"] = StandardError(metric) - return aggregate(results, statistics, by=by, design_columns=design_columns) + statistics[f"{metric} se"] = StandardError(metric) + return aggregate( + results, statistics=statistics, by=by, design_columns=design_columns + ) diff --git a/src/tatc/tradespace/fingerprint.py b/src/tatc/tradespace/fingerprint.py index 854fd9a9..7bc48d2c 100644 --- a/src/tatc/tradespace/fingerprint.py +++ b/src/tatc/tradespace/fingerprint.py @@ -667,6 +667,26 @@ def _differences(before: Any, after: Any, path: str) -> list[str]: return [path] +def _without_code(description: Any) -> Any: + """ + Gets a description of values without the code of their functions (the + instructions, constants, and names of compiled code, see + `_Describer.code`), which is the same for the same values with other + code (such as a function after it is edited, or compiled by another + version of Python). + """ + if isinstance(description, dict): + code = {"code", "constants", "names"} <= set(description) + return { + key: _without_code(value) + for key, value in description.items() + if not (code and key in ("code", "constants", "names")) + } + if isinstance(description, list): + return [_without_code(value) for value in description] + return description + + def compare_definitions(before: dict, after: dict, limit: int = 5) -> list[str]: """ Compares definitions (see `get_definition`), as to explain why results diff --git a/src/tatc/tradespace/histories.py b/src/tatc/tradespace/histories.py index 6d38874d..6070e51d 100644 --- a/src/tatc/tradespace/histories.py +++ b/src/tatc/tradespace/histories.py @@ -50,7 +50,7 @@ def evaluate_missions( """ Evaluates histories of a mission (such as those of a replicate, see `Deployment.simulate_many`): for each, the mean of each metric over the - phases of the mission (` mean`, see `summarize_phases`), its + phases of the mission (` mission`, see `summarize_phases`), its measures (see `MissionHistory.metrics`), and its cost (see `CostEstimate.metrics`, with a cost model). The histories share the observations of the replicate, so that a `PhaseCache` (as the metric) @@ -106,9 +106,12 @@ def summarize_missions( Summarizes histories of a mission (see `evaluate_missions`) as the metrics of an evaluation: the mean of each column over the histories (by the same name), quantiles of columns over the histories (` - p`, such as `"accurate mean p10"` for the 0.1 quantile, the - risk of the mission), and the share of the histories that meet each - requirement on a column (`P( )`). + histories p`, such as `"accurate mission histories p10"` for the + 0.1 quantile, the risk of the mission), and the share of the histories + that meet each requirement on a column (`P( + )`). The quantiles (and standard deviations) over the histories + of a replicate are named apart from statistics over the replicates + (such as a `Quantile`, see `Criteria`), which are taken of these. With `controls`, the means are estimated with control variates: columns whose expected values are known (such as the `availability` of a @@ -139,7 +142,8 @@ def summarize_missions( controls (Mapping[str, float] | None): The expected values of columns that are control variates, if any. spread (bool): `True` to add the standard deviation of each column - over the histories (` sd`), as for `allocate_histories`. + over the histories (` histories std`), as for + `allocate_histories`. Returns: dict[str, float]: the summary @@ -163,14 +167,14 @@ def summarize_missions( mean = _weighted_mean(values, weights) variance = _weighted_mean((values - mean) ** 2, weights) count = known.sum() - summary[f"{column} sd"] = ( + summary[f"{column} histories std"] = ( float(np.sqrt(variance * count / (count - 1))) if count > 1 else math.nan ) for column, values in (quantiles or {}).items(): for q in [values] if isinstance(values, (int, float)) else values: - summary[f"{column} p{100 * q:g}"] = _weighted_quantile( + summary[f"{column} histories p{100 * q:g}"] = _weighted_quantile( numeric[column].to_numpy(dtype=float), weights, q ) for requirement in requirements: @@ -365,7 +369,7 @@ def allocate_histories( of the failures of its mission in each replicate (cheap, with a `PhaseCache`), from a pilot study: the records of its replicates (see `summarize_missions`, with `spread`), each the mean (``) and - standard deviation (` sd`) of a metric over `histories` + standard deviation (` histories std`) of a metric over `histories` histories. The variance of a replicate's mean is `between + within / K` for `K` @@ -410,7 +414,9 @@ def allocate_histories( if histories < 2 or replicate_seconds <= 0 or history_seconds <= 0: raise ValueError("a pilot needs two or more histories and positive costs") means = records[metric].to_numpy(dtype=float) - within = float(np.mean(records[f"{metric} sd"].to_numpy(dtype=float) ** 2)) + within = float( + np.mean(records[f"{metric} histories std"].to_numpy(dtype=float) ** 2) + ) observed = float(np.var(means, ddof=1)) if observed < 0.5 * within / histories: warnings.warn( @@ -533,7 +539,7 @@ def expected_missions( Computes the expected capability of a mission without restoration (failed satellites are not restored, but may be replaced as planned at the end of their design life) over its failures: the expectation of the - mean of each metric over the phases of the mission (` mean`, as + mean of each metric over the phases of the mission (` mission`, as `summarize_phases` gives for one history) and of its availability (`availability`), exactly rather than from samples of histories. @@ -639,9 +645,9 @@ def expected_missions( for name, value in values.items(): if name in ("start", "end", "duration", "satellites"): continue - totals[f"{name} mean"] = totals.get(f"{name} mean", 0.0) + weight * float( - value - ) + totals[f"{name} mission"] = totals.get( + f"{name} mission", 0.0 + ) + weight * float(value) evaluated += weight sets += 1 if evaluated >= 1 - tolerance: diff --git a/src/tatc/tradespace/mission.py b/src/tatc/tradespace/mission.py index c0e33656..b570c97c 100644 --- a/src/tatc/tradespace/mission.py +++ b/src/tatc/tradespace/mission.py @@ -759,7 +759,7 @@ def summarize_phases( """ Summarizes the capability of a mission over its phases (see `evaluate_phases`): the mean of each metric weighted by the durations of - the phases (` mean`, over the mission, from its first launch), + the phases (` mission`, over the mission, from its first launch), and, for each requirement on a metric, the time (years from the start of development) at which a phase first meets it (` time`, infinite if none does). @@ -783,7 +783,7 @@ def summarize_phases( summary = {} for name in metrics: values = capability[name].to_numpy(dtype=float) - summary[f"{name} mean"] = float(np.sum(values * weights) / np.sum(weights)) + summary[f"{name} mission"] = float(np.sum(values * weights) / np.sum(weights)) for requirement in requirements: met = _OPERATORS[requirement.operator]( capability[requirement.name].to_numpy(dtype=float), requirement.value diff --git a/src/tatc/tradespace/observations.py b/src/tatc/tradespace/observations.py index ca7edfa5..4b083b61 100644 --- a/src/tatc/tradespace/observations.py +++ b/src/tatc/tradespace/observations.py @@ -4,9 +4,15 @@ observations, its deployment and costs, the histories of its failures, and the phases of its mission. -The parts refer to the values of designs by name (such as `"points_seed"` -for `d.points_seed`, or a path of `Design.flat`, such as -`"layout.walker.planes"`), or by a function of the (realized) design. +The parts refer to the values of designs by a `Reference`: a name (such as +`"points_seed"` for `d.points_seed`, or a path of `Design.flat`, such as +`"layout.walker.planes"`), or a function of the (realized) design (such as +`lambda d: d.layout`). A string given where a reference is expected is +always a reference, never a value itself: give a function that returns a +string (or a number, where numbers are references) to give a value:: + + MissionPlan(SCHEDULE, COST_MODEL, kind="field_of_regard") # d.field_of_regard + MissionPlan(SCHEDULE, COST_MODEL, kind=lambda d: "imager") # always "imager" @author: Paul T. Grogan """ @@ -14,6 +20,7 @@ from __future__ import annotations import dataclasses +import math import os from collections.abc import Callable, Mapping, Sequence from datetime import datetime, timedelta @@ -28,7 +35,7 @@ from .constellations import count_planes from .cost import CostModel from .criteria import Requirement -from .deployment import DeploymentSchedule +from .deployment import Deployment, DeploymentSchedule, Stage from .failures import FailureModel, RestorationPolicy from .histories import evaluate_missions, expected_missions, summarize_missions from .mission import Capability, PhaseCache, _given_design, summarize_phases @@ -39,8 +46,12 @@ _MAX_TARGETS = 32 """The most sets of targets (of seeds) kept in memory.""" +Reference = str | Callable[[Design], Any] +"""A reference to a value of a design: its name or path (see `Design.flat`), +or a function of the (realized) design that gives it (see `value_of`).""" + -def value_of(design: Design, reference: Any) -> Any: +def value_of(design: Design, reference: Reference | None) -> Any: """ Gets a value of a design that a reference names: a string names a value (`d.`, or a path of `Design.flat`, such as `"layout.walker.planes"`), @@ -48,7 +59,8 @@ def value_of(design: Design, reference: Any) -> Any: Args: design (Design): The (realized) design. - reference (Any): The reference: a string, a function, or `None`. + reference (Reference | None): The reference: a string, a function, + or `None`. Returns: Any: the value @@ -81,17 +93,24 @@ class Targets: source (pandas.DataFrame | Callable): The targets, or a function that generates them. *arguments (Any): The arguments of the function. - seed (Any): The value of the design that seeds the function (see - `value_of`), or `None` (to generate the same targets). + seed (Reference | None): The value of the design that seeds the + function (see `value_of`), or `None` (to generate the same + targets). **keywords (Any): The keyword arguments of the function. """ source: Any arguments: tuple keywords: dict - seed: Any + seed: Reference | None - def __init__(self, source: Any, *arguments: Any, seed: Any = None, **keywords: Any): + def __init__( + self, + source: Any, + *arguments: Any, + seed: Reference | None = None, + **keywords: Any, + ): if isinstance(source, pd.DataFrame): if arguments or keywords or seed is not None: raise ValueError("fixed targets take no arguments or seed") @@ -190,8 +209,8 @@ class Observations: Args: targets (Targets | pandas.DataFrame): The targets. - start (datetime | Any): The start of the period, or a value of the - design that gives it (see `value_of`). + start (datetime | Reference): The start of the period, or a value of + the design that gives it (see `value_of`). duration (timedelta): The duration of the period. analysis (Callable): The analysis of one satellite. directory (str | os.PathLike | None): A directory of the cache on @@ -201,7 +220,7 @@ class Observations: """ targets: Targets | pd.DataFrame - start: datetime | Any + start: datetime | Reference duration: timedelta analysis: Callable = collect_observations directory: str | os.PathLike | None = dataclasses.field( @@ -349,32 +368,34 @@ def schedule(d): deployment, or a function of the design that gives it. cost_model (CostModel | Callable | None): The costs, a function of the design that gives them, or `None`. - kind (Any): The kind of the satellites (for schedules and costs of - several kinds), as a value of the design. - spares (Any): The spares in orbit in each plane, or a value of the - design (replaced by the `orbit_spares` of a design's policy, see - `Failures`). - growth (Any): The growth of the costs (see `CostModel.estimate`): a - factor, a value of the design, or a mapping of each element (such - as `"development"`) to a factor or a value of the design. + kind (Reference | None): The kind of the satellites (for schedules + and costs of several kinds), as a value of the design. + spares (int | Reference): The spares in orbit in each plane, or a + value of the design (replaced by the `orbit_spares` of a design's + policy, see `Failures`). + growth (float | Reference | Mapping): The growth of the costs (see + `CostModel.estimate`): a factor, a value of the design, or a + mapping of each element (such as `"development"`) to a factor or + a value of the design. stages (Sequence[Stage] | Callable): The stages of the deployment (see `Stage`), or a function of the (realized) design that gives them, such as of a decision whether to stage it and of the values its rules read. Their rules may also read the capability of the satellites operating at a decision, by the study's metrics (see `Decision.capability`). - masses (Any): The mass (kg) of the satellites (or of each type, a - mapping), or a value of the design, for launches limited in mass, - or `None` for the masses of the cost model. + masses (float | Mapping | Reference | None): The mass (kg) of the + satellites (or of each type, a mapping), or a value of the + design, for launches limited in mass, or `None` for the masses of + the cost model. """ schedule: DeploymentSchedule | Callable[[Design], DeploymentSchedule] cost_model: CostModel | Callable[[Design], CostModel] | None = None - kind: Any = None - spares: Any = 0 - growth: Any = 1.0 - stages: Any = () - masses: Any = None + kind: Reference | None = None + spares: int | Reference = 0 + growth: float | Reference | Mapping[str, float | Reference] = 1.0 + stages: Sequence[Stage] | Callable[[Design], Sequence[Stage]] = () + masses: float | Mapping[Any, float] | Reference | None = None def schedule_of(self, design: Design) -> DeploymentSchedule: """ @@ -480,9 +501,9 @@ class Failures: model (FailureModel): The failures. policy (RestorationPolicy | None): The policy (`None` not to restore). histories (int): The histories of each replicate. - seed (Any): The value of the design that seeds the failures (see - `value_of`, such as of `Uncertain.seed`), or `None` for the one - history without failures. + seed (Reference | None): The value of the design that seeds the + failures (see `value_of`, such as of `Uncertain.seed`), or + `None` for the one history without failures. sampling (str): The sampling of the histories (see `Deployment.simulate_many`). quantiles (Mapping | None): Quantiles of the metrics of the @@ -495,22 +516,40 @@ class Failures: model: FailureModel policy: RestorationPolicy | None = None histories: int = 1 - seed: Any = None + seed: Reference | None = None sampling: str = "stratified" quantiles: Mapping[str, float | Sequence[float]] | None = None requirements: Sequence[Requirement] = () exact: bool = True +@dataclasses.dataclass(frozen=True) +class _Mission: + """ + The mission of a design (see `_Evaluation`): its planned deployment, the + policy that restores its failures, its cost model and growth, and the + context of the metrics of its phases. + """ + + deployment: Deployment + policy: RestorationPolicy | None + cost_model: CostModel | None + growth: Any + context: Any + + @dataclasses.dataclass(frozen=True, eq=False) class _Evaluation: """ - The evaluation of the satellites of a design (see `ObservationStudy`). + The evaluation of the satellites of a design (see `ObservationStudy`): + the metrics of the observations of every satellite and, with a plan, of + the mission: its deployment and costs, and either the phases of its + deployment or the histories of its failures. """ observations: Observations metrics: Callable[[pd.DataFrame], Mapping[str, Any]] - layout: Any = None + layout: Reference | None = None plan: MissionPlan | None = None failures: Failures | None = None phases: tuple[Requirement, ...] | None = None @@ -518,6 +557,23 @@ class _Evaluation: def __post_init__(self): object.__setattr__(self, "_phase_cache", PhaseCache(self.metrics)) + def __call__(self, satellites: Sequence[Satellite], design: Design) -> dict: + observations = self.observations(satellites, design) + record: dict[str, Any] = {"satellites": len(satellites)} + layout = value_of(design, self.layout) + if layout is not None: + record["planes"] = count_planes(layout) + mission = None + if self.plan is not None: + mission = self._mission(satellites, observations, design, layout) + record.update(self._planned(mission)) + record.update(_given_design(self.metrics, design)(observations)) + if mission is not None and self.failures is not None: + record.update(self._histories(mission, satellites, observations, design)) + elif mission is not None and self.phases is not None: + record.update(self._phases(mission, satellites, observations, design)) + return record + def _policy(self, design: Design) -> tuple[RestorationPolicy | None, Any]: """The policy of a design, and its spares in orbit in each plane.""" base = None if self.failures is None else self.failures.policy @@ -527,90 +583,126 @@ def _policy(self, design: Design) -> tuple[RestorationPolicy | None, Any]: return base, spares return configure(base or RestorationPolicy(), decided), decided.orbit_spares - def __call__(self, satellites: Sequence[Satellite], design: Design) -> dict: - observations = self.observations(satellites, design) - record: dict[str, Any] = {"satellites": len(satellites)} - layout = value_of(design, self.layout) - if layout is not None: - record["planes"] = count_planes(layout) + def _mission( + self, + satellites: Sequence[Satellite], + observations: pd.DataFrame, + design: Design, + layout: Any, + ) -> _Mission: + """ + Plans the mission of a design: its deployment (whose stages read the + capability of the satellites operating at their decisions), policy, + and costs. + """ # the metrics of phases are cached by the observations and, if they # are given the design, by its scenario context = self.observations.context_of(design) if _takes_design(self.metrics): context = (context, _scenario_of(design)) - if self.plan is not None: - policy, spares = self._policy(design) - kind = value_of(design, self.plan.kind) - cost_model = self.plan.cost_model_of(design) - deployment = self.plan.schedule_of(design).plan( - layout, - kind=kind, - spares=spares, - masses=self.plan.masses_of(design, cost_model), - stages=self.plan.stages_of(design), - ) - # the capability that the rules of stages read at their decisions - deployment.capability = Capability( - satellites, observations, self._phase_cache, context, design - ) - growth = self.plan.growth_of(design) - if cost_model is not None: - record.update(cost_model.estimate(deployment, growth).metrics()) - metrics = _given_design(self.metrics, design) - record.update(metrics(observations)) - if self.failures is not None: - histories = deployment.simulate_many( - self.failures.model, - policy, - value_of(design, self.failures.seed), - self.failures.histories, - sampling=self.failures.sampling, - ) - missions = evaluate_missions( - histories, + policy, spares = self._policy(design) + cost_model = self.plan.cost_model_of(design) + deployment = self.plan.schedule_of(design).plan( + layout, + kind=value_of(design, self.plan.kind), + spares=spares, + masses=self.plan.masses_of(design, cost_model), + stages=self.plan.stages_of(design), + ) + deployment.capability = Capability( + satellites, observations, self._phase_cache, context, design + ) + return _Mission( + deployment, policy, cost_model, self.plan.growth_of(design), context + ) + + @staticmethod + def _planned(mission: _Mission) -> dict[str, Any]: + """ + Gets the metrics of a planned mission: the time by which it is + deployed and, with a cost model, its costs. + """ + deployment = mission.deployment + record: dict[str, Any] = { + "deployed": deployment.deployed if deployment.launches else math.nan + } + if mission.cost_model is not None: + estimate = mission.cost_model.estimate(deployment, mission.growth) + record.update(estimate.metrics()) + return record + + def _phases( + self, + mission: _Mission, + satellites: Sequence[Satellite], + observations: pd.DataFrame, + design: Design, + ) -> dict[str, float]: + """Summarizes the metrics of the phases of a planned mission.""" + capability = self._phase_cache.evaluate( + mission.deployment.phases(satellites), + observations, + satellites, + mission.context, + design, + ) + return summarize_phases(capability, requirements=self.phases) + + def _histories( + self, + mission: _Mission, + satellites: Sequence[Satellite], + observations: pd.DataFrame, + design: Design, + ) -> dict[str, float]: + """ + Summarizes histories of the failures of a mission (with exact + expectations of the means of missions that are not restored or + staged, if the failures are exact). + """ + failures = self.failures + histories = mission.deployment.simulate_many( + failures.model, + mission.policy, + value_of(design, failures.seed), + failures.histories, + sampling=failures.sampling, + ) + missions = evaluate_missions( + histories, + satellites, + observations, + self._phase_cache, + context=mission.context, + cost_model=mission.cost_model, + growth=mission.growth, + design=design, + ) + record = summarize_missions( + missions, quantiles=failures.quantiles, requirements=failures.requirements + ) + if ( + failures.exact + and mission.policy is not None + and not mission.policy.restore + and not mission.deployment.stages + ): + exact = expected_missions( + mission.deployment, + failures.model, satellites, observations, self._phase_cache, - context=context, - cost_model=cost_model, - growth=growth, + context=mission.context, design=design, ) record.update( - summarize_missions( - missions, - quantiles=self.failures.quantiles, - requirements=self.failures.requirements, - ) + { + key: value + for key, value in exact.items() + if key.endswith(" mission") or key == "availability" + } ) - # exact expectations are of deployments that are not staged - if ( - self.failures.exact - and policy is not None - and not policy.restore - and not deployment.stages - ): - exact = expected_missions( - deployment, - self.failures.model, - satellites, - observations, - self._phase_cache, - context=context, - design=design, - ) - record.update( - { - key: value - for key, value in exact.items() - if key.endswith(" mean") or key == "availability" - } - ) - elif self.phases is not None: - capability = self._phase_cache.evaluate( - deployment.phases(satellites), observations, satellites, context, design - ) - record.update(summarize_phases(capability, requirements=self.phases)) return record @@ -618,12 +710,46 @@ class ObservationStudy(Study): """ A trade study of the observations of constellations: each replicate of a design builds its satellites, observes the targets of the replicate (see - `Observations`), and records the number of `satellites` (and of `planes`, - with a `layout`), the `metrics` of the observations, and, with a mission - `plan`, the costs of its deployment, and either the summaries of the - histories of its `failures` (see `Failures`) or of the `phases` of its - deployment (see `evaluate_phases` and `summarize_phases`, with - requirements, if any). + `Observations`), and records the metrics of the observations and, with a + mission `plan`, of the mission: its deployment and costs, and either the + `phases` of its deployment (see `evaluate_phases` and `summarize_phases`, + with requirements, if any) or the histories of its `failures` (see + `Failures`):: + + study = ObservationStudy( + space, + build, # the satellites of a design + Observations(Targets(generate_points_rotated_lattice, 100, seed="seed"), START, DAY), + sample, # the metrics of observations + layout="layout", + plan=MissionPlan(SCHEDULE, COST_MODEL), + phases=True, + ) + + Its results have the columns of every study (see `Study.run`) and: + + * `satellites`, and `planes` (with a `layout`): their numbers. + * the metrics of the observations of every satellite (by their names). + * with a plan: `deployed`, the years from the start of development to the + last launch of the planned deployment (without stages that rules decide + to deploy, see `Stage`), and, with a cost model, the costs of the + deployment (`cost`, `cost development`, and so on, see + `CostEstimate.metrics`). + * with phases: ` mission`, the mean of each metric over the + phases of the mission as its satellites are deployed, and + ` time`, the years until a phase first meets each requirement + on a metric (see `summarize_phases`). + * with failures: the means over the histories of the failures of each + replicate of ` mission` (the mean over the phases of each + history), of the measures of the missions (`availability`, `failures`, + `restorations`, and so on, see `MissionHistory.metrics`), and of their + costs; and the `quantiles` of columns over the histories + (` histories p`) and the shares of the histories that + meet `requirements` (`P()`), see `summarize_missions`. + + Statistics over the replicates of these columns (see `Criteria`) judge + designs: such as the mean over the replicates of `accurate mission`, or a + quantile over them of `cost histories p70`. The metrics are a function of the observations of any set of satellites (which may be empty), so that failures and phases evaluate them for the @@ -650,8 +776,9 @@ class ObservationStudy(Study): metrics (Callable): A function of observations (and of the realized design, if it has a parameter named `design`) that gives their metrics (a mapping). - layout (Any): The value of the design that is its layout (see - `value_of` and `layout_of`), if any, which a `plan` requires. + layout (Reference | None): The value of the design that is its + layout (see `value_of` and `layout_of`), if any, which a `plan` + requires. plan (MissionPlan | None): The deployment and costs, if any. failures (Failures | None): The failures, if any, which require a plan. @@ -668,7 +795,7 @@ def __init__( satellites: Callable[[Design], Sequence[Satellite]], observations: Observations, metrics: Callable[[pd.DataFrame], Mapping[str, Any]], - layout: Any = None, + layout: Reference | None = None, plan: MissionPlan | None = None, failures: Failures | None = None, phases: Sequence[Requirement] | bool | None = None, @@ -690,6 +817,19 @@ def __init__( evaluation = _Evaluation(observations, metrics, layout, plan, failures, phases) super().__init__(space, satellites, evaluation, **options) + def _arguments(self) -> dict[str, Any]: + return { + "space": self.space, + "satellites": self.build, + "observations": self.observations, + "metrics": self.metrics, + "layout": self.layout, + "plan": self.plan, + "failures": self.failures, + "phases": self.phases, + **self._settings(), + } + def satellites_of(self, design: Design, replicate: int = 0) -> list[Satellite]: """ Gets the satellites of a replicate of a design. diff --git a/src/tatc/tradespace/optimization.py b/src/tatc/tradespace/optimization.py index 0874c066..5a860029 100644 --- a/src/tatc/tradespace/optimization.py +++ b/src/tatc/tradespace/optimization.py @@ -32,7 +32,7 @@ from __future__ import annotations from collections.abc import Mapping -from dataclasses import dataclass +from dataclasses import dataclass, field from typing import Any import numpy as np @@ -46,7 +46,9 @@ _resolve, _signs, _Statistics, + aggregate, ) +from .pareto import pareto_front from .space import Design, Infeasible from .study import Study @@ -55,11 +57,14 @@ class Search: """ The outcome of a search with an optimizer (see `optimize_optuna` and - `optimize_pymoo`), whose designs and results refine and confirm its - front as for any study (see `refine` and `confirm`):: + `optimize_pymoo`): its `results`, the `summary` of its designs, and the + `designs` themselves, as the outcomes of other steps of a trade study + (see `Refinement`), which refine and confirm its front as for any + study:: search = optimize_optuna(study, criteria, n_trials=200) - refined = refine(study, search.designs, search.results, criteria) + refinement = refine(study, criteria, search.results) + confirmation = confirm(study, criteria, refinement.results) """ results: pd.DataFrame @@ -69,6 +74,10 @@ class Search: state: Any """Any: The optimizer's own outcome: the Optuna study (`optuna.Study`) or the result of pymoo (`pymoo.core.result.Result`).""" + summary: pd.DataFrame = field(default_factory=pd.DataFrame) + """pandas.DataFrame: A row per feasible design: the statistics of the + criteria over its replicates (see `aggregate`), and whether it is + efficient by them (`pareto`, see `pareto_front`).""" class Evaluations: @@ -182,6 +191,25 @@ def _run(self, designs: list[Design]) -> None: for requirement in self.criteria.requirements ) + def search(self, state: Any) -> Search: + """ + Gets the outcome of a search of these evaluations. + + Args: + state (Any): The optimizer's own outcome. + + Returns: + Search: the search + """ + results = self.results + summary = pd.DataFrame() + if len(results) > 0 and results["feasible"].any(): + summary = aggregate(results, self.criteria) + summary = summary.dropna(subset=list(self.criteria.objectives)) + summary = summary.reset_index(drop=True) + summary["pareto"] = pareto_front(summary, self.criteria).to_numpy() + return Search(results, list(self.designs.values()), state, summary) + def worst(self) -> list[float]: """ Gets the worst value of each objective of the feasible designs @@ -335,7 +363,7 @@ def infeasible(trial: Any, violation: float) -> None: optuna_study.tell( trial, list(np.where(np.isnan(values), evaluations.worst(), values)) ) - return Search(evaluations.results, list(evaluations.designs.values()), optuna_study) + return evaluations.search(optuna_study) def make_pymoo_problem(study: Study, criteria: Criteria | Mapping[str, str]) -> Any: @@ -530,4 +558,4 @@ def optimize_pymoo( _eliminate_duplicates(algorithm, problem.duplicates) result = minimize(problem, algorithm, termination, seed=seed, **kwargs) evaluations = problem.evaluations - return Search(evaluations.results, list(evaluations.designs.values()), result) + return evaluations.search(result) diff --git a/src/tatc/tradespace/pareto.py b/src/tatc/tradespace/pareto.py index 321b8bde..57f912e8 100644 --- a/src/tatc/tradespace/pareto.py +++ b/src/tatc/tradespace/pareto.py @@ -25,12 +25,15 @@ Requirement, _across_groups, _as_criteria, + _check_summary, _combiners, _get_tolerances, _groups, _resolve, _signs, _Statistics, + _value_columns, + _with_values, aggregate, ) @@ -156,11 +159,12 @@ def _dominated(costs: np.ndarray, tolerances: np.ndarray | None = None) -> np.nd def pareto_front( - frame: pd.DataFrame, criteria: Criteria | Mapping[str, str] + summary: pd.DataFrame, criteria: Criteria | Mapping[str, str] ) -> pd.Series: """ - Finds the Pareto-efficient (non-dominated) rows of a data frame (such as - the designs of a summary of a study, see `aggregate`): those that meet + Finds the Pareto-efficient (non-dominated) rows of a summary of designs + (a row per design, such as of `aggregate`, not the results of a study, + which have a row per replicate): those that meet the requirements of the criteria (by the columns of their statistics) and that no other row that meets them dominates, being no worse in every objective and better in at least one, in each group of the criteria's @@ -177,31 +181,37 @@ def pareto_front( `summarize`), or by a cheaper analysis (see `screen`). Args: - frame (pandas.DataFrame): The rows (such as designs). + summary (pandas.DataFrame): The rows (such as designs). criteria (Criteria | Mapping[str, str]): The criteria, or the objectives (columns) and their directions (`"min"` or `"max"`). Returns: pandas.Series: whether each row is efficient (boolean, with the - frame's index) + summary's index) + + Raises: + ValueError: if the summary has several rows of a design (in a group + of the criteria's `by`), as the results of a study do. """ criteria = _as_criteria(criteria) + _check_summary(summary, criteria.by) tolerances = _get_tolerances(criteria.objectives, criteria.tolerance) - efficient = np.zeros(len(frame), dtype=bool) - for _, positions in _groups(frame, criteria.by): - group = frame.iloc[positions] + efficient = np.zeros(len(summary), dtype=bool) + for _, positions in _groups(summary, criteria.by): + group = summary.iloc[positions] meets = _get_violation(group, criteria.requirements) == 0 if meets.any(): costs = _get_costs(group[meets], criteria.objectives) efficient[positions[meets]] = ~_dominated(costs, tolerances) - return pd.Series(efficient, index=frame.index, name="pareto") + return pd.Series(efficient, index=summary.index, name="pareto") def pareto_ranks( - frame: pd.DataFrame, criteria: Criteria | Mapping[str, str] + summary: pd.DataFrame, criteria: Criteria | Mapping[str, str] ) -> pd.Series: """ - Ranks the rows of a data frame by non-dominated sorting, in each group + Ranks the rows of a summary of designs (a row per design, see + `pareto_front`) by non-dominated sorting, in each group of the criteria's `by`: rank 0 is the Pareto front (see `pareto_front`), rank 1 the front of the others, and so on, with the tolerances of the criteria. Rows that miss the requirements of the criteria are ranked @@ -209,18 +219,23 @@ def pareto_ranks( violations of the requirements, see `Requirement`). Args: - frame (pandas.DataFrame): The rows (such as designs). + summary (pandas.DataFrame): The rows (such as designs). criteria (Criteria | Mapping[str, str]): The criteria, or the objectives (columns) and their directions (`"min"` or `"max"`). Returns: - pandas.Series: the rank of each row (with the frame's index) + pandas.Series: the rank of each row (with the summary's index) + + Raises: + ValueError: if the summary has several rows of a design (in a group + of the criteria's `by`), as the results of a study do. """ criteria = _as_criteria(criteria) + _check_summary(summary, criteria.by) tolerances = _get_tolerances(criteria.objectives, criteria.tolerance) - ranks = np.full(len(frame), -1, dtype=int) - for _, positions in _groups(frame, criteria.by): - group = frame.iloc[positions] + ranks = np.full(len(summary), -1, dtype=int) + for _, positions in _groups(summary, criteria.by): + group = summary.iloc[positions] violation = _get_violation(group, criteria.requirements) meets = violation == 0 costs = _get_costs(group[meets], criteria.objectives) @@ -234,7 +249,7 @@ def pareto_ranks( if (~meets).any(): order = pd.Series(violation[~meets]).rank(method="dense").to_numpy() ranks[positions[~meets]] = rank + order.astype(int) - 1 - return pd.Series(ranks, index=frame.index, name="pareto_rank") + return pd.Series(ranks, index=summary.index, name="pareto_rank") def _hypervolume(points: np.ndarray, reference: np.ndarray) -> float: @@ -265,12 +280,13 @@ def _hypervolume(points: np.ndarray, reference: np.ndarray) -> float: def hypervolume( - frame: pd.DataFrame, + summary: pd.DataFrame, criteria: Criteria | Mapping[str, str], reference: Mapping[str, float] | Sequence[float], ) -> float: """ - Computes the hypervolume of the rows of a data frame: the volume of the + Computes the hypervolume of the rows of a summary of designs (a row per + design, see `pareto_front`): the volume of the objective space that they dominate, up to a reference point that is worse than every row of interest in every objective. Rows that are not better than the reference in every objective, or that miss the @@ -283,7 +299,7 @@ def hypervolume( which takes long with many objectives and many efficient rows. Args: - frame (pandas.DataFrame): The rows (such as designs), of one group + summary (pandas.DataFrame): The rows (such as designs), of one group (criteria with `by` are not accepted). criteria (Criteria | Mapping[str, str]): The criteria, or the objectives (columns) and their directions (`"min"` or `"max"`). @@ -292,22 +308,28 @@ def hypervolume( Returns: float: the hypervolume, in the product of the units of the objectives + + Raises: + ValueError: if the summary has several rows of a design, as the + results of a study do (see `hypervolume_progress` for those of a + search). """ criteria = _as_criteria(criteria) if criteria.by: raise ValueError( "a hypervolume is of the rows of one group: give criteria without `by`" ) + _check_summary(summary) objectives = criteria.objectives if isinstance(reference, Mapping): reference = [reference[column] for column in objectives] if len(reference) != len(objectives): raise ValueError("the reference point needs a value for each objective") bound = _signs(criteria) * np.asarray(reference, dtype=float) - if len(frame) == 0: + if len(summary) == 0: return 0.0 - frame = frame[_get_violation(frame, criteria.requirements) == 0] - costs = _get_costs(frame, objectives) + summary = summary[_get_violation(summary, criteria.requirements) == 0] + costs = _get_costs(summary, objectives) costs = costs[np.all(costs < bound, axis=1)] return _hypervolume(costs, bound) @@ -361,6 +383,7 @@ def pareto_probability( criteria: Criteria | Mapping[str, str], n_resamples: int = 500, seed: int = 0, + design_columns: Sequence[str] | None = None, ) -> pd.DataFrame: """ Estimates the probability that each design is Pareto-efficient by @@ -395,9 +418,13 @@ def pareto_probability( (`"min"` or `"max"`). n_resamples (int): The number of resamples. seed (int): The seed of the resamples. + design_columns (Sequence[str] | None): The columns of the values of + designs, or `None` for those that are the same in every + replicate of a design (see `aggregate`). Returns: - pandas.DataFrame: a row per design (and group): the statistics of + pandas.DataFrame: a row per design (and group): the values of the + design (see `aggregate`), the statistics of the criteria over every replicate, the standard error of each objective (` se`, its standard deviation over the resamples), the number of `replicates`, @@ -415,6 +442,9 @@ def pareto_probability( feasible = results[results["feasible"]] if "feasible" in results else results combiners = None if criteria.across is None else _combiners(criteria) groups = _across_groups(results, criteria.across) + columns = _value_columns( + feasible, resolved, criteria.by, criteria.across, design_columns + ) rng = np.random.default_rng(seed) frames = [] for key, positions in _groups(feasible, criteria.by): @@ -458,6 +488,7 @@ def front(values, violation): frame = pd.DataFrame({"design": designs}) for name, value in zip(criteria.by, key): frame[name] = value + _with_values(frame, group, designs, columns) for name, value in values.items(): frame[name] = value for name in criteria.objectives: diff --git a/src/tatc/tradespace/refinement.py b/src/tatc/tradespace/refinement.py index 4f96f5b7..8c73c2c2 100644 --- a/src/tatc/tradespace/refinement.py +++ b/src/tatc/tradespace/refinement.py @@ -16,46 +16,55 @@ from .criteria import Criteria, _as_criteria, _get_tolerances from .pareto import pareto_probability -from .space import Design +from .space import Design, _designs from .study import Study @dataclass class Refinement: """ - The outcome of an adaptive replication (see `refine`). + The outcome of an adaptive replication (see `refine`): as the outcomes of + other steps of a trade study (see `Confirmation`, `Screening`, and + `Search`), its `results`, the `summary` of its designs, and the `designs` + themselves, for the next step:: + + refinement = refine(study, criteria, results) + confirmation = confirm(study, criteria, refinement.results) """ results: pd.DataFrame """pandas.DataFrame: The results of every evaluation, those given and those added (see `Study.run`).""" - probability: pd.DataFrame - """pandas.DataFrame: The probability that each design is efficient after - the last round (see `pareto_probability`), and whether its efficiency is - `uncertain` (by the bounds of `refine`, or with fewer than its least - replicates) and, if so, whether it is `indifferent` (its objectives are - known to within the precision of their tolerances).""" + summary: pd.DataFrame + """pandas.DataFrame: A row per design (and group of the criteria's `by`): + the probability that it is efficient after the last round (see + `pareto_probability`, with the values of the design), and whether its + efficiency is `uncertain` (by the bounds of `refine`, or with fewer than + its least replicates) and, if so, whether it is `indifferent` (its + objectives are known to within the precision of their tolerances).""" history: pd.DataFrame = field(default_factory=pd.DataFrame) """pandas.DataFrame: For each round, the number of designs whose efficiency is uncertain (`uncertain`), of these, those that are indifferent (`indifferent`), the number to which replicates were added (`refined`), and the evaluations added (`evaluations`).""" + designs: list[Design] = field(default_factory=list) + """list[Design]: The designs that could be refined.""" @property def uncertain(self) -> pd.DataFrame: - """pandas.DataFrame: The rows of `probability` whose efficiency is - still uncertain, and that more replicates would settle (those that are - not indifferent).""" - probability = self.probability - return probability[probability["uncertain"] & ~probability["indifferent"]] + """pandas.DataFrame: The rows of `summary` whose efficiency is still + uncertain, and that more replicates would settle (those that are not + indifferent).""" + summary = self.summary + return summary[summary["uncertain"] & ~summary["indifferent"]] @property def indifferent(self) -> pd.DataFrame: - """pandas.DataFrame: The rows of `probability` whose efficiency is + """pandas.DataFrame: The rows of `summary` whose efficiency is uncertain, but whose objectives are known to within the precision of their tolerances, so that whether they are within the tolerances of the front does not matter.""" - return self.probability[self.probability["indifferent"]] + return self.summary[self.summary["indifferent"]] def _precise( @@ -84,9 +93,10 @@ def _precise( def refine( study: Study, - designs: Sequence[Design], - results: pd.DataFrame, criteria: Criteria | Mapping[str, str], + results: pd.DataFrame, + designs: Sequence[Design | str] | pd.DataFrame | None = None, + *, bounds: tuple[float, float] = (0.05, 0.95), step: int | None = None, max_replicates: int | None = None, @@ -139,13 +149,17 @@ def refine( Args: study (Study): The study that evaluates designs. - designs (Sequence[Design]): The designs (those of the results). - results (pandas.DataFrame): The results of the designs (see - `Study.run`). criteria (Criteria | Mapping[str, str]): The criteria, or the objectives (metrics whose means they are) and their directions (`"min"` or `"max"`). A design is uncertain if it is in any group of the criteria's `by`. + results (pandas.DataFrame): The results of the designs (see + `Study.run`), such as those of an enumeration or a search. + designs (Sequence[Design | str] | pandas.DataFrame | None): The + designs that may be refined (designs, their keys, or a data + frame of them, such as rows of a summary), or `None` for every + design of the results (rebuilt from them, see + `DesignSpace.designs_of`). bounds (tuple[float, float]): The probabilities between which a design is uncertain. step (int | None): The replicates added to an uncertain design in a @@ -166,7 +180,8 @@ def refine( seed (int): The seed of the bootstraps. Returns: - Refinement: the results, the final probabilities, and the history + Refinement: the results, the final probabilities, the history, and + the designs """ criteria = _as_criteria(criteria) low, high = bounds @@ -181,7 +196,8 @@ def refine( raise ValueError("precision must be positive (or None)") if budget is not None and budget < 0: raise ValueError("budget must not be negative") - by_key = {design.key: design for design in designs} + refined = _designs(study.space, results if designs is None else designs, results) + by_key = {design.key: design for design in refined} frames = [results] history = [] spent = 0 @@ -289,6 +305,7 @@ def estimate(round_: int) -> pd.DataFrame: ) return Refinement( results=pd.concat(frames, ignore_index=True), - probability=probability, + summary=probability, history=pd.DataFrame(history), + designs=refined, ) diff --git a/src/tatc/tradespace/scenarios.py b/src/tatc/tradespace/scenarios.py index c7602586..a809c378 100644 --- a/src/tatc/tradespace/scenarios.py +++ b/src/tatc/tradespace/scenarios.py @@ -52,7 +52,7 @@ def robustness( each scenario, from the results of a study in each scenario (judged by the criteria in each scenario, see `aggregate` and `pareto_front`). - * `pareto trace`: the share of the scenarios in which the design is + * `pareto_trace`: the share of the scenarios in which the design is efficient (with the tolerances of the criteria, within which designs near the front are efficient, as in epoch-era analysis's fuzzy normalized Pareto trace). A design efficient in every scenario has a @@ -64,7 +64,7 @@ def robustness( and infinite if it misses the requirements of the criteria (or is infeasible in every replicate). With one objective, it is the difference from the best design. - * `max regret`: the largest regret of the design over the scenarios, which + * `max_regret`: the largest regret of the design over the scenarios, which the most robust designs minimize (minimax regret). With objectives of few levels (such as numbers of satellites), regret is @@ -90,8 +90,8 @@ def robustness( objective (if it has one), or else 1 (its units). Returns: - pandas.DataFrame: a row per design (`design`): its `pareto trace`, - `max regret`, and regret in each scenario (` regret`) + pandas.DataFrame: a row per design (`design`): its `pareto_trace`, + `max_regret`, and regret in each scenario (` regret`) Raises: ValueError: if the results have no scenarios, or the criteria group @@ -144,8 +144,8 @@ def robustness( frame = pd.DataFrame( { "design": designs, - "pareto trace": (trace / max(len(scenarios), 1)).to_numpy(), - "max regret": regret.max(axis=1).to_numpy(), + "pareto_trace": (trace / max(len(scenarios), 1)).to_numpy(), + "max_regret": regret.max(axis=1).to_numpy(), } ) for name in scenarios: diff --git a/src/tatc/tradespace/screening.py b/src/tatc/tradespace/screening.py index 661d87d8..3c4ca485 100644 --- a/src/tatc/tradespace/screening.py +++ b/src/tatc/tradespace/screening.py @@ -10,20 +10,22 @@ import math from collections.abc import Mapping, Sequence -from dataclasses import dataclass, field, replace +from dataclasses import dataclass, field import pandas as pd -from .criteria import Criteria, Tolerance, _as_criteria, aggregate +from .criteria import Criteria, _as_criteria, aggregate from .pareto import pareto_ranks -from .space import Design +from .space import Design, _designs from .study import Study @dataclass class Screening: """ - The outcome of a screening (see `screen`). + The outcome of a screening (see `screen`): its `results`, the `summary` + of the designs of its last stage, and the `designs` themselves, as the + outcomes of other steps of a trade study (see `Refinement`). """ results: pd.DataFrame @@ -37,7 +39,7 @@ class Screening: """list[Design]: The designs analyzed in the last stage.""" @property - def final(self) -> pd.DataFrame: + def summary(self) -> pd.DataFrame: """pandas.DataFrame: The summary of the last stage.""" return self.summaries[-1] @@ -54,13 +56,11 @@ def _per_stage(value, count: int, name: str) -> list: def screen( - designs: Sequence[Design], studies: Sequence[Study], - criteria: Criteria | Mapping[str, str], + criteria: Criteria | Mapping[str, str] | Sequence[Criteria | Mapping[str, str]], + designs: Sequence[Design] | pd.DataFrame, + *, keep: float | int | Sequence[float | int] = 0.25, - tolerance: ( - Mapping[str, Tolerance] | Sequence[Mapping[str, Tolerance] | None] | None - ) = None, ) -> Screening: """ Screens designs with studies of increasing fidelity (and cost): each @@ -80,61 +80,62 @@ def screen( A cheap analysis ranks designs less exactly than an expensive one, so a design it ranks just behind another may be better: keep enough designs, - or give a `tolerance` of each objective for the stages of cheap analyses - (in the units of the stage's analysis, in place of the criteria's), + or give the stages of cheap analyses criteria of their own, with a + tolerance of each objective (in the units of the stage's analysis) within which differences do not separate fronts (see `pareto_front`), - so that nearly efficient designs are kept. The last stage ranks designs - with the tolerances of the criteria. Compare the - final front with one found without screening on a sample of designs to - check that screening does not lose efficient designs. + so that nearly efficient designs are kept:: + + cheap = Criteria(objectives, tolerance={"sufficient": 5.0}) + screening = screen([quick, full], [cheap, objectives], designs, keep=0.1) + + Compare the final front with one found without screening on a sample of + designs to check that screening does not lose efficient designs. Args: - designs (Sequence[Design]): The designs to screen. studies (Sequence[Study]): The studies of each stage, in order of increasing fidelity. - criteria (Criteria | Mapping[str, str]): The criteria, without - `by` (see `Criteria`), or the objectives (metrics whose means they - are) and their directions (`"min"` or `"max"`). + criteria (Criteria | Mapping[str, str] | Sequence): The criteria, + without `by` (see `Criteria`), or the objectives (metrics whose + means they are) and their directions (`"min"` or `"max"`): the + same for every stage, or those of each stage. + designs (Sequence[Design] | pandas.DataFrame): The designs to + screen, or a data frame of their values (see + `DesignSpace.designs_of`). keep (float | int | Sequence): The designs kept by each stage but the last: a number (int), or a share of its feasible designs (float), or a value for each stage. - tolerance (Mapping | Sequence | None): The tolerances of objectives - in each stage but the last, in place of those of the criteria - (see `Criteria`): the same for each stage, or one for each (`None` - for the criteria's). Returns: - Screening: the results and summaries of each stage + Screening: the results and summaries of each stage, and the designs + of the last """ - criteria = _as_criteria(criteria) - if criteria.by: - raise ValueError( - "screening ranks designs by one record per evaluation: " - + "give criteria without `by`" - ) if len(studies) == 0: raise ValueError("at least one study is required") transitions = len(studies) - 1 keeps = _per_stage(keep, transitions, "keep") - if tolerance is None or isinstance(tolerance, Mapping): - tolerances = [tolerance] * transitions + if isinstance(criteria, (Criteria, Mapping)): + stages = [_as_criteria(criteria)] * len(studies) else: - tolerances = _per_stage(tolerance, transitions, "tolerance") - # the criteria of each stage: with the tolerance of a cheap stage, if any - stages = [ - criteria if value is None else replace(criteria, tolerance=value) - for value in tolerances - ] + [criteria] - current = list({design.key: design for design in designs}.values()) + stages = [ + _as_criteria(c) for c in _per_stage(criteria, len(studies), "criteria") + ] + for criteria in stages: + if criteria.by: + raise ValueError( + "screening ranks designs by one record per evaluation: " + + "give criteria without `by`" + ) + current = _designs(studies[0].space, designs) screening = Screening(results=pd.DataFrame()) frames = [] for stage, study in enumerate(studies): + criteria = stages[stage] results = study.run(current).assign(stage=stage) frames.append(results) - summary = aggregate(results, criteria, design_columns=[]) + summary = aggregate(results, criteria) summary = summary.dropna(subset=list(criteria.objectives)) summary = summary.reset_index(drop=True) - summary["pareto_rank"] = pareto_ranks(summary, stages[stage]) + summary["pareto_rank"] = pareto_ranks(summary, criteria) if stage < transitions: amount = keeps[stage] count = ( diff --git a/src/tatc/tradespace/sensitivity.py b/src/tatc/tradespace/sensitivity.py index 29eb874b..cc45e023 100644 --- a/src/tatc/tradespace/sensitivity.py +++ b/src/tatc/tradespace/sensitivity.py @@ -13,6 +13,8 @@ import numpy as np import pandas as pd +from .criteria import _check_summary + def _levels(values: pd.Series, max_levels: int) -> pd.Series: """ @@ -25,7 +27,7 @@ def _levels(values: pd.Series, max_levels: int) -> pd.Series: def main_effects( - frame: pd.DataFrame, variable: str, metric: str, max_levels: int = 10 + summary: pd.DataFrame, variable: str, metric: str, max_levels: int = 10 ) -> pd.DataFrame: """ Computes the main effects of a design variable on a metric: the mean (and @@ -34,9 +36,9 @@ def main_effects( (not `NaN`, as a variable of a branch not chosen is). Args: - frame (pandas.DataFrame): The designs, with their values (see - `Design.flat`) and metrics (such as a summary of a study, see - `summarize` or `aggregate`). + summary (pandas.DataFrame): The designs, a row each, with their + values (see `Design.flat`) and metrics (such as a summary of a + study, see `aggregate`). variable (str): The column of the variable. metric (str): The column of the metric. max_levels (int): The most levels of a numeric variable, beyond which @@ -46,13 +48,14 @@ def main_effects( pandas.DataFrame: a row per level: the `mean`, `std`, and `count` of the metric """ - active = frame.dropna(subset=[variable, metric]) + _check_summary(summary) + active = summary.dropna(subset=[variable, metric]) levels = _levels(active[variable], max_levels) return active.groupby(levels, sort=True)[metric].agg(["mean", "std", "count"]) def sensitivity( - frame: pd.DataFrame, + summary: pd.DataFrame, variables: Sequence[str], metrics: Sequence[str], max_levels: int = 10, @@ -84,9 +87,9 @@ def sensitivity( different designs, and compare how much each matters where it applies. Args: - frame (pandas.DataFrame): The designs, with their values (see - `Design.flat`) and metrics (such as a summary of a study, see - `summarize` or `aggregate`). + summary (pandas.DataFrame): The designs, a row each, with their + values (see `Design.flat`) and metrics (such as a summary of a + study, see `aggregate`, which keeps the values of the designs). variables (Sequence[str]): The columns of the variables. metrics (Sequence[str]): The columns of the metrics. max_levels (int): The most levels of a numeric variable, beyond which @@ -99,13 +102,14 @@ def sensitivity( variance it explains, and the share of designs in which it is `active`, sorted by the share of the first metric """ + _check_summary(summary) rows = [] for variable in variables: row: dict = {"variable": variable} - active = frame[variable].notna() + active = summary[variable].notna() row["active"] = float(active.mean()) for metric in metrics: - subset = frame[active & frame[metric].notna()] + subset = summary[active & summary[metric].notna()] values = subset[metric].astype(float) total = float(((values - values.mean()) ** 2).sum()) if len(subset) < 2 or total == 0: diff --git a/src/tatc/tradespace/space.py b/src/tatc/tradespace/space.py index b41708b9..b3ebbc7d 100644 --- a/src/tatc/tradespace/space.py +++ b/src/tatc/tradespace/space.py @@ -24,6 +24,7 @@ import hashlib import json +import math import re import zlib from collections.abc import Callable, Iterable, Iterator, Mapping, Sequence @@ -31,6 +32,7 @@ from typing import Any import numpy as np +import pandas as pd from .fingerprint import _Describer from .nodes import ( @@ -625,22 +627,121 @@ def _design(self, ctx: _Context) -> Design: values, decisions = _walk(self, "", Scope(), ctx) return Design(self, decisions, values) - def design(self, decisions: dict) -> Design: + def design( + self, decisions: Mapping | Design | None = None, /, **overrides: Any + ) -> Design: """ - Gets the design of given decisions (see `Design.decisions`), checking - its constraints. + Gets the design of given decisions (see `Design.decisions`), or of the + decisions of another design (such as of a design space this one + extends, see `extend`), with the decisions of some children replaced + (by name: a value, the decisions of a group or a choice, or a design + of their own space), checking its constraints:: + + space = base.extend(policy=policy_space(orbit_spares=Integer(0, 1))) + design = space.design(base_design, policy=policy_design) Args: - decisions (dict): The decisions. + decisions (Mapping | Design | None): The decisions, or a design + whose decisions to take. + **overrides (Any): The decisions of children, by name. Returns: Design: the design Raises: Infeasible: if the design violates a constraint. + ValueError: if an override names no child of the design space. """ - values, decisions = _walk(self, "", Scope(), _Context(), decisions) - return Design(self, decisions, values) + if isinstance(decisions, Design): + decisions = decisions.decisions + merged = dict(decisions or {}) + unknown = sorted(set(overrides) - set(self.children)) + if unknown: + raise ValueError(f"no children {unknown} of the design space") + for name, decision in overrides.items(): + merged[name] = ( + decision.decisions if isinstance(decision, Design) else decision + ) + values, merged = _walk(self, "", Scope(), _Context(), merged) + return Design(self, merged, values) + + def extend( + self, constraints: Sequence[Callable[[Scope], Any]] = (), **children: Any + ) -> DesignSpace: + """ + Gets a design space with other children: those named as children of + this one replace them (in their place), and others are added after + them, with this one's constraints and others. This one is unchanged:: + + policy_trade = space.extend(policy=policy_space(orbit_spares=Integer(0, 1))) + year = space.extend(epoch=Uncertain(draw_epoch)) + + Designs of this design space are designs of the other with the + decisions of its new children (see `design`). + + Args: + constraints (Sequence[Callable]): Other constraints. + **children (Any): The nodes, by name. + + Returns: + DesignSpace: the design space + """ + return DesignSpace( + [*self.constraints, *constraints], **{**self.children, **children} + ) + + def designs_of( + self, frame: pd.DataFrame, keys: Iterable[str] | None = None + ) -> list[Design]: + """ + Rebuilds designs from the rows of a data frame of their values by path + (see `Design.flat`): the results of a study (see `Study.run`), or a + summary that keeps the values of the designs (see `aggregate`). Each + design is rebuilt once, from its first row, in the order of its first + row (or of `keys`), and must have the key of its row (`design`, a + column or the name of the index), if the frame has one:: + + front = summary[pareto_front(summary, criteria)] + designs = space.designs_of(front) + + Args: + frame (pandas.DataFrame): The rows. + keys (Iterable[str] | None): The keys of the designs to rebuild, + or `None` for every design of the frame. + + Returns: + list[Design]: the designs + + Raises: + KeyError: if the frame has no rows of a key. + ValueError: if the frame lacks the value of a decision of a + design, or its values give a design of another key. + """ + rows = frame + if "design" not in rows.columns and rows.index.name == "design": + rows = rows.reset_index() + if "design" in rows.columns: + first = rows.drop_duplicates("design") + records = dict(zip(first["design"], first.to_dict("records"))) + order = list(records) if keys is None else list(dict.fromkeys(keys)) + missing = [key for key in order if key not in records] + if missing: + raise KeyError(f"no rows of designs {missing[:5]}") + pairs = [(key, records[key]) for key in order] + else: + if keys is not None: + raise ValueError("the frame has no keys of designs (`design`)") + pairs = [(None, record) for record in rows.to_dict("records")] + designs: dict[str, Design] = {} + for key, record in pairs: + design = self._design(_Context(choose=partial(_decided, record))) + if key is not None and design.key != key: + raise ValueError( + f"the values of design {key} give another design ({design.key}): " + + "are they of another design space?" + ) + designs.setdefault(design.key, design) + return list(designs.values()) def enumerate(self) -> list[Design]: """ @@ -899,6 +1000,96 @@ def _fixed_paths(node: Node, path: str) -> list[str]: return [] +def _missing(value: Any) -> bool: + """Whether a value of a data frame is missing (`None` or `NaN`).""" + return value is None or (isinstance(value, float) and math.isnan(value)) + + +def _decided(values: Mapping[str, Any], path: str, domain: _Domain) -> Any: + """ + Gets the decision of a path from values by path (such as a row of the + results of a study, see `DesignSpace.designs_of`): the level of the domain + that equals the value (whose type a data frame may have changed, as + integers in a column of floats), or the value of a continuous domain. + """ + value = values.get(path) + if _missing(value): + raise ValueError( + f"no value of {path}: rebuild designs from the results of a study, or " + + "from a summary that keeps the values of designs (see aggregate)" + ) + if domain.levels is None: + return float(value) + for level in domain.levels: + try: + if level == value: + return level + except (TypeError, ValueError): + continue + numeric = [ + level + for level in domain.levels + if isinstance(level, (int, float, np.number)) and not isinstance(level, bool) + ] + if isinstance(value, (int, float, np.number)): + for level in numeric: + if math.isclose(float(level), float(value), rel_tol=1e-9, abs_tol=1e-12): + return level + raise ValueError(f"{value!r} is not a level of {path} ({domain.levels})") + + +def _designs( + space: DesignSpace, + designs: Iterable[Design | str] | pd.DataFrame, + *frames: pd.DataFrame, +) -> list[Design]: + """ + Gets designs given as designs, keys, or a data frame of designs (with + their keys, `design`), each once, in order: designs given by their keys + are rebuilt from the values of the frame (if it has them) or of other + frames (such as the results of a study, see `DesignSpace.designs_of`). + """ + if isinstance(designs, pd.DataFrame): + if "design" in designs.columns: + items = list(designs["design"]) + elif designs.index.name == "design": + items = list(designs.index) + else: + raise ValueError("the data frame has no keys of designs (`design`)") + frames = (designs, *frames) + else: + items = list(designs) + found: dict[str, Design | None] = {} + for item in items: + if isinstance(item, Design): + found[item.key] = item + elif isinstance(item, str): + found.setdefault(item, None) + else: + raise TypeError(f"a design or the key of one, not {item!r}") + for frame in frames: + missing = [key for key, design in found.items() if design is None] + if not missing: + break + rows = frame.reset_index() if "design" not in frame else frame + if "design" not in rows: + continue + present = [key for key in missing if key in set(rows["design"])] + try: + for design in space.designs_of(rows, present): + found[design.key] = design + except ValueError: + continue # the frame lacks values of the designs: try the next + missing = [key for key, design in found.items() if design is None] + if missing: + raise ValueError( + f"the values of designs {missing[:5]} are not given: give the designs, " + + "or their keys with the results of a study (or a summary that keeps " + + "the values of designs, see aggregate)" + ) + return [design for design in found.values() if design is not None] + + def _check_scenario(space: DesignSpace, values: Mapping[str, Any]) -> None: """ Checks that the values of a scenario are of fixed values or uncertain diff --git a/src/tatc/tradespace/store.py b/src/tatc/tradespace/store.py index bb830bec..b2bd5ea8 100644 --- a/src/tatc/tradespace/store.py +++ b/src/tatc/tradespace/store.py @@ -112,8 +112,9 @@ class ResultStore: data frames of targets they close over or refer to, by their content), but not data that they read (such as from files) nor the code of other modules they call (other than TAT-C's): a `namespace` identifies these, - and must change whenever they do. Several studies may share a file, in - their own namespaces. + and must change whenever they do. Studies of other definitions (such as + variants of a study) may share a namespace, as their fingerprints keep + their records apart, and several namespaces may share a file. Records are kept as JSON (in the column `records` of the table `results`, a list of records per evaluation), which other tools can read: numbers @@ -124,8 +125,8 @@ class ResultStore: Args: path (str | os.PathLike): The database file (created if needed). - namespace (str): An identifier of the study (and of what its - fingerprint cannot see). + namespace (str): An identifier of what the fingerprints of the + studies cannot see (such as data they read from files), if any. """ def __init__(self, path: str | os.PathLike, namespace: str = ""): diff --git a/src/tatc/tradespace/study.py b/src/tatc/tradespace/study.py index 1e25ae10..16470ff5 100644 --- a/src/tatc/tradespace/study.py +++ b/src/tatc/tradespace/study.py @@ -21,7 +21,12 @@ import pandas as pd from pydantic import ValidationError -from .fingerprint import _fingerprint_of, compare_definitions, get_definition +from .fingerprint import ( + _fingerprint_of, + _without_code, + compare_definitions, + get_definition, +) from .nodes import Infeasible from .space import ( Design, @@ -29,6 +34,7 @@ _check_scenario, _check_uncertain, _describe_scenario, + _designs, ) from .store import ResultStore @@ -81,7 +87,11 @@ def _get_executor(n_jobs: int) -> Executor: class Study: """ A trade study: designs from a design space, each built into an - architecture (or any object to evaluate) and evaluated in replicates. + architecture (or any object to evaluate) and evaluated in replicates:: + + study = Study(space, build, evaluate, replicates=5, n_jobs=-1, store=store) + results = study.run() # every design, a row per replicate + more = study.replace(replicates=20).run(designs) Each replicate realizes a design (see `Design.realize`), builds it with `build`, and evaluates the result with `evaluate`, which returns its @@ -176,7 +186,11 @@ def evaluate(satellites, design): fingerprint, see `fingerprint`) are taken rather than evaluated again, and to which new ones are added as they complete (see `ResultStore`), by the workers that evaluate them (so its file - must be reachable from them). + must be reachable from them). Studies of other definitions may + share a store (and its namespace): their fingerprints keep their + evaluations apart. A warning is given if the store has + evaluations of the same study with other code (of its functions, + of TAT-C, or of Python), which are not reused. scenarios (Mapping[str, Mapping[str, Any]] | None): The scenarios in which to evaluate designs, if any: the values of fixed values and uncertain parameters of each (by path), by name. @@ -340,6 +354,61 @@ def _cases(self, shift: Mapping[str, int]) -> list[_Case]: for name, values in self.scenarios.items() ] + def replace(self, **changes: Any) -> Study: + """ + Gets a study like this one with some of its arguments changed (by + name, as of its class), such as a variant with more replicates, in + scenarios, or of another design space:: + + confirming = study.replace(replicates=20) + policies = study.replace(space=space.extend(policy=POLICY)) + + Args: + **changes (Any): The arguments to change. + + Returns: + Study: the study, of the same class + + Raises: + TypeError: if a change names no argument of the study's class. + """ + arguments = self._arguments() + unknown = sorted(set(changes) - set(arguments)) + if unknown: + raise TypeError(f"{type(self).__name__} has no arguments {unknown}") + return type(self)(**{**arguments, **changes}) + + def _arguments(self) -> dict[str, Any]: + """ + Gets the arguments of the study, by name, from which `replace` makes + another (a subclass with other arguments gives its own). + """ + if type(self).__init__ is not Study.__init__: + raise TypeError( + f"{type(self).__name__} does not give its arguments to replace" + ) + return { + "space": self.space, + "build": self.build, + "evaluate": self.evaluate, + **self._settings(), + } + + def _settings(self) -> dict[str, Any]: + """Gets the settings of the study (the arguments of every study but + its design space and functions), by name.""" + return { + "replicates": self.replicates, + "seed": self.seed, + "common_random_numbers": self.common_random_numbers, + "n_jobs": self.n_jobs, + "executor": self.executor, + "chunks_per_job": self.chunks_per_job, + "store": self.store, + "errors": self.errors, + "scenarios": self.scenarios, + } + @property def definition(self) -> dict: """dict: The definition of the study (see `get_definition`), which @@ -377,7 +446,7 @@ def workers(self) -> int: def run( self, - designs: Iterable[Design] | None = None, + designs: Iterable[Design] | pd.DataFrame | None = None, progress: Callable[[int, int], None] | None = None, replicates: Iterable[int] | None = None, shift: Mapping[str, int] | None = None, @@ -399,9 +468,10 @@ def run( scenario in each replicate. Args: - designs (Iterable[Design] | None): The designs, or `None` for - every design of the design space (see - `DesignSpace.enumerate`). + designs (Iterable[Design] | pandas.DataFrame | None): The designs, + a data frame of their values (such as a summary that keeps + them, see `DesignSpace.designs_of`), or `None` for every + design of the design space (see `DesignSpace.enumerate`). progress (Callable | None): A function called as evaluations complete with the number completed and the number of evaluations (not counting those taken from the store). @@ -424,8 +494,9 @@ def run( shift = {name: int(offset) for name, offset in (shift or {}).items() if offset} _check_uncertain(self.space, shift) cases = self._cases(shift) - designs = self.space.enumerate() if designs is None else designs - unique = list({design.key: design for design in designs}.values()) + unique = ( + self.space.enumerate() if designs is None else _designs(self.space, designs) + ) # tasks in the order of replicates (and scenarios), whose designs share # uncertain values tasks = [ @@ -594,27 +665,32 @@ def _takes_design(function: Callable) -> bool: def _warn_other_definitions(store: ResultStore, context: str, definition: dict) -> None: """ - Warns if a store has evaluations of its namespace by studies of other - definitions (which a study does not reuse), with the differences from - the definition of the latest (see `compare_definitions`). + Warns if a store has evaluations of its namespace by the same study with + other code (its functions', TAT-C's, or Python's: the same values but for + the code of functions, see `_without_code`), which a study does not + reuse, with the differences (see `compare_definitions`). Studies of other + values (such as other settings) share a namespace without a warning, as + their fingerprints keep their evaluations apart. """ - others = { - other: count for other, count in store.contexts().items() if other != context - } + contexts = store.contexts() + others = [other for other in contexts if other != context] if not others: return - message = ( - f"the store has {sum(others.values())} evaluations of namespace " - + f"{store.namespace!r} by studies of other definitions, which are not " - + "reused (see Study.fingerprint)" - ) - for other in reversed(list(others)): + values = _without_code(definition.get("values", {})) + for other in reversed(others): before = store.definition(other) - if before is not None: - differences = compare_definitions(before, definition) - message += "; the latest differs in: " + "; ".join(differences) - break - warnings.warn(message, stacklevel=3) + if before is None or _without_code(before.get("values", {})) != values: + continue + differences = compare_definitions(before, definition) + warnings.warn( + f"the store has {contexts[other]} evaluations of namespace " + + f"{store.namespace!r} by this study with other code, which are not " + + "reused (see Study.fingerprint, and ResultStore.prune to remove " + + "them); it differs in: " + + "; ".join(differences), + stacklevel=3, + ) + return def _unstored(records: list[dict]) -> bool: diff --git a/tests/tradespace/test_attribution.py b/tests/tradespace/test_attribution.py index 875cd51f..8a60bb6d 100644 --- a/tests/tradespace/test_attribution.py +++ b/tests/tradespace/test_attribution.py @@ -61,8 +61,8 @@ def setUpClass(cls): cls.designs = SPACE.enumerate() cls.attribution = attribute_variance( cls.study, - cls.designs, ["y", "z", "v", "w"], + cls.designs, replicates=300, n_resamples=200, ) @@ -125,6 +125,12 @@ def test_results(self): np.testing.assert_array_equal(mixed.u1, a.loc[shifted].u1) np.testing.assert_array_equal(mixed.u2, a.loc[mixed.index].u2) + def test_designs_of_frame(self): + """Designs may be given by a data frame of their values.""" + frame = pd.DataFrame([{"design": d.key, **d.flat()} for d in self.designs]) + a = attribute_variance(self.study, ["y"], frame.iloc[:1], replicates=2) + self.assertEqual(set(a.shares.design), {self.designs[0].key}) + def test_summary(self): """The summary pools the designs' shares, weighted by their variances.""" a = self.attribution @@ -154,8 +160,8 @@ def test_groups(self): """Groups of parameters are redrawn together.""" a = attribute_variance( self.study, - self.designs[:1], ["y"], + self.designs[:1], parameters={"normal": ["u1", "u2"], "seed": "s"}, replicates=50, n_resamples=50, @@ -165,7 +171,7 @@ def test_groups(self): np.testing.assert_allclose(_share(a, "y", "normal", "total"), 1.0, atol=0.3) np.testing.assert_array_equal(_share(a, "y", "seed", "total"), 0.0) named = attribute_variance( - self.study, self.designs[:1], ["y"], parameters=["u2"], replicates=50 + self.study, ["y"], self.designs[:1], parameters=["u2"], replicates=50 ) self.assertEqual(list(named.shares.parameter), ["u2"]) self.assertEqual(set(named.results.redrawn.dropna()), {"u2"}) @@ -176,15 +182,19 @@ def test_validation(self): with self.subTest(parameters=parameters): with self.assertRaises(ValueError): attribute_variance( - self.study, self.designs, ["y"], parameters, replicates=2 + self.study, + ["y"], + self.designs, + parameters=parameters, + replicates=2, ) with self.assertRaises(ValueError): - attribute_variance(self.study, self.designs, ["y"], replicates=1) + attribute_variance(self.study, ["y"], self.designs, replicates=1) with self.assertRaises(ValueError): - attribute_variance(self.study, self.designs, ["q"], replicates=2) + attribute_variance(self.study, ["q"], self.designs, replicates=2) certain = Study(DesignSpace(x=Integer(1, 2)), lambda d: d, lambda d: {"y": d.x}) with self.assertRaises(ValueError): - attribute_variance(certain, certain.space.enumerate(), ["y"]) + attribute_variance(certain, ["y"], certain.space.enumerate()) def test_inactive_branches(self): """Designs that do not draw a parameter are not evaluated for it.""" @@ -202,7 +212,7 @@ def evaluate(d): study = Study(space, lambda d: d, evaluate) designs = space.enumerate() - a = attribute_variance(study, designs, ["y"], replicates=20, n_resamples=20) + a = attribute_variance(study, ["y"], designs, replicates=20, n_resamples=20) redrawn = a.results[a.results.redrawn == "layout.a.phase"] self.assertEqual(set(redrawn.design), {designs[0].key}) shares = a.shares.set_index(["design", "parameter"]) @@ -224,7 +234,7 @@ def build(d): study = Study(SPACE, build, _evaluate) a = attribute_variance( - study, self.designs[:1], ["y"], parameters=["u1", "u2"], replicates=100 + study, ["y"], self.designs[:1], parameters=["u1", "u2"], replicates=100 ) self.assertFalse(a.results.feasible.all()) self.assertTrue(a.shares[["first", "total"]].notna().all().all()) @@ -234,12 +244,12 @@ def reject(d): never = Study(SPACE, reject, _evaluate) with self.assertWarns(UserWarning): - none = attribute_variance(never, self.designs, ["y"], replicates=2) + none = attribute_variance(never, ["y"], self.designs, replicates=2) self.assertEqual(len(none.shares), 0) self.assertEqual(len(none.summary()), 0) with self.assertWarns(UserWarning): separated = attribute_variance( - never, self.designs, ["y"], replicates=2, by=["sensor"] + never, ["y"], self.designs, replicates=2, by=["sensor"] ) self.assertEqual(len(separated.shares), 0) @@ -254,8 +264,8 @@ def evaluate(d): study = Study(SPACE, lambda d: d, evaluate) a = attribute_variance( study, - self.designs[:1], ["y"], + self.designs[:1], parameters=["u1", "u2"], replicates=20, by=["sensor"], @@ -266,7 +276,7 @@ def evaluate(d): self.assertEqual(shares["two", "u1"], 0.0) self.assertEqual(list(a.summary().index.names), ["sensor", "parameter"]) with self.assertRaises(ValueError): - attribute_variance(study, self.designs[:1], ["y"], replicates=2) + attribute_variance(study, ["y"], self.designs[:1], replicates=2) def test_store(self): """The evaluations are stored, and taken from the store again.""" @@ -279,10 +289,10 @@ def evaluate(d): with tempfile.TemporaryDirectory() as directory: store = ResultStore(Path(directory) / "results.sqlite", "attribution") study = Study(SPACE, lambda d: d, evaluate, replicates=3, store=store) - first = attribute_variance(study, self.designs, ["y"], replicates=3) + first = attribute_variance(study, ["y"], self.designs, replicates=3) self.assertEqual(len(self.calls), 2 * (2 * 3 + 3 * 3)) self.calls.clear() - again = attribute_variance(study, self.designs, ["y"], replicates=3) + again = attribute_variance(study, ["y"], self.designs, replicates=3) self.assertEqual(self.calls, []) pd.testing.assert_frame_equal(first.shares, again.shares) @@ -305,8 +315,8 @@ def setUpClass(cls): cls.study = Study(SPACE, lambda d: d, _evaluate_pairs) cls.attribution = attribute_variance( cls.study, - cls.designs, ["y", "c"], + cls.designs, parameters=["u1", "u2"], replicates=200, n_resamples=200, @@ -384,7 +394,7 @@ def evaluate(d): study = Study(space, lambda d: d, evaluate) designs = space.enumerate() - a = attribute_variance(study, designs, ["y"], replicates=20, n_resamples=20) + a = attribute_variance(study, ["y"], designs, replicates=20, n_resamples=20) d = a.differences().shares.set_index(["design", "other", "parameter"]) branch_a, b1, b2 = (design.key for design in designs) # a less b1 is the phase alone @@ -398,7 +408,7 @@ def test_independent_draws(self): """Without common random numbers, no parameter cancels.""" study = Study(SPACE, lambda d: d, _evaluate_pairs, common_random_numbers=False) a = attribute_variance( - study, self.designs, ["c"], parameters=["u1", "u2"], replicates=200 + study, ["c"], self.designs, parameters=["u1", "u2"], replicates=200 ) d = a.differences() # c of the designs differs by u1 of both and u2 of both: 5 and 2 of 7 diff --git a/tests/tradespace/test_cache.py b/tests/tradespace/test_cache.py index 431dc632..2a66c93c 100644 --- a/tests/tradespace/test_cache.py +++ b/tests/tradespace/test_cache.py @@ -20,8 +20,8 @@ Integer, SatelliteCache, Study, - get_satellite_key, ) +from tatc.tradespace.cache import get_satellite_key EPOCH = datetime(2026, 1, 1, tzinfo=timezone.utc) diff --git a/tests/tradespace/test_confirmation.py b/tests/tradespace/test_confirmation.py index 16a6dd65..91d11d4a 100644 --- a/tests/tradespace/test_confirmation.py +++ b/tests/tradespace/test_confirmation.py @@ -7,6 +7,7 @@ import unittest import numpy as np +import pandas as pd from tatc.tradespace import ( Criteria, @@ -58,7 +59,7 @@ def setUp(self): def test_removes_optimism(self): """New replicates remove the optimism of selection.""" confirmation = confirm( - self.study, self.selected, self.results, OBJECTIVES, replicates=20 + self.study, OBJECTIVES, self.results, self.selected, replicates=20 ) self.assertEqual(set(confirmation.summary.design), self.selected_keys) self.assertTrue((confirmation.summary.replicates == 20).all()) @@ -75,9 +76,22 @@ def test_removes_optimism(self): ) self.assertLess(abs(errors.mean()), 0.15) + def test_default_front(self): + """Without designs, the front of the results is confirmed; designs may + also be given by their keys or a data frame of them.""" + summary = summarize(self.results, list(OBJECTIVES), design_columns=[]) + front = summary[pareto_front(summary, OBJECTIVES)] + confirmation = confirm(self.study, OBJECTIVES, self.results) + self.assertEqual(set(confirmation.summary.design), set(front.design)) + self.assertEqual({d.key for d in confirmation.designs}, set(front.design)) + by_frame = confirm(self.study, OBJECTIVES, self.results, front) + pd.testing.assert_frame_equal(by_frame.summary, confirmation.summary) + by_keys = confirm(self.study, OBJECTIVES, self.results, list(front.design)) + pd.testing.assert_frame_equal(by_keys.summary, confirmation.summary) + def test_front(self): """The front is found among the confirmed designs by the new replicates.""" - confirmation = confirm(self.study, self.selected, self.results, OBJECTIVES) + confirmation = confirm(self.study, OBJECTIVES, self.results, self.selected) summary = confirmation.summary np.testing.assert_array_equal( summary.pareto, pareto_front(summary, OBJECTIVES).to_numpy() @@ -87,13 +101,13 @@ def test_requirements(self): """Requirements are judged by the new replicates.""" confirmation = confirm( self.study, - self.selected, - self.results, Criteria( OBJECTIVES, statistics={"reliability": Probability("value", ">=", 1.5)}, requirements=[Requirement("reliability", ">=", 0.5)], ), + self.results, + self.selected, ) summary = confirmation.summary self.assertIn("reliability selected", summary.columns) @@ -102,4 +116,4 @@ def test_requirements(self): ) self.assertFalse((summary.pareto & ~summary.meets_requirements).any()) with self.assertRaises(ValueError): - confirm(self.study, self.selected, self.results, OBJECTIVES, replicates=0) + confirm(self.study, OBJECTIVES, self.results, self.selected, replicates=0) diff --git a/tests/tradespace/test_constellations.py b/tests/tradespace/test_constellations.py index cb468230..80005438 100644 --- a/tests/tradespace/test_constellations.py +++ b/tests/tradespace/test_constellations.py @@ -17,21 +17,23 @@ DeploymentSchedule, DesignSpace, Integer, - Layout, - Plane, Real, Repeat, Uncertain, build_constellation, count_planes, count_satellites, + planes_space, + sso_planes_space, + walker_space, +) +from tatc.tradespace.constellations import ( + Layout, + Plane, hours_to_time, layout_of, plane_sizes, - planes_space, remove_failures, - sso_planes_space, - walker_space, ) from tatc.tradespace.constellations import Layouts, SSOPlanesLayout, WalkerLayout diff --git a/tests/tradespace/test_cost.py b/tests/tradespace/test_cost.py index 0594bd1f..394357d2 100644 --- a/tests/tradespace/test_cost.py +++ b/tests/tradespace/test_cost.py @@ -22,11 +22,11 @@ Uncertain, aggregate, count_satellites, - plane_sizes, planes_space, sso_planes_space, walker_space, ) +from tatc.tradespace.constellations import plane_sizes def _design(**children): @@ -235,7 +235,7 @@ def evaluate(d): results = Study(space, lambda d: d, evaluate, replicates=20).run(designs) summary = aggregate( - results, {"cost": "cost", "cost p70": Quantile("cost", 0.7)} + results, statistics={"cost": "cost", "cost p70": Quantile("cost", 0.7)} ) # the 0.7 quantile of a growth skewed upward exceeds the mean self.assertTrue((summary["cost p70"] > summary["cost"]).all()) diff --git a/tests/tradespace/test_criteria.py b/tests/tradespace/test_criteria.py index b8427628..04252766 100644 --- a/tests/tradespace/test_criteria.py +++ b/tests/tradespace/test_criteria.py @@ -152,7 +152,11 @@ def test_statistics(self): """Statistics and design values are aggregated, without violations.""" frame = aggregate( _results(), - {"value": "value", "value p25": Quantile("value", 0.25), "cost": "cost"}, + statistics={ + "value": "value", + "value p25": Quantile("value", 0.25), + "cost": "cost", + }, ).set_index("design") self.assertEqual(frame.loc["a", "value"], 13) self.assertAlmostEqual(frame.loc["b", "value p25"], 5) @@ -160,6 +164,32 @@ def test_statistics(self): self.assertTrue((frame.replicates == 4).all()) self.assertNotIn("violation", frame.columns) self.assertEqual(list(aggregate(_results(), ["value"]).value), [13, 17.5, 1]) + # a mapping of statistics by name is not one of objectives + with self.assertRaisesRegex(ValueError, "statistics"): + aggregate(_results(), {"value": "value"}) + with self.assertRaises(ValueError): + aggregate(_results()) + + def test_objectives(self): + """A mapping of objectives are criteria of their means, with others.""" + frame = aggregate( + _results(), + {"value": "max"}, + statistics={"value p25": Quantile("value", 0.25)}, + ).set_index("design") + self.assertEqual(frame.loc["a", "value"], 13) + self.assertAlmostEqual(frame.loc["b", "value p25"], 5) + self.assertTrue(frame.meets_requirements.all()) + # statistics that the criteria name otherwise + with self.assertRaisesRegex(ValueError, "otherwise"): + aggregate( + _results(), {"value": "max"}, statistics={"value": Quantile("value", 1)} + ) + # a statistic the criteria name the same way is not a clash + same = aggregate(_results(), {"value": "max"}, statistics={"value": "value"}) + self.assertEqual(list(same.value), [13, 17.5, 1]) + # objectives grouped by a column + self.assertEqual(len(aggregate(_results(), {"value": "max"}, by="size")), 3) def test_criteria(self): """Criteria add the violations of their requirements, relative to them.""" @@ -321,12 +351,12 @@ def test_misses_ranked_last(self): replicates=2, ) screening = screen( - space.enumerate(), [study, study], Criteria( {"cost": "min", "value": "max"}, requirements=[Requirement("cost", "<=", 3)], ), + space.enumerate(), keep=4, ) first = screening.summaries[0].set_index("design") diff --git a/tests/tradespace/test_deployment.py b/tests/tradespace/test_deployment.py index 8ef7c51d..489a99cc 100644 --- a/tests/tradespace/test_deployment.py +++ b/tests/tradespace/test_deployment.py @@ -16,15 +16,13 @@ DesignSpace, Exponential, FailureModel, - Phase, Real, Requirement, RestorationPolicy, - evaluate_phases, sso_planes_space, - summarize_phases, walker_space, ) +from tatc.tradespace.mission import Phase, evaluate_phases, summarize_phases def _walker(planes=3, per_plane=4): @@ -209,7 +207,7 @@ def metric(obs): ], ) expected = (50 * 0.5 + 25 * 0.5 + 75 * 1 + 100 * 2) / 4 - self.assertAlmostEqual(summary["targets mean"], expected) + self.assertAlmostEqual(summary["targets mission"], expected) self.assertEqual(summary["targets time"], math.inf) # the last requirement first = summarize_phases( capability, requirements=[Requirement("targets", ">=", 75)] diff --git a/tests/tradespace/test_failures.py b/tests/tradespace/test_failures.py index 4eb0c641..f7531a59 100644 --- a/tests/tradespace/test_failures.py +++ b/tests/tradespace/test_failures.py @@ -21,9 +21,7 @@ FailureModel, Integer, LaunchCost, - Lifetime, OperationsCost, - PhaseCache, Piecewise, Requirement, RestorationPolicy, @@ -32,18 +30,20 @@ Uncertain, Weibull, aggregate, - allocate_histories, build_constellation, - configure, - evaluate_missions, - evaluate_phases, - expected_missions, pareto_front, policy_space, - summarize_missions, - summarize_phases, walker_space, ) +from tatc.tradespace.failures import Lifetime +from tatc.tradespace.histories import ( + allocate_histories, + evaluate_missions, + expected_missions, + summarize_missions, +) +from tatc.tradespace.mission import PhaseCache, evaluate_phases, summarize_phases +from tatc.tradespace.values import configure def _walker(planes=1, per_plane=2): @@ -573,7 +573,7 @@ def test_evaluate_and_summarize(self): ) self.assertEqual(len(missions), 30) for column in ( - "share mean", + "share mission", "availability", "failures", "cost", @@ -582,23 +582,26 @@ def test_evaluate_and_summarize(self): self.assertIn(column, missions.columns) summary = summarize_missions( missions, - quantiles={"share mean": [0.1, 0.5], "cost": 0.7}, - requirements=[Requirement("share mean", ">=", 60)], + quantiles={"share mission": [0.1, 0.5], "cost": 0.7}, + requirements=[Requirement("share mission", ">=", 60)], + ) + self.assertAlmostEqual( + summary["share mission"], missions["share mission"].mean() ) - self.assertAlmostEqual(summary["share mean"], missions["share mean"].mean()) self.assertAlmostEqual( - summary["share mean p10"], missions["share mean"].quantile(0.1) + summary["share mission histories p10"], + missions["share mission"].quantile(0.1), ) - self.assertIn("share mean p50", summary) - self.assertIn("cost p70", summary) + self.assertIn("share mission histories p50", summary) + self.assertIn("cost histories p70", summary) self.assertAlmostEqual( - summary["P(share mean >= 60)"], (missions["share mean"] >= 60).mean() + summary["P(share mission >= 60)"], (missions["share mission"] >= 60).mean() ) # without a cache, the same evaluations direct = evaluate_missions( histories, self.satellites, self.observations, self._metric ) - np.testing.assert_allclose(direct["share mean"], missions["share mean"]) + np.testing.assert_allclose(direct["share mission"], missions["share mission"]) class TestVarianceReduction(unittest.TestCase): @@ -736,7 +739,7 @@ def _pilot(self, between, within, replicates=200, histories=20, seed=0): def test_recommendation(self): """Histories balance the variances and costs of the two levels.""" records = self._pilot(between=2, within=6) - self.assertIn("share sd", records.columns) + self.assertIn("share histories std", records.columns) result = allocate_histories( records, "share", @@ -827,9 +830,9 @@ def _compare(self, schedule, failures): missions = evaluate_missions( histories, self.satellites, self.observations, PhaseCache(self._metric) ) - error = missions["score mean"].std() / np.sqrt(len(missions)) + error = missions["score mission"].std() / np.sqrt(len(missions)) self.assertAlmostEqual( - exact["score mean"], missions["score mean"].mean(), delta=4 * error + exact["score mission"], missions["score mission"].mean(), delta=4 * error ) self.assertAlmostEqual( exact["availability"], missions["availability"].mean(), delta=0.01 @@ -866,7 +869,9 @@ def test_without_failures(self): planned = summarize_phases( evaluate_phases(phases, self.observations, self._metric) ) - self.assertAlmostEqual(exact["score mean"], planned["score mean"], places=6) + self.assertAlmostEqual( + exact["score mission"], planned["score mission"], places=6 + ) self.assertEqual(exact["availability"], 1.0) # every launch fails: nothing operates lost = expected_missions( @@ -877,7 +882,7 @@ def test_without_failures(self): self._metric, ) self.assertEqual(lost["availability"], 0.0) - self.assertEqual(lost["score mean"], 0.0) + self.assertEqual(lost["score mission"], 0.0) def test_limits(self): """Sets are enumerated within limits.""" @@ -989,8 +994,8 @@ def test_weighted_summaries(self): spread=True, ) self.assertAlmostEqual(summary["value"], (4 + 2 + 3 + 8) / 8) - self.assertEqual(summary["value p50"], 1.0) # half the weight is at 1 + self.assertEqual(summary["value histories p50"], 1.0) # half the weight is at 1 self.assertAlmostEqual(summary["P(value >= 3)"], 3 / 8) self.assertAlmostEqual(summary["effective histories"], 64 / 22) self.assertNotIn("weight", summary) - self.assertGreater(summary["value sd"], 0) + self.assertGreater(summary["value histories std"], 0) diff --git a/tests/tradespace/test_fingerprint.py b/tests/tradespace/test_fingerprint.py index 6cfb9f42..227f2342 100644 --- a/tests/tradespace/test_fingerprint.py +++ b/tests/tradespace/test_fingerprint.py @@ -30,6 +30,8 @@ SatelliteCost, Study, Uncertain, +) +from tatc.tradespace.fingerprint import ( compare_definitions, get_definition, get_fingerprint, diff --git a/tests/tradespace/test_observations.py b/tests/tradespace/test_observations.py index 95843f1e..7d548c45 100644 --- a/tests/tradespace/test_observations.py +++ b/tests/tradespace/test_observations.py @@ -42,9 +42,9 @@ count_planes, count_satellites, policy_space, - value_of, walker_space, ) +from tatc.tradespace.observations import value_of START = datetime(2026, 7, 1, tzinfo=timezone.utc) HOURS = timedelta(hours=3) @@ -231,8 +231,11 @@ def test_phases_and_failures(self): plan=PLAN, phases=[Requirement("observed", ">=", 50)], ).run(designs) - self.assertIn("observed mean", phased) + self.assertIn("observed mission", phased) self.assertIn("observed time", phased) + # the years by which the plan deploys every satellite + planned = [SCHEDULE.plan(d.layout).deployed for d in designs for _ in range(1)] + self.assertEqual(list(phased.deployed), planned) failures = Failures( FAILURES, RestorationPolicy(restore=False), histories=4, seed="failure_seed" ) @@ -245,7 +248,7 @@ def test_phases_and_failures(self): plan=PLAN, failures=failures, ).run(designs) - self.assertTrue({"observed mean", "availability", "cost"} <= set(degraded)) + self.assertTrue({"observed mission", "availability", "cost"} <= set(degraded)) # the policy of each design trade = DesignSpace( **SPACE.children, policy=policy_space(orbit_spares=Integer(0, 1)) @@ -297,11 +300,11 @@ def study(times, **options): scenarios = {"once": {}, "twice": {"times": 2}} both = study(1, scenarios=scenarios).run(space(1).enumerate()) - columns = ["observed", "observed mean", "availability", "cost"] + columns = ["observed", "observed mission", "availability", "cost"] once = both[both.scenario == "once"].reset_index(drop=True) twice = both[both.scenario == "twice"].reset_index(drop=True) self.assertTrue((once.observed >= twice.observed).all()) - self.assertTrue((once["observed mean"] > twice["observed mean"]).any()) + self.assertTrue((once["observed mission"] > twice["observed mission"]).any()) # as studies with the values of the scenarios for times, expected in ((1, once), (2, twice)): alone = study(times).run(space(times).enumerate()) @@ -406,9 +409,9 @@ def stages(design): phases=[Requirement("observed", ">=", 50)], **options, ).run(designs) - means = phased.groupby("staged")[["observed mean", "cost"]].mean() + means = phased.groupby("staged")[["observed mission", "cost"]].mean() self.assertLess( - means.loc[True, "observed mean"], means.loc[False, "observed mean"] + means.loc[True, "observed mission"], means.loc[False, "observed mission"] ) self.assertLess(means.loc[True, "cost"], means.loc[False, "cost"]) # failures without restoration: histories are sampled rather than exact @@ -452,7 +455,7 @@ def stages(design): results = ObservationStudy( space, _build, _observations(), _metrics, **options, **summary ).run(designs) - means = results.groupby("staging")[["observed mean", "cost"]].mean() + means = results.groupby("staging")[["observed mission", "cost"]].mean() pd.testing.assert_series_equal( means.loc["measured"], means.loc["delayed"], check_names=False ) @@ -463,6 +466,19 @@ def stages(design): means.loc["never", "cost"], means.loc["delayed", "cost"] ) + def test_replace(self): + """Variants of an observation study replace its arguments.""" + study = ObservationStudy(SPACE, _build, _observations(), _metrics) + phased = study.replace(layout="layout", plan=PLAN, phases=True) + self.assertEqual(phased.phases, ()) + self.assertIs(phased.build, study.build) + self.assertIs(phased.observations, study.observations) + results = phased.replace(replicates=2).run(SPACE.enumerate()[:1]) + self.assertEqual(len(results), 2) + self.assertIn("observed mission", results) + with self.assertRaises(TypeError): + study.replace(evaluate=_metrics) + def test_invalid(self): """Failures and phases need a plan, and a plan needs a layout.""" observations = _observations() diff --git a/tests/tradespace/test_optimization.py b/tests/tradespace/test_optimization.py index 58971dfb..e83a10b0 100644 --- a/tests/tradespace/test_optimization.py +++ b/tests/tradespace/test_optimization.py @@ -15,7 +15,6 @@ Choice, Criteria, DesignSpace, - Evaluations, Infeasible, Integer, Minimum, @@ -25,12 +24,12 @@ Study, Uncertain, hypervolume, - make_pymoo_problem, optimize_optuna, optimize_pymoo, pareto_front, summarize, ) +from tatc.tradespace.optimization import Evaluations, make_pymoo_problem HAS_OPTUNA = importlib.util.find_spec("optuna") is not None HAS_PYMOO = importlib.util.find_spec("pymoo") is not None @@ -227,6 +226,12 @@ def test_optimize(self): found = summarize(results, list(OBJECTIVES)) self.assertGreater(hypervolume(found, OBJECTIVES, REFERENCE), 0.9 * exact) self.assertFalse(results.feasible.all()) # some designs were too heavy + # the summary of the feasible designs, and their front + summary = search.summary + self.assertEqual(set(summary.design), set(results.design[results.feasible])) + np.testing.assert_array_equal( + summary.pareto, pareto_front(summary, OBJECTIVES).to_numpy() + ) def test_duplicates(self): """Proposals of the same design, or of designs evaluated before, are diff --git a/tests/tradespace/test_pareto.py b/tests/tradespace/test_pareto.py index 93aa6385..dc20ea4b 100644 --- a/tests/tradespace/test_pareto.py +++ b/tests/tradespace/test_pareto.py @@ -215,6 +215,58 @@ def test_groups(self): sorted(zip(winners.sensor, winners.design)), [("a", "d1"), ("b", "d0")] ) + def test_design_values(self): + """Probabilities keep the values of the designs, as summaries do.""" + results = self._results([[1, 2], [3, 4]]) + results["size"] = results["design"].map({"d0": "small", "d1": "large"}) + results["seed"] = results["replicate"] # an uncertain parameter + probability = pareto_probability(results, {"cost": "min", "value": "max"}) + self.assertEqual(list(probability["size"]), ["small", "large"]) + self.assertNotIn("seed", probability.columns) + bare = pareto_probability( + results, {"cost": "min", "value": "max"}, design_columns=[] + ) + self.assertNotIn("size", bare.columns) + + +class TestSummaries(unittest.TestCase): + """ + Unit tests for the functions of summaries given the results of a study. + """ + + def setUp(self): + self.results = TestParetoProbability._results([[1, 2, 3], [5, 6, 7]]) + self.objectives = {"cost": "min", "value": "max"} + + def test_results_raise(self): + """Results with a row per replicate are not summaries of designs.""" + for function in (pareto_front, pareto_ranks): + with self.assertRaisesRegex(ValueError, "aggregate"): + function(self.results, self.objectives) + with self.assertRaisesRegex(ValueError, "aggregate"): + hypervolume(self.results, self.objectives, [2, 0]) + indexed = self.results.set_index("design") + with self.assertRaisesRegex(ValueError, "aggregate"): + pareto_front(indexed, self.objectives) + + def test_groups_of_designs(self): + """A design may have a row in each group of the criteria's `by`.""" + summary = pd.concat( + [ + pd.DataFrame({"design": ["a", "b"], "value": [1, 2], "s": "x"}), + pd.DataFrame({"design": ["a", "b"], "value": [2, 1], "s": "y"}), + ] + ) + front = pareto_front(summary, Criteria({"value": "max"}, by="s")) + self.assertEqual(list(front), [False, True, True, False]) + with self.assertRaises(ValueError): + pareto_front(summary, {"value": "max"}) + # rows without designs are any rows + rows = pd.DataFrame({"value": [1, 1, 2]}) + self.assertEqual( + list(pareto_front(rows, {"value": "max"})), [False, False, True] + ) + class TestManyPoints(unittest.TestCase): """ diff --git a/tests/tradespace/test_refinement.py b/tests/tradespace/test_refinement.py index 63546d88..4606f654 100644 --- a/tests/tradespace/test_refinement.py +++ b/tests/tradespace/test_refinement.py @@ -54,13 +54,32 @@ def setUp(self): self.designs = self.study.space.enumerate() self.results = self.study.run(self.designs) + def test_designs_of_results(self): + """Without designs, every design of the results may be refined; designs + may also be given by their keys.""" + given = refine(self.study, OBJECTIVES, self.results, self.designs) + rebuilt = refine(self.study, OBJECTIVES, self.results) + pd.testing.assert_frame_equal( + given.results.drop(columns="seconds"), + rebuilt.results.drop(columns="seconds"), + ) + self.assertEqual( + [d.key for d in rebuilt.designs], [d.key for d in self.designs] + ) + keys = [d.key for d in self.designs[:4]] + some = refine(self.study, OBJECTIVES, self.results, keys) + added = some.results.iloc[len(self.results) :] + self.assertTrue(set(added.design) <= set(keys)) + self.assertIn("pareto_probability", some.summary.columns) + self.assertIn("variant", some.summary.columns) # the values of designs + def test_refines_uncertain_designs(self): """Replicates are added only to uncertain designs, which become fewer.""" refinement = refine( self.study, - self.designs, - self.results, OBJECTIVES, + self.results, + self.designs, step=5, max_rounds=6, n_resamples=200, @@ -84,7 +103,7 @@ def test_refines_uncertain_designs(self): def test_replicates_continue(self): """Added replicates follow each design's own.""" refinement = refine( - self.study, self.designs, self.results, OBJECTIVES, step=2, max_rounds=1 + self.study, OBJECTIVES, self.results, self.designs, step=2, max_rounds=1 ) added = refinement.results.iloc[len(self.results) :] self.assertTrue(set(added.replicate) <= {5, 6}) @@ -94,9 +113,9 @@ def test_limits(self): """Refinement stops at the most replicates of a design.""" refinement = refine( self.study, - self.designs, - self.results, OBJECTIVES, + self.results, + self.designs, step=3, max_replicates=8, max_rounds=5, @@ -107,22 +126,22 @@ def test_limits(self): self.assertEqual(refinement.history.refined.iloc[-1], 0) with self.assertRaises(ValueError): refine( - self.study, self.designs, self.results, OBJECTIVES, bounds=(0.9, 0.1) + self.study, OBJECTIVES, self.results, self.designs, bounds=(0.9, 0.1) ) def test_statistics(self): """Refinement uses the statistics of the objectives.""" refinement = refine( self.study, - self.designs, - self.results, Criteria( {"cost": "min", "value p25": "max"}, statistics={"value p25": Quantile("value", 0.25)}, ), + self.results, + self.designs, max_rounds=1, ) - self.assertIn("value p25", refinement.probability.columns) + self.assertIn("value p25", refinement.summary.columns) def test_tolerance(self): """A tolerance settles designs that are within it of the front.""" @@ -135,9 +154,9 @@ def test_tolerance(self): (strict.pareto_probability >= 0.95).sum(), ) refinement = refine( - self.study, self.designs, self.results, criteria, max_rounds=1 + self.study, criteria, self.results, self.designs, max_rounds=1 ) - settled = refinement.probability.pareto_probability >= 0.95 + settled = refinement.summary.pareto_probability >= 0.95 self.assertGreaterEqual( settled.sum(), (tolerant.pareto_probability >= 0.95).sum() ) @@ -163,12 +182,12 @@ def test_min_replicates(self): with warnings.catch_warnings(): warnings.simplefilter("ignore") refinement = refine( - study, designs, results, objectives, step=3, max_rounds=1 + study, objectives, results, designs, step=3, max_rounds=1 ) replicates = refinement.results.groupby("design").replicate.nunique() self.assertTrue((replicates >= 5).all()) with self.assertRaises(ValueError): - refine(study, designs, results, objectives, max_replicates=3) + refine(study, objectives, results, designs, max_replicates=3) def test_partial_step(self): """The last step of a design adds the replicates left to its limit.""" @@ -176,9 +195,9 @@ def test_partial_step(self): warnings.simplefilter("ignore") refinement = refine( self.study, - self.designs, - self.results, OBJECTIVES, + self.results, + self.designs, step=4, max_replicates=7, max_rounds=3, @@ -190,7 +209,7 @@ def test_partial_step(self): def test_warns_without_tolerance(self): """Designs that remain uncertain without a tolerance give a warning.""" with self.assertWarns(UserWarning): - refine(self.study, self.designs, self.results, OBJECTIVES, max_rounds=1) + refine(self.study, OBJECTIVES, self.results, self.designs, max_rounds=1) def test_precision(self): """A design about a tolerance from the front stops once precise enough.""" @@ -211,9 +230,9 @@ def test_precision(self): def refined(precision): refinement = refine( study, - designs, - results, criteria, + results, + designs, step=5, max_replicates=40, precision=precision, @@ -231,17 +250,17 @@ def refined(precision): self.assertEqual(len(refinement.uncertain), 0) self.assertEqual(refinement.history.indifferent.iloc[-1], 1) with self.assertRaises(ValueError): - refine(study, designs, results, criteria, precision=0) + refine(study, criteria, results, designs, precision=0) def test_budget(self): """A budget limits the evaluations, refining the least settled designs first.""" with warnings.catch_warnings(): warnings.simplefilter("ignore") refinement = refine( - self.study, self.designs, self.results, OBJECTIVES, step=5, budget=12 + self.study, OBJECTIVES, self.results, self.designs, step=5, budget=12 ) nothing = refine( - self.study, self.designs, self.results, OBJECTIVES, budget=0 + self.study, OBJECTIVES, self.results, self.designs, budget=0 ) self.assertEqual(refinement.history.evaluations.sum(), 12) replicates = refinement.results.groupby("design").replicate.nunique() diff --git a/tests/tradespace/test_scenarios.py b/tests/tradespace/test_scenarios.py index 8f8f2f8d..c8b32905 100644 --- a/tests/tradespace/test_scenarios.py +++ b/tests/tradespace/test_scenarios.py @@ -18,7 +18,6 @@ Across, Criteria, DesignSpace, - Evaluations, Fixed, Integer, Requirement, @@ -33,6 +32,7 @@ pareto_probability, robustness, ) +from tatc.tradespace.optimization import Evaluations HAS_OPTUNA = importlib.util.find_spec("optuna") is not None HAS_PYMOO = importlib.util.find_spec("pymoo") is not None @@ -136,7 +136,7 @@ def test_attribution(self): store = ResultStore(self.path, "scenarios") study = self._study(SCENARIOS, store=store) a = attribute_variance( - study, SPACE.enumerate(), ["y"], replicates=20, by=["scenario"] + study, ["y"], SPACE.enumerate(), replicates=20, by=["scenario"] ) shares = a.shares.set_index(["design", "scenario"])["total"] key = SPACE.enumerate()[0].key @@ -146,7 +146,7 @@ def test_attribution(self): self.assertTrue(np.isnan(shares[key, "pinned"])) self.calls.clear() attribute_variance( - study, SPACE.enumerate(), ["y"], replicates=20, by=["scenario"] + study, ["y"], SPACE.enumerate(), replicates=20, by=["scenario"] ) self.assertEqual(self.calls, []) @@ -209,14 +209,14 @@ def test_trace_and_regret(self): regret: the improvement in every objective to match the front.""" r = self._robustness() self.assertEqual( - list(r.columns), ["pareto trace", "max regret", "s1 regret", "s2 regret"] + list(r.columns), ["pareto_trace", "max_regret", "s1 regret", "s2 regret"] ) - np.testing.assert_allclose(r["pareto trace"], [0.5, 1.0, 0.0]) + np.testing.assert_allclose(r["pareto_trace"], [0.5, 1.0, 0.0]) # C in s1: 1 short of B in both objectives (3 short of A in perf) np.testing.assert_allclose(r["s1 regret"], [0, 0, 1]) # A in s2: 3 short of B in perf (2 in cost); C: 1 short of B in cost np.testing.assert_allclose(r["s2 regret"], [3, 0, 1]) - np.testing.assert_allclose(r["max regret"], [3, 0, 1]) + np.testing.assert_allclose(r["max_regret"], [3, 0, 1]) def test_scale(self): """Regret is in units of the scales of the objectives.""" @@ -233,7 +233,7 @@ def test_tolerance(self): is in tolerances by default.""" criteria = Criteria(OBJECTIVES, tolerance={"cost": 2}) r = self._robustness(criteria=criteria) - np.testing.assert_allclose(r["pareto trace"], [0.5, 1.0, 1.0]) + np.testing.assert_allclose(r["pareto_trace"], [0.5, 1.0, 1.0]) # A in s2: 3 short of B and C in perf np.testing.assert_allclose(r["s2 regret"], [3, 0, 0]) @@ -243,7 +243,7 @@ def test_requirements(self): criteria = Criteria(OBJECTIVES, requirements=[Requirement("perf", ">=", 7)]) r = self._robustness(criteria=criteria) self.assertEqual(r.loc["A", "s2 regret"], math.inf) - self.assertEqual(r.loc["A", "max regret"], math.inf) + self.assertEqual(r.loc["A", "max_regret"], math.inf) infeasible = pd.concat([RESULTS, _results([("D", "s1", None, None)])]) infeasible = pd.concat( [infeasible, _results([("D", "s2", 9, 2)])], ignore_index=True @@ -251,7 +251,7 @@ def test_requirements(self): r = self._robustness(results=infeasible) self.assertEqual(r.loc["D", "s1 regret"], math.inf) self.assertEqual(r.loc["D", "s2 regret"], 0) - self.assertEqual(r.loc["D", "pareto trace"], 0.5) + self.assertEqual(r.loc["D", "pareto_trace"], 0.5) def test_invalid(self): """Robustness needs scenarios, and criteria by them alone.""" @@ -269,7 +269,7 @@ def test_study(self): results = Study(SPACE, lambda d: d, _evaluate, scenarios=SCENARIOS).run() r = robustness(results, {"y": "max", "cost": "min"}) # every design trades y against cost, in every scenario - np.testing.assert_allclose(r["pareto trace"], 1.0) + np.testing.assert_allclose(r["pareto_trace"], 1.0) self.assertEqual(len(r), 3) diff --git a/tests/tradespace/test_screening.py b/tests/tradespace/test_screening.py index e50080df..fd265e56 100644 --- a/tests/tradespace/test_screening.py +++ b/tests/tradespace/test_screening.py @@ -61,7 +61,7 @@ def setUp(self): def test_keeps_whole_fronts(self): """Each stage keeps whole fronts until it keeps enough designs.""" screening = screen( - self.designs, [_study(0.3, 1), _study(0, 1)], OBJECTIVES, keep=20 + [_study(0.3, 1), _study(0, 1)], OBJECTIVES, self.designs, keep=20 ) first = screening.summaries[0] self.assertGreaterEqual(first.kept.sum(), 20) @@ -70,54 +70,52 @@ def test_keeps_whole_fronts(self): self.assertFalse((first[first.pareto_rank > last_rank].kept).any()) self.assertEqual(len(screening.designs), first.kept.sum()) self.assertEqual(set(screening.results.stage), {0, 1}) - self.assertEqual(len(screening.final), len(screening.designs)) + self.assertEqual(len(screening.summary), len(screening.designs)) def test_finds_front(self): """A tolerance of the noise of the first stage keeps the efficient designs.""" stages = [_study(0.3, 1), _study(0, 1)] # about two standard deviations of the noise of the first stage - screening = screen( - self.designs, stages, OBJECTIVES, keep=0.1, tolerance={"value": 0.6} - ) - final = screening.final + cheap = Criteria(OBJECTIVES, tolerance={"value": 0.6}) + screening = screen(stages, [cheap, OBJECTIVES], self.designs, keep=0.1) + final = screening.summary found = set(final.design[pareto_front(final, OBJECTIVES)]) self.assertEqual(found, self.front) self.assertLess(len(screening.designs), 0.6 * len(self.designs)) # without a tolerance, the noise loses efficient designs - screening = screen(self.designs, stages, OBJECTIVES, keep=0.1) - final = screening.final + screening = screen(stages, OBJECTIVES, self.designs, keep=0.1) + final = screening.summary found = set(final.design[pareto_front(final, OBJECTIVES)]) self.assertLess(len(found & self.front), len(self.front)) def test_three_stages(self): - """Values of keep and tolerance can be given for each transition.""" + """Values of keep and criteria can be given for each stage.""" screening = screen( - self.designs, [_study(0.5, 1), _study(0.1, 2), _study(0, 1)], - OBJECTIVES, + [Criteria(OBJECTIVES, tolerance={"value": 1.0}), OBJECTIVES, OBJECTIVES], + self.designs, keep=[0.5, 10], - tolerance=[{"value": 1.0}, None], ) counts = [len(summary) for summary in screening.summaries] self.assertEqual(counts[0], len(self.designs)) self.assertGreaterEqual(counts[1], 0.5 * counts[0]) self.assertGreaterEqual(counts[2], 10) with self.assertRaises(ValueError): - screen(self.designs, [_study(0, 1)] * 3, OBJECTIVES, keep=[0.5]) + screen([_study(0, 1)] * 3, OBJECTIVES, self.designs, keep=[0.5]) + with self.assertRaises(ValueError): + screen([_study(0, 1)] * 3, [OBJECTIVES] * 2, self.designs) with self.assertRaises(ValueError): - screen(self.designs, [_study(0, 1)], Criteria(OBJECTIVES, by="sensor")) + screen([_study(0, 1)], Criteria(OBJECTIVES, by="sensor"), self.designs) def test_criteria_tolerance(self): - """Stages use the tolerance of the criteria unless given their own.""" + """Every stage uses the tolerance of the criteria unless given its own.""" stages = [_study(0.3, 1), _study(0, 1)] criteria = Criteria(OBJECTIVES, tolerance={"value": 0.6}) - tolerant = screen(self.designs, stages, criteria, keep=0.1) - overridden = screen( - self.designs, stages, criteria, keep=0.1, tolerance={"value": 0.0} - ) + tolerant = screen(stages, criteria, self.designs, keep=0.1) + overridden = screen(stages, [OBJECTIVES, criteria], self.designs, keep=0.1) self.assertGreater(len(tolerant.designs), len(overridden.designs)) # the last stage ranks with the criteria's tolerance - final = tolerant.final + final = tolerant.summary self.assertTrue( (final.pareto_rank == 0).sum() >= pareto_front(final, OBJECTIVES).sum() ) diff --git a/tests/tradespace/test_sensitivity.py b/tests/tradespace/test_sensitivity.py index d614b139..7e16a17b 100644 --- a/tests/tradespace/test_sensitivity.py +++ b/tests/tradespace/test_sensitivity.py @@ -61,6 +61,16 @@ def test_main_effects(self): binned = main_effects(self.frame, "c", "metric", max_levels=4) self.assertEqual(len(binned), 4) + def test_results_raise(self): + """The results of a study (a row per replicate) are not summaries.""" + results = pd.DataFrame( + {"design": ["x", "x", "y", "y"], "a": [1, 1, 2, 2], "metric": [1, 2, 3, 4]} + ) + with self.assertRaisesRegex(ValueError, "aggregate"): + sensitivity(results, ["a"], ["metric"]) + with self.assertRaisesRegex(ValueError, "aggregate"): + main_effects(results, "a", "metric") + def test_irrelevant_variable(self): """The adjusted share of a variable that does not matter is near 0.""" rng = np.random.default_rng(1) diff --git a/tests/tradespace/test_space.py b/tests/tradespace/test_space.py index cf42599f..1d7539a1 100644 --- a/tests/tradespace/test_space.py +++ b/tests/tradespace/test_space.py @@ -7,6 +7,8 @@ import math import unittest +import pandas as pd + from tatc.tradespace import ( Categorical, Choice, @@ -360,3 +362,65 @@ def test_same_designs(self): self.assertEqual([d.key for d in designs], [d.key for d in expected]) self.assertEqual([d.flat() for d in designs], [d.flat() for d in expected]) self.assertEqual(space.size(), len(expected)) + + +class TestDesignsOf(unittest.TestCase): + """ + Unit tests for designs rebuilt from data frames of their values, and for + designs of extended design spaces. + """ + + def setUp(self): + self.space = _hierarchical_space() + self.designs = self.space.enumerate() + # values by path, as in the results of a study (with missing values of + # the branches a design does not choose, and integers as floats) + self.frame = pd.DataFrame( + [{"design": d.key, **d.realize(0).flat()} for d in self.designs] + ) + + def test_round_trip(self): + """Designs rebuilt from their values are the designs.""" + rebuilt = self.space.designs_of(self.frame) + self.assertEqual([d.key for d in rebuilt], [d.key for d in self.designs]) + self.assertEqual([d.flat() for d in rebuilt][5], self.designs[5].flat()) + # from a summary indexed by design, of some keys, in their order + keys = [self.designs[3].key, self.designs[1].key] + some = self.space.designs_of(self.frame.set_index("design"), keys) + self.assertEqual([d.key for d in some], keys) + # without keys, every row's design once + bare = self.frame.drop(columns="design") + rebuilt = self.space.designs_of(pd.concat([bare, bare])) + self.assertEqual(len(rebuilt), len(self.designs)) + + def test_errors(self): + """Rows without the values of decisions, or of other designs, raise.""" + with self.assertRaises(KeyError): + self.space.designs_of(self.frame, ["unknown"]) + with self.assertRaisesRegex(ValueError, "no value of altitude"): + self.space.designs_of(self.frame.drop(columns="altitude")) + other = self.frame.assign(design=self.frame.design.iloc[::-1].to_numpy()) + with self.assertRaisesRegex(ValueError, "another design"): + self.space.designs_of(other) + wrong = self.frame.assign(altitude=1.0) + with self.assertRaisesRegex(ValueError, "not a level"): + self.space.designs_of(wrong) + + def test_extend(self): + """Extended design spaces replace or add children, and keep constraints.""" + space = DesignSpace(a=Integer(1, 3), b=2.0, constraints=[lambda d: d.a <= 2]) + extended = space.extend(c=Categorical(["x", "y"]), b=Integer(0, 1)) + self.assertEqual(list(extended.children), ["a", "b", "c"]) + self.assertEqual(len(extended.enumerate()), 2 * 2 * 2) + self.assertEqual(list(space.children), ["a", "b"]) # unchanged + design = space.enumerate()[1] + derived = extended.design(design, b=1, c="y") + self.assertEqual((derived.a, derived.b, derived.c), (2, 1, "y")) + # a design of a group's own space gives its decisions + group = DesignSpace(k=Integer(0, 1)) + nested = space.extend(g=group).design(design, g=group.enumerate()[1]) + self.assertEqual(nested.g.k, 1) + with self.assertRaisesRegex(ValueError, "no children"): + extended.design(design, z=1) + with self.assertRaises(Infeasible): + extended.design({"a": 3, "b": 0, "c": "x"}) diff --git a/tests/tradespace/test_stages.py b/tests/tradespace/test_stages.py index 24967797..85542103 100644 --- a/tests/tradespace/test_stages.py +++ b/tests/tradespace/test_stages.py @@ -9,19 +9,18 @@ import pandas as pd from tatc.tradespace import ( - Capability, CostModel, DeploymentSchedule, DesignSpace, Exponential, FailureModel, - PhaseCache, RestorationPolicy, SatelliteCost, Stage, - expected_missions, walker_space, ) +from tatc.tradespace.histories import expected_missions +from tatc.tradespace.mission import Capability, PhaseCache # three planes of two satellites LAYOUT = DesignSpace(layout=walker_space(inclination=60, planes=3, per_plane=2)) diff --git a/tests/tradespace/test_store.py b/tests/tradespace/test_store.py index 9ff58753..a3a3e16a 100644 --- a/tests/tradespace/test_store.py +++ b/tests/tradespace/test_store.py @@ -9,6 +9,7 @@ import sqlite3 import tempfile import unittest +import warnings from concurrent.futures import ThreadPoolExecutor from contextlib import closing from datetime import date, datetime, time, timedelta, timezone @@ -17,7 +18,14 @@ import numpy as np import pandas as pd -from tatc.tradespace import DesignSpace, Integer, ResultStore, Study, Uncertain +from tatc.tradespace import ( + DesignSpace, + Integer, + ResultStore, + Study, + Uncertain, +) +from tatc.tradespace.fingerprint import compare_definitions class _Interrupt(Exception): @@ -118,14 +126,16 @@ def test_parallel(self): pd.testing.assert_frame_equal(results, again) def test_other_definitions(self): - """Records of studies of other definitions are not reused.""" + """Records of studies of other definitions are not reused, and studies + of other values share a store's namespace without a warning.""" store = ResultStore(self.path, "study") self._study(store).run() self.calls.clear() self._study(store).run() self.assertEqual(self.calls, []) # another seed draws other uncertain values - with self.assertWarns(UserWarning): + with warnings.catch_warnings(): + warnings.simplefilter("error") reseeded = self._study(store, seed=1).run() self.assertEqual(len(self.calls), 12) self.assertNotEqual( @@ -134,7 +144,8 @@ def test_other_definitions(self): # another fixed value of the design space self.calls.clear() self.space = DesignSpace(a=Integer(1, 4), b=2.0, noise=Uncertain.uniform(0, 1)) - with self.assertWarns(UserWarning): + with warnings.catch_warnings(): + warnings.simplefilter("error") self._study(store).run() self.assertEqual(len(self.calls), 12) # another value that the evaluation closes over @@ -149,10 +160,23 @@ def study(offset): ) study(0.0).run() - with self.assertWarnsRegex(UserWarning, r"defaults\[0\]: 0.0 -> 1.0"): + with warnings.catch_warnings(): + warnings.simplefilter("error") study(1.0).run() self.assertEqual(len(self.calls), 8) + def test_other_code(self): + """A study warns of records of the same study with other code.""" + store = ResultStore(self.path, "code") + + def study(evaluate): + return Study(self.space, lambda d: d, evaluate, replicates=2, store=store) + + study(lambda d: {"value": d.a}).run() + with self.assertWarnsRegex(UserWarning, "other code.*evaluate.code"): + edited = study(lambda d: {"value": d.a + 1}).run() + self.assertEqual(list(edited.value[:2]), [2, 2]) + def test_records_as_json(self): """Records are kept as JSON, and read as they were written.""" record = { @@ -203,8 +227,11 @@ def test_definitions(self): self.assertEqual(store.definition(study.fingerprint), study.definition) self.assertIsNone(store.definition("other")) reseeded = self._study(store, seed=1) - with self.assertWarnsRegex(UserWarning, "latest differs in: seed: 0 -> 1"): - reseeded.run() + reseeded.run() + self.assertEqual( + compare_definitions(study.definition, reseeded.definition), + ["seed: 0 -> 1"], + ) # contexts in the order they were defined, the latest last self.assertEqual( list(store.contexts()), [study.fingerprint, reseeded.fingerprint] diff --git a/tests/tradespace/test_study.py b/tests/tradespace/test_study.py index 752906a5..7cbf06d6 100644 --- a/tests/tradespace/test_study.py +++ b/tests/tradespace/test_study.py @@ -190,11 +190,37 @@ def test_summarize(self): first = results[results.design == summary.design[0]] self.assertAlmostEqual(summary["score"][0], first.score.mean()) self.assertAlmostEqual(summary["score std"][0], first.score.std()) - self.assertAlmostEqual(summary["score sem"][0], first.score.std() / np.sqrt(3)) + self.assertAlmostEqual(summary["score se"][0], first.score.std() / np.sqrt(3)) + self.assertNotIn("score sem", summary.columns) # a metric may also be a value of the design overlap = summarize(results, ["score", "planes"], design_columns=["planes"]) self.assertEqual(list(overlap.columns).count("planes"), 1) + def test_replace_and_frames(self): + """Variants of a study replace arguments; designs may be data frames.""" + study = Study( + self.space, + lambda d: d, + lambda d: {"score": d.planes + d.noise}, + replicates=2, + seed=3, + ) + more = study.replace(replicates=4) + self.assertEqual((more.replicates, more.seed), (4, 3)) + self.assertIs(more.evaluate, study.evaluate) + self.assertEqual(study.replicates, 2) + results = more.run() + self.assertEqual(len(results), 9 * 4) + with self.assertRaisesRegex(TypeError, "no arguments"): + study.replace(replicate=3) + # designs given by a data frame of their values (such as a summary) + summary = summarize(results, ["score"]) + best = summary.nlargest(2, "score") + again = study.run(best) + self.assertEqual(list(again.design.unique()), list(best.design)) + with self.assertRaisesRegex(ValueError, "not given"): + study.run(list(best.design)) + def test_summarize_by(self): """Summaries group the records of an evaluation.""" study = Study( diff --git a/tests/tradespace/test_utility.py b/tests/tradespace/test_utility.py index e021a762..9cfff8c2 100644 --- a/tests/tradespace/test_utility.py +++ b/tests/tradespace/test_utility.py @@ -180,7 +180,7 @@ def test_statistics(self): "reliable": Probability(self.utility, ">=", 0.5), "expected": Mean(self.utility), } - summary = aggregate(_results(), statistics).set_index("design") + summary = aggregate(_results(), statistics=statistics).set_index("design") self.assertEqual(summary.loc["x", "worst"], 0.0) self.assertEqual(summary.loc["x", "reliable"], 0.5) self.assertEqual(summary.loc["y", "reliable"], 1.0) From e680409942ca097155e8d3cd833374a79d14434b Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Thu, 12 Nov 2026 19:24:36 -0700 Subject: [PATCH 34/52] structure the cost risk of designs by the components they share Growth of each type of satellite; costs of satellites as sums of components whose growth by maturity is drawn from scores of the components and a common score (risk_space), so that designs sharing a component share its growth and develop it once; the probability that a metric of each design exceeds that of each other in the same replicate (exceedance, plot_exceedance); and a section of TradeCostAndUtility comparing uncertain costs (after Maier, Yeakel, and Wendoloski, 2023). --- CHANGELOG.md | 3 +- docs/api_reference/tradespace/judge.rst | 10 + docs/api_reference/tradespace/missions.rst | 12 +- docs/examples/TradeCostAndUtility.ipynb | 379 +++++++++++++++- src/tatc/tradespace/__init__.py | 24 +- src/tatc/tradespace/comparison.py | 160 +++++++ src/tatc/tradespace/cost.py | 492 +++++++++++++++++++-- src/tatc/tradespace/observations.py | 70 ++- src/tatc/tradespace/plotting.py | 77 +++- src/tatc/tradespace/space.py | 34 +- tests/tradespace/test_comparison.py | 121 +++++ tests/tradespace/test_cost.py | 367 +++++++++++++++ tests/tradespace/test_layering.py | 1 + tests/tradespace/test_observations.py | 59 +++ tests/tradespace/test_plotting.py | 33 +- 15 files changed, 1746 insertions(+), 96 deletions(-) create mode 100644 src/tatc/tradespace/comparison.py create mode 100644 tests/tradespace/test_comparison.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 52c6aade..ef8004e0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -33,10 +33,11 @@ Added: - Scenarios of studies (argument `scenarios` of `tradespace.Study`): conditions under which designs are compared rather than averaged over, each giving fixed values or uncertain parameters of the design space other values (`Design.realize` takes a `scenario`), so that each design is evaluated in each scenario (recorded as `scenario`, and judged in each with criteria `by` it). Each scenario's evaluations are stored by its values, so that a scenario added later is evaluated alone. Function `tradespace.robustness` gives each design's Pareto trace (the share of scenarios in which it is efficient) and its regret in each scenario (the improvement in every objective it would need to match the scenario's front) and the largest. The metrics of an `ObservationStudy` (and of `PhaseCache`, `evaluate_missions`, and `expected_missions`) are given the realized design if they have a parameter named `design`. - Criteria across the scenarios of a study (`tradespace.Across`, argument `across` of `Criteria`), which judge each design once by its worst or its (weighted) mean statistics over the scenarios (or the groups of another column), so that searches find designs robust to scenarios; a requirement may be met in every scenario while objectives are means. - Function `tradespace.attribute_variance` (and class `Attribution`), which attributes the variance of metrics between the replicates of each design to its uncertain parameters (or groups of them): the share that each causes, alone or with others, and the share that knowing it would remove, with standard errors, by evaluating designs with one parameter drawn as in other replicates and the others held (which works for seeds, whose values do not order outcomes); `Attribution.summary` pools the shares of several designs, and `Attribution.differences` attributes the variance of the differences between pairs of designs, from the same evaluations (parameters that act alike on both cancel, with common random numbers). `Design.realize` and `Study.run` take a `shift`, which draws named parameters as in other replicates (kept apart in a `ResultStore` as a variant of the replicates), and `DesignSpace.uncertain_paths` lists the uncertain parameters. + - Structured cost risk (after Maier, Yeakel, and Wendoloski, "Cost Variance Analysis in Constellation Architecture Studies," 2023): growth factors of each type of satellite (by kind, for development, production, and launches, in `CostModel.estimate` and `MissionPlan.growth`), and the costs of types of satellites as sums of their components (`tradespace.Component`, `SatelliteCost.components`), whose growth has a distribution by maturity (such as `tradespace.Triangular`), correlated between components (`CostModel.correlation`). `CostModel.draw` draws the growth of the components from standard normal scores of the components and a common score, which `tradespace.risk_space` declares as uncertain parameters of a design space (named by `MissionPlan.scores`, also of a nested group), so that common random numbers give the designs that share a component the same growth of it; without drawn growth, components cost their expected growth. Types of satellites that share a component (by name) develop it once in a deployment. Function `tradespace.exceedance` gives the probability that a metric of each design exceeds that of each other in the same replicate (such as that one design costs more than another), and `plot_exceedance` plots them as a matrix. - Searches with Optuna accept categorical options that depend on earlier decisions (a parameter for each set of options), use TPE with a constant liar in batches by default (which spreads the trials of a batch), and stop after `max_designs` designs evaluated (trials that suggest designs evaluated before are told their objectives without evaluating them again). A design infeasible in some of its replicates violates its feasibility by their share (`Evaluations.infeasibility`), and the first design evaluated in a search is evaluated alone, to check that evaluations give one record each. `Study` records errors of evaluations as infeasible, without storing them, with `errors="record"`. Enumeration walks the items of unordered repetitions in one order only (the same designs, in the same order, four times faster for three sun-synchronous planes), and `DesignSpace.size` counts designs without keeping them. Pareto fronts are found by a vectorized sweep in lexicographic order that compares designs only with the efficient designs before them, and fronts with tolerances by comparing designs only with the efficient designs without tolerances (which dominate every design that any design dominates within the tolerances), in blocks of bounded memory: 20,000 designs in 0.05 s (0.11 s with tolerances) rather than 17 s, and the bootstraps of `pareto_probability` (and so `refine`) about 20 times faster. - Studies of the observations of constellations (`tradespace.ObservationStudy`): the targets of each replicate (`Targets`, fixed or generated from a seed of the design), the observations of each satellite, cached on disk (`Observations`), the metrics of the observations, and, with a `MissionPlan`, the costs of the deployment and the summaries of its phases or of the histories of its `Failures`. Plots of the results of studies (`plot_designs`, `plot_progress`, and `plot_means`, with matplotlib, now in the `tradespace` extra), and the hypervolume of a search as it proceeds (`hypervolume_progress`). - The steps of trade studies share their arguments and outcomes: `tradespace.refine(study, criteria, results)`, `confirm(study, criteria, results)` (by default, the front of the results), `screen(studies, criteria, designs)` (with criteria for each stage, in place of a `tolerance` of its own), and `attribute_variance(study, metrics, designs)` take designs as `Design` objects, their keys, or rows of a summary or of results, and `Refinement`, `Confirmation`, `Screening`, and `Search` give their `results`, the `summary` of their designs, and the `designs`. `DesignSpace.designs_of` rebuilds designs from rows of their values, which summaries keep (also those of `pareto_probability`, `confirm`, and `screen`), and `DesignSpace.extend`, `DesignSpace.design(design, **overrides)`, and `Study.replace` make variants of design spaces, designs, and studies. `aggregate` takes criteria, a mapping of objectives, or metrics (as the other functions do), and other `statistics` by name; `pareto_front`, `pareto_ranks`, `hypervolume`, `sensitivity`, and `main_effects` raise an error given the results of a study (a row per replicate) rather than a summary. Studies with a mission plan record the years by which it is `deployed`, and the parts of observation studies that refer to values of designs are typed as a `Reference`. Columns: ` se` (rather than `sem`), ` mission` for the mean over the phases of a mission, ` histories p` and ` histories std` for statistics over the histories of failures, and `pareto_trace` and `max_regret`. Package `tradespace` exports the functions and classes of trade studies; the parts from which they are made (such as `PhaseCache`, `Layout`, `configure`, and the fingerprints) are imported from its modules. - - Example `SearchTradeSpace`, which searches a hierarchical trade space of constellations for the designs that sample points sufficiently: by evaluating every design, finding what drives the objectives, screening, and searching with Optuna and pymoo; and examples that take its trade further, importing its design space and study (`trade_space_example.py`): `RankUncertainDesigns` (the probability of efficiency, refinement, confirmation, and requirements on statistics), `CompareScenarios` (fronts, regret, and searches across scenarios), `TradeCostAndUtility`, and `PlanMissions` (deployment, staging, failures, and the attribution of variance). + - Example `SearchTradeSpace`, which searches a hierarchical trade space of constellations for the designs that sample points sufficiently: by evaluating every design, finding what drives the objectives, screening, and searching with Optuna and pymoo; and examples that take its trade further, importing its design space and study (`trade_space_example.py`): `RankUncertainDesigns` (the probability of efficiency, refinement, confirmation, and requirements on statistics), `CompareScenarios` (fronts, regret, and searches across scenarios), `TradeCostAndUtility` (cost at a confidence level, correlated cost risk of components, and utility), and `PlanMissions` (deployment, staging, failures, and the attribution of variance). - The `RunOSSEMonsoon` example declares its constellation trade as a design space, caches the looks of each satellite, evaluates its replicates in parallel, and finds its Pareto-efficient designs. Changed: diff --git a/docs/api_reference/tradespace/judge.rst b/docs/api_reference/tradespace/judge.rst index a6ef05bc..de2a04e6 100644 --- a/docs/api_reference/tradespace/judge.rst +++ b/docs/api_reference/tradespace/judge.rst @@ -54,6 +54,14 @@ Pareto Efficiency .. autofunction:: tatc.tradespace.hypervolume_progress +Comparisons +=========== + +.. automodule:: tatc.tradespace.comparison + :no-members: + +.. autofunction:: tatc.tradespace.exceedance + Scenarios ========= @@ -94,6 +102,8 @@ Plots .. autofunction:: tatc.tradespace.plot_means +.. autofunction:: tatc.tradespace.plot_exceedance + .. autofunction:: tatc.tradespace.plot_progress .. autofunction:: tatc.tradespace.style_axes diff --git a/docs/api_reference/tradespace/missions.rst b/docs/api_reference/tradespace/missions.rst index 07f901f4..3582fcd0 100644 --- a/docs/api_reference/tradespace/missions.rst +++ b/docs/api_reference/tradespace/missions.rst @@ -120,10 +120,18 @@ Costs :no-members: .. autoclass:: tatc.tradespace.CostModel - :members: estimate, discount + :members: estimate, draw, score_names, discount .. autoclass:: tatc.tradespace.SatelliteCost - :members: production + :members: production, total_development, total_first_unit + +.. autoclass:: tatc.tradespace.Component + :members: uncertain, factor + +.. autoclass:: tatc.tradespace.Triangular + :members: mean, std, ppf + +.. autofunction:: tatc.tradespace.risk_space .. autoclass:: tatc.tradespace.LaunchCost diff --git a/docs/examples/TradeCostAndUtility.ipynb b/docs/examples/TradeCostAndUtility.ipynb index f10ed6b4..aae6b4bc 100644 --- a/docs/examples/TradeCostAndUtility.ipynb +++ b/docs/examples/TradeCostAndUtility.ipynb @@ -7,7 +7,7 @@ "source": [ "# Trade Cost and Utility\n", "\n", - "This example demonstrates how to trade the life-cycle cost of designs against what they achieve with the `tatc.tradespace` module: costs estimated from a cost model and each design's deployment, with uncertain growth whose quantiles give the cost at a confidence level, a budget as a requirement, and utilities that weigh several objectives by a stakeholder's preferences.\n", + "This example demonstrates how to trade the life-cycle cost of designs against what they achieve with the `tatc.tradespace` module: costs estimated from a cost model and each design's deployment, with uncertain growth whose quantiles give the cost at a confidence level, a budget as a requirement, the probability that one design costs more than another when designs share the cost risk of their components, and utilities that weigh several objectives by a stakeholder's preferences.\n", "\n", "It continues the example `SearchTradeSpace`, whose design space and study it imports from `trade_space_example.py` (beside the notebooks). The evaluations of every design are taken from the study's store if `SearchTradeSpace` was run before (or are evaluated again, in a few minutes). Its replicates are refined where the efficiency of designs is uncertain, as in `RankUncertainDesigns` (from the store, if that example was run before)." ] @@ -18,10 +18,10 @@ "id": "38ec6b1f", "metadata": { "execution": { - "iopub.execute_input": "2026-11-12T17:21:07.465585Z", - "iopub.status.busy": "2026-11-12T17:21:07.465585Z", - "iopub.status.idle": "2026-11-12T17:21:34.293683Z", - "shell.execute_reply": "2026-11-12T17:21:34.292062Z" + "iopub.execute_input": "2026-11-13T02:19:01.506492Z", + "iopub.status.busy": "2026-11-13T02:19:01.506492Z", + "iopub.status.idle": "2026-11-13T02:21:00.638217Z", + "shell.execute_reply": "2026-11-13T02:21:00.638217Z" } }, "outputs": [ @@ -63,10 +63,10 @@ "id": "30e16c98", "metadata": { "execution": { - "iopub.execute_input": "2026-11-12T17:21:34.297309Z", - "iopub.status.busy": "2026-11-12T17:21:34.296795Z", - "iopub.status.idle": "2026-11-12T17:21:37.440566Z", - "shell.execute_reply": "2026-11-12T17:21:37.438573Z" + "iopub.execute_input": "2026-11-13T02:21:00.638217Z", + "iopub.status.busy": "2026-11-13T02:21:00.638217Z", + "iopub.status.idle": "2026-11-13T02:21:02.137775Z", + "shell.execute_reply": "2026-11-13T02:21:02.137775Z" } }, "outputs": [ @@ -355,6 +355,344 @@ "The growth of the cost of development affects every design alike in a replicate (common random numbers), so it shifts the costs at 70% confidence more for designs whose development costs more, here those of the wider imager. With five replicates of most designs, the 0.7 quantile of their costs is a coarse estimate: an evaluation that costs little more than the cost model (unlike the analysis of sampling) could draw more replicates of the cost alone." ] }, + { + "cell_type": "markdown", + "id": "8e89a30c", + "metadata": {}, + "source": [ + "## Compare Uncertain Costs\n", + "\n", + "The growth of cost above is one factor of the development of every design, drawn alike in each replicate (common random numbers): designs share all of their cost risk. Cost risk has more structure (M. W. Maier, K. L. Yeakel, and E. B. Wendoloski, \"Cost Variance Analysis in Constellation Architecture Studies,\" *IEEE Systems Journal* 17(2), 2023). The cost of a type of satellite is the sum of those of its components (`Component`, here its bus and imager), each growing by its maturity (a `Triangular` distribution, from formal risk assessments: wider and skewed further up for new components than for existing ones), and the growths of the components are correlated (here by 0.5, `CostModel.correlation`), as costs estimated alike tend to be underestimated together. The growth of each component is drawn from scores, standard normal values of each component and a common score (uncertain parameters of the design space, from `risk_space`), which common random numbers give alike to every design of a replicate (`CostModel.draw`): designs of the same imager share all of its cost risk, and designs of different imagers share the growth of the bus and the common score. Here, the bus exists, the narrower imager modifies an existing one, and the wider imager is new; their expected costs are about those of the cost model above.\n", + "\n", + "A study of the costs alone (whose evaluation estimates the cost of each design's deployment, with the growth of its components drawn from its scores) evaluates the most sufficient efficient design at each cost (as in the table above) in 500 replicates, with common random numbers and without. Its results give the probability that each design costs more than each other (`exceedance`), plotted with `plot_exceedance` in order of the mean cost:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "0e9ef4ae", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-13T02:21:02.139782Z", + "iopub.status.busy": "2026-11-13T02:21:02.139782Z", + "iopub.status.idle": "2026-11-13T02:21:33.519907Z", + "shell.execute_reply": "2026-11-13T02:21:33.519907Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "30 deg: expected development 40.1, first unit 12.1\n", + "60 deg: expected development 59.1, first unit 18.2\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import dataclasses\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "\n", + "from trade_space_example import COST_MODEL, SCHEDULE, space\n", + "from tatc.tradespace import Component, SatelliteCost, Study, Triangular, exceedance, plot_exceedance, risk_space\n", + "\n", + "# the growth of the costs of a component by its maturity: lowest, most likely (the estimate), and highest (Maier et\n", + "# al., 2023, Table I)\n", + "MATURITY = {\n", + " \"new\": Triangular(0.827, 2.274),\n", + " \"major modification\": Triangular(0.864, 1.993),\n", + " \"modified\": Triangular(0.904, 1.708),\n", + " \"minor modification\": Triangular(0.943, 1.423),\n", + " \"existing\": Triangular(0.981, 1.140),\n", + "}\n", + "# illustrative costs (millions of dollars) of the components of the satellites of each imager: an existing bus, a\n", + "# modified imager of 30 degrees, and a new imager of 60 degrees, whose growths are correlated by 0.5\n", + "BUS = Component(\"bus\", development=20, first_unit=7, growth=MATURITY[\"existing\"])\n", + "COMPONENT_COSTS = dataclasses.replace(\n", + " COST_MODEL,\n", + " satellites={\n", + " 30: SatelliteCost(\n", + " components=[BUS, Component(\"imager 30\", development=16, first_unit=4, growth=MATURITY[\"modified\"])],\n", + " learning_rate=0.9,\n", + " mass=60,\n", + " ),\n", + " 60: SatelliteCost(\n", + " components=[BUS, Component(\"imager 60\", development=28, first_unit=8, growth=MATURITY[\"new\"])],\n", + " learning_rate=0.9,\n", + " mass=90,\n", + " ),\n", + " },\n", + " correlation=0.5,\n", + ")\n", + "for kind, satellite in COMPONENT_COSTS.satellites.items():\n", + " print(\n", + " f\"{kind} deg: expected development {satellite.total_development:.1f}, first unit {satellite.total_first_unit:.1f}\"\n", + " )\n", + "# the scores of the components and the common score, drawn for each replicate\n", + "costed_space = space.extend(cost_risk=risk_space(COMPONENT_COSTS))\n", + "\n", + "\n", + "def deploy(d):\n", + " \"\"\"The deployment of a design's satellites.\"\"\"\n", + " return SCHEDULE.plan(d.layout, kind=d.field_of_regard)\n", + "\n", + "\n", + "def estimate(deployment, design):\n", + " \"\"\"The cost of a deployment, with the growth of the components drawn from the design's scores.\"\"\"\n", + " return COMPONENT_COSTS.draw(design.cost_risk).estimate(deployment).metrics()\n", + "\n", + "\n", + "# the most sufficient efficient design at each cost (as designs of the space with scores), evaluated with common\n", + "# random numbers and without\n", + "compared = efficient.sort_values([\"cost p70\", \"sufficient\"], ascending=[True, False]).drop_duplicates(\"cost p70\")\n", + "compared_designs = [costed_space.design(d) for d in space.designs_of(compared)]\n", + "labels = {\n", + " d.key: f\"{row.satellites:.0f} x {d.field_of_regard} deg, {planes_name(row.planes)}\"\n", + " for d, row in zip(compared_designs, compared.itertuples())\n", + "}\n", + "costs = Study(costed_space, deploy, estimate, replicates=500)\n", + "shared_results = costs.run(compared_designs)\n", + "independent_results = costs.replace(common_random_numbers=False).run(compared_designs)\n", + "shared = exceedance(shared_results, \"cost\") # in order of the mean cost\n", + "order = list(dict.fromkeys(shared.design))\n", + "independent = exceedance(independent_results, \"cost\", order)\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(12, 5.6))\n", + "for ax, frame, title in zip(axes, [shared, independent], [\"Common random numbers\", \"Independent draws\"]):\n", + " plot_exceedance(frame, labels=labels, colorbar=False, ax=ax)\n", + " ax.set_title(title, fontsize=10)\n", + "axes[1].set(ylabel=\"\")\n", + "axes[1].tick_params(labelleft=False)\n", + "scale = fig.colorbar(axes[0].images[0], ax=axes, fraction=0.025, pad=0.02)\n", + "scale.set_label(\"Probability that the design costs more than the other\", fontsize=9)\n", + "scale.ax.tick_params(labelsize=8, length=0)\n", + "scale.outline.set_visible(False)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "08e81bc1", + "metadata": {}, + "source": [ + "With common random numbers (left), the designs of the narrower imager are ordered in every replicate: they share the growth of all of their components, so that the design with more satellites or planes costs more whatever the growth, although neighbors differ by less than their costs spread (three satellites in one plane cost 5 million dollars more than two in two planes, and each spreads by about 5 million). So are the two designs of the wider imager, 10 million apart while each spreads by 15 to 17 million. Designs of different imagers share the growth of the bus, which spreads little, and the common score, but the spread of the costs of the wider imager is mostly the new imager's own, and their order is open where their costs are near (the pale cells between the designs of each imager): two satellites of the wider imager in two planes cost more than four of the narrower one in two planes in 60% of the replicates, as the growth of the new imager is skewed far up. With independent draws (right), the order of designs of the same imager is open as well: their costs spread as much as before, but no longer together." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ba40b595", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-13T02:21:33.519907Z", + "iopub.status.busy": "2026-11-13T02:21:33.519907Z", + "iopub.status.idle": "2026-11-13T02:21:33.551943Z", + "shell.execute_reply": "2026-11-13T02:21:33.551943Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "common random numbers: 22 of 22 pairs of the same imager settled, 9 of 14 of different imagers\n", + "independent draws: 16 of 22 pairs of the same imager settled, 8 of 14 of different imagers\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
designothercostcost stdcost differenceexceedance (common)exceedance (independent)
02 x 30 deg, 1 plane1 x 30 deg, 1 plane91.214.7913.411.000.98
12 x 30 deg, 2 planes2 x 30 deg, 1 plane98.964.797.751.000.86
23 x 30 deg, 1 plane2 x 30 deg, 2 planes103.985.515.011.000.75
33 x 30 deg, 3 planes3 x 30 deg, 1 plane119.235.5115.251.000.95
44 x 30 deg, 2 planes3 x 30 deg, 3 planes123.806.194.571.000.70
52 x 60 deg, 2 planes4 x 30 deg, 2 planes129.6014.695.800.600.55
64 x 30 deg, 4 planes2 x 60 deg, 2 planes138.806.199.200.770.76
73 x 60 deg, 1 plane4 x 30 deg, 4 planes139.7917.010.990.480.46
\n", + "
" + ], + "text/plain": [ + " design other cost cost std \\\n", + "0 2 x 30 deg, 1 plane 1 x 30 deg, 1 plane 91.21 4.79 \n", + "1 2 x 30 deg, 2 planes 2 x 30 deg, 1 plane 98.96 4.79 \n", + "2 3 x 30 deg, 1 plane 2 x 30 deg, 2 planes 103.98 5.51 \n", + "3 3 x 30 deg, 3 planes 3 x 30 deg, 1 plane 119.23 5.51 \n", + "4 4 x 30 deg, 2 planes 3 x 30 deg, 3 planes 123.80 6.19 \n", + "5 2 x 60 deg, 2 planes 4 x 30 deg, 2 planes 129.60 14.69 \n", + "6 4 x 30 deg, 4 planes 2 x 60 deg, 2 planes 138.80 6.19 \n", + "7 3 x 60 deg, 1 plane 4 x 30 deg, 4 planes 139.79 17.01 \n", + "\n", + " cost difference exceedance (common) exceedance (independent) \n", + "0 13.41 1.00 0.98 \n", + "1 7.75 1.00 0.86 \n", + "2 5.01 1.00 0.75 \n", + "3 15.25 1.00 0.95 \n", + "4 4.57 1.00 0.70 \n", + "5 5.80 0.60 0.55 \n", + "6 9.20 0.77 0.76 \n", + "7 0.99 0.48 0.46 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# the pairs whose order the replicates settle (one design costs more in at least 95% of them), of the same imager\n", + "# and of different imagers\n", + "position = {key: k for k, key in enumerate(order)}\n", + "imager = {d.key: d.field_of_regard for d in compared_designs}\n", + "for name, frame in [(\"common random numbers\", shared), (\"independent draws\", independent)]:\n", + " pairs = frame[frame.design.map(position) > frame.other.map(position)]\n", + " settled = (pairs.exceedance >= 0.95) | (pairs.exceedance <= 0.05)\n", + " same = pairs.design.map(imager) == pairs.other.map(imager)\n", + " print(\n", + " f\"{name}: {settled[same].sum()} of {same.sum()} pairs of the same imager settled, \"\n", + " + f\"{settled[~same].sum()} of {(~same).sum()} of different imagers\"\n", + " )\n", + "\n", + "# each design against the one before it in order of cost: the mean and standard deviation of its cost, the mean\n", + "# difference, and the probability that it costs more, with common random numbers and with independent draws\n", + "spread = shared_results.groupby(\"design\")[\"cost\"].agg([\"mean\", \"std\"])\n", + "neighbors = pd.DataFrame({\"design\": order[1:], \"other\": order[:-1]})\n", + "neighbors = neighbors.merge(shared, on=[\"design\", \"other\"]).merge(\n", + " independent[[\"design\", \"other\", \"exceedance\"]], on=[\"design\", \"other\"], suffixes=(\" (common)\", \" (independent)\")\n", + ")\n", + "neighbors[\"cost\"] = spread.loc[neighbors.design, \"mean\"].to_numpy()\n", + "neighbors[\"cost std\"] = spread.loc[neighbors.design, \"std\"].to_numpy()\n", + "neighbors[\"design\"] = neighbors.design.map(labels)\n", + "neighbors[\"other\"] = neighbors.other.map(labels)\n", + "neighbors[\n", + " [\"design\", \"other\", \"cost\", \"cost std\", \"cost difference\", \"exceedance (common)\", \"exceedance (independent)\"]\n", + "].round(2)" + ] + }, + { + "cell_type": "markdown", + "id": "946e61f2", + "metadata": {}, + "source": [ + "Along the order of cost, each design of the narrower imager costs more than the one before it in every replicate with common random numbers, and in 70 to 98% of them with independent draws: neighbors 5 million dollars apart (three satellites in one plane after two in two planes, and four in two planes after three in three planes) change order in a quarter to a third of the replicates drawn independently, as each spreads by 5 to 6 million. Of the pairs of designs of the same imager, all 22 are settled (one costs more in at least 95% of the replicates) with common random numbers and 16 with independent draws; of the pairs of different imagers, 9 of 14 with common random numbers and 8 with independent draws, as what they share (the bus, and the common score) spreads less than the new imager. Costs that share their risk settle the order of designs that differ by less than their costs spread, as far as they share what spreads, which comparisons of their quantiles, or of costs drawn independently, cannot see. Here, the order of the front's designs by cost is open only where they change imager, where a choice within a budget rests on the growth of the new imager.\n", + "\n", + "The growth of each type of satellite is the simplest structure of this kind (a factor of each kind, such as `growth={\"development\": {30: \"growth_30\", 60: \"growth_60\"}}` in a `MissionPlan`), and a `MissionPlan` draws the growth of components from the scores of each design (`scores=\"cost_risk\"`) in an `ObservationStudy`. The scores are uncertain parameters of the design space, so that the variance of costs, or of their differences, may be attributed to each component (`attribute_variance`, with the paths of the scores, such as `cost_risk.imager 60`) and to the risk that components share (`cost_risk.common`), and a scenario may fix a score (such as at a high quantile of the growth of the new imager)." + ] + }, { "cell_type": "markdown", "id": "b41fbb9e", @@ -367,14 +705,14 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "id": "1d83ea69", "metadata": { "execution": { - "iopub.execute_input": "2026-11-12T17:21:37.444572Z", - "iopub.status.busy": "2026-11-12T17:21:37.443572Z", - "iopub.status.idle": "2026-11-12T17:21:38.748571Z", - "shell.execute_reply": "2026-11-12T17:21:38.747456Z" + "iopub.execute_input": "2026-11-13T02:21:33.551943Z", + "iopub.status.busy": "2026-11-13T02:21:33.551943Z", + "iopub.status.idle": "2026-11-13T02:21:33.788242Z", + "shell.execute_reply": "2026-11-13T02:21:33.788242Z" } }, "outputs": [ @@ -433,14 +771,14 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "id": "182b77eb", "metadata": { "execution": { - "iopub.execute_input": "2026-11-12T17:21:38.751636Z", - "iopub.status.busy": "2026-11-12T17:21:38.751636Z", - "iopub.status.idle": "2026-11-12T17:21:38.772519Z", - "shell.execute_reply": "2026-11-12T17:21:38.771429Z" + "iopub.execute_input": "2026-11-13T02:21:33.788242Z", + "iopub.status.busy": "2026-11-13T02:21:33.788242Z", + "iopub.status.idle": "2026-11-13T02:21:33.804174Z", + "shell.execute_reply": "2026-11-13T02:21:33.804174Z" } }, "outputs": [ @@ -601,7 +939,7 @@ "64cf6542c326 True " ] }, - "execution_count": 4, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -632,6 +970,7 @@ "## Summary\n", "\n", "* A `CostModel` estimates the life-cycle cost of each deployment from the costs of its satellites, launches, and operations (given by the study, as TAT-C includes no cost-estimating relationships), dated by the deployment that a `DeploymentSchedule` plans from rates of production and launch, with uncertain growth whose quantiles give the cost at a confidence level, as an objective or a requirement in place of the numbers of satellites and planes.\n", + "* The costs of the components of satellites (`Component`), whose growth by their maturity is drawn from scores that are uncertain parameters of the design space (`risk_space`, `CostModel.draw`), share cost risk between the designs that share components: with common random numbers, the order of designs of the same imager is settled although they differ by less than their costs spread, and the probability that each design costs more than each other (`exceedance`, `plot_exceedance`) shows where the order of the front is open.\n", "* A `Utility` weighs metrics by a stakeholder's preferences (a single-attribute utility of each, combined by weights) into one objective against cost, and is a metric of any statistic (its mean is the expected utility): here, stakeholders who weigh sufficiency or accuracy most agree within the budget and part beyond it." ] } diff --git a/src/tatc/tradespace/__init__.py b/src/tatc/tradespace/__init__.py index 0a6043da..415d72ac 100644 --- a/src/tatc/tradespace/__init__.py +++ b/src/tatc/tradespace/__init__.py @@ -20,6 +20,7 @@ from .attribution import attribute_variance from .cache import SatelliteCache +from .comparison import exceedance from .confirmation import confirm from .constellations import ( build_constellation, @@ -29,7 +30,15 @@ sso_planes_space, walker_space, ) -from .cost import CostModel, LaunchCost, OperationsCost, SatelliteCost +from .cost import ( + Component, + CostModel, + LaunchCost, + OperationsCost, + SatelliteCost, + Triangular, + risk_space, +) from .criteria import ( Across, Criteria, @@ -74,7 +83,13 @@ pareto_probability, pareto_ranks, ) -from .plotting import plot_designs, plot_means, plot_progress, style_axes +from .plotting import ( + plot_designs, + plot_exceedance, + plot_means, + plot_progress, + style_axes, +) from .refinement import refine from .scenarios import robustness from .screening import screen @@ -106,6 +121,7 @@ "walker_space", # studies "Bathtub", + "Component", "CostModel", "DeploymentSchedule", "Exponential", @@ -124,7 +140,9 @@ "Stage", "Study", "Targets", + "Triangular", "Weibull", + "risk_space", # criteria and summaries "Across", "Criteria", @@ -141,6 +159,7 @@ "StandardError", "Utility", "aggregate", + "exceedance", "hypervolume", "hypervolume_progress", "main_effects", @@ -159,6 +178,7 @@ "screen", # plots "plot_designs", + "plot_exceedance", "plot_means", "plot_progress", "style_axes", diff --git a/src/tatc/tradespace/comparison.py b/src/tatc/tradespace/comparison.py new file mode 100644 index 00000000..80a3c97d --- /dev/null +++ b/src/tatc/tradespace/comparison.py @@ -0,0 +1,160 @@ +""" +Comparisons of designs by the replicates of a metric: the probability that +the metric of one design exceeds that of another in the same replicate, for +every pair of designs (such as the probability that one design costs more +than another). + +With common random numbers (see `Design.realize`), designs share the draws +of their uncertain parameters in each replicate, so that their metrics are +correlated by what they share (such as the growth of the cost of a +component that both carry, see `CostModel.draw`): the order of two designs +may then be settled although the metric of each spreads over the replicates +by more than they differ, as the noise that they share cancels in their +difference. Comparisons of the spreads of designs (such as their quantiles) +cannot see this, and judge the order of such designs unsettled. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +from collections.abc import Iterable, Sequence + +import numpy as np +import pandas as pd + +from .criteria import _get_matrices, _groups +from .space import Design, _design_items + + +def _keys_of(designs: Iterable[Design | str] | pd.DataFrame) -> list[str]: + """ + Gets the keys of designs given as designs, keys, or a data frame of them + (with keys `design`, a column or the name of the index), each once. + """ + keys = [d.key if isinstance(d, Design) else d for d in _design_items(designs)] + return list(dict.fromkeys(keys)) + + +def exceedance( + results: pd.DataFrame, + metric: str, + designs: Iterable[Design | str] | pd.DataFrame | None = None, + *, + by: Sequence[str] | str = (), +) -> pd.DataFrame: + """ + Estimates the probability that a metric of each design exceeds that of + each other design (and of itself) in the same replicate, from the + replicates in which both are feasible: the share of these replicates in + which it is greater, counting ties as half, so that the probabilities of + a pair and of its reverse add to 1 (and that of a design with itself is + 0.5). A probability near 0 or 1 is an order of the pair that the + replicates settle, and one near 0.5 an order that they do not:: + + results = study.run(designs) + compared = exceedance(results, "cost") + plot_exceedance(compared) + + With common random numbers (see `Design.realize`), the replicates of + designs share the draws of their uncertain parameters, and the + probability is that of the order of the designs given what they share + (such as the growth of the cost of a component that both carry, see + `CostModel.draw`). Without them, the draws are independent, and the + probability is that of the order of independent outcomes of the designs. + + Args: + results (pandas.DataFrame): The results of a study (see + `Study.run`), with a record per replicate of each design (and + group of `by`). Infeasible results, and those whose metric is + missing (`NaN`), are ignored. + metric (str): The metric. + designs (Iterable[Design | str] | pandas.DataFrame | None): The + designs (or their keys, or a data frame of them, such as a + summary), in order, or `None` for every design of the results + (of each group), by the mean of the metric (least first, and + those without a feasible result last). + by (Sequence[str] | str): The columns of groups of the results (such + as `scenario`) in which designs are compared separately. + + Returns: + pandas.DataFrame: a row per ordered pair of designs (and group), in + the order of the designs: the `design` and the `other`, the + columns of the group, the mean difference of the metric (the + design's less the other's, ` difference`), the + probability that the design's metric exceeds the other's + (`exceedance`), and the number of replicates in which both are + feasible (`replicates`) + + Raises: + ValueError: if the results lack the metric or a design, or have + several records of a design in a replicate (of a group). + """ + by = (by,) if isinstance(by, str) else tuple(by) + if metric not in results.columns: + raise ValueError(f"no metric {metric!r} in the results") + keys = None if designs is None else _keys_of(designs) + if keys is not None: + present = set(results["design"]) + missing = [key for key in keys if key not in present] + if missing: + raise ValueError(f"no results of designs {missing[:5]}") + frames = [] + for group_key, positions in _groups(results, by): + group = results.iloc[positions] + index = pd.Index(group["design"].unique() if keys is None else keys) + if index.empty: + continue + if "feasible" in group: + group = group[group["feasible"].astype(bool)] + _, _, matrices = _get_matrices(group, [metric], index) + values = matrices[metric] + valid = ~np.isnan(values) + if keys is None: + # by the mean of the metric, designs without feasible results last + with np.errstate(invalid="ignore", divide="ignore"): + means = np.where(valid, values, 0.0).sum(axis=1) / valid.sum(axis=1) + order = np.argsort(means, kind="stable") + index, values, valid = index[order], values[order], valid[order] + parts: dict[str, list[np.ndarray]] = { + "design": [], + "other": [], + "difference": [], + "exceedance": [], + "replicates": [], + } + for i, design in enumerate(index): + both = valid[i] & valid + counts = both.sum(axis=1) + greater = (both & (values[i] > values)).sum(axis=1) + ties = (both & (values[i] == values)).sum(axis=1) + with np.errstate(invalid="ignore", divide="ignore"): + difference = np.where(both, values[i] - values, 0.0) + parts["difference"].append(difference.sum(axis=1) / counts) + parts["exceedance"].append((greater + 0.5 * ties) / counts) + parts["design"].append(np.full(len(index), design, dtype=object)) + parts["other"].append(np.asarray(index, dtype=object)) + parts["replicates"].append(counts) + frame = pd.DataFrame( + { + "design": np.concatenate(parts["design"]), + "other": np.concatenate(parts["other"]), + **dict(zip(by, group_key)), + f"{metric} difference": np.concatenate(parts["difference"]), + "exceedance": np.concatenate(parts["exceedance"]), + "replicates": np.concatenate(parts["replicates"]), + } + ) + frames.append(frame) + if not frames: + return pd.DataFrame( + columns=[ + "design", + "other", + *by, + f"{metric} difference", + "exceedance", + "replicates", + ] + ) + return pd.concat(frames, ignore_index=True) diff --git a/src/tatc/tradespace/cost.py b/src/tatc/tradespace/cost.py index b1f9862f..34c9c6cd 100644 --- a/src/tatc/tradespace/cost.py +++ b/src/tatc/tradespace/cost.py @@ -9,10 +9,27 @@ each type of satellite (such as the satellites of each payload) and of launches and operations are given, as values or functions of a design (such as a mass-based relationship, as a `MissionPlan` of each design sizes them), -in a currency of the user's choice and constant-year amounts. Cost risk enters as uncertain growth factors (see -`CostModel.estimate`), drawn for each replicate like other uncertain -parameters, so that statistics of the cost over replicates (such as a 0.7 -`Quantile`) are objectives or requirements. +in a currency of the user's choice and constant-year amounts. Cost risk +enters as uncertain growth factors (see `CostModel.estimate`), drawn for +each replicate like other uncertain parameters, so that statistics of the +cost over replicates (such as a 0.7 `Quantile`) are objectives or +requirements: of every cost, of each element, or of each element of each +type of satellite. + +The costs of a type of satellite may also be the sum of those of its +components (such as its bus and instruments, see `Component`), each with an +uncertain growth by its maturity (such as a `Triangular` distribution, wider +for new components than for existing ones), correlated between the +components (`CostModel.correlation`), as in formal risk assessments of cost +estimates. Their growth is drawn from scores of the components and a common +score (`CostModel.draw`), uncertain parameters of the design space +(`risk_space`) that common random numbers give alike to every design of a +replicate: designs that share a component share its growth, so that the +costs of designs are correlated by what they share (as in M. W. Maier, K. +L. Yeakel, and E. B. Wendoloski, "Cost Variance Analysis in Constellation +Architecture Studies," IEEE Systems Journal 17(2), 2023), and comparisons +between them (such as the probability that one costs more than another, see +`exceedance`) see the differences of their costs. A deployment dates the costs: development of each type of satellite, production of its satellites, launches, replacements, and operations from @@ -32,8 +49,10 @@ def evaluate(built): from __future__ import annotations +import dataclasses import math -from collections.abc import Mapping +import numbers +from collections.abc import Mapping, Sequence from dataclasses import dataclass, field from typing import Any @@ -42,10 +61,141 @@ def evaluate(built): from .deployment import Deployment from .mission import MissionHistory +from .nodes import Uncertain +from .space import _RESERVED_NAMES, DesignSpace ELEMENTS = ("development", "production", "launch", "operations") """The elements of the cost of a constellation.""" +_PATH_CHARACTERS = (".", "[", "]") +"""Characters of the paths of values of designs, which names of scores lack.""" + +COMMON = "common" +"""The name of the common score of the growth of components (see +`CostModel.draw`), which no component may have.""" + + +@dataclass(frozen=True) +class Triangular: + """ + A triangular distribution of the growth of a cost, from `low` to `high` + and most likely `mode` (by default 1, the estimate), such as of a + component of a given maturity: wider and skewed further up for new + components than for existing ones. For example, formal risk assessments + of satellites have used growths from 0.827 to 2.274 for new components, + 0.904 to 1.708 for modified ones, and 0.981 to 1.140 for existing ones + (M. W. Maier, K. L. Yeakel, and E. B. Wendoloski, "Cost Variance Analysis + in Constellation Architecture Studies," IEEE Systems Journal 17(2), + 2023, Table I). + + Args: + low (float): The lowest growth. + high (float): The highest growth. + mode (float): The most likely growth. + """ + + low: float + high: float + mode: float = 1.0 + + def __post_init__(self): + if not 0 <= self.low <= self.mode <= self.high or self.low == self.high: + raise ValueError("growth must satisfy 0 <= low <= mode <= high, low < high") + + def mean(self) -> float: + """ + Gets the mean growth. + + Returns: + float: the mean + """ + return (self.low + self.mode + self.high) / 3 + + def std(self) -> float: + """ + Gets the standard deviation of the growth. + + Returns: + float: the standard deviation + """ + a, b, c = self.low, self.mode, self.high + return math.sqrt((a * a + b * b + c * c - a * b - a * c - b * c) / 18) + + def ppf(self, q: float) -> float: + """ + Gets the quantile of the growth at a probability (the inverse of its + cumulative distribution). + + Args: + q (float): The probability, in [0, 1]. + + Returns: + float: the growth + """ + low, mode, high = self.low, self.mode, self.high + split = (mode - low) / (high - low) + if q <= split: + return low + math.sqrt(q * (high - low) * (mode - low)) + return high - math.sqrt((1 - q) * (high - low) * (high - mode)) + + +def _is_number(value: Any) -> bool: + return isinstance(value, numbers.Real) and not isinstance(value, bool) + + +@dataclass(frozen=True) +class Component: + """ + A component of a type of satellite (such as its bus, an instrument, or + its software), whose costs of development and of its first unit grow by + the same factor: a number, or a distribution (an object with methods + `ppf` and `mean`, such as `Triangular`). A component's growth is drawn + from the distribution by its score (see `CostModel.draw`), and is + otherwise the mean of the distribution, so that estimates without drawn + growth are expected costs. + + Components are identified by name: those of the same name draw the same + score, in every type of satellite and design (such as an instrument + that several types carry), and the types of satellites of a cost model + that carry a component develop it once (see `CostModel.estimate`). + + Args: + name (str): The name. + development (float): The nonrecurring cost. + first_unit (float): The recurring cost of the first unit. + growth (Any): The growth factor of its costs, or its distribution. + """ + + name: str + development: float = 0.0 + first_unit: float = 0.0 + growth: Any = 1.0 + + def __post_init__(self): + if not isinstance(self.name, str) or not self.name: + raise ValueError("a component needs a name") + if self.development < 0 or self.first_unit < 0: + raise ValueError("costs must not be negative") + if _is_number(self.growth): + if self.growth < 0: + raise ValueError("growth must not be negative") + elif not (hasattr(self.growth, "ppf") and hasattr(self.growth, "mean")): + raise TypeError( + "growth must be a number or a distribution with methods ppf and mean" + ) + + @property + def uncertain(self) -> bool: + """bool: Whether its growth is drawn from a distribution.""" + return not _is_number(self.growth) + + @property + def factor(self) -> float: + """float: Its growth factor (or the mean of its distribution).""" + if self.uncertain: + return float(self.growth.mean()) + return float(self.growth) + @dataclass(frozen=True) class SatelliteCost: @@ -57,28 +207,62 @@ class SatelliteCost: doubling of the units built costs `learning_rate` times as much per unit (typically 0.85 to 0.95 for satellites, 1 for no learning). + The costs may also be, or include, those of its components (such as its + bus and instruments, see `Component`), each with its growth: the costs + of the type are its own and those of its components, grown by their + factors (`total_development` and `total_first_unit`, of the type + alone). The growths of components may be correlated (when drawn, see + `CostModel.correlation`). + Args: - development (float): The nonrecurring cost. - first_unit (float): The recurring cost of the first unit. + development (float): The nonrecurring cost (besides that of its + components). + first_unit (float): The recurring cost of the first unit (besides + that of its components). learning_rate (float): The learning rate, in (0, 1]. mass (float | None): The mass (kg), for launches priced by mass. + components (Sequence[Component]): The components, if any, of + distinct names. """ development: float = 0.0 first_unit: float = 0.0 learning_rate: float = 1.0 mass: float | None = None + components: Sequence[Component] = () def __post_init__(self): if not 0 < self.learning_rate <= 1: raise ValueError("learning_rate must be in (0, 1]") if self.development < 0 or self.first_unit < 0: raise ValueError("costs must not be negative") + components = tuple(self.components) + if not all(isinstance(c, Component) for c in components): + raise TypeError("components must be Components") + names = [c.name for c in components] + if len(set(names)) < len(names): + raise ValueError( + "the components of a type of satellite need distinct names" + ) + object.__setattr__(self, "components", components) + + @property + def total_development(self) -> float: + """float: The nonrecurring cost, with those of its components grown + by their factors (of the type alone: types that share a component + develop it once, see `CostModel.estimate`).""" + return self.development + sum(c.development * c.factor for c in self.components) + + @property + def total_first_unit(self) -> float: + """float: The recurring cost of the first unit, with those of its + components grown by their factors.""" + return self.first_unit + sum(c.first_unit * c.factor for c in self.components) def production(self, units: int) -> float: """ Gets the recurring cost of building units (the sum of the costs of - units 1 to `units` on the learning curve). + units 1 to `units` on the learning curve, from `total_first_unit`). Args: units (int): The number of units. @@ -89,7 +273,9 @@ def production(self, units: int) -> float: if units <= 0: return 0.0 exponent = math.log2(self.learning_rate) - return float(self.first_unit * np.sum(np.arange(1, units + 1) ** exponent)) + return float( + self.total_first_unit * np.sum(np.arange(1, units + 1) ** exponent) + ) @dataclass(frozen=True) @@ -225,9 +411,10 @@ def metrics(self, prefix: str = "cost") -> dict[str, float]: } -Growth = float | Mapping[str, float] +Growth = float | Mapping[str, float | Mapping[Any, float]] """Growth factors of costs: one for every element, or by element (see -`ELEMENTS`, others 1).""" +`ELEMENTS`, others 1), and of development, production, and launches, by +type of satellite (a mapping of each kind to its factor).""" @dataclass(frozen=True) @@ -242,14 +429,26 @@ class CostModel: `start` years after the present) has a present value of `cost / (1 + discount_rate) ** (start + t)`. + The growths of the components of satellites (see `Component`) may be + correlated (when drawn, see `draw`): costs estimated together tend to be + underestimated together, as are those of the software and management of + a satellite whose payload costs more than estimated. A correlation of + 0.5 between the components of a satellite is commonly assumed; here, it + is of every pair of components of the model (such as of the instruments + of different types of satellites, estimated alike). + Args: satellites (SatelliteCost | Mapping[str, SatelliteCost]): The cost of - the satellites, or of each type of satellite (by name). + the satellites, or of each type of satellite (by name). The + components of the same name of different types must be the same + (equal costs and growth). launch (LaunchCost): The cost of launches. operations (OperationsCost): The cost of operations. discount_rate (float): The annual discount rate (such as 0.03). start (float): The years from the present to the start of development. + correlation (float): The correlation of the scores of the components + (see `draw`), in [0, 1]. """ satellites: SatelliteCost | Mapping[str, SatelliteCost] @@ -257,10 +456,25 @@ class CostModel: operations: OperationsCost = OperationsCost() discount_rate: float = 0.0 start: float = 0.0 + correlation: float = 0.0 def __post_init__(self): if self.discount_rate <= -1: raise ValueError("discount_rate must be greater than -1") + if not 0 <= self.correlation <= 1: + raise ValueError("correlation must be in [0, 1]") + components: dict[str, Component] = {} + for _, _, cost in self._types(): + for component in cost.components: + if component.name == COMMON: + raise ValueError( + f"{COMMON!r} names the common score of cost risk, not a component" + ) + if components.setdefault(component.name, component) != component: + raise ValueError( + f"the components named {component.name!r} differ: types of " + + "satellites that share a component share its costs and growth" + ) def discount(self, time: float) -> float: """ @@ -283,6 +497,101 @@ def _get_type(self, kind: Any) -> SatelliteCost: raise ValueError(f"no cost of satellites of kind {kind!r}") return self.satellites[kind] + def _types(self) -> list[tuple[str, Any, SatelliteCost]]: + """ + Gets the types of satellites: the name of each (as of the units of + estimates), its kind, and its cost. + """ + if isinstance(self.satellites, SatelliteCost): + return [(_type_name(None), None, self.satellites)] + return [ + (_type_name(kind), kind, cost) for kind, cost in self.satellites.items() + ] + + def score_names(self) -> list[str]: + """ + Gets the names of the scores from which the growth of the components + is drawn (see `draw`): those of the components with distributions of + growth, after the common score (`"common"`) if they are correlated. + + Returns: + list[str]: the names, in the order of the types and components + """ + names = list( + dict.fromkeys( + component.name + for _, _, cost in self._types() + for component in cost.components + if component.uncertain + ) + ) + if names and self.correlation > 0: + names.insert(0, COMMON) + return names + + def draw(self, scores: Mapping[str, float]) -> CostModel: + """ + Draws the growth of the costs of the components of its types of + satellites (see `Component`) from their scores: standard normal + values of the components and a common score (by name, see + `score_names`), such as uncertain parameters of a design space drawn + for each replicate (see `risk_space`). The growth of a component is + the quantile of its distribution at the normal probability of its + score, mixed with the common score by the correlation (ρ, see + `correlation`): `sqrt(ρ) * score["common"] + sqrt(1 - ρ) * + score[component]`. The growths of the components are then + correlated (by about ρ), and a component that several types of + satellites carry has the same growth in each. + + With common random numbers (see `Design.realize`), a component (and + the common score) has the same score in the same replicate of every + design, so that designs that share it share its growth: the costs of + designs are correlated by what they share, and comparisons between + them (such as `exceedance`) see the differences of their costs + rather than of independent draws. + + Args: + scores (Mapping[str, float]): The scores, by name (others are + ignored). + + Returns: + CostModel: the cost model, whose components have the drawn growths + + Raises: + ValueError: if a score is missing. + """ + names = self.score_names() + missing = [name for name in names if name not in scores] + if missing: + raise ValueError(f"no scores of {missing}") + common = float(scores[COMMON]) if COMMON in names else 0.0 + probabilities = {} + for name in names: + if name != COMMON: + score = math.sqrt(self.correlation) * common + math.sqrt( + 1 - self.correlation + ) * float(scores[name]) + probabilities[name] = 0.5 * (1 + math.erf(score / math.sqrt(2))) + drawn = {} + for _, kind, cost in self._types(): + components = tuple( + ( + dataclasses.replace( + component, + growth=float( + component.growth.ppf(probabilities[component.name]) + ), + ) + if component.uncertain + else component + ) + for component in cost.components + ) + drawn[kind] = dataclasses.replace(cost, components=components) + if isinstance(self.satellites, SatelliteCost): + return dataclasses.replace(self, satellites=drawn[None]) + return dataclasses.replace(self, satellites=drawn) + def estimate( self, deployment: Deployment | MissionHistory, growth: Growth = 1.0 ) -> CostEstimate: @@ -296,25 +605,41 @@ def estimate( their production; each launch (including those that fail), when it flies; a fixed cost of operations over the mission; and the operations of each satellite while it is in orbit (operating, or a - spare waiting). + spare waiting). The costs of types of satellites include those of + their components, grown by their factors (drawn, see `draw`, or + otherwise the means of their distributions, for expected costs). A + component that several types of the deployment carry is developed + once, with the type whose development ends first (and by its growth + factor), and produced with each type (on its learning curve). Growth factors multiply the estimate, such as uncertain parameters of cost growth drawn for each replicate (for example, `Uncertain(lambda rng: rng.triangular(0.9, 1.0, 1.5))`), whose statistics over the replicates give the cost at a confidence level - (such as the 0.7 `Quantile`). Do not use uncertain growth in - constraints of a design space, which see their nominal values - (`NaN`). + (such as the 0.7 `Quantile`). Factors of each type of satellite (such + as `{"development": {"narrow": "growth_narrow", "wide": + "growth_wide"}}` in a `MissionPlan`) are independent between types + but shared by the designs of each type of a replicate (with common + random numbers, see `Design.realize`), so that the costs of designs + are correlated by the types of satellites they share. Do not use + uncertain growth in constraints of a design space, which see their + nominal values (`NaN`). Args: deployment (Deployment | MissionHistory): The deployment (see `DeploymentSchedule.plan`), or a simulated mission. - growth (float | Mapping[str, float]): A growth factor of the - cost, or of each element (`"development"`, `"production"`, - `"launch"`, or `"operations"`; others 1). + growth (float | Mapping): A growth factor of the cost, or of each + element (`"development"`, `"production"`, `"launch"`, or + `"operations"`; others 1), and of development, production, and + launches, of each kind of satellite (a mapping of each kind of + the deployment to its factor). Returns: CostEstimate: the estimate + + Raises: + ValueError: if growth names an unknown element, is of operations + by type of satellite, or lacks a kind of the deployment. """ factors = _get_growth(growth) history = ( @@ -323,19 +648,28 @@ def estimate( estimate = CostEstimate() flows: list[tuple[float, str, float]] = [] - def add(element: str, amounts: list[tuple[float, float]]) -> None: - flows.extend( - (time, element, amount * factors[element]) for time, amount in amounts - ) + def add( + element: str, amounts: list[tuple[float, float]], kind: Any = None + ) -> None: + factor = _get_factor(factors, element, kind) + flows.extend((time, element, amount * factor) for time, amount in amounts) if self.launch.per_kg > 0 and any( self._get_type(kind).mass is None for kind in history.development ): raise ValueError("launches priced by mass require masses") - for kind, developed in history.development.items(): - add( - "development", _spread(self._get_type(kind).development, 0.0, developed) + developed_components: set[str] = set() + for kind, developed in sorted( + history.development.items(), key=lambda item: item[1] + ): + cost = self._get_type(kind) + amount = cost.development + sum( + c.development * c.factor + for c in cost.components + if c.name not in developed_components ) + developed_components.update(c.name for c in cost.components) + add("development", _spread(amount, 0.0, developed), kind) built: dict[Any, int] = {} for batch in history.production: cost = self._get_type(batch.kind) @@ -344,11 +678,8 @@ def add(element: str, amounts: list[tuple[float, float]]) -> None: before ) built[batch.kind] = before + batch.satellites - add("production", _spread(amount, batch.begin, batch.end)) - estimate.units = { - "satellites" if kind is None else str(kind): units - for kind, units in built.items() - } + add("production", _spread(amount, batch.begin, batch.end), batch.kind) + estimate.units = {_type_name(kind): units for kind, units in built.items()} begin, end = history.begin, history.end for launch in history.launches: cost = self._get_type(launch.kind) @@ -356,7 +687,7 @@ def add(element: str, amounts: list[tuple[float, float]]) -> None: price = self.launch.per_launch + launch.satellites * ( self.launch.per_satellite + self.launch.per_kg * (cost.mass or 0.0) ) - add("launch", [(launch.time, price)]) + add("launch", [(launch.time, price)], launch.kind) for start, stop, count in history.in_orbit(): add( "operations", @@ -388,13 +719,94 @@ def add(element: str, amounts: list[tuple[float, float]]) -> None: return estimate -def _get_growth(growth: Growth) -> dict[str, float]: +def _type_name(kind: Any) -> str: + """ + Gets the name of a type of satellite (as of the units of estimates): its + kind, or `"satellites"` without one. + """ + return "satellites" if kind is None else str(kind) + + +def _get_growth(growth: Growth) -> dict[str, float | dict[Any, float]]: + """ + Gets the growth factor of each element of cost (or a mapping of each kind + of satellite to its factor). + """ + if not isinstance(growth, Mapping): + return {element: float(growth) for element in ELEMENTS} + unknown = set(growth) - set(ELEMENTS) + if unknown: + raise ValueError(f"growth of unknown elements: {sorted(unknown)}") + factors: dict[str, float | dict[Any, float]] = {} + for element in ELEMENTS: + value = growth.get(element, 1.0) + if isinstance(value, Mapping): + if element == "operations": + raise ValueError("the growth of operations is not by type of satellite") + factors[element] = {kind: float(factor) for kind, factor in value.items()} + else: + factors[element] = float(value) + return factors + + +def _get_factor( + factors: Mapping[str, float | Mapping[Any, float]], element: str, kind: Any +) -> float: """ - Gets the growth factor of each element of cost. + Gets the growth factor of an element of the cost of a kind of satellite + (`None` for costs of no type). + """ + factor = factors[element] + if not isinstance(factor, Mapping): + return factor + if kind is None: + raise ValueError(f"growth of {element} by type of satellite needs kinds") + if kind not in factor: + raise ValueError(f"no growth of {element} of satellites of kind {kind!r}") + return factor[kind] + + +def risk_space(*models: CostModel) -> DesignSpace: """ - if isinstance(growth, Mapping): - unknown = set(growth) - set(ELEMENTS) - if unknown: - raise ValueError(f"growth of unknown elements: {sorted(unknown)}") - return {element: float(growth.get(element, 1.0)) for element in ELEMENTS} - return {element: float(growth) for element in ELEMENTS} + Gets a group of a design space of the scores of the cost risk of cost + models (from which the growth of their components is drawn, see + `CostModel.draw`): an uncertain standard normal value of each name of + their scores (see `CostModel.score_names`), drawn for each replicate:: + + space = space.extend(cost_risk=risk_space(COST_MODEL)) + PLAN = MissionPlan(SCHEDULE, COST_MODEL, kind="payload", scores="cost_risk") + + With common random numbers (see `Design.realize`), each name has the same + score in the same replicate of every design, so that the designs that + share a component share its growth. The variance of costs (or of the + differences of the costs of designs) may be attributed to each component + by the paths of its score (such as `"cost_risk.imager"`, see + `attribute_variance`), and to the risk that components share by that of + the common score (`"cost_risk.common"`); a scenario may give a score a + value (such as 1.28, for a growth at the 0.9 quantile of a component + without correlation). + + Args: + *models (CostModel): The cost models (such as the models of the + designs of a study, whose scores are shared by name). + + Returns: + DesignSpace: the group of scores, by name + + Raises: + ValueError: if a name has a character of paths (`.`, `[`, or `]`), or + is reserved (`index`, `count`, or `choice`). + """ + names = list( + dict.fromkeys(name for model in models for name in model.score_names()) + ) + invalid = [n for n in names if any(c in n for c in _PATH_CHARACTERS)] + if invalid: + raise ValueError(f"names of scores must not have '.', '[', or ']': {invalid}") + reserved = sorted(_RESERVED_NAMES.intersection(names)) + if reserved: + raise ValueError( + f"names of scores must not be those of values of groups ({sorted(_RESERVED_NAMES)}): " + + f"{reserved}" + ) + return DesignSpace(**{name: Uncertain.normal(0.0, 1.0) for name in names}) diff --git a/src/tatc/tradespace/observations.py b/src/tatc/tradespace/observations.py index 4b083b61..ae74a203 100644 --- a/src/tatc/tradespace/observations.py +++ b/src/tatc/tradespace/observations.py @@ -21,6 +21,7 @@ import dataclasses import math +import numbers import os from collections.abc import Callable, Mapping, Sequence from datetime import datetime, timedelta @@ -54,7 +55,8 @@ def value_of(design: Design, reference: Reference | None) -> Any: """ Gets a value of a design that a reference names: a string names a value - (`d.`, or a path of `Design.flat`, such as `"layout.walker.planes"`), + (`d.`, or a path of `Design.flat`, such as `"layout.walker.planes"`, + or of a group of values, such as `"risk.cost_risk"`), a function computes it from the design, and `None` is `None`. Args: @@ -73,9 +75,19 @@ def value_of(design: Design, reference: Reference | None) -> Any: raise TypeError(f"a reference to a value of a design, not {reference!r}") if "." in reference or "[" in reference: values = design.flat() - if reference not in values: - raise KeyError(f"no value {reference!r} of the design") - return values[reference] + if reference in values: + return values[reference] + if "[" not in reference: + # a group of values (such as scores of `risk_space`), by its path + value: Any = design + try: + for name in reference.split("."): + value = value[name] + except (KeyError, TypeError, AttributeError): + pass + else: + return value + raise KeyError(f"no value {reference!r} of the design") return getattr(design, reference) @@ -363,6 +375,13 @@ def schedule(d): Launches limited in mass take the masses of the satellites from the cost model (`SatelliteCost.mass`, of each type), unless `masses` are given. + The growth of the costs of the components of the cost model (see + `Component`) is drawn from scores that are values of the design (such as + a group of `risk_space`), shared by designs that share components:: + + space = space.extend(cost_risk=risk_space(COST_MODEL)) + PLAN = MissionPlan(SCHEDULE, COST_MODEL, kind="payload", scores="cost_risk") + Args: schedule (DeploymentSchedule | Callable): The schedule of the deployment, or a function of the design that gives it. @@ -376,7 +395,8 @@ def schedule(d): growth (float | Reference | Mapping): The growth of the costs (see `CostModel.estimate`): a factor, a value of the design, or a mapping of each element (such as `"development"`) to a factor or - a value of the design. + a value of the design, or to a mapping of each kind of satellite + to one. stages (Sequence[Stage] | Callable): The stages of the deployment (see `Stage`), or a function of the (realized) design that gives them, such as of a decision whether to stage it and of the values @@ -387,15 +407,22 @@ def schedule(d): satellites (or of each type, a mapping), or a value of the design, for launches limited in mass, or `None` for the masses of the cost model. + scores (Reference | None): The scores from which the growth of the + components of the cost model is drawn (see `CostModel.draw`), as + a value of the design (such as a group of `risk_space`), or + `None` for the expected costs of the components. """ schedule: DeploymentSchedule | Callable[[Design], DeploymentSchedule] cost_model: CostModel | Callable[[Design], CostModel] | None = None kind: Reference | None = None spares: int | Reference = 0 - growth: float | Reference | Mapping[str, float | Reference] = 1.0 + growth: float | Reference | Mapping[str, float | Reference | Mapping[Any, Any]] = ( + 1.0 + ) stages: Sequence[Stage] | Callable[[Design], Sequence[Stage]] = () masses: float | Mapping[Any, float] | Reference | None = None + scores: Reference | None = None def schedule_of(self, design: Design) -> DeploymentSchedule: """ @@ -413,7 +440,8 @@ def schedule_of(self, design: Design) -> DeploymentSchedule: def cost_model_of(self, design: Design) -> CostModel | None: """ - Gets the cost model of a design. + Gets the cost model of a design, with the growth of its components + drawn from the design's scores (if any, see `CostModel.draw`). Args: design (Design): The (realized) design. @@ -421,9 +449,12 @@ def cost_model_of(self, design: Design) -> CostModel | None: Returns: CostModel | None: the cost model, if any """ - if self.cost_model is None or isinstance(self.cost_model, CostModel): - return self.cost_model - return self.cost_model(design) + model = self.cost_model + if model is not None and not isinstance(model, CostModel): + model = model(design) + if model is None or self.scores is None: + return model + return model.draw(value_of(design, self.scores)) def masses_of(self, design: Design, cost_model: CostModel | None = None) -> Any: """ @@ -471,16 +502,25 @@ def growth_of(self, design: Design) -> Any: design (Design): The (realized) design. Returns: - Any: a factor, or a mapping of each element to its factor + Any: a factor, or a mapping of each element to its factor (or to + a mapping of each kind of satellite to its factor) """ - if isinstance(self.growth, Mapping): - return {element: _number(design, g) for element, g in self.growth.items()} - return _number(design, self.growth) + if not isinstance(self.growth, Mapping): + return _number(design, self.growth) + growth: dict[str, Any] = {} + for element, value in self.growth.items(): + if isinstance(value, Mapping): + growth[element] = {k: _number(design, g) for k, g in value.items()} + else: + growth[element] = _number(design, value) + return growth def _number(design: Design, value: Any) -> Any: """A number, or a value of a design that a reference names.""" - return value if isinstance(value, (int, float)) else value_of(design, value) + if isinstance(value, numbers.Real): + return value + return value_of(design, value) @dataclasses.dataclass(frozen=True) diff --git a/src/tatc/tradespace/plotting.py b/src/tatc/tradespace/plotting.py index 5f6777ac..4fe66360 100644 --- a/src/tatc/tradespace/plotting.py +++ b/src/tatc/tradespace/plotting.py @@ -1,9 +1,10 @@ """ Plots of the results of trade studies (with matplotlib, an optional dependency, imported when a plot is drawn): designs by two metrics, with the -efficient designs ringed and labeled; the progress of searches; and the -means of metrics over replicates. Each plot draws on given axes (or new -ones) and returns them, for further labels and annotations. +efficient designs ringed and labeled; the progress of searches; the means +of metrics over replicates; and the probabilities that the metrics of +designs exceed those of others. Each plot draws on given axes (or new ones) +and returns them, for further labels and annotations. @author: Paul T. Grogan """ @@ -40,6 +41,9 @@ GRID = "#e6e6e3" """The color of grids.""" +NEUTRAL = "#f0efec" +"""The color of the midpoint of diverging scales (such as of even odds).""" + def _axes(ax: Any, size: tuple[float, float]) -> Any: """Gets the axes to draw on: those given, or those of a new figure.""" @@ -306,3 +310,70 @@ def plot_means( if legend is not None and by is not None: ax.legend(loc=legend, fontsize=8, frameon=False) return ax + + +def plot_exceedance( + frame: pd.DataFrame, + labels: Mapping[str, str] | Callable[[str], str] | None = None, + colorbar: bool = True, + ax: Any = None, +) -> Any: + """ + Plots the probabilities that the metric of each design exceeds that of + each other design (see `exceedance`) as a matrix: a row per design and a + column per other, in the order of the frame, colored from blue (0: the + design's metric is below the other's in every replicate) through gray + (0.5: as likely either way) to orange (1: above it in every replicate). + Pairs whose order the replicates settle are blue or orange, and those + whose order they leave open are gray: with designs in the order of the + metric's mean, a band of gray along the diagonal is the designs that + the replicates do not tell apart. + + Args: + frame (pandas.DataFrame): The probabilities of a group (see + `exceedance`). + labels (Mapping | Callable | None): The labels of the designs (by + key), or `None` for their keys. + colorbar (bool): `True` to draw a color bar. + ax (matplotlib.axes.Axes | None): The axes, or `None` for a new figure. + + Returns: + matplotlib.axes.Axes: the axes + + Raises: + ValueError: if the frame has several rows of a pair of designs (as of + several groups, of which plot one). + """ + if frame.duplicated(["design", "other"]).any(): + raise ValueError( + "the frame has several rows of a pair of designs: plot one group" + ) + ax = _axes(ax, (6.5, 5.5)) + # pylint: disable-next=import-outside-toplevel + from matplotlib.colors import LinearSegmentedColormap + + rows = list(pd.unique(frame["design"])) + columns = list(pd.unique(frame["other"])) + matrix = frame.pivot(index="design", columns="other", values="exceedance") + matrix = matrix.reindex(index=rows, columns=columns).to_numpy(dtype=float) + scale = LinearSegmentedColormap.from_list( + "exceedance", [COLORS[0], NEUTRAL, COLORS[1]] + ) + image = ax.imshow( + matrix, cmap=scale, vmin=0, vmax=1, interpolation="nearest", aspect="equal" + ) + ax.set_xticks(range(len(columns))) + ax.set_xticklabels([_name(labels, key) for key in columns], rotation=90) + ax.set_yticks(range(len(rows))) + ax.set_yticklabels([_name(labels, key) for key in rows]) + ax.tick_params(length=0, labelsize=8, colors=INK) + ax.set(xlabel="Other design", ylabel="Design") + for spine in ax.spines.values(): + spine.set_visible(False) + if colorbar: + legend = ax.figure.colorbar(image, ax=ax, fraction=0.046, pad=0.03) + legend.set_label("Probability that the design exceeds the other", fontsize=9) + legend.set_ticks([0, 0.25, 0.5, 0.75, 1]) + legend.ax.tick_params(labelsize=8, length=0) + legend.outline.set_visible(False) + return ax diff --git a/src/tatc/tradespace/space.py b/src/tatc/tradespace/space.py index b3ebbc7d..2b74ebf3 100644 --- a/src/tatc/tradespace/space.py +++ b/src/tatc/tradespace/space.py @@ -1038,6 +1038,26 @@ def _decided(values: Mapping[str, Any], path: str, domain: _Domain) -> Any: raise ValueError(f"{value!r} is not a level of {path} ({domain.levels})") +def _design_items(designs: Iterable[Design | str] | pd.DataFrame) -> list[Design | str]: + """ + Gets designs given as designs, keys, or a data frame of designs (with + their keys, `design`, as a column or the name of the index), in order. + """ + if isinstance(designs, pd.DataFrame): + if "design" in designs.columns: + items = list(designs["design"]) + elif designs.index.name == "design": + items = list(designs.index) + else: + raise ValueError("the data frame has no keys of designs (`design`)") + else: + items = list(designs) + for item in items: + if not isinstance(item, (Design, str)): + raise TypeError(f"a design or the key of one, not {item!r}") + return items + + def _designs( space: DesignSpace, designs: Iterable[Design | str] | pd.DataFrame, @@ -1050,23 +1070,13 @@ def _designs( frames (such as the results of a study, see `DesignSpace.designs_of`). """ if isinstance(designs, pd.DataFrame): - if "design" in designs.columns: - items = list(designs["design"]) - elif designs.index.name == "design": - items = list(designs.index) - else: - raise ValueError("the data frame has no keys of designs (`design`)") frames = (designs, *frames) - else: - items = list(designs) found: dict[str, Design | None] = {} - for item in items: + for item in _design_items(designs): if isinstance(item, Design): found[item.key] = item - elif isinstance(item, str): - found.setdefault(item, None) else: - raise TypeError(f"a design or the key of one, not {item!r}") + found.setdefault(item, None) for frame in frames: missing = [key for key, design in found.items() if design is None] if not missing: diff --git a/tests/tradespace/test_comparison.py b/tests/tradespace/test_comparison.py new file mode 100644 index 00000000..d6492f0a --- /dev/null +++ b/tests/tradespace/test_comparison.py @@ -0,0 +1,121 @@ +""" +Unit tests for comparisons of designs by the replicates of a metric. + +@author Paul T. Grogan +""" + +import unittest + +import numpy as np +import pandas as pd + +from tatc.tradespace import exceedance + + +def _results(values, feasible=None, **columns): + """Results of designs (by key) in replicates, from a mapping of keys to + the metric of each replicate.""" + rows = [] + for design, metrics in values.items(): + for replicate, value in enumerate(metrics): + rows.append({"design": design, "replicate": replicate, "cost": value}) + frame = pd.DataFrame(rows) + frame["feasible"] = True if feasible is None else feasible + for name, value in columns.items(): + frame[name] = value + return frame + + +class TestExceedance(unittest.TestCase): + """ + Unit tests for the probability that the metric of a design exceeds that + of another. + """ + + def test_pairs(self): + """Shares of the replicates in which a design's metric is greater, ties + counting as half.""" + results = _results( + {"a": [1.0, 2.0, 3.0, 4.0], "b": [2.0, 2.0, 1.0, 5.0], "c": [9.0] * 4} + ) + compared = exceedance(results, "cost").set_index(["design", "other"]) + # designs in the order of their means: a (2.5), b (2.5), c (9) + self.assertEqual( + list(compared.index.get_level_values(0).unique()), ["a", "b", "c"] + ) + self.assertAlmostEqual(compared.loc[("a", "b"), "exceedance"], 1.5 / 4) + self.assertAlmostEqual(compared.loc[("b", "a"), "exceedance"], 2.5 / 4) + self.assertEqual(compared.loc[("a", "a"), "exceedance"], 0.5) + self.assertEqual(compared.loc[("c", "a"), "exceedance"], 1.0) + self.assertAlmostEqual(compared.loc[("a", "b"), "cost difference"], 0.0) + self.assertAlmostEqual(compared.loc[("c", "a"), "cost difference"], 6.5) + self.assertTrue((compared["replicates"] == 4).all()) + self.assertEqual(len(compared), 9) + + def test_order_and_infeasible(self): + """Given designs keep their order, and only replicates in which both + designs are feasible count.""" + results = _results( + {"a": [1.0, 5.0, 1.0], "b": [2.0, 2.0, 2.0]}, + feasible=[True, False, True, True, True, True], + ) + compared = exceedance(results, "cost", ["b", "a"]) + self.assertEqual(list(compared["design"]), ["b", "b", "a", "a"]) + pair = compared[(compared.design == "b") & (compared.other == "a")].iloc[0] + self.assertEqual(pair["replicates"], 2) + self.assertEqual(pair["exceedance"], 1.0) + missing = _results({"a": [np.nan, np.nan], "b": [1.0, 2.0]}) + pair = exceedance(missing, "cost").set_index(["design", "other"]) + self.assertTrue(np.isnan(pair.loc[("a", "b"), "exceedance"])) + self.assertEqual(pair.loc[("a", "b"), "replicates"], 0) + + def test_groups(self): + """Designs are compared in each group of `by`, which several records of + an evaluation need.""" + hot = _results({"a": [1.0, 2.0], "b": [3.0, 4.0]}, scenario="hot") + cold = _results({"a": [5.0, 6.0], "b": [3.0, 4.0]}, scenario="cold") + results = pd.concat([hot, cold], ignore_index=True) + with self.assertRaises(ValueError): + exceedance(results, "cost") + compared = exceedance(results, "cost", by="scenario").set_index( + ["scenario", "design", "other"] + ) + self.assertEqual(compared.loc[("hot", "a", "b"), "exceedance"], 0.0) + self.assertEqual(compared.loc[("cold", "a", "b"), "exceedance"], 1.0) + + def test_infinite_and_infeasible(self): + """Infinite values are ordered (equal ones tie), designs infeasible in + every replicate come last, and results without feasible ones give + pairs of no replicates.""" + results = _results({"a": [np.inf, 2.0], "b": [np.inf, 1.0]}) + compared = exceedance(results, "cost").set_index(["design", "other"]) + self.assertEqual(compared.loc[("a", "a"), "exceedance"], 0.5) + self.assertEqual(compared.loc[("a", "b"), "exceedance"], 0.75) + self.assertEqual(compared.loc[("b", "a"), "exceedance"], 0.25) + results = _results( + {"a": [3.0, 4.0], "b": [1.0, 2.0]}, feasible=[False, False, True, True] + ) + compared = exceedance(results, "cost") + self.assertEqual(list(compared["design"].unique()), ["b", "a"]) + self.assertTrue(compared[compared.design == "a"]["exceedance"].isna().all()) + results["feasible"] = False + compared = exceedance(results, "cost") + self.assertEqual(len(compared), 4) + self.assertTrue((compared["replicates"] == 0).all()) + empty = exceedance(results.iloc[:0], "cost") + self.assertTrue(empty.empty) + self.assertIn("exceedance", empty.columns) + + def test_invalid(self): + """The metric and the designs must be in the results.""" + results = _results({"a": [1.0], "b": [2.0]}) + with self.assertRaises(ValueError): + exceedance(results, "mass") + with self.assertRaises(ValueError): + exceedance(results, "cost", ["a", "z"]) + with self.assertRaises(TypeError): + exceedance(results, "cost", [1, 2]) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/tradespace/test_cost.py b/tests/tradespace/test_cost.py index 394357d2..20eba2e1 100644 --- a/tests/tradespace/test_cost.py +++ b/tests/tradespace/test_cost.py @@ -4,12 +4,15 @@ @author Paul T. Grogan """ +import dataclasses +import math import unittest import numpy as np from tatc.tradespace import ( Categorical, + Component, CostModel, DeploymentSchedule, DesignSpace, @@ -19,10 +22,13 @@ Quantile, SatelliteCost, Study, + Triangular, Uncertain, aggregate, count_satellites, + exceedance, planes_space, + risk_space, sso_planes_space, walker_space, ) @@ -299,3 +305,364 @@ def test_annual(self): self.assertAlmostEqual( dated.metrics()["cost peak annual"], annual["total"].max() ) + + +NEW = Triangular(0.827, 2.274) +"""The growth of new components (Maier et al., 2023, Table I).""" +EXISTING = Triangular(0.981, 1.140) +"""The growth of existing components (Maier et al., 2023, Table I).""" + + +def _normal_probability(score): + return 0.5 * (1 + math.erf(score / math.sqrt(2))) + + +class TestTriangular(unittest.TestCase): + """ + Unit tests for triangular distributions of growth. + """ + + def test_moments(self): + """The mean and standard deviation of a triangular distribution.""" + self.assertAlmostEqual(NEW.mean(), 1.367, places=3) + self.assertAlmostEqual(EXISTING.mean(), 1.0403, places=4) + rng = np.random.default_rng(1) + draws = rng.triangular(0.827, 1.0, 2.274, 200000) + self.assertAlmostEqual(NEW.std(), draws.std(), places=2) + + def test_quantiles(self): + """Quantiles run from the lowest to the highest growth, through the mode.""" + self.assertAlmostEqual(NEW.ppf(0.0), 0.827) + self.assertAlmostEqual(NEW.ppf(1.0), 2.274) + self.assertAlmostEqual(NEW.ppf((1 - 0.827) / (2.274 - 0.827)), 1.0) + draws = [NEW.ppf(q) for q in np.random.default_rng(2).random(100000)] + self.assertAlmostEqual(np.mean(draws), NEW.mean(), places=2) + with self.assertRaises(ValueError): + Triangular(1.2, 1.5) # mode below the lowest growth + with self.assertRaises(ValueError): + Triangular(1.0, 1.0) + + +class TestComponents(unittest.TestCase): + """ + Unit tests for the costs of the components of satellites. + """ + + def setUp(self): + self.satellite = SatelliteCost( + development=10, + first_unit=1, + components=[ + Component("bus", development=20, first_unit=4), + Component("imager", development=30, first_unit=6, growth=NEW), + ], + ) + + def test_expected_costs(self): + """Without drawn growth, components cost their expected growth.""" + expected_development = 10 + 20 + 30 * NEW.mean() + expected_first_unit = 1 + 4 + 6 * NEW.mean() + self.assertAlmostEqual(self.satellite.total_development, expected_development) + self.assertAlmostEqual(self.satellite.total_first_unit, expected_first_unit) + self.assertAlmostEqual(self.satellite.production(2), 2 * expected_first_unit) + estimate = CostModel(self.satellite).estimate( + DeploymentSchedule().plan(_walker(1, 2)) + ) + self.assertAlmostEqual(estimate.development, expected_development) + self.assertAlmostEqual(estimate.production, 2 * expected_first_unit) + # a satellite without components costs as before + self.assertEqual(SatelliteCost(development=5).total_development, 5) + + def test_invalid(self): + """Components need names, costs that are not negative, and growth.""" + with self.assertRaises(ValueError): + Component("") + with self.assertRaises(ValueError): + Component("bus", development=-1) + with self.assertRaises(ValueError): + Component("bus", growth=-0.5) + with self.assertRaises(TypeError): + Component("bus", growth="new") + with self.assertRaises(ValueError): + SatelliteCost(components=[Component("bus"), Component("bus")]) + with self.assertRaises(ValueError): + CostModel(self.satellite, correlation=1.5) + with self.assertRaises(TypeError): + SatelliteCost(components=["bus"]) + # the name of the common score is not a component's + with self.assertRaises(ValueError): + CostModel(SatelliteCost(components=[Component("common", growth=NEW)])) + # types that share a component share its costs and growth + other = SatelliteCost( + components=[Component("bus", development=25, first_unit=4)] + ) + with self.assertRaises(ValueError): + CostModel({"a": self.satellite, "b": other}) + + def test_score_names(self): + """Scores are of uncertain components, after the common score if they + are correlated.""" + wide = SatelliteCost( + components=[ + Component("bus", development=20, first_unit=4), + Component("wide imager", development=50, growth=NEW), + ] + ) + model = CostModel({"narrow": self.satellite, "wide": wide}, correlation=0.5) + self.assertEqual(model.score_names(), ["common", "imager", "wide imager"]) + self.assertEqual(CostModel(self.satellite).score_names(), ["imager"]) + self.assertEqual(CostModel(SatelliteCost(), correlation=0.5).score_names(), []) + + def test_draw(self): + """Growth is the quantile at the probability of the scores of the + component and the common score, mixed by the correlation.""" + model = CostModel({"narrow": self.satellite}, correlation=0.5) + drawn = model.draw({"common": 1.0, "imager": -0.5, "other": 3.0}) + imager = drawn.satellites["narrow"].components[1] + score = math.sqrt(0.5) * 1.0 + math.sqrt(0.5) * -0.5 + self.assertAlmostEqual(imager.growth, NEW.ppf(_normal_probability(score))) + self.assertFalse(imager.uncertain) + # components of fixed growth, and the model, are unchanged + self.assertEqual(drawn.satellites["narrow"].components[0].growth, 1.0) + self.assertTrue(model.satellites["narrow"].components[1].uncertain) + self.assertAlmostEqual( + drawn.satellites["narrow"].total_development, 10 + 20 + 30 * imager.growth + ) + # without correlation, the component's score alone + independent = CostModel( + SatelliteCost(components=[Component("imager", 30, growth=NEW)]) + ) + self.assertEqual(independent.score_names(), ["imager"]) + growth = independent.draw({"imager": 0.0}).satellites.components[0].growth + self.assertAlmostEqual(growth, NEW.ppf(0.5)) + with self.assertRaises(ValueError): + model.draw({"imager": 0.0}) # no common score + + def test_correlation(self): + """Drawn growths are correlated between every pair of components, and a + component that types share has the same growth in each.""" + bus = Component("bus", 1, growth=NEW) + model = CostModel( + { + "a": SatelliteCost( + components=[bus, Component("imager", 1, growth=NEW)] + ), + "b": SatelliteCost( + components=[bus, Component("sounder", 1, growth=NEW)] + ), + }, + correlation=0.5, + ) + rng = np.random.default_rng(3) + draws = [] + for _ in range(4000): + scores = {name: rng.normal() for name in model.score_names()} + drawn = model.draw(scores).satellites + draws.append( + [c.growth for c in drawn["a"].components] + + [c.growth for c in drawn["b"].components] + ) + draws = np.array(draws) + np.testing.assert_array_equal(draws[:, 0], draws[:, 2]) + r = np.corrcoef(draws.T) + self.assertAlmostEqual(r[0, 1], 0.5, delta=0.06) + self.assertAlmostEqual(r[1, 3], 0.5, delta=0.06) + independent = dataclasses.replace(model, correlation=0.0) + draws = [] + for _ in range(4000): + scores = {name: rng.normal() for name in independent.score_names()} + drawn = independent.draw(scores).satellites + draws.append( + [c.growth for c in drawn["a"].components + drawn["b"].components] + ) + r = np.corrcoef(np.array(draws).T) + self.assertAlmostEqual(r[1, 3], 0.0, delta=0.06) + + def test_shared_development(self): + """A component that types of a deployment share is developed once, and + produced with each type.""" + bus = Component("bus", development=20, first_unit=4) + model = CostModel( + { + "a": SatelliteCost( + development=5, components=[bus, Component("imager", 30, 6)] + ), + "b": SatelliteCost( + development=7, components=[bus, Component("sounder", 10, 2)] + ), + } + ) + sso = _design( + layout=sso_planes_space(crossing=13.5, satellites=3, count=1) + ).layout + mixed = model.estimate( + DeploymentSchedule().plan({"a": _walker(1, 2), "b": sso}) + ) + self.assertAlmostEqual(mixed.development, 5 + 30 + 7 + 10 + 20) + self.assertAlmostEqual(mixed.production, 2 * (4 + 6) + 3 * (4 + 2)) + alone = model.estimate(DeploymentSchedule().plan(_walker(1, 2), kind="b")) + self.assertAlmostEqual(alone.development, 7 + 10 + 20) + + +class TestGrowthByType(unittest.TestCase): + """ + Unit tests for growth factors of each type of satellite. + """ + + def setUp(self): + self.model = CostModel( + { + "narrow": SatelliteCost(development=50, first_unit=10), + "wide": SatelliteCost(development=80, first_unit=16), + }, + launch=LaunchCost(per_launch=20), + operations=OperationsCost(per_year=1), + ) + sso = _design( + layout=sso_planes_space(crossing=13.5, satellites=2, count=1) + ).layout + self.deployment = DeploymentSchedule().plan( + {"narrow": _walker(1, 2), "wide": sso} + ) + + def test_by_type(self): + """Each type of satellite grows by its own factor.""" + base = self.model.estimate(self.deployment) + grown = self.model.estimate( + self.deployment, + growth={ + "development": {"narrow": 2.0, "wide": 1.0}, + "production": {"narrow": 1.0, "wide": 1.5}, + "launch": {"narrow": 1.0, "wide": 3.0}, + "operations": 2.0, + }, + ) + self.assertAlmostEqual(grown.development, 2 * 50 + 80) + self.assertAlmostEqual(grown.production, 20 + 1.5 * 32) + self.assertAlmostEqual(grown.launch, 20 + 3 * 20) + self.assertAlmostEqual(grown.operations, 2 * base.operations) + + def test_invalid(self): + """Growth by type needs every kind of the deployment, and is not of + operations.""" + with self.assertRaises(ValueError): + self.model.estimate(self.deployment, growth={"development": {"narrow": 2}}) + with self.assertRaises(ValueError): + self.model.estimate( + self.deployment, growth={"operations": {"narrow": 1, "wide": 1}} + ) + single = CostModel(SatelliteCost(development=10)) + with self.assertRaises(ValueError): + single.estimate( + DeploymentSchedule().plan(_walker(1, 2)), + growth={"development": {"satellites": 2}}, + ) + + def test_shared_types(self): + """Common random numbers correlate the costs of designs of the same type + (as in Maier et al., 2023): the order of such designs is settled, and + that of designs of different types is not.""" + space = DesignSpace( + imager=Categorical(["narrow", "wide"]), + layout=walker_space( + inclination=55.0, planes=1, per_plane=Integer(2, 3), relative_spacing=0 + ), + narrow=Uncertain.normal(1.0, 0.3), + wide=Uncertain.normal(1.0, 0.3), + ) + schedule = DeploymentSchedule() + + def evaluate(d): + deployment = schedule.plan(d.layout, kind=d.imager) + growth = {"narrow": d.narrow, "wide": d.wide} + return self.model.estimate( + deployment, growth={"development": growth, "production": growth} + ).metrics() + + designs = space.enumerate() + + def compare(common): + study = Study( + space, + lambda d: d, + evaluate, + replicates=200, + common_random_numbers=common, + ) + compared = exceedance(study.run(designs), "cost", designs) + return compared.set_index(["design", "other"])["exceedance"] + + shared, independent = compare(True), compare(False) + narrow2, narrow3 = (d.key for d in designs if d.imager == "narrow") + wide2 = next(d.key for d in designs if d.imager == "wide") + # three narrow satellites cost more than two in every replicate + self.assertEqual(shared[(narrow3, narrow2)], 1.0) + self.assertLess(independent[(narrow3, narrow2)], 0.99) + # designs of different types are not ordered by their shared draws + self.assertLess(shared[(wide2, narrow3)], 1.0) + self.assertGreater(shared[(wide2, narrow3)], 0.0) + + +class TestRiskSpace(unittest.TestCase): + """ + Unit tests for the scores of the cost risk of designs. + """ + + def setUp(self): + self.model = CostModel( + { + 30: SatelliteCost( + components=[ + Component("bus", 20, 4, growth=EXISTING), + Component("imager 30", 15, 3, growth=NEW), + ], + ), + 60: SatelliteCost( + components=[ + Component("bus", 20, 4, growth=EXISTING), + Component("imager 60", 30, 6, growth=NEW), + ], + ), + }, + correlation=0.5, + ) + + def test_scores(self): + """A standard normal score of each name, the same in every design of a + replicate.""" + group = risk_space(self.model) + self.assertEqual( + list(group.children), ["common", "bus", "imager 30", "imager 60"] + ) + space = DesignSpace( + imager=Categorical([30, 60]), + layout=walker_space( + inclination=55.0, planes=1, per_plane=2, relative_spacing=0 + ), + cost_risk=group, + ) + self.assertIn("cost_risk.imager 30", space.uncertain_paths()) + narrow, wide = space.enumerate() + a, b = narrow.realize(4), wide.realize(4) + self.assertEqual(a.cost_risk["bus"], b.cost_risk["bus"]) + # every design of a replicate draws the same growths, and the bus grows + # alike in both types + drawn = self.model.draw(a.cost_risk) + self.assertEqual(drawn, self.model.draw(b.cost_risk)) + self.assertEqual( + drawn.satellites[30].components[0], drawn.satellites[60].components[0] + ) + scores = np.array([narrow.realize(r).cost_risk["bus"] for r in range(500)]) + self.assertAlmostEqual(scores.mean(), 0.0, delta=0.15) + self.assertAlmostEqual(scores.std(), 1.0, delta=0.15) + + def test_invalid(self): + """Names are not reserved, nor have characters of paths.""" + reserved = CostModel(SatelliteCost(components=[Component("count", growth=NEW)])) + with self.assertRaisesRegex(ValueError, "count"): + risk_space(reserved) + dotted = CostModel( + SatelliteCost(components=[Component("imager.v2", growth=NEW)]) + ) + with self.assertRaises(ValueError): + risk_space(dotted) diff --git a/tests/tradespace/test_layering.py b/tests/tradespace/test_layering.py index 6d837f00..06fb1c76 100644 --- a/tests/tradespace/test_layering.py +++ b/tests/tradespace/test_layering.py @@ -16,6 +16,7 @@ GENERAL = { "attribution", + "comparison", "confirmation", "criteria", "fingerprint", diff --git a/tests/tradespace/test_observations.py b/tests/tradespace/test_observations.py index 7d548c45..066fe9cc 100644 --- a/tests/tradespace/test_observations.py +++ b/tests/tradespace/test_observations.py @@ -5,6 +5,7 @@ """ import dataclasses +import math import pickle import tempfile import unittest @@ -12,6 +13,7 @@ from functools import partial from pathlib import Path +import numpy as np import pandas as pd from tatc.analysis import collect_observations @@ -19,6 +21,7 @@ from tatc.schemas import Instrument from tatc.tradespace import ( Categorical, + Component, CostModel, DeploymentSchedule, DesignSpace, @@ -37,11 +40,13 @@ Stage, Study, Targets, + Triangular, Uncertain, build_constellation, count_planes, count_satellites, policy_space, + risk_space, walker_space, ) from tatc.tradespace.observations import value_of @@ -388,6 +393,60 @@ def study(plan): light.groupby("altitude")["cost launch"].mean()[700e3], planes[700e3] ) + def test_cost_risk(self): + """Plans draw the growth of the components of each design from its + scores, and resolve growth by type of satellite.""" + growth = Triangular(0.9, 1.5) + model = CostModel( + SatelliteCost( + components=[Component("imager", development=10, growth=growth)] + ), + correlation=0.5, + ) + space = SPACE.extend(cost_risk=risk_space(model)) + designs = [d for d in space.enumerate() if d.layout.per_plane == 2] + + def study(plan): + return ObservationStudy( + space, + _build, + _observations(), + _metrics, + layout="layout", + plan=plan, + replicates=2, + ) + + results = study(MissionPlan(SCHEDULE, model, scores="cost_risk")).run(designs) + score = math.sqrt(0.5) * ( + results["cost_risk.common"] + results["cost_risk.imager"] + ) + probability = 0.5 * (1 + score.map(lambda z: math.erf(z / math.sqrt(2)))) + expected = 10 * probability.map(growth.ppf) + pd.testing.assert_series_equal( + results["cost development"], expected, check_names=False + ) + # designs of a replicate share the growth (common random numbers) + self.assertEqual( + results.groupby("replicate")["cost development"].nunique().max(), 1 + ) + # without scores, the expected growth + nominal = study(MissionPlan(SCHEDULE, model)).run(designs) + self.assertTrue((nominal["cost development"] == 10 * growth.mean()).all()) + # growth by type of satellite resolves the values of the design + plan = MissionPlan( + SCHEDULE, model, growth={"development": {"a": "growth", "b": np.int64(2)}} + ) + design = designs[0].realize(0) + self.assertEqual( + plan.growth_of(design), {"development": {"a": design.growth, "b": 2}} + ) + # scores of a group nested in another + nested = SPACE.extend(risk=DesignSpace(cost_risk=risk_space(model))) + design = nested.enumerate()[0].realize(3) + plan = MissionPlan(SCHEDULE, model, scores="risk.cost_risk") + self.assertEqual(plan.cost_model_of(design), model.draw(design.risk.cost_risk)) + def test_stages(self): """Plans stage the deployments of designs that decide to.""" space = DesignSpace(**SPACE.children, staged=Categorical([False, True])) diff --git a/tests/tradespace/test_plotting.py b/tests/tradespace/test_plotting.py index 02ac4a58..0afea236 100644 --- a/tests/tradespace/test_plotting.py +++ b/tests/tradespace/test_plotting.py @@ -9,7 +9,14 @@ import numpy as np import pandas as pd -from tatc.tradespace import pareto_front, plot_designs, plot_means, plot_progress +from tatc.tradespace import ( + exceedance, + pareto_front, + plot_designs, + plot_exceedance, + plot_means, + plot_progress, +) try: import matplotlib @@ -104,3 +111,27 @@ def test_means(self): np.testing.assert_allclose(ax.lines[0].get_ydata(), [2.0, 4.0]) single = plot_means(results, "satellites", "resolved") self.assertEqual(len(single.lines), 1) + + def test_exceedance(self): + """A matrix of the probabilities, in the order of the designs, labeled.""" + results = pd.DataFrame( + { + "design": ["a", "a", "b", "b", "c", "c"], + "replicate": [0, 1, 0, 1, 0, 1], + "cost": [1.0, 2.0, 1.5, 1.5, 3.0, 4.0], + "scenario": "nominal", + } + ) + compared = exceedance(results, "cost") + ax = plot_exceedance(compared, labels={"a": "first"}) + matrix = ax.images[0].get_array() + self.assertEqual(matrix.shape, (3, 3)) + self.assertEqual(matrix[2, 0], 1.0) # c costs more than a + self.assertEqual(matrix[0, 1], 0.5) # a and b, each once + self.assertEqual( + [t.get_text() for t in ax.get_yticklabels()], ["first", "b", "c"] + ) + self.assertEqual(len(ax.figure.axes), 2) # with a color bar + twice = pd.concat([compared, compared.assign(scenario="other")]) + with self.assertRaises(ValueError): + plot_exceedance(twice) From 7f4ac5abd5ecd4e84141c1221bd504ed31c714ff Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Thu, 12 Nov 2026 19:36:30 -0700 Subject: [PATCH 35/52] produce satellites in blocks that redevelop their type and restart learning A block size and a share of development repeated for each block after the first (dated just before its first unit is produced), with the learning curve restarting each block, and the blocks of each type in cost estimates (after Maier, Yeakel, and Wendoloski, 2023). --- CHANGELOG.md | 2 +- docs/api_reference/tradespace/missions.rst | 2 +- src/tatc/tradespace/cost.py | 91 ++++++++++++++++++++-- tests/tradespace/test_cost.py | 50 ++++++++++++ 4 files changed, 137 insertions(+), 8 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index ef8004e0..f795f1fc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -33,7 +33,7 @@ Added: - Scenarios of studies (argument `scenarios` of `tradespace.Study`): conditions under which designs are compared rather than averaged over, each giving fixed values or uncertain parameters of the design space other values (`Design.realize` takes a `scenario`), so that each design is evaluated in each scenario (recorded as `scenario`, and judged in each with criteria `by` it). Each scenario's evaluations are stored by its values, so that a scenario added later is evaluated alone. Function `tradespace.robustness` gives each design's Pareto trace (the share of scenarios in which it is efficient) and its regret in each scenario (the improvement in every objective it would need to match the scenario's front) and the largest. The metrics of an `ObservationStudy` (and of `PhaseCache`, `evaluate_missions`, and `expected_missions`) are given the realized design if they have a parameter named `design`. - Criteria across the scenarios of a study (`tradespace.Across`, argument `across` of `Criteria`), which judge each design once by its worst or its (weighted) mean statistics over the scenarios (or the groups of another column), so that searches find designs robust to scenarios; a requirement may be met in every scenario while objectives are means. - Function `tradespace.attribute_variance` (and class `Attribution`), which attributes the variance of metrics between the replicates of each design to its uncertain parameters (or groups of them): the share that each causes, alone or with others, and the share that knowing it would remove, with standard errors, by evaluating designs with one parameter drawn as in other replicates and the others held (which works for seeds, whose values do not order outcomes); `Attribution.summary` pools the shares of several designs, and `Attribution.differences` attributes the variance of the differences between pairs of designs, from the same evaluations (parameters that act alike on both cancel, with common random numbers). `Design.realize` and `Study.run` take a `shift`, which draws named parameters as in other replicates (kept apart in a `ResultStore` as a variant of the replicates), and `DesignSpace.uncertain_paths` lists the uncertain parameters. - - Structured cost risk (after Maier, Yeakel, and Wendoloski, "Cost Variance Analysis in Constellation Architecture Studies," 2023): growth factors of each type of satellite (by kind, for development, production, and launches, in `CostModel.estimate` and `MissionPlan.growth`), and the costs of types of satellites as sums of their components (`tradespace.Component`, `SatelliteCost.components`), whose growth has a distribution by maturity (such as `tradespace.Triangular`), correlated between components (`CostModel.correlation`). `CostModel.draw` draws the growth of the components from standard normal scores of the components and a common score, which `tradespace.risk_space` declares as uncertain parameters of a design space (named by `MissionPlan.scores`, also of a nested group), so that common random numbers give the designs that share a component the same growth of it; without drawn growth, components cost their expected growth. Types of satellites that share a component (by name) develop it once in a deployment. Function `tradespace.exceedance` gives the probability that a metric of each design exceeds that of each other in the same replicate (such as that one design costs more than another), and `plot_exceedance` plots them as a matrix. + - Structured cost risk (after Maier, Yeakel, and Wendoloski, "Cost Variance Analysis in Constellation Architecture Studies," 2023): growth factors of each type of satellite (by kind, for development, production, and launches, in `CostModel.estimate` and `MissionPlan.growth`), and the costs of types of satellites as sums of their components (`tradespace.Component`, `SatelliteCost.components`), whose growth has a distribution by maturity (such as `tradespace.Triangular`), correlated between components (`CostModel.correlation`). `CostModel.draw` draws the growth of the components from standard normal scores of the components and a common score, which `tradespace.risk_space` declares as uncertain parameters of a design space (named by `MissionPlan.scores`, also of a nested group), so that common random numbers give the designs that share a component the same growth of it; without drawn growth, components cost their expected growth. Types of satellites that share a component (by name) develop it once in a deployment. Production in blocks (`SatelliteCost.block_size`): each block after the first develops its type again (a share of its development, `redevelopment`) before its first unit is produced, and restarts the learning curve; `CostEstimate.blocks` counts the blocks of each type. Function `tradespace.exceedance` gives the probability that a metric of each design exceeds that of each other in the same replicate (such as that one design costs more than another), and `plot_exceedance` plots them as a matrix. - Searches with Optuna accept categorical options that depend on earlier decisions (a parameter for each set of options), use TPE with a constant liar in batches by default (which spreads the trials of a batch), and stop after `max_designs` designs evaluated (trials that suggest designs evaluated before are told their objectives without evaluating them again). A design infeasible in some of its replicates violates its feasibility by their share (`Evaluations.infeasibility`), and the first design evaluated in a search is evaluated alone, to check that evaluations give one record each. `Study` records errors of evaluations as infeasible, without storing them, with `errors="record"`. Enumeration walks the items of unordered repetitions in one order only (the same designs, in the same order, four times faster for three sun-synchronous planes), and `DesignSpace.size` counts designs without keeping them. Pareto fronts are found by a vectorized sweep in lexicographic order that compares designs only with the efficient designs before them, and fronts with tolerances by comparing designs only with the efficient designs without tolerances (which dominate every design that any design dominates within the tolerances), in blocks of bounded memory: 20,000 designs in 0.05 s (0.11 s with tolerances) rather than 17 s, and the bootstraps of `pareto_probability` (and so `refine`) about 20 times faster. - Studies of the observations of constellations (`tradespace.ObservationStudy`): the targets of each replicate (`Targets`, fixed or generated from a seed of the design), the observations of each satellite, cached on disk (`Observations`), the metrics of the observations, and, with a `MissionPlan`, the costs of the deployment and the summaries of its phases or of the histories of its `Failures`. Plots of the results of studies (`plot_designs`, `plot_progress`, and `plot_means`, with matplotlib, now in the `tradespace` extra), and the hypervolume of a search as it proceeds (`hypervolume_progress`). - The steps of trade studies share their arguments and outcomes: `tradespace.refine(study, criteria, results)`, `confirm(study, criteria, results)` (by default, the front of the results), `screen(studies, criteria, designs)` (with criteria for each stage, in place of a `tolerance` of its own), and `attribute_variance(study, metrics, designs)` take designs as `Design` objects, their keys, or rows of a summary or of results, and `Refinement`, `Confirmation`, `Screening`, and `Search` give their `results`, the `summary` of their designs, and the `designs`. `DesignSpace.designs_of` rebuilds designs from rows of their values, which summaries keep (also those of `pareto_probability`, `confirm`, and `screen`), and `DesignSpace.extend`, `DesignSpace.design(design, **overrides)`, and `Study.replace` make variants of design spaces, designs, and studies. `aggregate` takes criteria, a mapping of objectives, or metrics (as the other functions do), and other `statistics` by name; `pareto_front`, `pareto_ranks`, `hypervolume`, `sensitivity`, and `main_effects` raise an error given the results of a study (a row per replicate) rather than a summary. Studies with a mission plan record the years by which it is `deployed`, and the parts of observation studies that refer to values of designs are typed as a `Reference`. Columns: ` se` (rather than `sem`), ` mission` for the mean over the phases of a mission, ` histories p` and ` histories std` for statistics over the histories of failures, and `pareto_trace` and `max_regret`. Package `tradespace` exports the functions and classes of trade studies; the parts from which they are made (such as `PhaseCache`, `Layout`, `configure`, and the fingerprints) are imported from its modules. diff --git a/docs/api_reference/tradespace/missions.rst b/docs/api_reference/tradespace/missions.rst index 3582fcd0..4ea04db8 100644 --- a/docs/api_reference/tradespace/missions.rst +++ b/docs/api_reference/tradespace/missions.rst @@ -123,7 +123,7 @@ Costs :members: estimate, draw, score_names, discount .. autoclass:: tatc.tradespace.SatelliteCost - :members: production, total_development, total_first_unit + :members: production, blocks, total_development, total_first_unit .. autoclass:: tatc.tradespace.Component :members: uncertain, factor diff --git a/src/tatc/tradespace/cost.py b/src/tatc/tradespace/cost.py index 34c9c6cd..5278f41e 100644 --- a/src/tatc/tradespace/cost.py +++ b/src/tatc/tradespace/cost.py @@ -31,7 +31,8 @@ between them (such as the probability that one costs more than another, see `exceedance`) see the differences of their costs. -A deployment dates the costs: development of each type of satellite, +A deployment dates the costs: development of each type of satellite (and +of each later block of its production, see `SatelliteCost.block_size`), production of its satellites, launches, replacements, and operations from launch to the end of the mission, so that each design's costs follow from its satellites and planes. The dated costs give the present value of the @@ -214,6 +215,17 @@ class SatelliteCost: alone). The growths of components may be correlated (when drawn, see `CostModel.correlation`). + Satellites may be produced in blocks of `block_size` units, each block + after the first a new design of the type (as its components become + obsolete over a long mission of replacements): its development is + repeated (a share of it, `redevelopment`, 1 for a full redesign) before + its first unit is produced, and the learning curve restarts with its + first unit, so that a type replaced over decades costs the development + and first units of each block (as in M. W. Maier, K. L. Yeakel, and E. + B. Wendoloski, "Cost Variance Analysis in Constellation Architecture + Studies," IEEE Systems Journal 17(2), 2023). Smaller blocks cost more + developments and first units for the same satellites. + Args: development (float): The nonrecurring cost (besides that of its components). @@ -223,6 +235,11 @@ class SatelliteCost: mass (float | None): The mass (kg), for launches priced by mass. components (Sequence[Component]): The components, if any, of distinct names. + block_size (int | None): The units of each block of production, or + `None` for one block of every unit. + redevelopment (float): The share of the development (with that of + its components, `total_development`) repeated for each block + after the first. """ development: float = 0.0 @@ -230,12 +247,22 @@ class SatelliteCost: learning_rate: float = 1.0 mass: float | None = None components: Sequence[Component] = () + block_size: int | None = None + redevelopment: float = 1.0 def __post_init__(self): if not 0 < self.learning_rate <= 1: raise ValueError("learning_rate must be in (0, 1]") if self.development < 0 or self.first_unit < 0: raise ValueError("costs must not be negative") + if self.block_size is not None and ( + isinstance(self.block_size, bool) + or not isinstance(self.block_size, numbers.Integral) + or self.block_size < 1 + ): + raise ValueError("block_size must be a positive integer (or None)") + if self.redevelopment < 0: + raise ValueError("redevelopment must not be negative") components = tuple(self.components) if not all(isinstance(c, Component) for c in components): raise TypeError("components must be Components") @@ -262,7 +289,8 @@ def total_first_unit(self) -> float: def production(self, units: int) -> float: """ Gets the recurring cost of building units (the sum of the costs of - units 1 to `units` on the learning curve, from `total_first_unit`). + units 1 to `units` on the learning curve, from `total_first_unit`, + which restarts with each block). Args: units (int): The number of units. @@ -273,9 +301,29 @@ def production(self, units: int) -> float: if units <= 0: return 0.0 exponent = math.log2(self.learning_rate) - return float( - self.total_first_unit * np.sum(np.arange(1, units + 1) ** exponent) - ) + size = units if self.block_size is None else int(self.block_size) + full, rest = divmod(units, size) + + def curve(count: int) -> float: + return float(np.sum(np.arange(1, count + 1) ** exponent)) + + return float(self.total_first_unit * (full * curve(size) + curve(rest))) + + def blocks(self, units: int) -> int: + """ + Gets the number of blocks of production that building units starts. + + Args: + units (int): The number of units. + + Returns: + int: the blocks (1 for any units without a block size) + """ + if units <= 0: + return 0 + if self.block_size is None: + return 1 + return -(-units // int(self.block_size)) @dataclass(frozen=True) @@ -353,6 +401,9 @@ class CostEstimate: development), element, and amount of each.""" present: dict[str, float] = field(default_factory=dict) """dict: The present value of each element.""" + blocks: dict[str, int] = field(default_factory=dict) + """dict: The blocks of production of each type of satellite (see + `SatelliteCost.block_size`).""" @property def total(self) -> float: @@ -610,7 +661,10 @@ def estimate( otherwise the means of their distributions, for expected costs). A component that several types of the deployment carry is developed once, with the type whose development ends first (and by its growth - factor), and produced with each type (on its learning curve). + factor), and produced with each type (on its learning curve). Each + block of production after the first (see `SatelliteCost.block_size`) + develops its type again (a share of its development), dated over the + type's development just before the production of its first unit. Growth factors multiply the estimate, such as uncertain parameters of cost growth drawn for each replicate (for example, @@ -679,7 +733,32 @@ def add( ) built[batch.kind] = before + batch.satellites add("production", _spread(amount, batch.begin, batch.end), batch.kind) + if cost.block_size is not None and cost.redevelopment > 0: + # the development of each later block, before its first unit + duration = history.development.get(batch.kind, 0.0) + size = int(cost.block_size) + for unit in range(before, before + batch.satellites): + if unit > 0 and unit % size == 0: + begins = ( + batch.begin + + (unit - before) + * (batch.end - batch.begin) + / batch.satellites + ) + add( + "development", + _spread( + cost.redevelopment * cost.total_development, + begins - duration, + begins, + ), + batch.kind, + ) estimate.units = {_type_name(kind): units for kind, units in built.items()} + estimate.blocks = { + _type_name(kind): self._get_type(kind).blocks(units) + for kind, units in built.items() + } begin, end = history.begin, history.end for launch in history.launches: cost = self._get_type(launch.kind) diff --git a/tests/tradespace/test_cost.py b/tests/tradespace/test_cost.py index 20eba2e1..39af7071 100644 --- a/tests/tradespace/test_cost.py +++ b/tests/tradespace/test_cost.py @@ -68,6 +68,17 @@ def test_learning_curve(self): with self.assertRaises(ValueError): SatelliteCost(development=-1) + def test_blocks(self): + """The learning curve restarts with each block of production.""" + blocks = SatelliteCost(first_unit=10, learning_rate=0.9, block_size=2) + self.assertAlmostEqual(blocks.production(2), 10 + 9) + self.assertAlmostEqual(blocks.production(5), 3 * 10 + 2 * 9) + self.assertEqual([blocks.blocks(n) for n in (0, 1, 2, 3, 5)], [0, 1, 1, 2, 3]) + self.assertEqual(SatelliteCost(first_unit=10).blocks(7), 1) + for invalid in ({"block_size": 0}, {"block_size": 2.5}, {"redevelopment": -1}): + with self.assertRaises(ValueError): + SatelliteCost(**invalid) + class TestPlaneSizes(unittest.TestCase): """ @@ -288,6 +299,36 @@ def test_production(self): self.assertAlmostEqual(production[0][0], 2.25) # middle of [2, 2.5) self.assertAlmostEqual(production[0][2], self.terms["satellites"].production(4)) + def test_blocks(self): + """Each block of production after the first develops its type again, + just before its first unit, and restarts the learning curve.""" + self.terms["satellites"] = dataclasses.replace( + self.terms["satellites"], block_size=4, redevelopment=0.5 + ) + dated = self._estimate(development_years=2, production_rate=8) + self.assertEqual(dated.units, {"satellites": 24}) + self.assertEqual(dated.blocks, {"satellites": 6}) + self.assertAlmostEqual(dated.development, 90 + 5 * 45) + learning = SatelliteCost(first_unit=10, learning_rate=0.9) + self.assertAlmostEqual(dated.production, 6 * learning.production(4)) + development = [ + (t, a) for t, element, a in dated.flows if element == "development" + ] + # the second block (the second plane of the first generation, produced + # from 2.5) is developed over the two years before + self.assertIn((1.0, 22.5), development) + self.assertIn((2.0, 22.5), development) + # the fourth (the first replacements, produced from 5.25) + self.assertIn((3.75, 22.5), development) + self.assertIn((4.75, 22.5), development) + # without blocks, one + self.assertEqual( + CostModel(SatelliteCost(development=90)) + .estimate(DeploymentSchedule(years=6, design_life=3).plan(self.layout)) + .blocks, + {"satellites": 1}, + ) + def test_operations_from_launch(self): """Satellites launched later are operated for less of the mission.""" dated = self._estimate(development_years=2, launch_interval=1) @@ -373,6 +414,15 @@ def test_expected_costs(self): # a satellite without components costs as before self.assertEqual(SatelliteCost(development=5).total_development, 5) + def test_redevelopment(self): + """Blocks develop their components again, grown by their factors.""" + satellite = dataclasses.replace(self.satellite, block_size=1) + estimate = CostModel(satellite).estimate( + DeploymentSchedule().plan(_walker(1, 2)) + ) + self.assertAlmostEqual(estimate.development, 2 * satellite.total_development) + self.assertAlmostEqual(estimate.production, 2 * satellite.total_first_unit) + def test_invalid(self): """Components need names, costs that are not negative, and growth.""" with self.assertRaises(ValueError): From 35de0bf8ff47e3e58295747c99d1f9ec123fd78b Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Thu, 12 Nov 2026 22:14:11 -0700 Subject: [PATCH 36/52] test the tradespace extra in CI, and skip parallel studies without joblib CI installs the tradespace extra, so the tests of searches with Optuna and pymoo, of parallel studies, and of plots run there. Without joblib, the tests of parallel studies skip, as those of Optuna and pymoo do without them. --- .github/workflows/unit-test.yml | 2 +- tests/tradespace/test_cache.py | 4 ++++ tests/tradespace/test_observations.py | 4 ++++ tests/tradespace/test_store.py | 4 ++++ tests/tradespace/test_study.py | 4 ++++ 5 files changed, 17 insertions(+), 1 deletion(-) diff --git a/.github/workflows/unit-test.yml b/.github/workflows/unit-test.yml index a48ff4e0..12b626da 100644 --- a/.github/workflows/unit-test.yml +++ b/.github/workflows/unit-test.yml @@ -31,7 +31,7 @@ jobs: - name: Install project in editable mode run: | - pip install -e ".[preprocess]" + pip install -e ".[preprocess,tradespace]" - name: Run unit tests run: python -m unittest diff --git a/tests/tradespace/test_cache.py b/tests/tradespace/test_cache.py index 2a66c93c..8cb781ef 100644 --- a/tests/tradespace/test_cache.py +++ b/tests/tradespace/test_cache.py @@ -4,6 +4,7 @@ @author Paul T. Grogan """ +import importlib.util import pickle import tempfile import unittest @@ -23,6 +24,8 @@ ) from tatc.tradespace.cache import get_satellite_key +HAS_JOBLIB = importlib.util.find_spec("joblib") is not None + EPOCH = datetime(2026, 1, 1, tzinfo=timezone.utc) @@ -180,6 +183,7 @@ def test_unreadable_file(self): third(_satellite("c")) self.assertEqual((third.hits, third.misses), (1, 0)) + @unittest.skipUnless(HAS_JOBLIB, "requires joblib") def test_disk_cache_in_parallel(self): """Workers of a study share a cache on disk, storing each result once.""" satellites = [_satellite(f"s{i}", anomaly=30 * (i % 4)) for i in range(40)] diff --git a/tests/tradespace/test_observations.py b/tests/tradespace/test_observations.py index 066fe9cc..cb9d7178 100644 --- a/tests/tradespace/test_observations.py +++ b/tests/tradespace/test_observations.py @@ -5,6 +5,7 @@ """ import dataclasses +import importlib.util import math import pickle import tempfile @@ -51,6 +52,8 @@ ) from tatc.tradespace.observations import value_of +HAS_JOBLIB = importlib.util.find_spec("joblib") is not None + START = datetime(2026, 7, 1, tzinfo=timezone.utc) HOURS = timedelta(hours=3) N_POINTS = 20 @@ -557,6 +560,7 @@ def test_invalid(self): phases=True, ) + @unittest.skipUnless(HAS_JOBLIB, "requires joblib") def test_parallel(self): """Studies of observations run in parallel, with a cache on disk.""" designs = SPACE.enumerate() diff --git a/tests/tradespace/test_store.py b/tests/tradespace/test_store.py index a3a3e16a..20ce7e1d 100644 --- a/tests/tradespace/test_store.py +++ b/tests/tradespace/test_store.py @@ -4,6 +4,7 @@ @author Paul T. Grogan """ +import importlib.util import json import math import sqlite3 @@ -27,6 +28,8 @@ ) from tatc.tradespace.fingerprint import compare_definitions +HAS_JOBLIB = importlib.util.find_spec("joblib") is not None + class _Interrupt(Exception): """An interruption of a study.""" @@ -109,6 +112,7 @@ def test_more_replicates(self): self.assertEqual(len(self.calls), 4 * 2) self.assertEqual(len(results), 4 * 5) + @unittest.skipUnless(HAS_JOBLIB, "requires joblib") def test_parallel(self): """Parallel studies store their evaluations as chunks complete.""" store = ResultStore(self.path, "study") diff --git a/tests/tradespace/test_study.py b/tests/tradespace/test_study.py index 7cbf06d6..898f34e5 100644 --- a/tests/tradespace/test_study.py +++ b/tests/tradespace/test_study.py @@ -4,6 +4,7 @@ @author Paul T. Grogan """ +import importlib.util import tempfile import unittest import warnings @@ -31,6 +32,8 @@ summarize, ) +HAS_JOBLIB = importlib.util.find_spec("joblib") is not None + class TestStudy(unittest.TestCase): """ @@ -164,6 +167,7 @@ def _noise_study(self, **kwargs): **kwargs, ) + @unittest.skipUnless(HAS_JOBLIB, "requires joblib") def test_parallel_matches_sequential(self): """Evaluations in worker processes give the results of a sequential run.""" sequential = self._noise_study().run() From a380a33495afb841abb99c992d4392aef8646d3b Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Thu, 12 Nov 2026 22:38:36 -0700 Subject: [PATCH 37/52] copy the metrics of a design before marking its infeasible replicates pandas 3 (on Python 3.11 and later) gives read-only views of a frame's values, so attribute_variance's differences failed to assign NaN to them. --- src/tatc/tradespace/attribution.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/tatc/tradespace/attribution.py b/src/tatc/tradespace/attribution.py index d7905753..26247a8c 100644 --- a/src/tatc/tradespace/attribution.py +++ b/src/tatc/tradespace/attribution.py @@ -340,7 +340,8 @@ def _tables( def table(part: pd.DataFrame) -> pd.DataFrame: indexed = part.set_index([*by, "replicate"]) feasible = indexed["feasible"].astype(bool).to_numpy() - values = indexed.reindex(columns=list(metrics)).to_numpy(dtype=float) + # a copy, as pandas may give a read-only view of the frame + values = indexed.reindex(columns=list(metrics)).to_numpy(dtype=float, copy=True) values[~feasible] = np.nan frame = pd.DataFrame(values, index=indexed.index, columns=list(metrics)) frame["feasible"] = feasible From 578f1d8d826ac1fe6bb7589a91f958ea2756600f Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Fri, 13 Nov 2026 12:20:17 -0700 Subject: [PATCH 38/52] reproduce the two-constellation cost variance example of Maier et al. (2023) in a validation notebook --- CHANGELOG.md | 2 +- .../ValidateCostVarianceNSOSA.ipynb | 1911 +++++++++++++++++ docs/validation/index.rst | 5 +- docs/validation/summary.rst | 34 +- 4 files changed, 1948 insertions(+), 4 deletions(-) create mode 100644 docs/validation/ValidateCostVarianceNSOSA.ipynb diff --git a/CHANGELOG.md b/CHANGELOG.md index a10f4c39..3745698d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -33,7 +33,7 @@ Added: - Scenarios of studies (argument `scenarios` of `tradespace.Study`): conditions under which designs are compared rather than averaged over, each giving fixed values or uncertain parameters of the design space other values (`Design.realize` takes a `scenario`), so that each design is evaluated in each scenario (recorded as `scenario`, and judged in each with criteria `by` it). Each scenario's evaluations are stored by its values, so that a scenario added later is evaluated alone. Function `tradespace.robustness` gives each design's Pareto trace (the share of scenarios in which it is efficient) and its regret in each scenario (the improvement in every objective it would need to match the scenario's front) and the largest. The metrics of an `ObservationStudy` (and of `PhaseCache`, `evaluate_missions`, and `expected_missions`) are given the realized design if they have a parameter named `design`. - Criteria across the scenarios of a study (`tradespace.Across`, argument `across` of `Criteria`), which judge each design once by its worst or its (weighted) mean statistics over the scenarios (or the groups of another column), so that searches find designs robust to scenarios; a requirement may be met in every scenario while objectives are means. - Function `tradespace.attribute_variance` (and class `Attribution`), which attributes the variance of metrics between the replicates of each design to its uncertain parameters (or groups of them): the share that each causes, alone or with others, and the share that knowing it would remove, with standard errors, by evaluating designs with one parameter drawn as in other replicates and the others held (which works for seeds, whose values do not order outcomes); `Attribution.summary` pools the shares of several designs, and `Attribution.differences` attributes the variance of the differences between pairs of designs, from the same evaluations (parameters that act alike on both cancel, with common random numbers). `Design.realize` and `Study.run` take a `shift`, which draws named parameters as in other replicates (kept apart in a `ResultStore` as a variant of the replicates), and `DesignSpace.uncertain_paths` lists the uncertain parameters. - - Structured cost risk (after Maier, Yeakel, and Wendoloski, "Cost Variance Analysis in Constellation Architecture Studies," 2023): growth factors of each type of satellite (by kind, for development, production, and launches, in `CostModel.estimate` and `MissionPlan.growth`), and the costs of types of satellites as sums of their components (`tradespace.Component`, `SatelliteCost.components`), whose growth has a distribution by maturity (such as `tradespace.Triangular`), correlated between components (`CostModel.correlation`). `CostModel.draw` draws the growth of the components from standard normal scores of the components and a common score, which `tradespace.risk_space` declares as uncertain parameters of a design space (named by `MissionPlan.scores`, also of a nested group), so that common random numbers give the designs that share a component the same growth of it; without drawn growth, components cost their expected growth. Types of satellites that share a component (by name) develop it once in a deployment. Production in blocks (`SatelliteCost.block_size`): each block after the first develops its type again (a share of its development, `redevelopment`) before its first unit is produced, and restarts the learning curve; `CostEstimate.blocks` counts the blocks of each type. Function `tradespace.exceedance` gives the probability that a metric of each design exceeds that of each other in the same replicate (such as that one design costs more than another), and `plot_exceedance` plots them as a matrix. + - Structured cost risk (after Maier, Yeakel, and Wendoloski, "Cost Variance Analysis in Constellation Architecture Studies," 2023): growth factors of each type of satellite (by kind, for development, production, and launches, in `CostModel.estimate` and `MissionPlan.growth`), and the costs of types of satellites as sums of their components (`tradespace.Component`, `SatelliteCost.components`), whose growth has a distribution by maturity (such as `tradespace.Triangular`), correlated between components (`CostModel.correlation`). `CostModel.draw` draws the growth of the components from standard normal scores of the components and a common score, which `tradespace.risk_space` declares as uncertain parameters of a design space (named by `MissionPlan.scores`, also of a nested group), so that common random numbers give the designs that share a component the same growth of it; without drawn growth, components cost their expected growth. Types of satellites that share a component (by name) develop it once in a deployment. Production in blocks (`SatelliteCost.block_size`): each block after the first develops its type again (a share of its development, `redevelopment`) before its first unit is produced, and restarts the learning curve; `CostEstimate.blocks` counts the blocks of each type. Function `tradespace.exceedance` gives the probability that a metric of each design exceeds that of each other in the same replicate (such as that one design costs more than another), and `plot_exceedance` plots them as a matrix. The validation notebook `ValidateCostVarianceNSOSA` reproduces the paper's example of two NSOSA constellations that share a configuration. - Searches with Optuna accept categorical options that depend on earlier decisions (a parameter for each set of options), use TPE with a constant liar in batches by default (which spreads the trials of a batch), and stop after `max_designs` designs evaluated (trials that suggest designs evaluated before are told their objectives without evaluating them again). A design infeasible in some of its replicates violates its feasibility by their share (`Evaluations.infeasibility`), and the first design evaluated in a search is evaluated alone, to check that evaluations give one record each. `Study` records errors of evaluations as infeasible, without storing them, with `errors="record"`. Enumeration walks the items of unordered repetitions in one order only (the same designs, in the same order, four times faster for three sun-synchronous planes), and `DesignSpace.size` counts designs without keeping them. Pareto fronts are found by a vectorized sweep in lexicographic order that compares designs only with the efficient designs before them, and fronts with tolerances by comparing designs only with the efficient designs without tolerances (which dominate every design that any design dominates within the tolerances), in blocks of bounded memory: 20,000 designs in 0.05 s (0.11 s with tolerances) rather than 17 s, and the bootstraps of `pareto_probability` (and so `refine`) about 20 times faster. - Studies of the observations of constellations (`tradespace.ObservationStudy`): the targets of each replicate (`Targets`, fixed or generated from a seed of the design), the observations of each satellite, cached on disk (`Observations`), the metrics of the observations, and, with a `MissionPlan`, the costs of the deployment and the summaries of its phases or of the histories of its `Failures`. Plots of the results of studies (`plot_designs`, `plot_progress`, and `plot_means`, with matplotlib, now in the `tradespace` extra), and the hypervolume of a search as it proceeds (`hypervolume_progress`). - The steps of trade studies share their arguments and outcomes: `tradespace.refine(study, criteria, results)`, `confirm(study, criteria, results)` (by default, the front of the results), `screen(studies, criteria, designs)` (with criteria for each stage, in place of a `tolerance` of its own), and `attribute_variance(study, metrics, designs)` take designs as `Design` objects, their keys, or rows of a summary or of results, and `Refinement`, `Confirmation`, `Screening`, and `Search` give their `results`, the `summary` of their designs, and the `designs`. `DesignSpace.designs_of` rebuilds designs from rows of their values, which summaries keep (also those of `pareto_probability`, `confirm`, and `screen`), and `DesignSpace.extend`, `DesignSpace.design(design, **overrides)`, and `Study.replace` make variants of design spaces, designs, and studies. `aggregate` takes criteria, a mapping of objectives, or metrics (as the other functions do), and other `statistics` by name; `pareto_front`, `pareto_ranks`, `hypervolume`, `sensitivity`, and `main_effects` raise an error given the results of a study (a row per replicate) rather than a summary. Studies with a mission plan record the years by which it is `deployed`, and the parts of observation studies that refer to values of designs are typed as a `Reference`. Columns: ` se` (rather than `sem`), ` mission` for the mean over the phases of a mission, ` histories p` and ` histories std` for statistics over the histories of failures, and `pareto_trace` and `max_regret`. Package `tradespace` exports the functions and classes of trade studies; the parts from which they are made (such as `PhaseCache`, `Layout`, `configure`, and the fingerprints) are imported from its modules. diff --git a/docs/validation/ValidateCostVarianceNSOSA.ipynb b/docs/validation/ValidateCostVarianceNSOSA.ipynb new file mode 100644 index 00000000..53172a97 --- /dev/null +++ b/docs/validation/ValidateCostVarianceNSOSA.ipynb @@ -0,0 +1,1911 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2467114e", + "metadata": {}, + "source": [ + "# Cost Variance Validation: NSOSA Constellations\n", + "\n", + "Architecture studies of satellite constellations compare alternatives whose costs are uncertain and correlated: alternatives that share a satellite design share its cost risk. Maier, Yeakel, and Wendoloski (\"Cost Variance Analysis in Constellation Architecture Studies,\" *IEEE Systems Journal* 17(2), 1928–1938, 2023, [doi:10.1109/JSYST.2022.3218598](https://doi.org/10.1109/JSYST.2022.3218598)) model the uncertain cost of each satellite configuration from the growth of its components by their maturity (the formal risk assessment of system cost estimates, FRISK). They extend it to constellations whose configurations are produced in blocks over decades, and work through two constellations of the NOAA Satellite Observing System Architecture (NSOSA) study that share a geostationary configuration, whose order of cost depends on what they share. TAT-C's `tradespace` module models the same structure: the growth of components by maturity (`Triangular`, `Component`), correlated within a cost model (`CostModel.correlation`); types of satellites produced in blocks (`SatelliteCost.block_size`); deployments from launch schedules (`DeploymentSchedule`); and scores of the cost risk drawn as uncertain parameters (`risk_space`, `CostModel.draw`), which common random numbers share between the designs of a `Study`, compared with `exceedance`. This notebook reproduces the paper's example and asks:\n", + "\n", + "1. **Growth by maturity.** Do `Triangular` growths reproduce the cost growth factors of Table I, and does `CostModel.correlation` reproduce the variance of a configuration of correlated components (eq. 2)?\n", + "2. **Production blocks.** Does `DeploymentSchedule` reproduce the launches and production blocks of the configurations from their launch schedules (Tables II and III), and the numbers of developments, first units, and later units of each constellation (matrix *B* of eq. 5)?\n", + "3. **Constellation costs.** Do the replicates of a `Study` reproduce the means, variances, and covariance of the costs of the two constellations (eqs. 6 and 8, Fig. 2)?\n", + "4. **Order of costs.** Does `exceedance` reproduce the probability that one constellation costs more than the other (eqs. 9 to 15, Fig. 3), and how much of it comes from the configuration they share?\n", + "\n", + "The paper's other results are not reproduced. Its efficient frontier and rank-swap matrix of NSOSA constellations (Figs. 1 and 4) need costs of constellations that were not published, and its comparison with the GOES-R and JPSS programs (Figs. 5 and 6) needs the Aerospace Concept Design Center's cost models and the programs' historical costs. Costs are relative, as in the paper: multiples of the annual cost of the least expensive NSOSA constellation." + ] + }, + { + "cell_type": "markdown", + "id": "80f73ec6", + "metadata": {}, + "source": [ + "## Reference Data\n", + "\n", + "The reference values are those published in the paper:\n", + "\n", + "* **Table I** gives the cost growth factors of components by maturity (new, major modification, modified, minor modification, and existing): the lowest, most likely (1), and highest growth of a triangular distribution, and its mean.\n", + "* **Table II** gives the configurations of the two constellations. C1 flies the geostationary configuration G4c (an advanced GOES-R) on a 48-month launch schedule from April 2029, and the large low Earth orbit (LEO) configuration L3e every 54 months from July 2032. C2 flies G4c every 32 months from April 2029, and the smaller LEO configuration L4f \"46 (x2) months\" from July 2028, read here as two satellites every 46 months. Each configuration is produced in blocks of four satellites.\n", + "* **Eq. (5)** gives the matrix *A* of the shares of a block's cost in its development (Dev), the production and launch of its first unit (T1), and of each later unit (Ta), and the matrix *B* of the number of each in each constellation from 2020 to the end of September 2050 (Table III shows how G4c's numbers in C1 are counted).\n", + "* **Eqs. (6) and (7)** give the expected cost of a block of each configuration, E[*Q*], and its variance (*R*), uncorrelated between configurations. The variances are in millionths of the squared relative cost: the standard deviation of a block of G4c is 0.0997.\n", + "\n", + "From these, the expected costs of the constellations are E[*C*] = *BA* E[*Q*] (eq. 6) and their covariance *BARA*ᵀ*B*ᵀ (eq. 8). The probability that C2 costs more than C1 is the integral of their bivariate normal distribution above the line *y* = *x* (eq. 15), computed here both numerically and in closed form (the normal probability of the mean difference over the standard deviation of the difference). The published results are the expected costs and standard deviations (eq. 6 and Fig. 2), the covariance matrix (eq. 8), and the probability (Fig. 3)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "dc72e779", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-13T17:10:00.253846Z", + "iopub.status.busy": "2026-11-13T17:10:00.253846Z", + "iopub.status.idle": "2026-11-13T17:10:01.714921Z", + "shell.execute_reply": "2026-11-13T17:10:01.714921Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "P(C2 > C1): 0.9779 by eq. (15), 0.9779 in closed form; 0.9491 if the costs were independent\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
publishedfrom the published inputs
E[C1]8.2708.2592
E[C2]8.9308.9275
std C10.3400.3408
std C20.2300.2253
var C1 (millionths)116118.000116118.1421
cov C1, C2 (millionths)28260.00028260.8967
var C2 (millionths)50757.00050757.8163
P(C2 > C1)0.9780.9779
\n", + "
" + ], + "text/plain": [ + " published from the published inputs\n", + "E[C1] 8.270 8.2592\n", + "E[C2] 8.930 8.9275\n", + "std C1 0.340 0.3408\n", + "std C2 0.230 0.2253\n", + "var C1 (millionths) 116118.000 116118.1421\n", + "cov C1, C2 (millionths) 28260.000 28260.8967\n", + "var C2 (millionths) 50757.000 50757.8163\n", + "P(C2 > C1) 0.978 0.9779" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import math\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "from scipy import integrate, stats\n", + "\n", + "BLUE, ORANGE, GRAY, INK = \"#2a78d6\", \"#eb6834\", \"#8a8a86\", \"#2b2b29\"\n", + "\n", + "# Table I: the lowest and highest cost growth factors of components by maturity (most likely 1), and their mean\n", + "TABLE_I = pd.DataFrame(\n", + " {\n", + " \"low\": [0.827, 0.864, 0.904, 0.943, 0.981],\n", + " \"high\": [2.274, 1.993, 1.708, 1.423, 1.140],\n", + " \"mean\": [1.367, 1.286, 1.204, 1.122, 1.041],\n", + " },\n", + " index=pd.Index(\n", + " [\"new\", \"major modification\", \"modified\", \"minor modification\", \"existing\"],\n", + " name=\"maturity\",\n", + " ),\n", + ")\n", + "# eq. (5), matrix A: the shares of the cost of a block in its development, first unit, and each later unit\n", + "SHARES = {\n", + " \"G4c\": (0.309, 0.132, 0.115),\n", + " \"L3e\": (0.290, 0.126, 0.110),\n", + " \"L4f\": (0.217, 0.054, 0.047),\n", + "}\n", + "# eq. (6): the expected cost of a block, E[Q]; eq. (7): its variance, R (published in millionths)\n", + "MEAN_Q = {\"G4c\": 3.33, \"L3e\": 3.14, \"L4f\": 1.61}\n", + "VARIANCE_Q = {\"G4c\": 9930e-6, \"L3e\": 71900e-6, \"L4f\": 5260e-6}\n", + "# eq. (5), matrix B: the developments, first units, and later units of each configuration of each constellation\n", + "PUBLISHED = {\n", + " \"C1\": {\"G4c\": (2, 2, 4.37), \"L3e\": (2, 2, 3)},\n", + " \"C2\": {\"G4c\": (3, 3, 6.37), \"L4f\": (2.9, 2.9, 10.8)},\n", + "}\n", + "CONSTELLATIONS = list(PUBLISHED)\n", + "CONFIGURATIONS = list(MEAN_Q)\n", + "\n", + "\n", + "def exposures(counts):\n", + " \"\"\"The matrix BA: the multiple of the cost of a block of each configuration in each constellation.\"\"\"\n", + " return np.array(\n", + " [\n", + " [np.dot(counts[name].get(c, (0, 0, 0)), SHARES[c]) for c in CONFIGURATIONS]\n", + " for name in CONSTELLATIONS\n", + " ]\n", + " )\n", + "\n", + "\n", + "def moments(counts, correlated=True):\n", + " \"\"\"The expected costs of the constellations (eq. 6) and their covariance (eq. 8), or only their variances.\"\"\"\n", + " ba = exposures(counts)\n", + " mean = ba @ np.array([MEAN_Q[c] for c in CONFIGURATIONS])\n", + " covariance = ba @ np.diag([VARIANCE_Q[c] for c in CONFIGURATIONS]) @ ba.T\n", + " return mean, covariance if correlated else np.diag(np.diag(covariance))\n", + "\n", + "\n", + "def probability_exceeds(mean, covariance):\n", + " \"\"\"The probability that the second cost exceeds the first: eq. (15) integrated numerically, and in closed form.\"\"\"\n", + " sx, sy = np.sqrt(np.diag(covariance))\n", + " rho = covariance[0, 1] / (sx * sy)\n", + " sigma = sy * math.sqrt(1 - rho**2) # eq. (12)\n", + "\n", + " def integrand(x):\n", + " mu = mean[1] + sy / sx * rho * (x - mean[0]) # eq. (11)\n", + " return stats.norm.pdf(x, mean[0], sx) * stats.norm.sf(x, mu, sigma)\n", + "\n", + " numerical = integrate.quad(integrand, mean[0] - 12 * sx, mean[0] + 12 * sx)[0]\n", + " spread = math.sqrt(covariance[0, 0] + covariance[1, 1] - 2 * covariance[0, 1])\n", + " return numerical, stats.norm.cdf((mean[1] - mean[0]) / spread)\n", + "\n", + "\n", + "mean, covariance = moments(PUBLISHED)\n", + "numerical, closed = probability_exceeds(mean, covariance)\n", + "independent = probability_exceeds(*moments(PUBLISHED, correlated=False))[1]\n", + "reference = pd.DataFrame(\n", + " {\n", + " \"published\": [8.27, 8.93, 0.34, 0.23, 116118, 28260, 50757, 0.978],\n", + " \"from the published inputs\": [\n", + " *mean,\n", + " *np.sqrt(np.diag(covariance)),\n", + " covariance[0, 0] * 1e6,\n", + " covariance[0, 1] * 1e6,\n", + " covariance[1, 1] * 1e6,\n", + " numerical,\n", + " ],\n", + " },\n", + " index=[\n", + " \"E[C1]\",\n", + " \"E[C2]\",\n", + " \"std C1\",\n", + " \"std C2\",\n", + " \"var C1 (millionths)\",\n", + " \"cov C1, C2 (millionths)\",\n", + " \"var C2 (millionths)\",\n", + " \"P(C2 > C1)\",\n", + " ],\n", + ")\n", + "print(\n", + " f\"P(C2 > C1): {numerical:.4f} by eq. (15), {closed:.4f} in closed form; \"\n", + " + f\"{independent:.4f} if the costs were independent\"\n", + ")\n", + "reference.round(4)" + ] + }, + { + "cell_type": "markdown", + "id": "c6e246b0", + "metadata": {}, + "source": [ + "The published inputs reproduce the published results, within the rounding of *A*'s shares: expected costs of 8.26 and 8.93 (eq. 6 gives 8.27 and 8.93, and Fig. 2 gives 8.27 and 8.94), standard deviations of 0.34 and 0.23, the covariance matrix of eq. (8) within one millionth, and a probability of 97.8% that C2 costs more than C1 (eq. 15, equal to the closed form). If the costs of the two constellations were independent, the probability would be 94.9%: the shared configuration G4c makes the order more certain.\n", + "\n", + "## Test 1: Growth by Maturity\n", + "\n", + "FRISK models the growth of the cost of each component as a triangular distribution from a low to a high multiple of its point estimate, most likely the estimate itself. The spread and skew grow as the component's maturity falls (Table I). The variance of each component is that of its triangular distribution (eq. 1), and the variance of a configuration is the sum of the covariances of its components, correlated by 0.5 (eq. 2). In TAT-C, `Triangular(low, high)` gives the distribution (most likely 1), and a `Component` grows by it. A `CostModel` with `correlation=0.5` draws the growths of its components from standard normal scores mixed with a common score (`CostModel.draw`): the growth of each component is the quantile of its distribution at the normal probability of `sqrt(0.5) * common + sqrt(0.5) * own`, so that the scores of every pair of components are correlated by 0.5. The scores are uncertain parameters of a design space (`risk_space`), drawn in each replicate of a `Study`.\n", + "\n", + "The paper gives no component costs of its configurations, so eq. (2) is checked for a configuration of one component of each maturity with equal point estimates (1), in 20,000 replicates. The correlation of the growths themselves is computed exactly (by Gauss–Hermite quadrature over the bivariate normal scores) as well as from the replicates. The standard deviations of Table I's distributions are compared with SciPy's triangular distribution, an independent implementation." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c35c2309", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-13T17:10:01.716352Z", + "iopub.status.busy": "2026-11-13T17:10:01.716352Z", + "iopub.status.idle": "2026-11-13T17:10:07.395850Z", + "shell.execute_reply": "2026-11-13T17:10:07.394949Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "correlation of growths: 0.4862 to 0.4862 exactly, 0.488 to 0.502 in the replicates (10 pairs)\n", + "variance of the configuration: 0.5075 by eq. (2), 0.5008 in the replicates (-1.3%), 0.4994 by eq. (2) with the exact correlation\n", + "correlation of scores that correlates growths by 0.5: 0.5139\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
lowhighmeanTAT-C meanmean of replicatesstd (SciPy)TAT-C stdstd of replicatesmode (share of range)
maturity
new0.8272.2741.3671.36701.36360.32260.32260.32190.1196
major modification0.8641.9931.2861.28571.28420.25160.25160.25150.1205
modified0.9041.7081.2041.20401.20280.17930.17930.17890.1194
minor modification0.9431.4231.1221.12201.12200.10710.10710.10720.1188
existing0.9811.1401.0411.04031.04000.03550.03550.03550.1195
\n", + "
" + ], + "text/plain": [ + " low high mean TAT-C mean mean of replicates \\\n", + "maturity \n", + "new 0.827 2.274 1.367 1.3670 1.3636 \n", + "major modification 0.864 1.993 1.286 1.2857 1.2842 \n", + "modified 0.904 1.708 1.204 1.2040 1.2028 \n", + "minor modification 0.943 1.423 1.122 1.1220 1.1220 \n", + "existing 0.981 1.140 1.041 1.0403 1.0400 \n", + "\n", + " std (SciPy) TAT-C std std of replicates \\\n", + "maturity \n", + "new 0.3226 0.3226 0.3219 \n", + "major modification 0.2516 0.2516 0.2515 \n", + "modified 0.1793 0.1793 0.1789 \n", + "minor modification 0.1071 0.1071 0.1072 \n", + "existing 0.0355 0.0355 0.0355 \n", + "\n", + " mode (share of range) \n", + "maturity \n", + "new 0.1196 \n", + "major modification 0.1205 \n", + "modified 0.1194 \n", + "minor modification 0.1188 \n", + "existing 0.1195 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from scipy import optimize\n", + "\n", + "from tatc.tradespace import (\n", + " Component,\n", + " CostModel,\n", + " DesignSpace,\n", + " SatelliteCost,\n", + " Study,\n", + " Triangular,\n", + " risk_space,\n", + ")\n", + "\n", + "GROWTH = {name: Triangular(row.low, row.high) for name, row in TABLE_I.iterrows()}\n", + "CORRELATION = 0.5 # of the scores of the components (eq. 2 assumes it of their costs)\n", + "REPLICATES = 20_000\n", + "\n", + "# a configuration of one component of each maturity, with equal point estimates\n", + "mixed = CostModel(\n", + " SatelliteCost(\n", + " components=[\n", + " Component(name, development=1.0, growth=g) for name, g in GROWTH.items()\n", + " ]\n", + " ),\n", + " correlation=CORRELATION,\n", + ")\n", + "mixed_space = DesignSpace(cost_risk=risk_space(mixed))\n", + "\n", + "\n", + "def growths(_, design):\n", + " \"\"\"The growth of each component, drawn from the replicate's scores, and of the configuration.\"\"\"\n", + " drawn = mixed.draw(design.cost_risk)\n", + " values = {c.name: c.growth for c in drawn.satellites.components}\n", + " return {**values, \"configuration\": sum(values.values())}\n", + "\n", + "\n", + "draws = Study(mixed_space, lambda d: None, growths, replicates=REPLICATES).run(\n", + " mixed_space.enumerate()\n", + ")\n", + "\n", + "\n", + "def growth_correlation(a, b, rho, nodes=200):\n", + " \"\"\"The correlation of the growths of two components whose scores are correlated by rho (Gauss-Hermite).\"\"\"\n", + " z, w = np.polynomial.hermite_e.hermegauss(nodes)\n", + " w = np.outer(w, w) / w.sum() ** 2\n", + " za, zb = np.meshgrid(z, z, indexing=\"ij\")\n", + " ga = np.vectorize(a.ppf)(stats.norm.cdf(za))\n", + " gb = np.vectorize(b.ppf)(stats.norm.cdf(rho * za + math.sqrt(1 - rho**2) * zb))\n", + " return np.sum(w * (ga - a.mean()) * (gb - b.mean())) / (a.std() * b.std())\n", + "\n", + "\n", + "table1 = TABLE_I.assign(\n", + " **{\n", + " \"TAT-C mean\": [g.mean() for g in GROWTH.values()],\n", + " \"mean of replicates\": draws[list(GROWTH)].mean().to_numpy(),\n", + " \"std (SciPy)\": [\n", + " stats.triang((1 - g.low) / (g.high - g.low), g.low, g.high - g.low).std()\n", + " for g in GROWTH.values()\n", + " ],\n", + " \"TAT-C std\": [g.std() for g in GROWTH.values()],\n", + " \"std of replicates\": draws[list(GROWTH)].std().to_numpy(),\n", + " \"mode (share of range)\": [\n", + " (1 - g.low) / (g.high - g.low) for g in GROWTH.values()\n", + " ],\n", + " }\n", + ")\n", + "pairs = [(a, b) for i, a in enumerate(GROWTH) for b in list(GROWTH)[i + 1 :]]\n", + "exact = [growth_correlation(GROWTH[a], GROWTH[b], CORRELATION) for a, b in pairs]\n", + "sampled = [draws[a].corr(draws[b]) for a, b in pairs]\n", + "sigma = np.array([g.std() for g in GROWTH.values()])\n", + "off_diagonal = sigma.sum() ** 2 - (sigma**2).sum() # twice the sum of products of pairs\n", + "eq2 = (sigma**2).sum() + CORRELATION * off_diagonal\n", + "eq2_exact = (sigma**2).sum() + np.mean(exact) * off_diagonal\n", + "matching = optimize.brentq(\n", + " lambda rho: growth_correlation(GROWTH[\"new\"], GROWTH[\"existing\"], rho) - 0.5,\n", + " 0.4,\n", + " 0.7,\n", + ")\n", + "print(\n", + " f\"correlation of growths: {min(exact):.4f} to {max(exact):.4f} exactly, \"\n", + " + f\"{min(sampled):.3f} to {max(sampled):.3f} in the replicates (10 pairs)\"\n", + ")\n", + "print(\n", + " f\"variance of the configuration: {eq2:.4f} by eq. (2), {draws.configuration.var():.4f} in the replicates \"\n", + " + f\"({draws.configuration.var() / eq2 - 1:+.1%}), {eq2_exact:.4f} by eq. (2) with the exact correlation\"\n", + ")\n", + "print(f\"correlation of scores that correlates growths by 0.5: {matching:.4f}\")\n", + "table1.round(4)" + ] + }, + { + "cell_type": "markdown", + "id": "2d79d7b2", + "metadata": {}, + "source": [ + "`Triangular` reproduces Table I: its means equal the published means to the table's three decimals for four of the five maturities. The fifth, existing components, is 1.0403 against the published 1.041; the mean of (0.981, 1, 1.140) is 1.0403, so the table's last digit is rounded up. Its standard deviations equal SciPy's, and the replicates drawn through `CostModel.draw` reproduce the means and standard deviations within their sampling errors (at most 0.0023 for the means).\n", + "\n", + "`CostModel.correlation` correlates the scores of components, not their growths: the quantile transform of a skewed distribution lowers the correlation of the growths to 0.486 for every pair. Table I's distributions all have the same shape (the most likely growth at 12% of each one's range), so all pairs are lowered alike. The replicates give 0.488 to 0.502, within their sampling error of about 0.006. The configuration's variance is 1.3% below eq. (2), as eq. (2) with the exact correlation predicts. A correlation of the scores of 0.514 gives growths correlated by 0.5, as eq. (2) assumes. This difference is small next to the uncertainty of the correlation itself, which the paper puts at 0.5 as \"generally appropriate.\"\n", + "\n", + "## Test 2: Production Blocks\n", + "\n", + "The paper costs each configuration over 2020 to 2050 in blocks of four satellites. Each block is a new design, whose development (Dev) and first unit (T1) are paid again, followed by three later units (Ta). In TAT-C, a type of satellite with `block_size=4` (and `redevelopment=1`, a full redesign) develops each block after the first before the production of the block's first unit, over the type's development time (see `CostModel.estimate`).\n", + "\n", + "A `DeploymentSchedule` plans each configuration's deployment:\n", + "\n", + "* **Launches.** A design life equal to the launch interval launches a replacement at that interval from the first launch, until the end of the mission (here, the end of September 2050).\n", + "* **Production.** Each launch's satellites are produced over the four years before it, as Table III's later units are.\n", + "* **Development.** Development runs from the start (1 March 2020, when Table III begins G4c's first development) to the production of the first unit.\n", + "\n", + "The satellites of one deployment share a design life, so each configuration is planned with its own schedule, and the cost of a constellation is the sum of the costs of its configurations. The layout of a configuration is its slots: a subclass of `Layout`, which needs only its planes to be deployed and costed (the orbits matter only to build the satellites)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "156026e5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-13T17:10:07.397851Z", + "iopub.status.busy": "2026-11-13T17:10:07.397851Z", + "iopub.status.idle": "2026-11-13T17:10:07.426328Z", + "shell.execute_reply": "2026-11-13T17:10:07.426328Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "C1 G4c: launches in Apr 2029, Apr 2033, Apr 2037, Apr 2041, Apr 2045, Apr 2049\n", + "C1 L3e: launches in Jul 2032, Jan 2037, Jul 2041, Jan 2046, Jul 2050\n", + "C2 G4c: launches in Apr 2029, Dec 2031, Aug 2034, Apr 2037, Dec 2039, Aug 2042, Apr 2045, Dec 2047, Aug 2050\n", + "C2 L4f: launches in Jul 2028, May 2032, Mar 2036, Jan 2040, Nov 2043, Sep 2047\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
paper developmentTAT-C developmentpaper productionTAT-C productionpaper launchTAT-C launchpaper countedTAT-C counted
unit
block 1, unit 1Mar 2020Mar 2020Sep 2023Apr 2025Apr 2029Apr 20291.001.000
block 1, unit 2NoneNoneApr 2029Apr 2029Apr 2033Apr 20331.001.000
block 1, unit 3NoneNoneApr 2033Apr 2033Apr 2037Apr 20371.001.000
block 1, unit 4NoneNoneApr 2037Apr 2037Apr 2041Apr 20411.001.000
block 2, unit 1Mar 2036Mar 2036Sep 2039Apr 2041Apr 2045Apr 20451.001.000
block 2, unit 2NoneNoneApr 2045Apr 2045Apr 2049Apr 20491.001.000
block 2, unit 3NoneNoneApr 2049Apr 2049Apr 2053Apr 20530.370.375
\n", + "
" + ], + "text/plain": [ + " paper development TAT-C development paper production \\\n", + "unit \n", + "block 1, unit 1 Mar 2020 Mar 2020 Sep 2023 \n", + "block 1, unit 2 None None Apr 2029 \n", + "block 1, unit 3 None None Apr 2033 \n", + "block 1, unit 4 None None Apr 2037 \n", + "block 2, unit 1 Mar 2036 Mar 2036 Sep 2039 \n", + "block 2, unit 2 None None Apr 2045 \n", + "block 2, unit 3 None None Apr 2049 \n", + "\n", + " TAT-C production paper launch TAT-C launch paper counted \\\n", + "unit \n", + "block 1, unit 1 Apr 2025 Apr 2029 Apr 2029 1.00 \n", + "block 1, unit 2 Apr 2029 Apr 2033 Apr 2033 1.00 \n", + "block 1, unit 3 Apr 2033 Apr 2037 Apr 2037 1.00 \n", + "block 1, unit 4 Apr 2037 Apr 2041 Apr 2041 1.00 \n", + "block 2, unit 1 Apr 2041 Apr 2045 Apr 2045 1.00 \n", + "block 2, unit 2 Apr 2045 Apr 2049 Apr 2049 1.00 \n", + "block 2, unit 3 Apr 2049 Apr 2053 Apr 2053 0.37 \n", + "\n", + " TAT-C counted \n", + "unit \n", + "block 1, unit 1 1.000 \n", + "block 1, unit 2 1.000 \n", + "block 1, unit 3 1.000 \n", + "block 1, unit 4 1.000 \n", + "block 2, unit 1 1.000 \n", + "block 2, unit 2 1.000 \n", + "block 2, unit 3 0.375 " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import DeploymentSchedule\n", + "from tatc.tradespace.constellations import Layout, Plane\n", + "\n", + "BLOCK_SIZE = 4\n", + "PRODUCTION_YEARS = 4 # the production of each launch's satellites (Table III)\n", + "MONTHS = \"Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec\".split()\n", + "\n", + "\n", + "def year(y, m):\n", + " \"\"\"The start of a month, in years from 1 March 2020.\"\"\"\n", + " return y - 2020 + (m - 3) / 12\n", + "\n", + "\n", + "def month(time):\n", + " \"\"\"The month of a time, in years from 1 March 2020.\"\"\"\n", + " months = round(time * 12) + 2\n", + " return f\"{MONTHS[months % 12]} {2020 + months // 12}\"\n", + "\n", + "\n", + "END = year(2050, 10) # the end of September 2050\n", + "# Table II: the first launch, the months between launches, and the satellites of each launch\n", + "SCHEDULES = {\n", + " \"C1\": {\"G4c\": (year(2029, 4), 48, 1), \"L3e\": (year(2032, 7), 54, 1)},\n", + " \"C2\": {\"G4c\": (year(2029, 4), 32, 1), \"L4f\": (year(2028, 7), 46, 2)},\n", + "}\n", + "\n", + "\n", + "class Slots(Layout):\n", + " \"\"\"Orbital slots, whose satellites are launched together (one plane, for deployments).\"\"\"\n", + "\n", + " def __init__(self, count):\n", + " self.count = count\n", + "\n", + " def planes(self):\n", + " return [Plane(self.count)]\n", + "\n", + "\n", + "def plan(configuration, first, months, satellites, end=END):\n", + " \"\"\"The deployment of a configuration: launches at an interval from the first, until the end.\"\"\"\n", + " schedule = DeploymentSchedule(\n", + " years=end - first,\n", + " design_life=months / 12,\n", + " development_years=first - PRODUCTION_YEARS,\n", + " production_rate=satellites / PRODUCTION_YEARS,\n", + " )\n", + " return schedule.plan(Slots(satellites), kind=configuration)\n", + "\n", + "\n", + "DEPLOYMENTS = {\n", + " name: {c: plan(c, *s) for c, s in configurations.items()}\n", + " for name, configurations in SCHEDULES.items()\n", + "}\n", + "for name, deployments in DEPLOYMENTS.items():\n", + " for c, deployment in deployments.items():\n", + " print(\n", + " f\"{name} {c}: launches in\",\n", + " \", \".join(month(l.time) for l in deployment.launches),\n", + " )\n", + "\n", + "\n", + "def shares_produced(deployment, end=END):\n", + " \"\"\"The share of each unit of a deployment produced by the end, in the order of production.\"\"\"\n", + " shares = []\n", + " for batch in deployment.production:\n", + " done = (end - batch.begin) / (batch.end - batch.begin)\n", + " shares += [min(max(done, 0.0), 1.0)] * batch.satellites\n", + " return shares\n", + "\n", + "\n", + "# Table III: G4c in C1 (the start of development of each block, and of production and launch of each unit)\n", + "TABLE_III = pd.DataFrame(\n", + " [\n", + " (\"Mar 2020\", \"Sep 2023\", \"Apr 2029\", 1.0),\n", + " (None, \"Apr 2029\", \"Apr 2033\", 1.0),\n", + " (None, \"Apr 2033\", \"Apr 2037\", 1.0),\n", + " (None, \"Apr 2037\", \"Apr 2041\", 1.0),\n", + " (\"Mar 2036\", \"Sep 2039\", \"Apr 2045\", 1.0),\n", + " (None, \"Apr 2045\", \"Apr 2049\", 1.0),\n", + " (None, \"Apr 2049\", \"Apr 2053\", 0.37),\n", + " ],\n", + " columns=[\"development\", \"production\", \"launch\", \"counted\"],\n", + ")\n", + "# planned past the end, for the units in production at the end\n", + "extended = plan(\"G4c\", *SCHEDULES[\"C1\"][\"G4c\"], end=END + 5)\n", + "developed = extended.development[\"G4c\"]\n", + "table3 = []\n", + "for unit, (batch, launch, share) in enumerate(\n", + " zip(extended.production, extended.launches, shares_produced(extended))\n", + "):\n", + " first = unit % BLOCK_SIZE == 0\n", + " table3.append(\n", + " {\n", + " \"unit\": f\"block {unit // BLOCK_SIZE + 1}, unit {unit % BLOCK_SIZE + 1}\",\n", + " # each block's development ends as the production of its first unit begins\n", + " \"TAT-C development\": (\n", + " month(max(batch.begin - developed, 0)) if first else None\n", + " ),\n", + " \"TAT-C production\": month(batch.begin),\n", + " \"TAT-C launch\": month(launch.time),\n", + " \"TAT-C counted\": share,\n", + " }\n", + " )\n", + "table3 = pd.DataFrame(table3).join(TABLE_III.add_prefix(\"paper \")).set_index(\"unit\")\n", + "table3[[f\"{side} {column}\" for column in TABLE_III for side in (\"paper\", \"TAT-C\")]]" + ] + }, + { + "cell_type": "markdown", + "id": "160dc0ea", + "metadata": {}, + "source": [ + "TAT-C's deployment of G4c in C1 reproduces Table III's launches, the production of its later units, and the starts of development of both blocks (March 2020 and March 2036). With development ending as production begins, the second block's development takes the 5.1 years before its first unit's production (April 2041), which starts it in March 2036, as Table III does. Table III's Phases B and C start the first unit's production earlier (September 2023, 5.6 years before launch), where TAT-C produces every unit over four years: the dates of the first units' costs differ, not their amounts.\n", + "\n", + "The two conventions differ at the end of the study period. Table III counts the share of a unit produced by the end of September 2050 (18 of the 48 months of the unit launched in April 2053, 0.37), and so does the last column of TAT-C's counts above (0.375, from a deployment planned past the end). TAT-C's cost model counts the units that the deployment launches before the end of its mission. The numbers of each constellation:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "64739846", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-13T17:10:07.428322Z", + "iopub.status.busy": "2026-11-13T17:10:07.428322Z", + "iopub.status.idle": "2026-11-13T17:10:07.501848Z", + "shell.execute_reply": "2026-11-13T17:10:07.501848Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
DevT1Taexpected cost
constellationconfigurationcount
C1G4cTAT-C, share produced2.00002.00004.37504.6125
TAT-C, units launched2.00002.00004.00004.4689
paper2.00002.00004.37004.6106
L3eTAT-C, share produced2.00002.00003.00003.6487
TAT-C, units launched2.00002.00003.00003.6487
paper2.00002.00003.00003.6487
C2G4cTAT-C, share produced3.00003.00006.37506.8469
TAT-C, units launched3.00003.00006.00006.7033
paper3.00003.00006.37006.8450
L4fTAT-C, share produced3.81253.81259.81252.4059
TAT-C, units launched3.00003.00009.00001.9900
paper2.90002.900010.80002.0825
\n", + "
" + ], + "text/plain": [ + " Dev T1 Ta \\\n", + "constellation configuration count \n", + "C1 G4c TAT-C, share produced 2.0000 2.0000 4.3750 \n", + " TAT-C, units launched 2.0000 2.0000 4.0000 \n", + " paper 2.0000 2.0000 4.3700 \n", + " L3e TAT-C, share produced 2.0000 2.0000 3.0000 \n", + " TAT-C, units launched 2.0000 2.0000 3.0000 \n", + " paper 2.0000 2.0000 3.0000 \n", + "C2 G4c TAT-C, share produced 3.0000 3.0000 6.3750 \n", + " TAT-C, units launched 3.0000 3.0000 6.0000 \n", + " paper 3.0000 3.0000 6.3700 \n", + " L4f TAT-C, share produced 3.8125 3.8125 9.8125 \n", + " TAT-C, units launched 3.0000 3.0000 9.0000 \n", + " paper 2.9000 2.9000 10.8000 \n", + "\n", + " expected cost \n", + "constellation configuration count \n", + "C1 G4c TAT-C, share produced 4.6125 \n", + " TAT-C, units launched 4.4689 \n", + " paper 4.6106 \n", + " L3e TAT-C, share produced 3.6487 \n", + " TAT-C, units launched 3.6487 \n", + " paper 3.6487 \n", + "C2 G4c TAT-C, share produced 6.8469 \n", + " TAT-C, units launched 6.7033 \n", + " paper 6.8450 \n", + " L4f TAT-C, share produced 2.4059 \n", + " TAT-C, units launched 1.9900 \n", + " paper 2.0825 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
E[C1]E[C2]E[C2] - E[C1]P(C2 > C1)
count
paper8.25928.92750.66830.9779
TAT-C, units launched8.11758.69330.57570.9590
TAT-C, share produced8.26119.25280.99170.9984
\n", + "
" + ], + "text/plain": [ + " E[C1] E[C2] E[C2] - E[C1] P(C2 > C1)\n", + "count \n", + "paper 8.2592 8.9275 0.6683 0.9779\n", + "TAT-C, units launched 8.1175 8.6933 0.5757 0.9590\n", + "TAT-C, share produced 8.2611 9.2528 0.9917 0.9984" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def counted(deployment):\n", + " \"\"\"The developments, first units, and later units by the end, as Table III counts them.\"\"\"\n", + " shares = shares_produced(deployment)\n", + " first = sum(\n", + " shares[::BLOCK_SIZE]\n", + " ) # each block's development is counted with its first unit\n", + " return (first, first, sum(shares) - first)\n", + "\n", + "\n", + "blocks = SatelliteCost(block_size=BLOCK_SIZE)\n", + "COUNTS = {\"paper\": PUBLISHED, \"TAT-C, units launched\": {}, \"TAT-C, share produced\": {}}\n", + "for name, configurations in SCHEDULES.items():\n", + " for key in list(COUNTS)[1:]:\n", + " COUNTS[key][name] = {}\n", + " for c, schedule in configurations.items():\n", + " units = DEPLOYMENTS[name][c].units[c]\n", + " n = blocks.blocks(units)\n", + " COUNTS[\"TAT-C, units launched\"][name][c] = (n, n, units - n)\n", + " COUNTS[\"TAT-C, share produced\"][name][c] = counted(\n", + " plan(c, *schedule, end=END + 10)\n", + " )\n", + "rows = [\n", + " {\n", + " \"constellation\": name,\n", + " \"configuration\": c,\n", + " \"count\": key,\n", + " **dict(zip([\"Dev\", \"T1\", \"Ta\"], values)),\n", + " \"expected cost\": MEAN_Q[c] * np.dot(values, SHARES[c]),\n", + " }\n", + " for key, counts in COUNTS.items()\n", + " for name, configurations in counts.items()\n", + " for c, values in configurations.items()\n", + "]\n", + "counts = (\n", + " pd.DataFrame(rows)\n", + " .set_index([\"constellation\", \"configuration\", \"count\"])\n", + " .sort_index()\n", + ")\n", + "totals = []\n", + "for key, table in COUNTS.items():\n", + " mean, covariance = moments(table)\n", + " totals.append(\n", + " {\n", + " \"count\": key,\n", + " \"E[C1]\": mean[0],\n", + " \"E[C2]\": mean[1],\n", + " \"E[C2] - E[C1]\": mean[1] - mean[0],\n", + " \"P(C2 > C1)\": probability_exceeds(mean, covariance)[1],\n", + " }\n", + " )\n", + "display(counts.round(4))\n", + "pd.DataFrame(totals).set_index(\"count\").round(4)" + ] + }, + { + "cell_type": "markdown", + "id": "e631bd2d", + "metadata": {}, + "source": [ + "Counted as Table III counts them, TAT-C's deployments reproduce the published numbers of G4c in both constellations (2, 2, 4.375 and 3, 3, 6.375 against 4.37 and 6.37) and of L3e (2, 2, 3). The published numbers of L4f (2.9 developments and first units, 10.8 later units) cannot be derived from its schedule this way. Its six launches of two satellites before the end of September 2050 (12 units, 3 blocks), and the 0.81 of the next two produced, give 3.81 developments and first units and 9.81 later units: about the same units (13.6 against 13.7), but 0.91 more developments. Two satellites per launch every 46 months is one reading of Table II's \"46 (x2)\". Other readings, such as two slots with blocks of their own (4 developments) or one launch every 23 months (3.81), do not give 2.9 either. The 0.91 more developments and first units, and 0.99 fewer later units, add 0.32 to C2's expected cost, so with these counts the probability that C2 costs more than C1 would be 99.8%.\n", + "\n", + "TAT-C's cost model counts the units launched. It leaves out the 0.375 of a G4c unit in production at the end in both constellations (0.14 of each one's cost), and costs L4f at 0.09 less than its published counts. Both constellations then cost less (8.12 and 8.69), C2 by 0.58 more than C1 rather than 0.67, and the probability that C2 costs more is 95.9%. The tests below therefore evaluate the costs of the published numbers, to test TAT-C's cost risk on the paper's inputs, and also TAT-C's own estimates of these deployments.\n", + "\n", + "## Test 3: Constellation Costs\n", + "\n", + "The paper's cost of a block of a configuration is a random variable *Q* (normal, from its FRISK estimate), of which fixed shares are its development, first unit, and each later unit: every element of every block grows with *Q*. In TAT-C, each configuration is a type of satellite with one component (named after it) whose growth is normal, with mean 1 and the standard deviation of *Q* relative to its mean. The growth is a SciPy distribution, which has the `ppf` and `mean` that a `Component` needs. Without learning (the default learning rate of 1), each unit costs the component's `first_unit`, here the cost of a later unit (Ta). The first unit's premium (T1 - Ta) is charged with each block's development, so that a block costs Dev + T1 + 3 Ta, as in the paper. (A learning curve would also give the premium: Ta/T1 is about 0.87 for all three configurations, the mean of units 2 to 4 on a 91% curve, but the paper charges every later unit the same.) The growths of the configurations are uncorrelated (`correlation=0`, the default), as the paper assumes, so the scores of the cost risk are those of G4c, L3e, and L4f (`risk_space`).\n", + "\n", + "The design space has one design variable, the constellation (C1 or C2), and the scores. Two evaluations of the replicates are compared:\n", + "\n", + "* **Published counts.** The cost of the published numbers of developments and units (*B*): each block costs the `total_development` and each unit the `total_first_unit` of the configuration drawn from the replicate's scores. This tests TAT-C's cost risk on the paper's inputs.\n", + "* **TAT-C deployments.** TAT-C's own estimate (`CostModel.estimate`) of the deployments of Test 2, with whole units.\n", + "\n", + "Each runs 20,000 replicates with common random numbers (the default), in which both constellations draw the same scores, and 20,000 with independent draws (for Test 4)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2333f84b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-13T17:10:07.503857Z", + "iopub.status.busy": "2026-11-13T17:10:07.503857Z", + "iopub.status.idle": "2026-11-13T17:11:45.580106Z", + "shell.execute_reply": "2026-11-13T17:11:45.580106Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "scores: ['cost_risk.G4c', 'cost_risk.L3e', 'cost_risk.L4f']\n", + "C1: blocks [{'G4c': 2}, {'L3e': 2}], units [{'G4c': 6}, {'L3e': 5}], expected cost 8.1175\n", + "C2: blocks [{'G4c': 3}, {'L4f': 3}], units [{'G4c': 9}, {'L4f': 12}], expected cost 8.6933\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "standard errors of the means of the replicates: 0.0024\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
E[C1]E[C2]std C1std C2cov (millionths)correlation
paper (eqs. 6 and 8)8.27008.93000.34080.225328260.00000.3681
published counts: expected8.25928.92750.34080.225328260.89670.3681
published counts: replicates8.26228.92690.34010.224127968.41920.3669
TAT-C deployments: expected8.11758.69330.33910.219726825.35880.3601
TAT-C deployments: replicates8.12058.69260.33850.218626544.82850.3588
\n", + "
" + ], + "text/plain": [ + " E[C1] E[C2] std C1 std C2 \\\n", + "paper (eqs. 6 and 8) 8.2700 8.9300 0.3408 0.2253 \n", + "published counts: expected 8.2592 8.9275 0.3408 0.2253 \n", + "published counts: replicates 8.2622 8.9269 0.3401 0.2241 \n", + "TAT-C deployments: expected 8.1175 8.6933 0.3391 0.2197 \n", + "TAT-C deployments: replicates 8.1205 8.6926 0.3385 0.2186 \n", + "\n", + " cov (millionths) correlation \n", + "paper (eqs. 6 and 8) 28260.0000 0.3681 \n", + "published counts: expected 28260.8967 0.3681 \n", + "published counts: replicates 27968.4192 0.3669 \n", + "TAT-C deployments: expected 26825.3588 0.3601 \n", + "TAT-C deployments: replicates 26544.8285 0.3588 " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import Categorical\n", + "\n", + "TYPES = {\n", + " c: SatelliteCost(\n", + " components=[\n", + " Component(\n", + " c,\n", + " development=(dev + first - later) * MEAN_Q[c],\n", + " first_unit=later * MEAN_Q[c],\n", + " growth=stats.norm(1, math.sqrt(VARIANCE_Q[c]) / MEAN_Q[c]),\n", + " )\n", + " ],\n", + " block_size=BLOCK_SIZE,\n", + " )\n", + " for c, (dev, first, later) in SHARES.items()\n", + "}\n", + "MODEL = CostModel(TYPES)\n", + "space = DesignSpace(\n", + " constellation=Categorical(CONSTELLATIONS), cost_risk=risk_space(MODEL)\n", + ")\n", + "designs = space.enumerate()\n", + "print(\"scores:\", space.uncertain_paths())\n", + "# the expected costs of TAT-C's deployments (with the components' mean growth), against the counts of Test 2\n", + "for name, deployments in DEPLOYMENTS.items():\n", + " estimates = {c: MODEL.estimate(d) for c, d in deployments.items()}\n", + " print(\n", + " f\"{name}: blocks {[e.blocks for e in estimates.values()]}, units {[e.units for e in estimates.values()]}, \"\n", + " + f\"expected cost {sum(e.total for e in estimates.values()):.4f}\"\n", + " )\n", + "\n", + "\n", + "def build(design):\n", + " return design.constellation\n", + "\n", + "\n", + "def published(constellation, design):\n", + " \"\"\"The cost of the published numbers of developments and units, drawn in the replicate.\"\"\"\n", + " drawn = MODEL.draw(design.cost_risk)\n", + " cost = 0.0\n", + " for c, (developments, first, later) in PUBLISHED[constellation].items():\n", + " configuration = drawn.satellites[c]\n", + " # developments and first units are counted alike: each block costs Dev + T1 - Ta, and each unit Ta\n", + " cost += developments * configuration.total_development\n", + " cost += (first + later) * configuration.total_first_unit\n", + " return {\"cost\": cost}\n", + "\n", + "\n", + "def deployed(constellation, design):\n", + " \"\"\"TAT-C's estimate of the cost of the constellation's deployments, drawn in the replicate.\"\"\"\n", + " drawn = MODEL.draw(design.cost_risk)\n", + " return {\n", + " \"cost\": sum(\n", + " drawn.estimate(d).total for d in DEPLOYMENTS[constellation].values()\n", + " )\n", + " }\n", + "\n", + "\n", + "EVALUATIONS = {\n", + " \"published counts\": (published, PUBLISHED),\n", + " \"TAT-C deployments\": (deployed, COUNTS[\"TAT-C, units launched\"]),\n", + "}\n", + "results = {\n", + " (name, draws): Study(\n", + " space,\n", + " build,\n", + " evaluate,\n", + " replicates=REPLICATES,\n", + " common_random_numbers=draws == \"common\",\n", + " ).run(designs)\n", + " for name, (evaluate, _) in EVALUATIONS.items()\n", + " for draws in (\"common\", \"independent\")\n", + "}\n", + "wide = {\n", + " key: frame.pivot(index=\"replicate\", columns=\"constellation\", values=\"cost\")\n", + " for key, frame in results.items()\n", + "}\n", + "\n", + "\n", + "def statistics(mean, covariance):\n", + " std = np.sqrt(np.diag(covariance))\n", + " return {\n", + " \"E[C1]\": mean[0],\n", + " \"E[C2]\": mean[1],\n", + " \"std C1\": std[0],\n", + " \"std C2\": std[1],\n", + " \"cov (millionths)\": covariance[0, 1] * 1e6,\n", + " \"correlation\": covariance[0, 1] / (std[0] * std[1]),\n", + " }\n", + "\n", + "\n", + "rows = {\n", + " \"paper (eqs. 6 and 8)\": statistics(\n", + " [8.27, 8.93], np.array([[116118, 28260], [28260, 50757]]) * 1e-6\n", + " )\n", + "}\n", + "for name, (_, table) in EVALUATIONS.items():\n", + " rows[f\"{name}: expected\"] = statistics(*moments(table))\n", + " sample = wide[name, \"common\"]\n", + " rows[f\"{name}: replicates\"] = statistics(\n", + " sample.mean().to_numpy(), np.cov(sample.to_numpy().T)\n", + " )\n", + "print(\n", + " f\"standard errors of the means of the replicates: {wide['published counts', 'common'].std().max() / math.sqrt(REPLICATES):.4f}\"\n", + ")\n", + "pd.DataFrame(rows).T.round(4)" + ] + }, + { + "cell_type": "markdown", + "id": "e31bfc64", + "metadata": {}, + "source": [ + "With the published counts, the replicates reproduce the expected costs, standard deviations, and covariance of eqs. (6) and (8) within their sampling errors: 0.0024 for the means, 0.0017 and 0.0011 for the standard deviations, and about 580 millionths for the covariance (whose correlation is 0.37). TAT-C's estimates of its deployments, with the components' mean growth, match the expected costs of their counts exactly, and their replicates match their own expectations as closely. Their standard deviations are within 0.006 of the paper's, as the units left out at the end are a small part of each constellation's variance. Most of C1's variance is L3e's (its less mature payload makes its block the most uncertain), and most of C2's is G4c's.\n", + "\n", + "The distributions of the costs of the replicates (Fig. 2 of the paper) with the normal distributions of eqs. (6) and (8):" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "caff9d73", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-13T17:11:45.582282Z", + "iopub.status.busy": "2026-11-13T17:11:45.582282Z", + "iopub.status.idle": "2026-11-13T17:11:45.766966Z", + "shell.execute_reply": "2026-11-13T17:11:45.766966Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 3.6))\n", + "x = np.linspace(7, 10, 400)\n", + "paper = {\"C1\": (8.27, 0.34), \"C2\": (8.93, 0.23)}\n", + "for name, color, side in zip(CONSTELLATIONS, [BLUE, ORANGE], [-1, 1]):\n", + " sample = wide[\"published counts\", \"common\"][name]\n", + " ax.hist(\n", + " sample,\n", + " bins=72,\n", + " range=(7, 10),\n", + " density=True,\n", + " color=color,\n", + " alpha=0.35,\n", + " label=f\"{name}, TAT-C replicates\",\n", + " )\n", + " ax.plot(\n", + " x,\n", + " stats.norm.pdf(x, *paper[name]),\n", + " color=color,\n", + " lw=2,\n", + " label=f\"{name}, paper (normal)\",\n", + " )\n", + " peak = stats.norm.pdf(paper[name][0], *paper[name])\n", + " # labeled on the outer side of each peak, clear of the other distribution\n", + " ax.annotate(\n", + " f\"{name}: mean {sample.mean():.2f}, std {sample.std():.2f}\",\n", + " (paper[name][0] + side * 0.6 * paper[name][1], 0.85 * peak),\n", + " xytext=(side * 6, 0),\n", + " textcoords=\"offset points\",\n", + " ha=\"left\" if side > 0 else \"right\",\n", + " color=INK,\n", + " fontsize=9,\n", + " )\n", + "ax.set(xlabel=\"Relative total program cost\", ylabel=\"Probability density\", xlim=(7, 10))\n", + "ax.spines[[\"top\", \"right\"]].set_visible(False)\n", + "ax.legend(frameon=False, fontsize=8, loc=\"upper left\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "71b64aab", + "metadata": {}, + "source": [ + "## Test 4: Order of Costs\n", + "\n", + "The probability that C2 costs more than C1 is, for the replicates, the share of replicates in which it does (`exceedance`, which counts ties as half). With common random numbers, both constellations draw the same scores in each replicate, so their costs are correlated by the configuration they share, as in eq. (15). With independent draws, they are not. The share of the variance of each constellation's cost, and of the difference of their costs, that each configuration's score causes is estimated with `attribute_variance` (by redrawing each score in turn, in 10,000 replicates of each design) and `Attribution.differences`, against the exact shares of the linear model (the square of each configuration's exposure, times its variance, over the variance of the cost)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "4df699ad", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-13T17:11:45.767965Z", + "iopub.status.busy": "2026-11-13T17:11:45.767965Z", + "iopub.status.idle": "2026-11-13T17:12:19.164672Z", + "shell.execute_reply": "2026-11-13T17:12:19.164672Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "paper: P(C2 > C1) = 0.978 (Fig. 3)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
P(C2 > C1), expectedP(C2 > C1), replicatesstandard errormean difference
costsdraws
published countscommon0.97790.97820.00100.6647
independent0.94910.94750.00160.6690
TAT-C deploymentscommon0.95900.95910.00140.5721
independent0.92290.92250.00190.5764
\n", + "
" + ], + "text/plain": [ + " P(C2 > C1), expected P(C2 > C1), replicates \\\n", + "costs draws \n", + "published counts common 0.9779 0.9782 \n", + " independent 0.9491 0.9475 \n", + "TAT-C deployments common 0.9590 0.9591 \n", + " independent 0.9229 0.9225 \n", + "\n", + " standard error mean difference \n", + "costs draws \n", + "published counts common 0.0010 0.6647 \n", + " independent 0.0016 0.6690 \n", + "TAT-C deployments common 0.0014 0.5721 \n", + " independent 0.0019 0.5764 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
exact shareTAT-C sharestandard errorexact variance (millionths)
costconfiguration
C1G4c0.1640.1640.00319035.599
L3e0.8360.8410.01097082.544
L4f0.0000.0000.0000.000
C2G4c0.8270.8340.01041957.088
L3e0.0000.0000.0000.000
L4f0.1730.1720.0038800.728
C2 - C1G4c0.0410.0410.0014470.893
L3e0.8800.8850.01097082.544
L4f0.0800.0790.0018800.728
\n", + "
" + ], + "text/plain": [ + " exact share TAT-C share standard error \\\n", + "cost configuration \n", + "C1 G4c 0.164 0.164 0.003 \n", + " L3e 0.836 0.841 0.010 \n", + " L4f 0.000 0.000 0.000 \n", + "C2 G4c 0.827 0.834 0.010 \n", + " L3e 0.000 0.000 0.000 \n", + " L4f 0.173 0.172 0.003 \n", + "C2 - C1 G4c 0.041 0.041 0.001 \n", + " L3e 0.880 0.885 0.010 \n", + " L4f 0.080 0.079 0.001 \n", + "\n", + " exact variance (millionths) \n", + "cost configuration \n", + "C1 G4c 19035.599 \n", + " L3e 97082.544 \n", + " L4f 0.000 \n", + "C2 G4c 41957.088 \n", + " L3e 0.000 \n", + " L4f 8800.728 \n", + "C2 - C1 G4c 4470.893 \n", + " L3e 97082.544 \n", + " L4f 8800.728 " + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import attribute_variance, exceedance\n", + "\n", + "key = {d.key: d.constellation for d in designs}\n", + "rows = []\n", + "for name, (_, table) in EVALUATIONS.items():\n", + " for draws in (\"common\", \"independent\"):\n", + " compared = exceedance(results[name, draws], \"cost\", designs)\n", + " row = compared[\n", + " (compared.design.map(key) == \"C2\") & (compared.other.map(key) == \"C1\")\n", + " ].iloc[0]\n", + " p = row.exceedance\n", + " rows.append(\n", + " {\n", + " \"costs\": name,\n", + " \"draws\": draws,\n", + " \"P(C2 > C1), expected\": probability_exceeds(\n", + " *moments(table, correlated=draws == \"common\")\n", + " )[1],\n", + " \"P(C2 > C1), replicates\": p,\n", + " \"standard error\": math.sqrt(p * (1 - p) / row.replicates),\n", + " \"mean difference\": row[\"cost difference\"],\n", + " }\n", + " )\n", + "print(\"paper: P(C2 > C1) = 0.978 (Fig. 3)\")\n", + "display(pd.DataFrame(rows).set_index([\"costs\", \"draws\"]).round(4))\n", + "\n", + "# the shares of the variance of each cost, and of the difference, that each configuration's score causes\n", + "attribution = attribute_variance(\n", + " Study(space, build, published, replicates=10_000), [\"cost\"], designs\n", + ")\n", + "c1, c2 = (\n", + " next(d for d in designs if d.constellation == name) for name in CONSTELLATIONS\n", + ")\n", + "difference = attribution.differences([(c2, c1)])\n", + "ba = exposures(PUBLISHED)\n", + "variance = np.array([VARIANCE_Q[c] for c in CONFIGURATIONS])\n", + "exact = {\n", + " \"C1\": ba[0] ** 2 * variance,\n", + " \"C2\": ba[1] ** 2 * variance,\n", + " \"C2 - C1\": (ba[1] - ba[0]) ** 2 * variance,\n", + "}\n", + "rows = []\n", + "for label, shares in [\n", + " (\"C1\", attribution.shares[attribution.shares.design == c1.key]),\n", + " (\"C2\", attribution.shares[attribution.shares.design == c2.key]),\n", + " (\"C2 - C1\", difference.shares),\n", + "]:\n", + " for c, part in zip(CONFIGURATIONS, exact[label]):\n", + " share = shares[shares.parameter == f\"cost_risk.{c}\"].iloc[0]\n", + " rows.append(\n", + " {\n", + " \"cost\": label,\n", + " \"configuration\": c,\n", + " \"exact share\": part / exact[label].sum(),\n", + " \"TAT-C share\": share.total,\n", + " \"standard error\": share[\"total se\"],\n", + " \"exact variance (millionths)\": part * 1e6,\n", + " }\n", + " )\n", + "pd.DataFrame(rows).set_index([\"cost\", \"configuration\"]).round(3)" + ] + }, + { + "cell_type": "markdown", + "id": "13f0a6d9", + "metadata": {}, + "source": [ + "`exceedance` reproduces the paper's probability: with the published counts and common random numbers, C2 costs more than C1 in 97.8% of the replicates (97.82% against 97.79% expected, with a standard error of 0.10%). With independent draws, it does in 94.8% (94.9% expected). With TAT-C's own deployments, the probabilities are those expected of their counts: 95.9% and 92.3%. The shares of variance that `attribute_variance` estimates match the exact shares within about one standard error (0.001 to 0.010).\n", + "\n", + "The shares show why sharing G4c settles the order. G4c is 16% of the variance of C1's cost and 83% of C2's, but 4% of the variance of their difference: of its variance in C1 (19,000 millionths) and in C2 (42,000 millionths), 4,500 remain in the difference, since a costlier G4c raises both. The variance of the difference (110,000 millionths, against 167,000 if the costs were independent) is mostly L3e's, which only C1 flies. The joint distribution of the costs of the replicates (Fig. 3 of the paper), with the ellipse that holds 95% of the normal distribution of eqs. (6) and (8):" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "3e371959", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-13T17:12:19.167173Z", + "iopub.status.busy": "2026-11-13T17:12:19.166169Z", + "iopub.status.idle": "2026-11-13T17:12:19.322593Z", + "shell.execute_reply": "2026-11-13T17:12:19.321609Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(1, 2, figsize=(10, 4.4), sharex=True, sharey=True)\n", + "angles = np.linspace(0, 2 * np.pi, 200)\n", + "radius = math.sqrt(stats.chi2.ppf(0.95, 2))\n", + "for ax, draws in zip(axes, (\"common\", \"independent\")):\n", + " sample = wide[\"published counts\", draws].iloc[:4000]\n", + " ax.scatter(sample.C1, sample.C2, s=4, color=BLUE, alpha=0.3, lw=0)\n", + " mean, covariance = moments(PUBLISHED, correlated=draws == \"common\")\n", + " ellipse = mean[:, None] + np.linalg.cholesky(covariance) @ (\n", + " radius * np.array([np.cos(angles), np.sin(angles)])\n", + " )\n", + " ax.plot(\n", + " *ellipse,\n", + " color=INK,\n", + " lw=1.5,\n", + " label=\"95% of the normal distribution of eqs. (6) and (8)\",\n", + " )\n", + " ax.plot(\n", + " [7, 10.5], [7, 10.5], color=GRAY, lw=1, ls=\"--\", label=\"y = x (equal costs)\"\n", + " )\n", + " above = (\n", + " wide[\"published counts\", draws].C2 > wide[\"published counts\", draws].C1\n", + " ).mean()\n", + " ax.set_title(f\"{draws.capitalize()} draws: C2 > C1 in {above:.1%}\", fontsize=10)\n", + " ax.set(xlabel=\"C1 relative total program cost\", xlim=(7, 10.5), ylim=(7.5, 10.5))\n", + " ax.spines[[\"top\", \"right\"]].set_visible(False)\n", + "axes[0].set_ylabel(\"C2 relative total program cost\")\n", + "axes[0].legend(frameon=False, fontsize=8, loc=\"upper left\")\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "173c71c3", + "metadata": {}, + "source": [ + "With common random numbers (left), the replicates fill the ellipse of eq. (8), tilted by the configuration the constellations share, and 2.2% fall below the line *y* = *x*. With independent draws (right), each cost spreads as much as before but the ellipse is not tilted, and 5.2% fall below the line.\n", + "\n", + "## Summary\n", + "\n", + "| Test | Result |\n", + "| --- | --- |\n", + "| 1. Growth by maturity (`Triangular`, `Component`, `CostModel.correlation`) | Table I's means reproduced to its three decimals (existing components 1.0403 against 1.041, rounded up in the table); standard deviations equal to SciPy's; scores correlated by 0.5 correlate the growths by 0.486, so a configuration's variance is 1.3% below eq. (2) (a correlation of 0.514 gives 0.5) |\n", + "| 2. Production blocks (`DeploymentSchedule`, `SatelliteCost.block_size`) | Table III's launches, production of later units, and developments of both blocks of G4c reproduced to the month; counted as Table III counts them, the published numbers of G4c (4.375 and 6.375 later units) and L3e reproduced, but not those of L4f (3.81 developments against 2.9); TAT-C's cost model counts whole units launched, leaving out units in production at the end of the study period |\n", + "| 3. Constellation costs (`risk_space`, `CostModel.draw`, `Study`) | with the published counts, expected costs, standard deviations, and covariance of eqs. (6) and (8) within the sampling error of 20,000 replicates (means 8.26 and 8.93, standard deviations 0.34 and 0.22); TAT-C's deployments cost 8.12 and 8.69, as their counts predict |\n", + "| 4. Order of costs (`exceedance`, `attribute_variance`) | P(C2 > C1) of 97.8% with the published counts and common random numbers (97.8% published), 94.8% with independent draws (94.9% expected); 95.9% with TAT-C's deployments; G4c is 83% of C2's variance but 4% of the variance of the difference |\n", + "\n", + "**Cost risk.** TAT-C's structured cost risk reproduces the paper's example. Configurations whose growth is drawn from scores, shared by common random numbers, give the constellations the covariance of eq. (8), and `exceedance` the probability of eq. (15), with no model of the covariance itself: what the constellations share is shared by drawing it once in each replicate. The same holds for configurations that share components or a common score, and for costs that are not linear in the growths (such as those of deployments with failures), which eq. (8) does not cover.\n", + "\n", + "**Correlation.** `CostModel.correlation` is the correlation of the normal scores of components, from which their growths are drawn; the growths of Table I's skewed distributions are correlated slightly less (0.486 for 0.5). To reproduce a FRISK estimate that correlates costs by 0.5, use a correlation of about 0.514.\n", + "\n", + "**Study periods.** The paper counts the costs of a sustained constellation over a fixed study period, including the share of the units in production at its end; TAT-C's cost model counts the satellites that a deployment launches before the end of its mission. Over 30 years, the difference is about 2% of the cost, but it falls unevenly on alternatives, and so shifts the probability that one costs more than another (here, from 97.8% to 95.9%). Comparisons of sustained constellations in TAT-C are like for like when every alternative has the same mission, or when their costs are compared per year of mission." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/validation/index.rst b/docs/validation/index.rst index 283f5aef..cb5541f4 100644 --- a/docs/validation/index.rst +++ b/docs/validation/index.rst @@ -2,7 +2,7 @@ Validation ========== -The following compare TAT-C analysis results with reference data from operational missions. The :doc:`summary` collects their headline results by capability, with modeling guidance and the limits of what TAT-C models. The :doc:`catalog` gives instruments of operational missions, ready to use, with their results against the :doc:`standard`. +The following compare TAT-C analysis results with reference data from operational missions, or with published studies. The :doc:`summary` collects their headline results by capability, with modeling guidance and the limits of what TAT-C models. The :doc:`catalog` gives instruments of operational missions, ready to use, with their results against the :doc:`standard`. .. toctree:: :maxdepth: 1 @@ -48,8 +48,9 @@ The following compare TAT-C analysis results with reference data from operationa ValidateYawFlipGPM.ipynb ValidateSampleSizes.ipynb ValidateFeaturesTCPRIMED.ipynb + ValidateCostVarianceNSOSA.ipynb -These notebooks download reference data on first run, except ``ValidateSampleSizes``, which reuses the data of the imager and conical scanner notebooks, and ``ValidateSpaceCOSMIC2``, which reuses the data of ``ValidateROCOSMIC2``. ``ValidateSpaceSOCRATES`` includes a sample of a SOCRATES run (data from CelesTrak). The MLS, NISAR, AMSR2, GMI, SWOT, ICESat-2, ECOSTRESS, PACE, MODIS, OCO-2, GPM, GRACE-FO, SMAP, and IMERG data require a free `NASA Earthdata Login `_ account, and the orbit histories of the Landsat 9, TC PRIMED, and GRACE-FO notebooks a free `Space-Track.org `_ account. The notebooks require additional dependencies, which can be installed via:: +These notebooks download reference data on first run, except ``ValidateSampleSizes``, which reuses the data of the imager and conical scanner notebooks, and ``ValidateSpaceCOSMIC2``, which reuses the data of ``ValidateROCOSMIC2``. ``ValidateSpaceSOCRATES`` includes a sample of a SOCRATES run (data from CelesTrak). ``ValidateCostVarianceNSOSA`` needs no data: its reference values are those published in the paper it reproduces. The MLS, NISAR, AMSR2, GMI, SWOT, ICESat-2, ECOSTRESS, PACE, MODIS, OCO-2, GPM, GRACE-FO, SMAP, and IMERG data require a free `NASA Earthdata Login `_ account, and the orbit histories of the Landsat 9, TC PRIMED, and GRACE-FO notebooks a free `Space-Track.org `_ account. The notebooks require additional dependencies, which can be installed via:: pip install tatc[validation] diff --git a/docs/validation/summary.rst b/docs/validation/summary.rst index fc319c2a..e0f0a096 100644 --- a/docs/validation/summary.rst +++ b/docs/validation/summary.rst @@ -4,7 +4,8 @@ Validation Summary The validation notebooks compare TAT-C's analyses with data from operational missions: recorded orbits, geolocated samples, acquisition catalogs, and -archives of observations, mostly from 2025 and 2026. This page summarizes +archives of observations, mostly from 2025 and 2026, and one compares its +trade study capabilities with a published cost analysis. This page summarizes their headline results by capability, the modeling choices they found to matter, and the limits of what TAT-C models. Each result links to the notebook with its full method, data, and figures. Results marked as held out come from the @@ -276,6 +277,29 @@ Ground Systems and Navigation - Within 0.01% (median) of an independent computation for the same satellites, including a clock per system (:doc:`ValidateDopGNSS`) +Trade Studies +============= + +.. list-table:: + :header-rows: 1 + :widths: 20 25 55 + + * - Capability + - Reference + - Result + * - Correlated cost risk (`Triangular`, `Component`, `CostModel.draw`, `risk_space`, `exceedance`) + - Maier, Yeakel, and Wendoloski (2023): two NSOSA constellations that share a geostationary configuration + - With the published numbers of blocks and units, replicates with common random numbers reproduce the + expected costs, standard deviations, and covariance of the constellations within their sampling error, and + the probability that one costs more than the other (97.8%; 94.8% with independent draws); Table I's growth + factors reproduced (:doc:`ValidateCostVarianceNSOSA`) + * - Production blocks (`DeploymentSchedule`, `SatelliteCost.block_size`) + - Launch schedules and production blocks of the same study + - Launches, production of later units, and developments of both blocks of the geostationary configuration + reproduced to the month; TAT-C counts the units launched within the mission, not the share of units in + production at the end of the study period, which lowers the costs by about 2% and the probability above to + 95.9% (:doc:`ValidateCostVarianceNSOSA`) + Modeling Guidance ================= @@ -322,6 +346,11 @@ numerical error in TAT-C: 0.16); smoothed or regional standard deviations, from climatology or another period, give calibrated sampling errors, and one regional decorrelation time suffices. +* **Correlation of cost growth.** `CostModel.correlation` correlates the normal + scores from which the growths of components are drawn; the growths of skewed + distributions are correlated slightly less (0.486 for 0.5, with the cost + growth factors of formal risk assessments). Use about 0.514 to correlate the + costs of components by 0.5. * **Navigation constellations.** Model the operational satellites (those with healthy broadcast ephemerides); public TLE groups include others, which make DOP 4 to 16% optimistic. @@ -337,6 +366,9 @@ Not Modeled * Pointing limits in `collect_space_observations`, such as an antenna's field of view, and slews between attitudes, which are instantaneous. * Acquisition plans, downlink processing time, and data gaps. +* Costs within a study period: the costs of a deployment are those of the + satellites it launches before the end of its mission, not the share of the + units in production at the end of a fixed study period. * Daily cycles of sampled fields: sampling errors model a stationary field, so sun-synchronous sampling of a field with a strong daily cycle has errors up to 25% larger than predicted, and a small bias (2 to 3% for IMERG From 8079ab1ce619ffb58d0d5785e010775efcfc7a71 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Fri, 13 Nov 2026 12:58:48 -0700 Subject: [PATCH 39/52] add a design life of each type of satellite, and sustained deployments whose costs are those incurred by the end of the mission --- CHANGELOG.md | 2 +- .../ValidateCostVarianceNSOSA.ipynb | 504 +++++++++++------- docs/validation/summary.rst | 20 +- src/tatc/tradespace/cost.py | 58 +- src/tatc/tradespace/deployment.py | 118 ++-- src/tatc/tradespace/mission.py | 18 +- tests/tradespace/test_cost.py | 35 ++ tests/tradespace/test_deployment.py | 43 ++ tests/tradespace/test_stages.py | 14 + 9 files changed, 547 insertions(+), 265 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3745698d..53e06132 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -22,7 +22,7 @@ Added: - Building blocks of constellations: fragments of design spaces of Walker constellations (`tradespace.walker_space`) and planes of sun-synchronous orbits (`sso_planes_space`, whose planes have different crossing times), `build_constellation`, which builds the satellites of either with instruments or entries of the instrument catalog (with their validated attitudes, and several entries on one satellite), and `count_satellites` and `count_planes`. The phase and node of the lead satellite of a Walker constellation (`phase_fraction` and `node_fraction`, design variables or uncertain parameters) are fractions of the intervals over which they give distinct constellations (`360 / per_plane` degrees of phase, and `360 / planes` degrees of node for a delta configuration or 360 for a star), so that a search does not evaluate the same constellation at several phases or nodes. Planes of inclined orbits (`planes_space`), each with its own inclination and node (uncertain by default, as of satellites launched as secondary payloads). The satellites of the planes of `sso_planes_space` and `planes_space` are evenly spaced, or follow each other in a train at an `interval` (minutes), on the same ground track or in the same plane (`repeat_ground_track`). The phase of each plane (`phase_fraction`, which replaces `phase` of `sso_planes_space`) is a fraction of the interval over which it gives distinct planes (`360 / satellites` degrees for evenly spaced satellites, 360 for a train), from which each fragment derives the plane's `true_anomaly`, as for the lead satellite of a Walker constellation. `build_constellation`, `count_satellites`, and `count_planes` take several layouts (a list, or a `Repeat` of a `Choice` of layouts), such as the shells of a mixed constellation. The values of each fragment in a design are those of a `Layout` (`layout_of`, with `WalkerLayout`, `SSOPlanesLayout`, `PlanesLayout`, and `Layouts` of several), which gives its `Plane`s and the orbits of their satellites in order; other layouts subclass it and are built, counted (`plane_sizes`), deployed, and costed as the others. - Function `tradespace.screen` (and class `Screening`), which screens designs with studies of increasing fidelity, keeping whole fronts of the best designs of each stage for the next. - Searches of design spaces with optional optimizers: `tradespace.optimize_optuna` suggests designs with Optuna trials (`DesignSpace.suggest`, define-by-run over the hierarchical space), and `optimize_pymoo` and `make_pymoo_problem` search the unit hypercube that encodes a design space (`DesignSpace.unit_paths`, `encode`, and `decode`) with pymoo, whose algorithms eliminate the proposals of designs proposed or evaluated before (`distinct`, by design rather than by point of the hypercube, `make_pymoo_problem`'s `duplicates`). Each design is evaluated once, and the designs proposed together are evaluated together, in parallel if the study is. A search returns its results and designs (`Search`), which `refine` and `confirm` refine and confirm as for any study. Constraints of a design space may return the amount of their violation (`Infeasible.violation`), which Optuna's trials record (`set_constraint`) for its constraint-aware samplers, and which is the constraint value of pymoo problems. Optional dependencies `tradespace` (joblib, Optuna, and pymoo). - - Deployment of constellations (`tradespace.DeploymentSchedule`): from the rates and durations of a study (the mission and design life, the development of each type of satellite, its production on a line at a production rate, and launches at a cadence and capacity, in number or mass, optionally in an order of planes), each design's deployment (`DeploymentSchedule.plan`, a `Deployment` of its `Production`, `Launch`es, and replacements), so that a design of more satellites and planes takes longer to deploy. Its launches divide the mission into phases of constant sets of operating satellites (`Deployment.phases`), evaluated over the study's representative period from the observations of the full constellation (`evaluate_phases`) and combined over the mission (`summarize_phases`: the time-weighted mean of each metric and the time until it first meets a requirement). + - Deployment of constellations (`tradespace.DeploymentSchedule`): from the rates and durations of a study (the mission, the design life, development, and production rate of each type of satellite, its production on a line, and launches at a cadence and capacity, in number or mass, optionally in an order of planes), each design's deployment (`DeploymentSchedule.plan`, a `Deployment` of its `Production`, `Launch`es, and replacements), so that a design of more satellites and planes takes longer to deploy. A sustained constellation (`DeploymentSchedule.sustained`, such as of an operational program over the period of a study) is replaced after the end of the mission as before it, and its costs are those incurred by the end, which count the units in production then by the share produced and later blocks by the share of their development done. A deployment's launches divide the mission into phases of constant sets of operating satellites (`Deployment.phases`), evaluated over the study's representative period from the observations of the full constellation (`evaluate_phases`) and combined over the mission (`summarize_phases`: the time-weighted mean of each metric and the time until it first meets a requirement). - Simulated missions with failures (`Deployment.simulate`, a `MissionHistory` for each replicate, drawn from its seed with common random numbers between designs): lives of satellites whose failure rates vary over the lifecycle (`tradespace.Exponential`, `Weibull`, `Bathtub` of competing causes, and `Piecewise` rates by age, `Lifetime`), failures of launches (`FailureModel`), and a policy that degrades or restores failed satellites (`RestorationPolicy`) by spares in orbit (taking a failed satellite's place after drifting), spares on the ground (launched at the next launch slot), or satellites produced when needed (after procurement, on the production line), optionally replenishing spares and batching restorations in launches. A history gives the phases in which satellites operate (`MissionHistory.phases`), measures of the mission (`MissionHistory.metrics`: failures, restorations, spares used, time to restore, and availability), and, priced by a `CostModel`, the cost of what it produces and launches. Policies are decisions of designs with a fragment of a design space (`policy_space`: whether to restore, spares in orbit and on the ground, and other fields of the policy, without spares that would never be used), and `configure` makes a policy (or a deployment schedule, or another dataclass) from the values of a design. Many histories of a replicate's mission (`Deployment.simulate_many`) share its sample of targets: `evaluate_missions` evaluates them (with their measures and costs) with a cache that evaluates each set of operating satellites once (`PhaseCache`, keyed by the content of the satellites and shared by the histories, policies, and designs of a replicate), and `summarize_missions` gives their means, quantiles (the risk of the mission), and probabilities of meeting requirements, as one record of the replicate. The histories of a replicate are stratified by default (a Latin hypercube over the histories of each satellite's life and each launch, drawn from uniform numbers by `Lifetime.from_uniform`), which estimates the means of missions 3 to 15 times more precisely than independent histories, and means may be estimated with control variates (`summarize_missions(controls=...)`, such as the availability of the mission, whose expected value simulations alone estimate, `Deployment.expected_metrics`). `allocate_histories` recommends the histories of each replicate (and the replicates, for a standard error) from a pilot with independent histories, by the variances between replicates and between histories and their costs (`summarize_missions(spread=True)` gives the standard deviations of the histories). `expected_missions` computes the expected capability and availability of a mission without restoration exactly (the sets of operating satellites by their probabilities, from the survival of each launch group, with planned replacements), without sampling error. Histories may be drawn from stressed failures for importance sampling (`simulate_many(stress=...)`: hazards and launch failures times a factor, each history weighted by its likelihood ratio censored at the end of the mission, `Lifetime.stressed` and `MissionHistory.weight`), which `summarize_missions` weighs in every statistic, with the effective number of histories: the probabilities of rare losses with 30 to 70 times less variance. - Life-cycle costs of deployments for trade studies (`tradespace.CostModel`): the development of each type of satellite, the production of its units on a learning curve (`SatelliteCost`), launches (per launch, or prices per satellite and kg, `LaunchCost`), operations (`OperationsCost`), replacements, and spares in orbit, dated by the deployment for their present value at a discount rate (`CostEstimate.present_value`, metric `cost present`) and annual costs (`CostEstimate.annual`, metric `cost peak annual`), with growth factors for cost risk (such as uncertain parameters, whose quantiles over replicates give the cost at a confidence level). TAT-C does not include cost-estimating relationships: the costs are given by the study. Fingerprints describe dataclasses (such as cost models) by their fields. - Function `tradespace.confirm` (and class `Confirmation`), which evaluates selected designs (such as a front) with new replicates that played no part in their selection, removing the optimism of the selection (the winner's curse, `Confirmation.optimism`). `ResultStore` keys evaluations by the fingerprint of a study (`Study.fingerprint`, a hash of `Study.definition`, see `get_definition`: its seed, use of common random numbers, design space, and build and evaluation functions, with the data frames they are given described by their content, the version of Python, and the source of the modules of TAT-C and resource files they depend on, found from their imports) and keeps each definition, so that variants of a study share a store without mixing their evaluations, and a study warns of evaluations of the same study with other code (of its functions, of TAT-C, or of Python), which are not reused, naming what differs (`fingerprint.compare_definitions`); `ResultStore.prune` removes them. Changes to TAT-C that a study does not depend on (such as to modules it does not use) keep its results. Namespaces of stores and caches are optional, for what fingerprints cannot see (data that functions read from files, and the code of other modules). `refine` treats designs with fewer than `min_replicates` (5) as uncertain whatever their probability, adds the replicates left to `max_replicates` in a last partial step, and warns if designs remain uncertain without a tolerance. `sensitivity` gives adjusted shares (epsilon squared) by default, without the share that the levels of a variable explain by chance (`adjusted=False` for correlation ratios). diff --git a/docs/validation/ValidateCostVarianceNSOSA.ipynb b/docs/validation/ValidateCostVarianceNSOSA.ipynb index 53172a97..8f304565 100644 --- a/docs/validation/ValidateCostVarianceNSOSA.ipynb +++ b/docs/validation/ValidateCostVarianceNSOSA.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "2467114e", + "id": "0c531f02", "metadata": {}, "source": [ "# Cost Variance Validation: NSOSA Constellations\n", @@ -10,7 +10,7 @@ "Architecture studies of satellite constellations compare alternatives whose costs are uncertain and correlated: alternatives that share a satellite design share its cost risk. Maier, Yeakel, and Wendoloski (\"Cost Variance Analysis in Constellation Architecture Studies,\" *IEEE Systems Journal* 17(2), 1928–1938, 2023, [doi:10.1109/JSYST.2022.3218598](https://doi.org/10.1109/JSYST.2022.3218598)) model the uncertain cost of each satellite configuration from the growth of its components by their maturity (the formal risk assessment of system cost estimates, FRISK). They extend it to constellations whose configurations are produced in blocks over decades, and work through two constellations of the NOAA Satellite Observing System Architecture (NSOSA) study that share a geostationary configuration, whose order of cost depends on what they share. TAT-C's `tradespace` module models the same structure: the growth of components by maturity (`Triangular`, `Component`), correlated within a cost model (`CostModel.correlation`); types of satellites produced in blocks (`SatelliteCost.block_size`); deployments from launch schedules (`DeploymentSchedule`); and scores of the cost risk drawn as uncertain parameters (`risk_space`, `CostModel.draw`), which common random numbers share between the designs of a `Study`, compared with `exceedance`. This notebook reproduces the paper's example and asks:\n", "\n", "1. **Growth by maturity.** Do `Triangular` growths reproduce the cost growth factors of Table I, and does `CostModel.correlation` reproduce the variance of a configuration of correlated components (eq. 2)?\n", - "2. **Production blocks.** Does `DeploymentSchedule` reproduce the launches and production blocks of the configurations from their launch schedules (Tables II and III), and the numbers of developments, first units, and later units of each constellation (matrix *B* of eq. 5)?\n", + "2. **Production blocks.** Does `DeploymentSchedule` reproduce the launches and production blocks of the configurations from their launch schedules (Tables II and III), and does `CostModel.estimate` count the developments, first units, and later units of each constellation over the study period (matrix *B* of eq. 5)?\n", "3. **Constellation costs.** Do the replicates of a `Study` reproduce the means, variances, and covariance of the costs of the two constellations (eqs. 6 and 8, Fig. 2)?\n", "4. **Order of costs.** Does `exceedance` reproduce the probability that one constellation costs more than the other (eqs. 9 to 15, Fig. 3), and how much of it comes from the configuration they share?\n", "\n", @@ -19,7 +19,7 @@ }, { "cell_type": "markdown", - "id": "80f73ec6", + "id": "fb98d147", "metadata": {}, "source": [ "## Reference Data\n", @@ -37,13 +37,13 @@ { "cell_type": "code", "execution_count": 1, - "id": "dc72e779", + "id": "713ba549", "metadata": { "execution": { - "iopub.execute_input": "2026-11-13T17:10:00.253846Z", - "iopub.status.busy": "2026-11-13T17:10:00.253846Z", - "iopub.status.idle": "2026-11-13T17:10:01.714921Z", - "shell.execute_reply": "2026-11-13T17:10:01.714921Z" + "iopub.execute_input": "2026-11-13T19:42:53.191079Z", + "iopub.status.busy": "2026-11-13T19:42:53.191079Z", + "iopub.status.idle": "2026-11-13T19:42:54.678456Z", + "shell.execute_reply": "2026-11-13T19:42:54.677459Z" } }, "outputs": [ @@ -249,7 +249,7 @@ }, { "cell_type": "markdown", - "id": "c6e246b0", + "id": "b2d91888", "metadata": {}, "source": [ "The published inputs reproduce the published results, within the rounding of *A*'s shares: expected costs of 8.26 and 8.93 (eq. 6 gives 8.27 and 8.93, and Fig. 2 gives 8.27 and 8.94), standard deviations of 0.34 and 0.23, the covariance matrix of eq. (8) within one millionth, and a probability of 97.8% that C2 costs more than C1 (eq. 15, equal to the closed form). If the costs of the two constellations were independent, the probability would be 94.9%: the shared configuration G4c makes the order more certain.\n", @@ -264,13 +264,13 @@ { "cell_type": "code", "execution_count": 2, - "id": "c35c2309", + "id": "bee8a3c4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-13T17:10:01.716352Z", - "iopub.status.busy": "2026-11-13T17:10:01.716352Z", - "iopub.status.idle": "2026-11-13T17:10:07.395850Z", - "shell.execute_reply": "2026-11-13T17:10:07.394949Z" + "iopub.execute_input": "2026-11-13T19:42:54.680457Z", + "iopub.status.busy": "2026-11-13T19:42:54.680457Z", + "iopub.status.idle": "2026-11-13T19:43:00.311731Z", + "shell.execute_reply": "2026-11-13T19:43:00.310738Z" } }, "outputs": [ @@ -515,7 +515,7 @@ }, { "cell_type": "markdown", - "id": "2d79d7b2", + "id": "65f2a574", "metadata": {}, "source": [ "`Triangular` reproduces Table I: its means equal the published means to the table's three decimals for four of the five maturities. The fifth, existing components, is 1.0403 against the published 1.041; the mean of (0.981, 1, 1.140) is 1.0403, so the table's last digit is rounded up. Its standard deviations equal SciPy's, and the replicates drawn through `CostModel.draw` reproduce the means and standard deviations within their sampling errors (at most 0.0023 for the means).\n", @@ -526,25 +526,26 @@ "\n", "The paper costs each configuration over 2020 to 2050 in blocks of four satellites. Each block is a new design, whose development (Dev) and first unit (T1) are paid again, followed by three later units (Ta). In TAT-C, a type of satellite with `block_size=4` (and `redevelopment=1`, a full redesign) develops each block after the first before the production of the block's first unit, over the type's development time (see `CostModel.estimate`).\n", "\n", - "A `DeploymentSchedule` plans each configuration's deployment:\n", + "A `DeploymentSchedule` plans the deployment of each constellation, with the design life, development time, and production rate of each configuration (mappings by kind):\n", "\n", - "* **Launches.** A design life equal to the launch interval launches a replacement at that interval from the first launch, until the end of the mission (here, the end of September 2050).\n", + "* **Launches.** A design life equal to a configuration's launch interval launches a replacement at that interval from its first launch.\n", "* **Production.** Each launch's satellites are produced over the four years before it, as Table III's later units are.\n", "* **Development.** Development runs from the start (1 March 2020, when Table III begins G4c's first development) to the production of the first unit.\n", + "* **Study period.** The mission ends at the end of September 2050, and the constellation is `sustained`: replaced after the end as before it. The units in production at the end are then produced (though not launched in the mission), and the costs of the deployment are those incurred by the end, which count each development and each unit by the share done (see `CostModel.estimate`).\n", "\n", - "The satellites of one deployment share a design life, so each configuration is planned with its own schedule, and the cost of a constellation is the sum of the costs of its configurations. The layout of a configuration is its slots: a subclass of `Layout`, which needs only its planes to be deployed and costed (the orbits matter only to build the satellites)." + "The layout of a configuration is its slots: a subclass of `Layout`, which needs only its planes to be deployed and costed (the orbits matter only to build the satellites)." ] }, { "cell_type": "code", "execution_count": 3, - "id": "156026e5", + "id": "1a3450b1", "metadata": { "execution": { - "iopub.execute_input": "2026-11-13T17:10:07.397851Z", - "iopub.status.busy": "2026-11-13T17:10:07.397851Z", - "iopub.status.idle": "2026-11-13T17:10:07.426328Z", - "shell.execute_reply": "2026-11-13T17:10:07.426328Z" + "iopub.execute_input": "2026-11-13T19:43:00.313930Z", + "iopub.status.busy": "2026-11-13T19:43:00.312735Z", + "iopub.status.idle": "2026-11-13T19:43:00.340975Z", + "shell.execute_reply": "2026-11-13T19:43:00.340975Z" } }, "outputs": [ @@ -757,35 +758,40 @@ " return [Plane(self.count)]\n", "\n", "\n", - "def plan(configuration, first, months, satellites, end=END):\n", - " \"\"\"The deployment of a configuration: launches at an interval from the first, until the end.\"\"\"\n", + "def plan(name, sustained=True):\n", + " \"\"\"The deployment of a constellation: each configuration launched at its interval from its first launch.\"\"\"\n", + " configurations = SCHEDULES[name]\n", " schedule = DeploymentSchedule(\n", - " years=end - first,\n", - " design_life=months / 12,\n", - " development_years=first - PRODUCTION_YEARS,\n", - " production_rate=satellites / PRODUCTION_YEARS,\n", + " years=END - min(first for first, _, _ in configurations.values()),\n", + " design_life={c: months / 12 for c, (_, months, _) in configurations.items()},\n", + " development_years={\n", + " c: first - PRODUCTION_YEARS for c, (first, _, _) in configurations.items()\n", + " },\n", + " production_rate={\n", + " c: satellites / PRODUCTION_YEARS\n", + " for c, (_, _, satellites) in configurations.items()\n", + " },\n", + " sustained=sustained,\n", + " )\n", + " return schedule.plan(\n", + " {c: Slots(satellites) for c, (_, _, satellites) in configurations.items()}\n", " )\n", - " return schedule.plan(Slots(satellites), kind=configuration)\n", "\n", "\n", - "DEPLOYMENTS = {\n", - " name: {c: plan(c, *s) for c, s in configurations.items()}\n", - " for name, configurations in SCHEDULES.items()\n", - "}\n", - "for name, deployments in DEPLOYMENTS.items():\n", - " for c, deployment in deployments.items():\n", - " print(\n", - " f\"{name} {c}: launches in\",\n", - " \", \".join(month(l.time) for l in deployment.launches),\n", - " )\n", + "DEPLOYMENTS = {name: plan(name) for name in SCHEDULES}\n", + "for name, deployment in DEPLOYMENTS.items():\n", + " for c in SCHEDULES[name]:\n", + " launches = [l.time for l in deployment.launches if l.kind == c]\n", + " print(f\"{name} {c}: launches in\", \", \".join(month(t) for t in launches))\n", "\n", "\n", - "def shares_produced(deployment, end=END):\n", - " \"\"\"The share of each unit of a deployment produced by the end, in the order of production.\"\"\"\n", + "def shares_produced(deployment, configuration):\n", + " \"\"\"The share of each unit of a configuration produced by the end, in the order of production.\"\"\"\n", " shares = []\n", " for batch in deployment.production:\n", - " done = (end - batch.begin) / (batch.end - batch.begin)\n", - " shares += [min(max(done, 0.0), 1.0)] * batch.satellites\n", + " if batch.kind == configuration:\n", + " done = (END - batch.begin) / (batch.end - batch.begin)\n", + " shares += [min(max(done, 0.0), 1.0)] * batch.satellites\n", " return shares\n", "\n", "\n", @@ -802,13 +808,12 @@ " ],\n", " columns=[\"development\", \"production\", \"launch\", \"counted\"],\n", ")\n", - "# planned past the end, for the units in production at the end\n", - "extended = plan(\"G4c\", *SCHEDULES[\"C1\"][\"G4c\"], end=END + 5)\n", - "developed = extended.development[\"G4c\"]\n", + "c1 = DEPLOYMENTS[\"C1\"]\n", + "developed = c1.development[\"G4c\"]\n", + "# the units of G4c in production by the end, including the one launched after it\n", + "batches = [b for b in c1.production if b.kind == \"G4c\" and b.begin < END]\n", "table3 = []\n", - "for unit, (batch, launch, share) in enumerate(\n", - " zip(extended.production, extended.launches, shares_produced(extended))\n", - "):\n", + "for unit, (batch, share) in enumerate(zip(batches, shares_produced(c1, \"G4c\"))):\n", " first = unit % BLOCK_SIZE == 0\n", " table3.append(\n", " {\n", @@ -818,7 +823,7 @@ " month(max(batch.begin - developed, 0)) if first else None\n", " ),\n", " \"TAT-C production\": month(batch.begin),\n", - " \"TAT-C launch\": month(launch.time),\n", + " \"TAT-C launch\": month(batch.end), # each unit is produced until its launch\n", " \"TAT-C counted\": share,\n", " }\n", " )\n", @@ -828,24 +833,24 @@ }, { "cell_type": "markdown", - "id": "160dc0ea", + "id": "f90da62e", "metadata": {}, "source": [ - "TAT-C's deployment of G4c in C1 reproduces Table III's launches, the production of its later units, and the starts of development of both blocks (March 2020 and March 2036). With development ending as production begins, the second block's development takes the 5.1 years before its first unit's production (April 2041), which starts it in March 2036, as Table III does. Table III's Phases B and C start the first unit's production earlier (September 2023, 5.6 years before launch), where TAT-C produces every unit over four years: the dates of the first units' costs differ, not their amounts.\n", + "TAT-C's deployment of G4c in C1 reproduces Table III's launches, the production of its later units, and the starts of development of both blocks (March 2020 and March 2036). With development ending as production begins, the second block's development takes the 5.1 years before its first unit's production (April 2041), which starts it in March 2036, as Table III does. Table III's Phases B and C start the first unit's production earlier (September 2023, 5.6 years before launch), where TAT-C produces every unit over four years: the dates of the first units' costs differ, not their amounts. The sustained deployment produces the unit launched in April 2053 from April 2049: 18 of its 48 months by the end of September 2050, or 0.375 of it (Table III's 0.37).\n", "\n", - "The two conventions differ at the end of the study period. Table III counts the share of a unit produced by the end of September 2050 (18 of the 48 months of the unit launched in April 2053, 0.37), and so does the last column of TAT-C's counts above (0.375, from a deployment planned past the end). TAT-C's cost model counts the units that the deployment launches before the end of its mission. The numbers of each constellation:" + "TAT-C's estimate counts the developments and units of a configuration as costs. A model that costs 1 for each development and each unit of one configuration (and nothing for the others) gives the number of developments, *D*, and of units, *U*, each counted by the share done by the end. With each block's first-unit premium (T1 − Ta) charged with its development, as Test 3 costs the configurations, these cost as *D* developments and first units and *U* − *D* later units, the form of *B*. The counts of each constellation are below, together with two alternatives: TAT-C's dates counted as Table III counts them (each block's development with the share of its first unit produced), and a mission that is not sustained, whose costs are those of the units it launches by its end." ] }, { "cell_type": "code", "execution_count": 4, - "id": "64739846", + "id": "57810fa2", "metadata": { "execution": { - "iopub.execute_input": "2026-11-13T17:10:07.428322Z", - "iopub.status.busy": "2026-11-13T17:10:07.428322Z", - "iopub.status.idle": "2026-11-13T17:10:07.501848Z", - "shell.execute_reply": "2026-11-13T17:10:07.501848Z" + "iopub.execute_input": "2026-11-13T19:43:00.342785Z", + "iopub.status.busy": "2026-11-13T19:43:00.342785Z", + "iopub.status.idle": "2026-11-13T19:43:00.436893Z", + "shell.execute_reply": "2026-11-13T19:43:00.435865Z" } }, "outputs": [ @@ -889,22 +894,29 @@ " \n", " \n", " \n", - " C1\n", - " G4c\n", - " TAT-C, share produced\n", + " C1\n", + " G4c\n", + " TAT-C's dates, counted as Table III\n", " 2.0000\n", " 2.0000\n", " 4.3750\n", " 4.6125\n", " \n", " \n", - " TAT-C, units launched\n", + " TAT-C, mission\n", " 2.0000\n", " 2.0000\n", " 4.0000\n", " 4.4689\n", " \n", " \n", + " TAT-C, study period\n", + " 2.0000\n", + " 2.0000\n", + " 4.3750\n", + " 4.6125\n", + " \n", + " \n", " paper\n", " 2.0000\n", " 2.0000\n", @@ -912,15 +924,22 @@ " 4.6106\n", " \n", " \n", - " L3e\n", - " TAT-C, share produced\n", + " L3e\n", + " TAT-C's dates, counted as Table III\n", + " 2.0000\n", + " 2.0000\n", + " 3.0000\n", + " 3.6487\n", + " \n", + " \n", + " TAT-C, mission\n", " 2.0000\n", " 2.0000\n", " 3.0000\n", " 3.6487\n", " \n", " \n", - " TAT-C, units launched\n", + " TAT-C, study period\n", " 2.0000\n", " 2.0000\n", " 3.0000\n", @@ -934,22 +953,29 @@ " 3.6487\n", " \n", " \n", - " C2\n", - " G4c\n", - " TAT-C, share produced\n", + " C2\n", + " G4c\n", + " TAT-C's dates, counted as Table III\n", " 3.0000\n", " 3.0000\n", " 6.3750\n", " 6.8469\n", " \n", " \n", - " TAT-C, units launched\n", + " TAT-C, mission\n", " 3.0000\n", " 3.0000\n", " 6.0000\n", " 6.7033\n", " \n", " \n", + " TAT-C, study period\n", + " 3.0000\n", + " 3.0000\n", + " 6.3750\n", + " 6.8469\n", + " \n", + " \n", " paper\n", " 3.0000\n", " 3.0000\n", @@ -957,21 +983,28 @@ " 6.8450\n", " \n", " \n", - " L4f\n", - " TAT-C, share produced\n", + " L4f\n", + " TAT-C's dates, counted as Table III\n", " 3.8125\n", " 3.8125\n", " 9.8125\n", " 2.4059\n", " \n", " \n", - " TAT-C, units launched\n", + " TAT-C, mission\n", " 3.0000\n", " 3.0000\n", " 9.0000\n", " 1.9900\n", " \n", " \n", + " TAT-C, study period\n", + " 4.0000\n", + " 4.0000\n", + " 9.6250\n", + " 2.4736\n", + " \n", + " \n", " paper\n", " 2.9000\n", " 2.9000\n", @@ -983,35 +1016,81 @@ "" ], "text/plain": [ - " Dev T1 Ta \\\n", - "constellation configuration count \n", - "C1 G4c TAT-C, share produced 2.0000 2.0000 4.3750 \n", - " TAT-C, units launched 2.0000 2.0000 4.0000 \n", - " paper 2.0000 2.0000 4.3700 \n", - " L3e TAT-C, share produced 2.0000 2.0000 3.0000 \n", - " TAT-C, units launched 2.0000 2.0000 3.0000 \n", - " paper 2.0000 2.0000 3.0000 \n", - "C2 G4c TAT-C, share produced 3.0000 3.0000 6.3750 \n", - " TAT-C, units launched 3.0000 3.0000 6.0000 \n", - " paper 3.0000 3.0000 6.3700 \n", - " L4f TAT-C, share produced 3.8125 3.8125 9.8125 \n", - " TAT-C, units launched 3.0000 3.0000 9.0000 \n", - " paper 2.9000 2.9000 10.8000 \n", + " Dev \\\n", + "constellation configuration count \n", + "C1 G4c TAT-C's dates, counted as Table III 2.0000 \n", + " TAT-C, mission 2.0000 \n", + " TAT-C, study period 2.0000 \n", + " paper 2.0000 \n", + " L3e TAT-C's dates, counted as Table III 2.0000 \n", + " TAT-C, mission 2.0000 \n", + " TAT-C, study period 2.0000 \n", + " paper 2.0000 \n", + "C2 G4c TAT-C's dates, counted as Table III 3.0000 \n", + " TAT-C, mission 3.0000 \n", + " TAT-C, study period 3.0000 \n", + " paper 3.0000 \n", + " L4f TAT-C's dates, counted as Table III 3.8125 \n", + " TAT-C, mission 3.0000 \n", + " TAT-C, study period 4.0000 \n", + " paper 2.9000 \n", "\n", - " expected cost \n", - "constellation configuration count \n", - "C1 G4c TAT-C, share produced 4.6125 \n", - " TAT-C, units launched 4.4689 \n", - " paper 4.6106 \n", - " L3e TAT-C, share produced 3.6487 \n", - " TAT-C, units launched 3.6487 \n", - " paper 3.6487 \n", - "C2 G4c TAT-C, share produced 6.8469 \n", - " TAT-C, units launched 6.7033 \n", - " paper 6.8450 \n", - " L4f TAT-C, share produced 2.4059 \n", - " TAT-C, units launched 1.9900 \n", - " paper 2.0825 " + " T1 \\\n", + "constellation configuration count \n", + "C1 G4c TAT-C's dates, counted as Table III 2.0000 \n", + " TAT-C, mission 2.0000 \n", + " TAT-C, study period 2.0000 \n", + " paper 2.0000 \n", + " L3e TAT-C's dates, counted as Table III 2.0000 \n", + " TAT-C, mission 2.0000 \n", + " TAT-C, study period 2.0000 \n", + " paper 2.0000 \n", + "C2 G4c TAT-C's dates, counted as Table III 3.0000 \n", + " TAT-C, mission 3.0000 \n", + " TAT-C, study period 3.0000 \n", + " paper 3.0000 \n", + " L4f TAT-C's dates, counted as Table III 3.8125 \n", + " TAT-C, mission 3.0000 \n", + " TAT-C, study period 4.0000 \n", + " paper 2.9000 \n", + "\n", + " Ta \\\n", + "constellation configuration count \n", + "C1 G4c TAT-C's dates, counted as Table III 4.3750 \n", + " TAT-C, mission 4.0000 \n", + " TAT-C, study period 4.3750 \n", + " paper 4.3700 \n", + " L3e TAT-C's dates, counted as Table III 3.0000 \n", + " TAT-C, mission 3.0000 \n", + " TAT-C, study period 3.0000 \n", + " paper 3.0000 \n", + "C2 G4c TAT-C's dates, counted as Table III 6.3750 \n", + " TAT-C, mission 6.0000 \n", + " TAT-C, study period 6.3750 \n", + " paper 6.3700 \n", + " L4f TAT-C's dates, counted as Table III 9.8125 \n", + " TAT-C, mission 9.0000 \n", + " TAT-C, study period 9.6250 \n", + " paper 10.8000 \n", + "\n", + " expected cost \n", + "constellation configuration count \n", + "C1 G4c TAT-C's dates, counted as Table III 4.6125 \n", + " TAT-C, mission 4.4689 \n", + " TAT-C, study period 4.6125 \n", + " paper 4.6106 \n", + " L3e TAT-C's dates, counted as Table III 3.6487 \n", + " TAT-C, mission 3.6487 \n", + " TAT-C, study period 3.6487 \n", + " paper 3.6487 \n", + "C2 G4c TAT-C's dates, counted as Table III 6.8469 \n", + " TAT-C, mission 6.7033 \n", + " TAT-C, study period 6.8469 \n", + " paper 6.8450 \n", + " L4f TAT-C's dates, counted as Table III 2.4059 \n", + " TAT-C, mission 1.9900 \n", + " TAT-C, study period 2.4736 \n", + " paper 2.0825 " ] }, "metadata": {}, @@ -1060,29 +1139,37 @@ " 0.9779\n", " \n", " \n", - " TAT-C, units launched\n", - " 8.1175\n", - " 8.6933\n", - " 0.5757\n", - " 0.9590\n", + " TAT-C, study period\n", + " 8.2611\n", + " 9.3205\n", + " 1.0593\n", + " 0.9991\n", " \n", " \n", - " TAT-C, share produced\n", + " TAT-C's dates, counted as Table III\n", " 8.2611\n", " 9.2528\n", " 0.9917\n", " 0.9984\n", " \n", + " \n", + " TAT-C, mission\n", + " 8.1175\n", + " 8.6933\n", + " 0.5757\n", + " 0.9590\n", + " \n", " \n", "\n", "" ], "text/plain": [ - " E[C1] E[C2] E[C2] - E[C1] P(C2 > C1)\n", - "count \n", - "paper 8.2592 8.9275 0.6683 0.9779\n", - "TAT-C, units launched 8.1175 8.6933 0.5757 0.9590\n", - "TAT-C, share produced 8.2611 9.2528 0.9917 0.9984" + " E[C1] E[C2] E[C2] - E[C1] P(C2 > C1)\n", + "count \n", + "paper 8.2592 8.9275 0.6683 0.9779\n", + "TAT-C, study period 8.2611 9.3205 1.0593 0.9991\n", + "TAT-C's dates, counted as Table III 8.2611 9.2528 0.9917 0.9984\n", + "TAT-C, mission 8.1175 8.6933 0.5757 0.9590" ] }, "execution_count": 4, @@ -1091,27 +1178,47 @@ } ], "source": [ - "def counted(deployment):\n", + "def counted(deployment, configuration):\n", + " \"\"\"The developments and units of a configuration that TAT-C's estimate costs, as (Dev, T1, Ta).\"\"\"\n", + " each = SatelliteCost(development=1.0, first_unit=1.0, block_size=BLOCK_SIZE)\n", + " model = CostModel(\n", + " {\n", + " c: each if c == configuration else SatelliteCost()\n", + " for c in deployment.development\n", + " }\n", + " )\n", + " estimate = model.estimate(deployment)\n", + " return (\n", + " estimate.development,\n", + " estimate.development,\n", + " estimate.production - estimate.development,\n", + " )\n", + "\n", + "\n", + "def counted_as_table_iii(deployment, configuration):\n", " \"\"\"The developments, first units, and later units by the end, as Table III counts them.\"\"\"\n", - " shares = shares_produced(deployment)\n", + " shares = shares_produced(deployment, configuration)\n", " first = sum(\n", " shares[::BLOCK_SIZE]\n", " ) # each block's development is counted with its first unit\n", " return (first, first, sum(shares) - first)\n", "\n", "\n", - "blocks = SatelliteCost(block_size=BLOCK_SIZE)\n", - "COUNTS = {\"paper\": PUBLISHED, \"TAT-C, units launched\": {}, \"TAT-C, share produced\": {}}\n", + "COUNTS = {\n", + " \"paper\": PUBLISHED,\n", + " \"TAT-C, study period\": {},\n", + " \"TAT-C's dates, counted as Table III\": {},\n", + " \"TAT-C, mission\": {},\n", + "}\n", "for name, configurations in SCHEDULES.items():\n", - " for key in list(COUNTS)[1:]:\n", - " COUNTS[key][name] = {}\n", - " for c, schedule in configurations.items():\n", - " units = DEPLOYMENTS[name][c].units[c]\n", - " n = blocks.blocks(units)\n", - " COUNTS[\"TAT-C, units launched\"][name][c] = (n, n, units - n)\n", - " COUNTS[\"TAT-C, share produced\"][name][c] = counted(\n", - " plan(c, *schedule, end=END + 10)\n", - " )\n", + " ending = plan(name, sustained=False)\n", + " COUNTS[\"TAT-C, study period\"][name] = {\n", + " c: counted(DEPLOYMENTS[name], c) for c in configurations\n", + " }\n", + " COUNTS[\"TAT-C's dates, counted as Table III\"][name] = {\n", + " c: counted_as_table_iii(DEPLOYMENTS[name], c) for c in configurations\n", + " }\n", + " COUNTS[\"TAT-C, mission\"][name] = {c: counted(ending, c) for c in configurations}\n", "rows = [\n", " {\n", " \"constellation\": name,\n", @@ -1147,12 +1254,12 @@ }, { "cell_type": "markdown", - "id": "e631bd2d", + "id": "9ce2ecf4", "metadata": {}, "source": [ - "Counted as Table III counts them, TAT-C's deployments reproduce the published numbers of G4c in both constellations (2, 2, 4.375 and 3, 3, 6.375 against 4.37 and 6.37) and of L3e (2, 2, 3). The published numbers of L4f (2.9 developments and first units, 10.8 later units) cannot be derived from its schedule this way. Its six launches of two satellites before the end of September 2050 (12 units, 3 blocks), and the 0.81 of the next two produced, give 3.81 developments and first units and 9.81 later units: about the same units (13.6 against 13.7), but 0.91 more developments. Two satellites per launch every 46 months is one reading of Table II's \"46 (x2)\". Other readings, such as two slots with blocks of their own (4 developments) or one launch every 23 months (3.81), do not give 2.9 either. The 0.91 more developments and first units, and 0.99 fewer later units, add 0.32 to C2's expected cost, so with these counts the probability that C2 costs more than C1 would be 99.8%.\n", + "Over the study period, TAT-C's estimates reproduce the published numbers of G4c in both constellations (2, 2, 4.375 and 3, 3, 6.375 against 4.37 and 6.37) and of L3e (2, 2, 3), and so C1's expected cost (8.2611 against 8.2592, the difference being the rounding of 4.375). The published numbers of L4f (2.9 developments and first units, 10.8 later units) cannot be derived from its schedule. Its six launches of two satellites before the end (12 units, 3 blocks), and the 0.81 of the next two produced, give about the same units (13.6 against 13.7) but more developments. TAT-C counts 4, as the fourth block is developed from March 2043 until its first unit's production begins in July 2047, before the end. Table III's count, which counts that development with the 0.81 of its first unit, gives 3.81. Two satellites per launch every 46 months is one reading of Table II's \"46 (x2)\". Other readings, such as two slots with blocks of their own (4 developments) or one launch every 23 months (3.81), do not give 2.9 either. With TAT-C's counts, L4f costs 0.39 more than with its published counts, and the probability that C2 costs more than C1 is 99.9% (99.8% with Table III's count).\n", "\n", - "TAT-C's cost model counts the units launched. It leaves out the 0.375 of a G4c unit in production at the end in both constellations (0.14 of each one's cost), and costs L4f at 0.09 less than its published counts. Both constellations then cost less (8.12 and 8.69), C2 by 0.58 more than C1 rather than 0.67, and the probability that C2 costs more is 95.9%. The tests below therefore evaluate the costs of the published numbers, to test TAT-C's cost risk on the paper's inputs, and also TAT-C's own estimates of these deployments.\n", + "A mission that is not sustained costs the units it launches by its end. It leaves out the 0.375 of a G4c unit in production at the end in both constellations (0.14 of each one's cost) and L4f's fourth block, whose units are launched after the end. Both constellations then cost less (8.12 and 8.69), and the probability that C2 costs more is 95.9%: nearer the paper's 97.8%, but only because its cost of L4f (1.99) happens to be nearer the published one (2.08). The tests below evaluate the costs of the published numbers, to test TAT-C's cost risk on the paper's inputs, and also TAT-C's own estimates of the deployments over the study period.\n", "\n", "## Test 3: Constellation Costs\n", "\n", @@ -1161,7 +1268,7 @@ "The design space has one design variable, the constellation (C1 or C2), and the scores. Two evaluations of the replicates are compared:\n", "\n", "* **Published counts.** The cost of the published numbers of developments and units (*B*): each block costs the `total_development` and each unit the `total_first_unit` of the configuration drawn from the replicate's scores. This tests TAT-C's cost risk on the paper's inputs.\n", - "* **TAT-C deployments.** TAT-C's own estimate (`CostModel.estimate`) of the deployments of Test 2, with whole units.\n", + "* **TAT-C deployments.** TAT-C's own estimate (`CostModel.estimate`) of the sustained deployments of Test 2, over the study period.\n", "\n", "Each runs 20,000 replicates with common random numbers (the default), in which both constellations draw the same scores, and 20,000 with independent draws (for Test 4)." ] @@ -1169,13 +1276,13 @@ { "cell_type": "code", "execution_count": 5, - "id": "2333f84b", + "id": "f2a83d51", "metadata": { "execution": { - "iopub.execute_input": "2026-11-13T17:10:07.503857Z", - "iopub.status.busy": "2026-11-13T17:10:07.503857Z", - "iopub.status.idle": "2026-11-13T17:11:45.580106Z", - "shell.execute_reply": "2026-11-13T17:11:45.580106Z" + "iopub.execute_input": "2026-11-13T19:43:00.438893Z", + "iopub.status.busy": "2026-11-13T19:43:00.437893Z", + "iopub.status.idle": "2026-11-13T19:44:43.282295Z", + "shell.execute_reply": "2026-11-13T19:44:43.281821Z" } }, "outputs": [ @@ -1184,8 +1291,8 @@ "output_type": "stream", "text": [ "scores: ['cost_risk.G4c', 'cost_risk.L3e', 'cost_risk.L4f']\n", - "C1: blocks [{'G4c': 2}, {'L3e': 2}], units [{'G4c': 6}, {'L3e': 5}], expected cost 8.1175\n", - "C2: blocks [{'G4c': 3}, {'L4f': 3}], units [{'G4c': 9}, {'L4f': 12}], expected cost 8.6933\n" + "C1: blocks begun {'G4c': 2, 'L3e': 2}, units begun {'G4c': 7, 'L3e': 5}, expected cost 8.2611 (8.2611 from the counts of Test 2)\n", + "C2: blocks begun {'L4f': 4, 'G4c': 3}, units begun {'L4f': 14, 'G4c': 10}, expected cost 9.3205 (9.3205 from the counts of Test 2)\n" ] }, { @@ -1254,21 +1361,21 @@ " \n", " \n", " TAT-C deployments: expected\n", - " 8.1175\n", - " 8.6933\n", - " 0.3391\n", - " 0.2197\n", - " 26825.3588\n", - " 0.3601\n", + " 8.2611\n", + " 9.3205\n", + " 0.3408\n", + " 0.2332\n", + " 28280.5421\n", + " 0.3558\n", " \n", " \n", " TAT-C deployments: replicates\n", - " 8.1205\n", - " 8.6926\n", - " 0.3385\n", - " 0.2186\n", - " 26544.8285\n", - " 0.3588\n", + " 8.2641\n", + " 9.3200\n", + " 0.3402\n", + " 0.2319\n", + " 27992.9533\n", + " 0.3548\n", " \n", " \n", "\n", @@ -1279,15 +1386,15 @@ "paper (eqs. 6 and 8) 8.2700 8.9300 0.3408 0.2253 \n", "published counts: expected 8.2592 8.9275 0.3408 0.2253 \n", "published counts: replicates 8.2622 8.9269 0.3401 0.2241 \n", - "TAT-C deployments: expected 8.1175 8.6933 0.3391 0.2197 \n", - "TAT-C deployments: replicates 8.1205 8.6926 0.3385 0.2186 \n", + "TAT-C deployments: expected 8.2611 9.3205 0.3408 0.2332 \n", + "TAT-C deployments: replicates 8.2641 9.3200 0.3402 0.2319 \n", "\n", " cov (millionths) correlation \n", "paper (eqs. 6 and 8) 28260.0000 0.3681 \n", "published counts: expected 28260.8967 0.3681 \n", "published counts: replicates 27968.4192 0.3669 \n", - "TAT-C deployments: expected 26825.3588 0.3601 \n", - "TAT-C deployments: replicates 26544.8285 0.3588 " + "TAT-C deployments: expected 28280.5421 0.3558 \n", + "TAT-C deployments: replicates 27992.9533 0.3548 " ] }, "execution_count": 5, @@ -1319,11 +1426,12 @@ "designs = space.enumerate()\n", "print(\"scores:\", space.uncertain_paths())\n", "# the expected costs of TAT-C's deployments (with the components' mean growth), against the counts of Test 2\n", - "for name, deployments in DEPLOYMENTS.items():\n", - " estimates = {c: MODEL.estimate(d) for c, d in deployments.items()}\n", + "for name, deployment in DEPLOYMENTS.items():\n", + " estimate = MODEL.estimate(deployment)\n", + " expected = moments(COUNTS[\"TAT-C, study period\"])[0][CONSTELLATIONS.index(name)]\n", " print(\n", - " f\"{name}: blocks {[e.blocks for e in estimates.values()]}, units {[e.units for e in estimates.values()]}, \"\n", - " + f\"expected cost {sum(e.total for e in estimates.values()):.4f}\"\n", + " f\"{name}: blocks begun {estimate.blocks}, units begun {estimate.units}, \"\n", + " + f\"expected cost {estimate.total:.4f} ({expected:.4f} from the counts of Test 2)\"\n", " )\n", "\n", "\n", @@ -1344,18 +1452,14 @@ "\n", "\n", "def deployed(constellation, design):\n", - " \"\"\"TAT-C's estimate of the cost of the constellation's deployments, drawn in the replicate.\"\"\"\n", + " \"\"\"TAT-C's estimate of the cost of the constellation's deployment, drawn in the replicate.\"\"\"\n", " drawn = MODEL.draw(design.cost_risk)\n", - " return {\n", - " \"cost\": sum(\n", - " drawn.estimate(d).total for d in DEPLOYMENTS[constellation].values()\n", - " )\n", - " }\n", + " return {\"cost\": drawn.estimate(DEPLOYMENTS[constellation]).total}\n", "\n", "\n", "EVALUATIONS = {\n", " \"published counts\": (published, PUBLISHED),\n", - " \"TAT-C deployments\": (deployed, COUNTS[\"TAT-C, units launched\"]),\n", + " \"TAT-C deployments\": (deployed, COUNTS[\"TAT-C, study period\"]),\n", "}\n", "results = {\n", " (name, draws): Study(\n", @@ -1405,10 +1509,10 @@ }, { "cell_type": "markdown", - "id": "e31bfc64", + "id": "6a6ea60a", "metadata": {}, "source": [ - "With the published counts, the replicates reproduce the expected costs, standard deviations, and covariance of eqs. (6) and (8) within their sampling errors: 0.0024 for the means, 0.0017 and 0.0011 for the standard deviations, and about 580 millionths for the covariance (whose correlation is 0.37). TAT-C's estimates of its deployments, with the components' mean growth, match the expected costs of their counts exactly, and their replicates match their own expectations as closely. Their standard deviations are within 0.006 of the paper's, as the units left out at the end are a small part of each constellation's variance. Most of C1's variance is L3e's (its less mature payload makes its block the most uncertain), and most of C2's is G4c's.\n", + "With the published counts, the replicates reproduce the expected costs, standard deviations, and covariance of eqs. (6) and (8) within their sampling errors: 0.0024 for the means, 0.0017 and 0.0011 for the standard deviations, and about 580 millionths for the covariance (whose correlation is 0.37). TAT-C's estimates of its deployments, with the components' mean growth, match the expected costs of their counts exactly, and their replicates match their own expectations as closely. C1's statistics are the paper's, and C2's standard deviation is 0.233 against 0.225, from L4f's larger count. Most of C1's variance is L3e's (its less mature payload makes its block the most uncertain), and most of C2's is G4c's.\n", "\n", "The distributions of the costs of the replicates (Fig. 2 of the paper) with the normal distributions of eqs. (6) and (8):" ] @@ -1416,13 +1520,13 @@ { "cell_type": "code", "execution_count": 6, - "id": "caff9d73", + "id": "2404d5e2", "metadata": { "execution": { - "iopub.execute_input": "2026-11-13T17:11:45.582282Z", - "iopub.status.busy": "2026-11-13T17:11:45.582282Z", - "iopub.status.idle": "2026-11-13T17:11:45.766966Z", - "shell.execute_reply": "2026-11-13T17:11:45.766966Z" + "iopub.execute_input": "2026-11-13T19:44:43.282295Z", + "iopub.status.busy": "2026-11-13T19:44:43.282295Z", + "iopub.status.idle": "2026-11-13T19:44:43.469621Z", + "shell.execute_reply": "2026-11-13T19:44:43.468976Z" } }, "outputs": [ @@ -1478,7 +1582,7 @@ }, { "cell_type": "markdown", - "id": "71b64aab", + "id": "231d9a3c", "metadata": {}, "source": [ "## Test 4: Order of Costs\n", @@ -1489,13 +1593,13 @@ { "cell_type": "code", "execution_count": 7, - "id": "4df699ad", + "id": "47356024", "metadata": { "execution": { - "iopub.execute_input": "2026-11-13T17:11:45.767965Z", - "iopub.status.busy": "2026-11-13T17:11:45.767965Z", - "iopub.status.idle": "2026-11-13T17:12:19.164672Z", - "shell.execute_reply": "2026-11-13T17:12:19.164672Z" + "iopub.execute_input": "2026-11-13T19:44:43.470651Z", + "iopub.status.busy": "2026-11-13T19:44:43.470651Z", + "iopub.status.idle": "2026-11-13T19:45:17.110548Z", + "shell.execute_reply": "2026-11-13T19:45:17.110548Z" } }, "outputs": [ @@ -1561,17 +1665,17 @@ " \n", " TAT-C deployments\n", " common\n", - " 0.9590\n", - " 0.9591\n", - " 0.0014\n", - " 0.5721\n", + " 0.9991\n", + " 0.9992\n", + " 0.0002\n", + " 1.0559\n", " \n", " \n", " independent\n", - " 0.9229\n", - " 0.9225\n", - " 0.0019\n", - " 0.5764\n", + " 0.9948\n", + " 0.9959\n", + " 0.0005\n", + " 1.0601\n", " \n", " \n", "\n", @@ -1582,15 +1686,15 @@ "costs draws \n", "published counts common 0.9779 0.9782 \n", " independent 0.9491 0.9475 \n", - "TAT-C deployments common 0.9590 0.9591 \n", - " independent 0.9229 0.9225 \n", + "TAT-C deployments common 0.9991 0.9992 \n", + " independent 0.9948 0.9959 \n", "\n", " standard error mean difference \n", "costs draws \n", "published counts common 0.0010 0.6647 \n", " independent 0.0016 0.6690 \n", - "TAT-C deployments common 0.0014 0.5721 \n", - " independent 0.0019 0.5764 " + "TAT-C deployments common 0.0002 1.0559 \n", + " independent 0.0005 1.0601 " ] }, "metadata": {}, @@ -1799,10 +1903,10 @@ }, { "cell_type": "markdown", - "id": "13f0a6d9", + "id": "03b50728", "metadata": {}, "source": [ - "`exceedance` reproduces the paper's probability: with the published counts and common random numbers, C2 costs more than C1 in 97.8% of the replicates (97.82% against 97.79% expected, with a standard error of 0.10%). With independent draws, it does in 94.8% (94.9% expected). With TAT-C's own deployments, the probabilities are those expected of their counts: 95.9% and 92.3%. The shares of variance that `attribute_variance` estimates match the exact shares within about one standard error (0.001 to 0.010).\n", + "`exceedance` reproduces the paper's probability: with the published counts and common random numbers, C2 costs more than C1 in 97.8% of the replicates (97.82% against 97.79% expected, with a standard error of 0.10%). With independent draws, it does in 94.8% (94.9% expected). With TAT-C's own deployments, C2 costs more in 99.92% of the replicates with common draws and 99.59% with independent ones (99.91% and 99.48% expected; the larger gap is 2.2 standard errors), higher than the paper's for L4f's counts (Test 2). The shares of variance that `attribute_variance` estimates match the exact shares within about one standard error (0.001 to 0.010).\n", "\n", "The shares show why sharing G4c settles the order. G4c is 16% of the variance of C1's cost and 83% of C2's, but 4% of the variance of their difference: of its variance in C1 (19,000 millionths) and in C2 (42,000 millionths), 4,500 remain in the difference, since a costlier G4c raises both. The variance of the difference (110,000 millionths, against 167,000 if the costs were independent) is mostly L3e's, which only C1 flies. The joint distribution of the costs of the replicates (Fig. 3 of the paper), with the ellipse that holds 95% of the normal distribution of eqs. (6) and (8):" ] @@ -1810,13 +1914,13 @@ { "cell_type": "code", "execution_count": 8, - "id": "3e371959", + "id": "4cc9a667", "metadata": { "execution": { - "iopub.execute_input": "2026-11-13T17:12:19.167173Z", - "iopub.status.busy": "2026-11-13T17:12:19.166169Z", - "iopub.status.idle": "2026-11-13T17:12:19.322593Z", - "shell.execute_reply": "2026-11-13T17:12:19.321609Z" + "iopub.execute_input": "2026-11-13T19:45:17.110548Z", + "iopub.status.busy": "2026-11-13T19:45:17.110548Z", + "iopub.status.idle": "2026-11-13T19:45:17.282746Z", + "shell.execute_reply": "2026-11-13T19:45:17.282440Z" } }, "outputs": [ @@ -1865,7 +1969,7 @@ }, { "cell_type": "markdown", - "id": "173c71c3", + "id": "778f85d7", "metadata": {}, "source": [ "With common random numbers (left), the replicates fill the ellipse of eq. (8), tilted by the configuration the constellations share, and 2.2% fall below the line *y* = *x*. With independent draws (right), each cost spreads as much as before but the ellipse is not tilted, and 5.2% fall below the line.\n", @@ -1875,15 +1979,15 @@ "| Test | Result |\n", "| --- | --- |\n", "| 1. Growth by maturity (`Triangular`, `Component`, `CostModel.correlation`) | Table I's means reproduced to its three decimals (existing components 1.0403 against 1.041, rounded up in the table); standard deviations equal to SciPy's; scores correlated by 0.5 correlate the growths by 0.486, so a configuration's variance is 1.3% below eq. (2) (a correlation of 0.514 gives 0.5) |\n", - "| 2. Production blocks (`DeploymentSchedule`, `SatelliteCost.block_size`) | Table III's launches, production of later units, and developments of both blocks of G4c reproduced to the month; counted as Table III counts them, the published numbers of G4c (4.375 and 6.375 later units) and L3e reproduced, but not those of L4f (3.81 developments against 2.9); TAT-C's cost model counts whole units launched, leaving out units in production at the end of the study period |\n", - "| 3. Constellation costs (`risk_space`, `CostModel.draw`, `Study`) | with the published counts, expected costs, standard deviations, and covariance of eqs. (6) and (8) within the sampling error of 20,000 replicates (means 8.26 and 8.93, standard deviations 0.34 and 0.22); TAT-C's deployments cost 8.12 and 8.69, as their counts predict |\n", - "| 4. Order of costs (`exceedance`, `attribute_variance`) | P(C2 > C1) of 97.8% with the published counts and common random numbers (97.8% published), 94.8% with independent draws (94.9% expected); 95.9% with TAT-C's deployments; G4c is 83% of C2's variance but 4% of the variance of the difference |\n", + "| 2. Production blocks (`DeploymentSchedule`, `SatelliteCost.block_size`) | Table III's launches, production of later units, and developments of both blocks of G4c reproduced to the month, with 0.375 of the unit in production at the end (0.37 published); over the study period (`sustained`, with a design life of each configuration), the published numbers of G4c (4.375 and 6.375 later units) and L3e reproduced, and C1's expected cost (8.261 against 8.259), but not those of L4f (4 developments against 2.9, 3.81 counted as Table III counts them) |\n", + "| 3. Constellation costs (`risk_space`, `CostModel.draw`, `Study`) | with the published counts, expected costs, standard deviations, and covariance of eqs. (6) and (8) within the sampling error of 20,000 replicates (means 8.26 and 8.93, standard deviations 0.34 and 0.22); TAT-C's deployments cost 8.26 and 9.32, as their counts predict |\n", + "| 4. Order of costs (`exceedance`, `attribute_variance`) | P(C2 > C1) of 97.8% with the published counts and common random numbers (97.8% published), 94.8% with independent draws (94.9% expected); 99.9% with TAT-C's deployments, whose L4f costs 0.39 more; G4c is 83% of C2's variance but 4% of the variance of the difference |\n", "\n", "**Cost risk.** TAT-C's structured cost risk reproduces the paper's example. Configurations whose growth is drawn from scores, shared by common random numbers, give the constellations the covariance of eq. (8), and `exceedance` the probability of eq. (15), with no model of the covariance itself: what the constellations share is shared by drawing it once in each replicate. The same holds for configurations that share components or a common score, and for costs that are not linear in the growths (such as those of deployments with failures), which eq. (8) does not cover.\n", "\n", "**Correlation.** `CostModel.correlation` is the correlation of the normal scores of components, from which their growths are drawn; the growths of Table I's skewed distributions are correlated slightly less (0.486 for 0.5). To reproduce a FRISK estimate that correlates costs by 0.5, use a correlation of about 0.514.\n", "\n", - "**Study periods.** The paper counts the costs of a sustained constellation over a fixed study period, including the share of the units in production at its end; TAT-C's cost model counts the satellites that a deployment launches before the end of its mission. Over 30 years, the difference is about 2% of the cost, but it falls unevenly on alternatives, and so shifts the probability that one costs more than another (here, from 97.8% to 95.9%). Comparisons of sustained constellations in TAT-C are like for like when every alternative has the same mission, or when their costs are compared per year of mission." + "**Study periods.** The paper counts the costs of a sustained constellation over a fixed study period, including the share of the units in production at its end. A sustained `DeploymentSchedule` (`sustained=True`) does the same, and reproduces the paper's counts of G4c and L3e. A mission that is not sustained costs the satellites it launches by its end: here 1.7% less for C1 and 6.7% less for C2, whose fourth block of L4f is developed before the end but launched after it. The difference falls unevenly on alternatives, and so shifts the probability that one costs more than another (here, from 99.9% to 95.9%). The probability over the study period differs from the published one (97.8%) only because L4f's published counts cannot be derived from its schedule." ] } ], diff --git a/docs/validation/summary.rst b/docs/validation/summary.rst index e0f0a096..24f11a6b 100644 --- a/docs/validation/summary.rst +++ b/docs/validation/summary.rst @@ -293,12 +293,14 @@ Trade Studies expected costs, standard deviations, and covariance of the constellations within their sampling error, and the probability that one costs more than the other (97.8%; 94.8% with independent draws); Table I's growth factors reproduced (:doc:`ValidateCostVarianceNSOSA`) - * - Production blocks (`DeploymentSchedule`, `SatelliteCost.block_size`) + * - Production blocks and study periods (`DeploymentSchedule`, `SatelliteCost.block_size`) - Launch schedules and production blocks of the same study - Launches, production of later units, and developments of both blocks of the geostationary configuration - reproduced to the month; TAT-C counts the units launched within the mission, not the share of units in - production at the end of the study period, which lowers the costs by about 2% and the probability above to - 95.9% (:doc:`ValidateCostVarianceNSOSA`) + reproduced to the month; over the study period (a sustained constellation, with a design life of each + configuration), the published numbers of developments and units of two of three configurations + reproduced, and one constellation's expected cost; the third configuration's published numbers cannot be + derived from its schedule, which costs the constellation that flies it 4% more than published and raises + the probability above to 99.9% (:doc:`ValidateCostVarianceNSOSA`) Modeling Guidance ================= @@ -351,6 +353,13 @@ numerical error in TAT-C: distributions are correlated slightly less (0.486 for 0.5, with the cost growth factors of formal risk assessments). Use about 0.514 to correlate the costs of components by 0.5. +* **Costs within a study period.** A mission that is not sustained costs the + satellites it launches by its end. To compare operational constellations + over a fixed study period, as architecture studies do, use + `DeploymentSchedule(sustained=True)`, which counts the share of the units + (and later blocks' developments) in production at the end; the two differ by + 2 to 7% of the cost of a constellation over 30 years, unevenly between + alternatives. * **Navigation constellations.** Model the operational satellites (those with healthy broadcast ephemerides); public TLE groups include others, which make DOP 4 to 16% optimistic. @@ -366,9 +375,6 @@ Not Modeled * Pointing limits in `collect_space_observations`, such as an antenna's field of view, and slews between attitudes, which are instantaneous. * Acquisition plans, downlink processing time, and data gaps. -* Costs within a study period: the costs of a deployment are those of the - satellites it launches before the end of its mission, not the share of the - units in production at the end of a fixed study period. * Daily cycles of sampled fields: sampling errors model a stationary field, so sun-synchronous sampling of a field with a strong daily cycle has errors up to 25% larger than predicted, and a small bias (2 to 3% for IMERG diff --git a/src/tatc/tradespace/cost.py b/src/tatc/tradespace/cost.py index 5278f41e..bdfbfb54 100644 --- a/src/tatc/tradespace/cost.py +++ b/src/tatc/tradespace/cost.py @@ -35,9 +35,12 @@ of each later block of its production, see `SatelliteCost.block_size`), production of its satellites, launches, replacements, and operations from launch to the end of the mission, so that each design's costs follow from -its satellites and planes. The dated costs give the present value of the -cost at a discount rate, and the cost of each year (such as its peak, for -annual budgets):: +its satellites and planes. The costs of a constellation sustained after the +end of its mission (such as of an operational program over the period of a +study, see `DeploymentSchedule`) are those incurred by the end, which count +the units in production then by the share produced. The dated costs give +the present value of the cost at a discount rate, and the cost of each year +(such as its peak, for annual budgets):: def evaluate(built): d, satellites = built @@ -360,17 +363,20 @@ class OperationsCost: per_satellite_year: float = 0.0 -def _spread(amount: float, begin: float, end: float) -> list[tuple[float, float]]: +def _spread( + amount: float, begin: float, end: float, until: float = math.inf +) -> list[tuple[float, float]]: """ Spreads an amount evenly from `begin` to `end` (years), dated at the - middle of each of its years (or at `begin`, if it has no duration). + middle of each of its years (or at `begin`, if it has no duration), the + part before `until` (the end of a sustained mission). """ if end <= begin: - return [(begin, amount)] + return [(begin, amount)] if begin < until else [] flows = [] - time = begin - while time < end - 1e-12: - step = min(1.0, end - time) + time, stop = begin, min(end, until) + while time < stop - 1e-12: + step = min(1.0, stop - time) flows.append((time + step / 2, amount * step / (end - begin))) time += step return flows @@ -393,7 +399,8 @@ class CostEstimate: """float: The cost of operations.""" units: dict[str, int] = field(default_factory=dict) """dict: The units built of each type of satellite (including - replacements and spares).""" + replacements and spares, and those in production at the end of a + sustained mission).""" launches: int = 0 """int: The launches priced per launch.""" flows: list[tuple[float, str, float]] = field(default_factory=list) @@ -666,6 +673,19 @@ def estimate( develops its type again (a share of its development), dated over the type's development just before the production of its first unit. + The costs of a sustained constellation (see `DeploymentSchedule`), + such as of an operational program over the period of a study, are + those incurred by the end of the mission: of each cost spread over a + duration (the development of each type and block, and the production + of each batch of satellites), the share before the end, so that the + units in production at the end count by the share produced (as in M. + W. Maier, K. L. Yeakel, and E. B. Wendoloski, "Cost Variance Analysis + in Constellation Architecture Studies," IEEE Systems Journal 17(2), + 2023), and a later block counts the share of its development before + the end, whether or not its first unit is in production. The units + (and blocks) of the estimate are those whose production begins + before the end. + Growth factors multiply the estimate, such as uncertain parameters of cost growth drawn for each replicate (for example, `Uncertain(lambda rng: rng.triangular(0.9, 1.0, 1.5))`), whose @@ -712,6 +732,8 @@ def add( self._get_type(kind).mass is None for kind in history.development ): raise ValueError("launches priced by mass require masses") + # the costs of a sustained constellation are those incurred by the end + until = history.end if history.schedule.sustained else math.inf developed_components: set[str] = set() for kind, developed in sorted( history.development.items(), key=lambda item: item[1] @@ -723,8 +745,9 @@ def add( if c.name not in developed_components ) developed_components.update(c.name for c in cost.components) - add("development", _spread(amount, 0.0, developed), kind) + add("development", _spread(amount, 0.0, developed, until), kind) built: dict[Any, int] = {} + begun: dict[Any, int] = {} for batch in history.production: cost = self._get_type(batch.kind) before = built.get(batch.kind, 0) @@ -732,7 +755,13 @@ def add( before ) built[batch.kind] = before + batch.satellites - add("production", _spread(amount, batch.begin, batch.end), batch.kind) + if batch.begin < until: + begun[batch.kind] = begun.get(batch.kind, 0) + batch.satellites + add( + "production", + _spread(amount, batch.begin, batch.end, until), + batch.kind, + ) if cost.block_size is not None and cost.redevelopment > 0: # the development of each later block, before its first unit duration = history.development.get(batch.kind, 0.0) @@ -751,13 +780,14 @@ def add( cost.redevelopment * cost.total_development, begins - duration, begins, + until, ), batch.kind, ) - estimate.units = {_type_name(kind): units for kind, units in built.items()} + estimate.units = {_type_name(kind): units for kind, units in begun.items()} estimate.blocks = { _type_name(kind): self._get_type(kind).blocks(units) - for kind, units in built.items() + for kind, units in begun.items() } begin, end = history.begin, history.end for launch in history.launches: diff --git a/src/tatc/tradespace/deployment.py b/src/tatc/tradespace/deployment.py index 92ff9233..d5cd363c 100644 --- a/src/tatc/tradespace/deployment.py +++ b/src/tatc/tradespace/deployment.py @@ -129,9 +129,12 @@ class Deployment: development: dict[Any, float] = field(default_factory=dict) """dict: The end of the development of each type of satellite (years).""" production: list[Production] = field(default_factory=list) - """list[Production]: The production of the satellites, in order.""" + """list[Production]: The production of the satellites, in order (of a + sustained constellation, also of replacements launched after the end of + the mission, see `DeploymentSchedule`).""" launches: list[Launch] = field(default_factory=list) - """list[Launch]: The launches (and planned replacements), in order.""" + """list[Launch]: The launches (and planned replacements) of the mission, + in order.""" masses: dict[Any, float | None] = field(default_factory=dict) """dict: The mass (kg) of each type of satellite, if given.""" plane_values: list[Any] = field(default_factory=list) @@ -168,10 +171,12 @@ def deployed(self) -> float: @property def units(self) -> dict[Any, int]: """dict: The satellites produced of each type (including replacements - and spares).""" + and spares, and, of a sustained constellation, those in production + at the end of the mission).""" units: dict[Any, int] = {} for batch in self.production: - units[batch.kind] = units.get(batch.kind, 0) + batch.satellites + if not self.schedule.sustained or batch.begin < self.end: + units[batch.kind] = units.get(batch.kind, 0) + batch.satellites return units def simulate( @@ -353,12 +358,22 @@ class DeploymentSchedule: or mass, or one per plane), at most one every `launch_interval` years, in the order the planes are ready. * The mission lasts `years` from the first launch. Satellites are - replaced at the end of their `design_life` (if before the end of the - mission), each replacement produced at the production rate just - before it is needed and launched then. A design life does not retire - a satellite: one that is not replaced (as near the end of the mission, - or if its replacement's launch fails) operates until it fails (by the - wear-out of its life, see `FailureModel`). + replaced at the end of their `design_life` (one for every type, or one + for each; if before the end of the mission), each replacement produced + at the production rate just before it is needed and launched then. A + design life does not retire a satellite: one that is not replaced (as + near the end of the mission, or if its replacement's launch fails) + operates until it fails (by the wear-out of its life, see + `FailureModel`). + * A `sustained` constellation (such as of an operational program, whose + mission is the period of a study) is replaced after the end of the + mission as before it: the replacements needed after the end are + produced (their production begun before the end, or within the + development years of their type after it, for the development of a + later block of production, see `SatelliteCost.block_size`), though + not launched in the mission, and its costs are those incurred by the + end (see `CostModel.estimate`), which count the units in production + at the end by the share produced. A schedule that is itself a decision (such as the launch cadence) is a design variable, with the schedule made for each design (such as with @@ -366,9 +381,9 @@ class DeploymentSchedule: Args: years (float): The duration of the mission, from the first launch. - design_life (float | None): The design life of the satellites, or - `None` if they last the mission (or fail, see - `Deployment.simulate`). + design_life (float | Mapping | None): The design life of the + satellites (of each type), or `None` if they last the mission (or + fail, see `Deployment.simulate`). development_years (float | Mapping): The duration of development of each type of satellite, before production. production_rate (float | Mapping | None): The satellites of each type @@ -385,21 +400,27 @@ class DeploymentSchedule: plane (`None` for the planes of a Walker layout) that gives the key by which its type's planes are produced and launched, if not in the order of the layouts. + sustained (bool): Whether the constellation is replaced after the + end of the mission, whose costs are then those incurred by the + end. """ years: float = 1.0 - design_life: float | None = None + design_life: PerType | None = None development_years: PerType = 0.0 production_rate: PerType | None = None launch_interval: float = 0.0 launch_capacity: int | None = None launch_mass_capacity: float | Callable[[int, Any], float] | None = None order: Callable[[int, Any], Any] | None = None + sustained: bool = False def __post_init__(self): if self.years <= 0: raise ValueError("years must be positive") - if self.design_life is not None and self.design_life <= 0: + lives = self.design_life + values = lives.values() if isinstance(lives, Mapping) else [lives] + if any(life is not None and life <= 0 for life in values): raise ValueError("design_life must be positive") if self.launch_interval < 0: raise ValueError("launch_interval must not be negative") @@ -414,6 +435,46 @@ def __post_init__(self): if any(value < 0 for value in values): raise ValueError("development_years must not be negative") + def design_life_of(self, kind: Any = None) -> float | None: + """ + Gets the design life of a type of satellite. + + Args: + kind (Any): The type of the satellites. + + Returns: + float | None: the design life (years), or `None` if they last + the mission + """ + return _per_type(self.design_life, kind, "design life") + + def _replacements( + self, kind: Any, time: float, satellites: int, end: float + ) -> list[tuple[float, float, int]]: + """ + Gets the planned replacements of satellites launched at a time: the + start of the production and the launch of each, and its generation. + Replacements are launched before the end of the mission, or, for a + sustained constellation, produced after it from those whose + production begins within the development years of their type after + the end (whose later blocks of production may be developed before + it). + """ + life = self.design_life_of(kind) + if life is None: + return [] + rate = _per_type(self.production_rate, kind, "production rate") + producing = 0.0 if rate is None else satellites / rate + horizon = end + if self.sustained: + horizon += float(_per_type(self.development_years, kind, "development")) + replacements = [] + need, generation = time + life, 1 + while (need - producing if self.sustained else need) < horizon - 1e-9: + replacements.append((need - producing, need, generation)) + need, generation = need + life, generation + 1 + return replacements + def mass_capacity_of(self, plane: tuple[int, Any] | None = None) -> float | None: """ Gets the most mass (kg) of a launch to a plane, if limited. @@ -558,23 +619,17 @@ def plan( position += carried cadence = first + count * self.launch_interval end = deployment.end - if self.design_life is not None: - for launch in list(deployment.launches): - rate = _per_type(self.production_rate, launch.kind, "production rate") - need, generation = launch.time + self.design_life, 1 - while need < end - 1e-9: - produced = need - ( - 0.0 if rate is None else launch.satellites / rate - ) - deployment.production.append( - Production( - launch.kind, - produced, - need, - launch.satellites, - "replacement", - ) + for launch in list(deployment.launches): + for produced, need, generation in self._replacements( + launch.kind, launch.time, launch.satellites, end + ): + deployment.production.append( + Production( + launch.kind, produced, need, launch.satellites, "replacement" ) + ) + # not those of a sustained constellation after the end + if need < end - 1e-9: deployment.launches.append( Launch( need, @@ -586,7 +641,6 @@ def plan( "replacement", ) ) - need, generation = need + self.design_life, generation + 1 deployment.production.sort(key=lambda batch: batch.begin) deployment.launches.sort(key=lambda launch: (launch.time, launch.plane)) return deployment diff --git a/src/tatc/tradespace/mission.py b/src/tatc/tradespace/mission.py index b570c97c..f4049400 100644 --- a/src/tatc/tradespace/mission.py +++ b/src/tatc/tradespace/mission.py @@ -619,7 +619,6 @@ def _deploy(self, time: float, stage: Any) -> None: type's line), launched at the next launch slots, and replaced at the end of their design life. """ - life = self.schedule.design_life for plane in stage.planes: kind, size, spares = self.deployment.planes[plane] count = size + spares @@ -640,23 +639,20 @@ def _deploy(self, time: float, stage: Any) -> None: at = self._slot(ready) self.booked = sorted(self.booked + [at]) self._push(at, "planned", Launch(at, plane, kind, position, carried)) - need, generation = at + (math.inf if life is None else life), 1 - while need < self.end - 1e-9: + # pylint: disable-next=protected-access + for produced, need, generation in self.schedule._replacements( + kind, at, carried, self.end + ): self.history.production.append( - Production( - kind, - need - self._producing(kind, carried), - need, - carried, - "replacement", - ) + Production(kind, produced, need, carried, "replacement") ) + if need >= self.end - 1e-9: + continue # of a sustained constellation, after the end replacement = Launch( need, plane, kind, position, carried, generation, "replacement" ) self.booked = sorted(self.booked + [need]) self._push(need, "planned", replacement) - need, generation = need + life, generation + 1 position += carried def _producing(self, kind: Any, count: int) -> float: diff --git a/tests/tradespace/test_cost.py b/tests/tradespace/test_cost.py index 39af7071..aa60a84a 100644 --- a/tests/tradespace/test_cost.py +++ b/tests/tradespace/test_cost.py @@ -329,6 +329,41 @@ def test_blocks(self): {"satellites": 1}, ) + def test_sustained(self): + """The costs of a sustained constellation are those incurred by the end + of the mission: the share of each development and production before + it, also of a block whose first unit is produced after it.""" + model = CostModel( + SatelliteCost(development=90, first_unit=10, block_size=2), + launch=LaunchCost(per_launch=30), + ) + terms = { + "years": 5, + "design_life": 2, + "development_years": 3, + "production_rate": 0.5, + } + # units produced over [3, 5], [5, 7], [7, 9], [9, 11], and [11, 13] + # (the last two after the end at 10), in blocks of two + ending = model.estimate(DeploymentSchedule(**terms).plan(_walker(1, 1))) + sustained = model.estimate( + DeploymentSchedule(**terms, sustained=True).plan(_walker(1, 1)) + ) + self.assertEqual(ending.units, {"satellites": 3}) + self.assertEqual(ending.development, 90 + 90) + self.assertEqual(ending.production, 30) + self.assertEqual(sustained.units, {"satellites": 4}) + self.assertEqual(sustained.blocks, {"satellites": 2}) + # the third block is developed over [8, 11], two thirds by the end + self.assertAlmostEqual(sustained.development, 90 + 90 + 60) + # half of the fourth unit, and none of the fifth + self.assertAlmostEqual(sustained.production, 30 + 5) + # the fourth unit is launched after the end + self.assertEqual(sustained.launch, ending.launch) + self.assertEqual(sustained.launch, 3 * 30) + self.assertLess(max(time for time, *_ in sustained.flows), 10) + self.assertAlmostEqual(sustained.annual()["total"].sum(), sustained.total) + def test_operations_from_launch(self): """Satellites launched later are operated for less of the mission.""" dated = self._estimate(development_years=2, launch_interval=1) diff --git a/tests/tradespace/test_deployment.py b/tests/tradespace/test_deployment.py index 489a99cc..9cb2342f 100644 --- a/tests/tradespace/test_deployment.py +++ b/tests/tradespace/test_deployment.py @@ -134,6 +134,48 @@ def test_types_and_order(self): _walker(), kind="heritage" ) + def test_design_life_by_type(self): + """Each type of satellite has its own design life (or none).""" + schedule = DeploymentSchedule( + years=6, design_life={"short": 2, "long": None}, development_years=1 + ) + deployment = schedule.plan({"short": _walker(1, 2), "long": _walker(1, 2)}) + replacements = [ + (l.kind, l.time) for l in deployment.launches if l.purpose == "replacement" + ] + self.assertEqual(replacements, [("short", 3), ("short", 5)]) + self.assertEqual(deployment.units, {"short": 6, "long": 2}) + self.assertEqual(schedule.design_life_of("short"), 2) + self.assertIsNone(schedule.design_life_of("long")) + with self.assertRaises(ValueError): + DeploymentSchedule(design_life={"short": 2}).plan(_walker(), kind="long") + + def test_sustained(self): + """A sustained constellation's replacements are produced after the end + of the mission (from within its development years after the end), but + not launched in it.""" + terms = { + "years": 5, + "design_life": 2, + "development_years": 3, + "production_rate": 0.5, + } + ending = DeploymentSchedule(**terms).plan(_walker(1, 1)) + sustained = DeploymentSchedule(**terms, sustained=True).plan(_walker(1, 1)) + self.assertEqual(sustained.end, 10) + self.assertEqual( + [(b.begin, b.end) for b in ending.production], [(3, 5), (5, 7), (7, 9)] + ) + self.assertEqual( + [(b.begin, b.end) for b in sustained.production], + [(3, 5), (5, 7), (7, 9), (9, 11), (11, 13)], + ) + self.assertEqual([l.time for l in sustained.launches], [5, 7, 9]) + self.assertEqual(sustained.launches, ending.launches) + # those in production at the end, not those begun after it + self.assertEqual(sustained.units, {None: 4}) + self.assertEqual(ending.units, {None: 3}) + def test_mass_capacity(self): """A launch carries as many satellites as its mass capacity allows.""" schedule = DeploymentSchedule(launch_mass_capacity=120) @@ -149,6 +191,7 @@ def test_validation(self): for invalid in ( {"years": 0}, {"design_life": 0}, + {"design_life": {"a": 2, "b": 0}}, {"production_rate": 0}, {"launch_interval": -1}, {"launch_capacity": 0}, diff --git a/tests/tradespace/test_stages.py b/tests/tradespace/test_stages.py index 85542103..a2d330d0 100644 --- a/tests/tradespace/test_stages.py +++ b/tests/tradespace/test_stages.py @@ -4,6 +4,7 @@ @author Paul T. Grogan """ +import dataclasses import unittest import pandas as pd @@ -76,6 +77,19 @@ def test_planned_delay(self): self.assertEqual(history.operating[2, 0][0][0], decided + 2 / 4) self.assertEqual(history.metrics()["stages deployed"], 1.0) + def test_sustained(self): + """A deployed stage of a sustained constellation is replaced after the + end of the mission as the other planes are: produced, not launched.""" + schedule = dataclasses.replace(SCHEDULE, design_life=3.75, sustained=True) + history = schedule.plan(_layout(), stages=[Stage(2, 1.0)]).simulate() + self.assertEqual(history.end, 6.5) + # launched at 3, its replacement needed at 6.75, after the end + self.assertEqual(_launches(history, 2), [(3.0, "deployment")]) + after = [(b.begin, b.end) for b in history.production if b.end > history.end] + self.assertEqual(after, [(6.25, 6.75)]) + # eleven units of 2: five planes launched, and half of the sixth + self.assertAlmostEqual(COSTS.estimate(history).production, 11 * 2) + def test_not_deployed(self): """A stage that its rule does not deploy is neither produced nor launched.""" never = SCHEDULE.plan( From 4cefdc8bd5b26eb6f0e1e97bad9a7aafcda7df90 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Fri, 13 Nov 2026 16:10:27 -0700 Subject: [PATCH 40/52] add an example notebook that shows the qualities of the sampling sufficiency methods with a synthetic nature run --- CHANGELOG.md | 2 +- docs/examples/AssessSamplingSufficiency.ipynb | 1295 +++++++++++++++++ docs/examples/index.rst | 3 +- 3 files changed, 1298 insertions(+), 2 deletions(-) create mode 100644 docs/examples/AssessSamplingSufficiency.ipynb diff --git a/CHANGELOG.md b/CHANGELOG.md index 53e06132..c08b3337 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,7 +12,7 @@ Added: - Field `is_swept` of `PointedInstrument`, for an instrument whose view sweeps along track: its footprint over a time step is the strip its cross-track line (the directions at an along-track angle of zero, which `collect_observations` checks) sweeps between the step's bounds, trimmed to blind intervals, so that ground track swaths (`compute_ground_track`) and region swaths do not depend on the time step, while its along-track field of view still sets the instantaneous view. Method `PointedInstrument.compute_swept_footprints`, utility method `compute_swept_footprints`, argument `time_step` of `collect_ground_track` and `compute_ground_track` (the span of each footprint, by default half the gap to the neighboring times on each side), and runtime configuration `swept_footprint_max_substep`. The default, `False`, leaves footprints unchanged. - Field `type` (`instrument`, `pointed`, or `conical`) of `Instrument`, `PointedInstrument`, and `ConicalInstrument`, which identifies the instrument class in serialized data. Data without a `type` loads as the class its fields imply. - Function `generation.generate_points_rotated_lattice`, the points of a Fibonacci lattice in a random orientation: a stratified sample of the sphere (or of a mask), each point uniform by area, whose statistics have about 1.5 to 4 times less variance between replicates of trade studies than those of random points. - - Analysis methods of the statistical sufficiency of observations (module `analysis.sufficiency`): `estimate_sampling_error`, the error of estimating the mean of a field over a period from each target's samples, for a field with a standard deviation and an exponential correlation in time (exact, see `sampling_error_variance`), with the effective number of independent samples; `sample_field`, which samples a field (an xarray `DataArray`, such as a nature run) at the time and place of each observation, and `compare_sampled_means`, which measures the sampling error against it; `compute_revisit_statistics`, the quantiles of revisits and the longest gap of each target (including the edges of the period); and `compute_local_time_coverage`, the distribution of samples in local time of day. The decorrelation time of `estimate_sampling_error` may differ between targets. The validation notebook `ValidateSamplingErrorIMERG` compares its predictions with the errors of monthly means of IMERG precipitation sampled by four constellation designs. `estimate_sampling_error` and `compute_revisit_statistics` compute the statistics of every target at once (the sum of the correlations between pairs of samples by a recursion over their times, and the gaps and their quantiles from the samples in order), with the same results 3 to 12 times faster. + - Analysis methods of the statistical sufficiency of observations (module `analysis.sufficiency`): `estimate_sampling_error`, the error of estimating the mean of a field over a period from each target's samples, for a field with a standard deviation and an exponential correlation in time (exact, see `sampling_error_variance`), with the effective number of independent samples; `sample_field`, which samples a field (an xarray `DataArray`, such as a nature run) at the time and place of each observation, and `compare_sampled_means`, which measures the sampling error against it; `compute_revisit_statistics`, the quantiles of revisits and the longest gap of each target (including the edges of the period); and `compute_local_time_coverage`, the distribution of samples in local time of day. The decorrelation time of `estimate_sampling_error` may differ between targets. The validation notebook `ValidateSamplingErrorIMERG` compares its predictions with the errors of monthly means of IMERG precipitation sampled by four constellation designs, and the example notebook `AssessSamplingSufficiency` shows the qualities of the methods with a synthetic nature run. `estimate_sampling_error` and `compute_revisit_statistics` compute the statistics of every target at once (the sum of the correlations between pairs of samples by a recursion over their times, and the gaps and their quantiles from the samples in order), with the same results 3 to 12 times faster. - Module `tradespace` (prototype) for trade studies. A `DesignSpace` declares design variables (`Real`, `Integer`, `Categorical`), fixed and `Derived` values, and `Uncertain` parameters (drawn per replicate, not searched), grouped hierarchically with `Choice` (one of several branches) and `Repeat` (a variable number of items, such as orbit planes, optionally unordered). Bounds, derived values, and constraints are callables of the values decided before them. `DesignSpace.enumerate` gives every feasible design (a full factorial design, including variables that exist only in some designs), and `sample` a Latin hypercube or random sample. A `Design` has a `key` from its decisions and `flat` values by path, and `realize` draws a replicate's uncertain parameters, with common random numbers between designs by default. `Study` builds and evaluates designs in replicates into a data frame, in worker processes with `n_jobs` (or on an `executor`; idle workers wait two minutes for more evaluations before they exit), giving the realized design to an evaluation function with a parameter named `design`, recording as infeasible the designs that its functions reject with `Infeasible` or that fail the validation of TAT-C's schemas (other errors, including other `ValueError`s, are raised or recorded as failed), and raising an error for metrics that would replace its status columns or a design's values; `summarize` gives the mean, standard deviation, and standard error of metrics over replicates. - Class `tradespace.SatelliteCache`, which caches an analysis of single satellites by their content (orbit, instruments, and attitude, not their name, see `get_satellite_key`), in memory or on disk, so that designs that share satellites compute their results once. On disk, results are kept by namespace and by the definition of the function (see `get_definition`); a cache warns if its namespace has results only of other definitions, naming what differs, `SatelliteCache.prune` removes them, and results that cannot be read are computed again. - Functions `tradespace.pareto_front`, `pareto_ranks` (both with optional tolerances of objectives, within which designs near the front are efficient), and `hypervolume` (exact) of designs with several objectives to minimize or maximize, and `pareto_probability`, the probability that each design is efficient given the uncertainty of its replicates (a bootstrap that resamples the same replicates for every design). diff --git a/docs/examples/AssessSamplingSufficiency.ipynb b/docs/examples/AssessSamplingSufficiency.ipynb new file mode 100644 index 00000000..4deaf0c3 --- /dev/null +++ b/docs/examples/AssessSamplingSufficiency.ipynb @@ -0,0 +1,1295 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "949d68b3", + "metadata": {}, + "source": [ + "# Assess Sampling Sufficiency\n", + "\n", + "Observations sample a varying field, such as precipitation or temperature, at discrete times, and a study estimates a statistic of the field from the samples: for example, the mean precipitation at each place over a month. Whether a constellation samples a field *sufficiently* depends on more than how many samples it takes. It depends on how the samples are spread in time relative to how quickly the field changes, and, for fields with daily cycles, on the times of day they see. This example uses the methods of `tatc.analysis` that assess the sufficiency of observations to show these qualities:\n", + "\n", + "* `estimate_sampling_error` predicts the error of estimating the mean of a field over a period from each target's samples, for a model of the field, with the effective number of independent samples;\n", + "* `compute_revisit_statistics` describes the times between samples, including the longest gap;\n", + "* `compute_local_time_coverage` describes the samples' times of day;\n", + "* `sample_field` and `compare_sampled_means` measure the actual errors against a simulation of the field (a nature run).\n", + "\n", + "The example compares four designs of a constellation: one satellite in a sun-synchronous orbit, a train of three satellites in that orbit minutes apart, three satellites in sun-synchronous orbits of different crossing times, and one satellite in a precessing, inclined orbit. Running it requires xarray for the nature run (in addition to `tatc[examples]`, `pip install xarray`)." + ] + }, + { + "cell_type": "markdown", + "id": "5e7868c1", + "metadata": {}, + "source": [ + "## The Model of a Sampled Field\n", + "\n", + "`estimate_sampling_error` models the field at each target as stationary, with a standard deviation and an exponential correlation in time, `exp(-|dt| / T)`, whose decorrelation time `T` is the time over which its values become nearly independent: hours for convective precipitation, days for synoptic temperature. For this model, the variance of the error of the mean of the samples, compared with the mean of the field over the period, is exact (`sampling_error_variance`). The error is relative to the field's standard deviation (`relative_error`), or in its units (`sampling_error`) given the standard deviation.\n", + "\n", + "The model's predictions show the first quality: what matters is how the samples spread in time relative to the decorrelation time. The figure gives the relative error of the monthly mean from samples evenly spaced over 30 days, for fields that decorrelate in an hour, six hours, and a day, and the error of independent samples, `1 / sqrt(n)`, often assumed." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "5d7db5c4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-13T23:01:06.400277Z", + "iopub.status.busy": "2026-11-13T23:01:06.400277Z", + "iopub.status.idle": "2026-11-13T23:01:09.148247Z", + "shell.execute_reply": "2026-11-13T23:01:09.148247Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
1 hour6 hours1 dayindependent
samples per day
0.50.25280.22350.14430.2582
2.00.11780.07220.03720.1291
8.00.04270.01860.00930.0645
24.00.01510.00620.00310.0373
\n", + "
" + ], + "text/plain": [ + " 1 hour 6 hours 1 day independent\n", + "samples per day \n", + "0.5 0.2528 0.2235 0.1443 0.2582\n", + "2.0 0.1178 0.0722 0.0372 0.1291\n", + "8.0 0.0427 0.0186 0.0093 0.0645\n", + "24.0 0.0151 0.0062 0.0031 0.0373" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from datetime import datetime, timedelta, timezone\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "from tatc.analysis import sampling_error_variance\n", + "\n", + "INK, GRAY, GRID = \"#0b0b0b\", \"#8a8984\", \"#e6e5e0\"\n", + "plt.rcParams.update(\n", + " {\n", + " \"axes.edgecolor\": GRAY,\n", + " \"axes.labelcolor\": INK,\n", + " \"axes.titlecolor\": INK,\n", + " \"xtick.color\": GRAY,\n", + " \"ytick.color\": GRAY,\n", + " \"xtick.labelcolor\": INK,\n", + " \"ytick.labelcolor\": INK,\n", + " \"axes.spines.top\": False,\n", + " \"axes.spines.right\": False,\n", + " \"grid.color\": GRID,\n", + " }\n", + ")\n", + "\n", + "START = datetime(2025, 7, 1, tzinfo=timezone.utc)\n", + "END = START + timedelta(days=30)\n", + "LENGTH = (END - START).total_seconds()\n", + "\n", + "\n", + "def evenly_spaced(per_day):\n", + " \"\"\"The times (seconds after the start) of samples evenly spaced over the period.\"\"\"\n", + " count = round(30 * per_day)\n", + " return (np.arange(count) + 0.5) * LENGTH / count\n", + "\n", + "\n", + "# decorrelation times, light to dark\n", + "RAMP = {\n", + " \"1 hour\": (timedelta(hours=1), \"#86b6ef\"),\n", + " \"6 hours\": (timedelta(hours=6), \"#2a78d6\"),\n", + " \"1 day\": (timedelta(days=1), \"#104281\"),\n", + "}\n", + "rates = np.geomspace(0.25, 48, 60) # samples per day\n", + "errors = pd.DataFrame(\n", + " {\n", + " label: [\n", + " np.sqrt(\n", + " sampling_error_variance(evenly_spaced(r), LENGTH, t.total_seconds())\n", + " )\n", + " for r in rates\n", + " ]\n", + " for label, (t, _) in RAMP.items()\n", + " },\n", + " index=rates,\n", + ")\n", + "errors[\"independent\"] = 1 / np.sqrt(np.round(30 * rates))\n", + "\n", + "fig, ax = plt.subplots(figsize=(8, 4.5))\n", + "ax.plot(\n", + " rates,\n", + " errors[\"independent\"],\n", + " color=GRAY,\n", + " lw=2,\n", + " ls=\"--\",\n", + " label=\"independent samples, 1 / sqrt(n)\",\n", + ")\n", + "for label, (_, color) in RAMP.items():\n", + " ax.plot(\n", + " rates, errors[label], color=color, lw=2, label=f\"decorrelation time {label}\"\n", + " )\n", + " ax.annotate(\n", + " label,\n", + " (rates[-1], errors[label].iloc[-1]),\n", + " xytext=(4, 0),\n", + " textcoords=\"offset points\",\n", + " va=\"center\",\n", + " color=INK,\n", + " fontsize=9,\n", + " )\n", + "ax.set(\n", + " xscale=\"log\",\n", + " yscale=\"log\",\n", + " xlabel=\"Samples per day, evenly spaced over 30 days\",\n", + " ylabel=\"Relative error of the monthly mean\",\n", + ")\n", + "ax.set_xticks(\n", + " [0.25, 0.5, 1, 2, 5, 10, 20, 48], [\"0.25\", \"0.5\", \"1\", \"2\", \"5\", \"10\", \"20\", \"48\"]\n", + ")\n", + "ax.set_yticks(\n", + " [0.002, 0.005, 0.01, 0.02, 0.05, 0.1, 0.2, 0.5],\n", + " [\"0.002\", \"0.005\", \"0.01\", \"0.02\", \"0.05\", \"0.1\", \"0.2\", \"0.5\"],\n", + ")\n", + "ax.minorticks_off()\n", + "ax.grid(True, lw=0.8)\n", + "ax.legend(frameon=False, fontsize=9, loc=\"lower left\")\n", + "plt.show()\n", + "\n", + "# the errors at a few rates\n", + "pd.DataFrame(\n", + " {\n", + " **{\n", + " label: [\n", + " np.sqrt(\n", + " sampling_error_variance(evenly_spaced(r), LENGTH, t.total_seconds())\n", + " )\n", + " for r in (0.5, 2, 8, 24)\n", + " ]\n", + " for label, (t, _) in RAMP.items()\n", + " },\n", + " \"independent\": [1 / np.sqrt(30 * r) for r in (0.5, 2, 8, 24)],\n", + " },\n", + " index=pd.Index([0.5, 2, 8, 24], name=\"samples per day\"),\n", + ").round(4)" + ] + }, + { + "cell_type": "markdown", + "id": "e32fcdd3", + "metadata": {}, + "source": [ + "Samples farther apart than the decorrelation time are nearly independent, and their error is about `1 / sqrt(n)`: at one sample every two days, 0.253 for a field that decorrelates in an hour, against 0.258. Samples closer together than the decorrelation time repeat each other, but they also follow the field's variations through the month, so the error of their mean falls faster than `1 / sqrt(n)`: at eight samples a day (every three hours), the error for a field that decorrelates in six hours is 0.019, against 0.065. Assuming independent samples overstates the error of dense sampling, here by more than three times.\n", + "\n", + "A field that changes slowly is followed by fewer samples: at two samples a day, the error is 0.037 for a field that decorrelates in a day and 0.118 for one that decorrelates in an hour. The error is that of the mean over the period (here, the month), not of a long-term mean. The monthly mean of a slowly changing field itself differs from month to month, which the error does not include." + ] + }, + { + "cell_type": "markdown", + "id": "eb178431", + "metadata": {}, + "source": [ + "## Four Designs\n", + "\n", + "The designs observe a grid of points from 50 deg S to 50 deg N (every 5 deg of latitude and 10 deg of longitude) over July 2025. Three carry a sounder with a 2,600 km swath at 824 km (like ATMS) in sun-synchronous orbits, which cross the equator at fixed local times; the precessing design carries a radiometer with an 885 km swath at 407 km in a 65 deg inclined orbit (like GMI on the GPM Core Observatory), whose crossing times drift through the day over about 46 days. The train's three satellites follow one another in the same orbit five minutes apart (`TrainConstellation`). The field decorrelates in six hours.\n", + "\n", + "For each design, the table gives the median over the points of the samples, the effective samples, the relative error, and the error that the samples would have if they were independent, and of the revisit statistics: the mean time between samples, its median and 90th percentile, and the longest gap (including those from the start of the month to the first sample and from the last sample to the end)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "be0a90c8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-13T23:01:09.149714Z", + "iopub.status.busy": "2026-11-13T23:01:09.149714Z", + "iopub.status.idle": "2026-11-13T23:01:51.926380Z", + "shell.execute_reply": "2026-11-13T23:01:51.926380Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
satellitessampleseffective samplesrelative errorif independentmean revisit (h)median revisit (h)90th percentile revisit (h)longest gap (h)
one sun-synchronous1.063.044.6860.0760.12611.41712.42112.42514.041
train of three3.0189.045.1090.0750.0733.7660.08312.25713.874
three sun-synchronous3.0189.057.5300.0290.0733.8073.3875.0495.653
precessing1.025.022.2030.1690.20027.64023.12651.28957.615
\n", + "
" + ], + "text/plain": [ + " satellites samples effective samples relative error \\\n", + "one sun-synchronous 1.0 63.0 44.686 0.076 \n", + "train of three 3.0 189.0 45.109 0.075 \n", + "three sun-synchronous 3.0 189.0 57.530 0.029 \n", + "precessing 1.0 25.0 22.203 0.169 \n", + "\n", + " if independent mean revisit (h) median revisit (h) \\\n", + "one sun-synchronous 0.126 11.417 12.421 \n", + "train of three 0.073 3.766 0.083 \n", + "three sun-synchronous 0.073 3.807 3.387 \n", + "precessing 0.200 27.640 23.126 \n", + "\n", + " 90th percentile revisit (h) longest gap (h) \n", + "one sun-synchronous 12.425 14.041 \n", + "train of three 12.257 13.874 \n", + "three sun-synchronous 5.049 5.653 \n", + "precessing 51.289 57.615 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import geopandas as gpd\n", + "from shapely.geometry import Point\n", + "\n", + "from tatc.analysis import (\n", + " collect_observations,\n", + " compute_revisit_statistics,\n", + " estimate_sampling_error,\n", + ")\n", + "from tatc.schemas import (\n", + " CircularOrbit,\n", + " Instrument,\n", + " Satellite,\n", + " SunSynchronousOrbit,\n", + " TrainConstellation,\n", + ")\n", + "from tatc.utils import hash_geometry, swath_width_to_field_of_regard\n", + "\n", + "LATITUDES = np.arange(-50, 51, 5)\n", + "LONGITUDES = np.arange(-180, 180, 10)\n", + "lon, lat = np.meshgrid(LONGITUDES, LATITUDES)\n", + "points = gpd.GeoDataFrame(\n", + " geometry=[Point(x, y) for x, y in zip(lon.ravel(), lat.ravel())], crs=\"EPSG:4326\"\n", + ")\n", + "points[\"target_hash\"] = [hash_geometry(point) for point in points.geometry]\n", + "\n", + "SOUNDER = Instrument(\n", + " name=\"sounder\", field_of_regard=swath_width_to_field_of_regard(824e3, 2600e3)\n", + ")\n", + "RADIOMETER = Instrument(\n", + " name=\"radiometer\", field_of_regard=swath_width_to_field_of_regard(407e3, 885e3)\n", + ")\n", + "\n", + "\n", + "def sun_synchronous(crossing):\n", + " \"\"\"A sun-synchronous orbit at 824 km with an ascending equator crossing time.\"\"\"\n", + " return SunSynchronousOrbit(\n", + " altitude=824e3, equator_crossing_time=crossing, epoch=START\n", + " )\n", + "\n", + "\n", + "train = TrainConstellation(\n", + " name=\"train\",\n", + " orbit=sun_synchronous(\"13:30\"),\n", + " number_satellites=3,\n", + " interval=timedelta(minutes=5),\n", + " instruments=[SOUNDER],\n", + ")\n", + "DESIGNS = {\n", + " \"one sun-synchronous\": [\n", + " Satellite(name=\"13:30\", orbit=sun_synchronous(\"13:30\"), instruments=[SOUNDER])\n", + " ],\n", + " \"train of three\": train.generate_members(),\n", + " \"three sun-synchronous\": [\n", + " Satellite(name=crossing, orbit=sun_synchronous(crossing), instruments=[SOUNDER])\n", + " for crossing in (\"13:30\", \"17:30\", \"21:30\")\n", + " ],\n", + " \"precessing\": [\n", + " Satellite(\n", + " name=\"precessing\",\n", + " orbit=CircularOrbit(altitude=407e3, inclination=65, epoch=START),\n", + " instruments=[RADIOMETER],\n", + " )\n", + " ],\n", + "}\n", + "COLORS = dict(zip(DESIGNS, [\"#2a78d6\", \"#eb6834\", \"#1baf7a\", \"#eda100\"]))\n", + "DECORRELATION_TIME = timedelta(hours=6)\n", + "\n", + "observations = {\n", + " name: collect_observations(points, satellites, START, END)\n", + " for name, satellites in DESIGNS.items()\n", + "}\n", + "estimates, revisits = {}, {}\n", + "for name in DESIGNS:\n", + " estimates[name] = estimate_sampling_error(\n", + " observations[name], START, END, DECORRELATION_TIME, targets=points\n", + " ).set_index(\"target_hash\")\n", + " revisits[name] = compute_revisit_statistics(\n", + " observations[name], START, END, targets=points\n", + " ).set_index(\"target_hash\")\n", + "hours = pd.Timedelta(hours=1)\n", + "pd.DataFrame(\n", + " {\n", + " name: {\n", + " \"satellites\": len(DESIGNS[name]),\n", + " \"samples\": estimates[name].samples.median(),\n", + " \"effective samples\": estimates[name].effective_samples.median(),\n", + " \"relative error\": estimates[name].relative_error.median(),\n", + " \"if independent\": (1 / np.sqrt(estimates[name].samples)).median(),\n", + " \"mean revisit (h)\": revisits[name].revisit.median() / hours,\n", + " \"median revisit (h)\": revisits[name][\"revisit p50\"].median() / hours,\n", + " \"90th percentile revisit (h)\": revisits[name][\"revisit p90\"].median()\n", + " / hours,\n", + " \"longest gap (h)\": revisits[name].max_gap.median() / hours,\n", + " }\n", + " for name in DESIGNS\n", + " }\n", + ").T.round(3)" + ] + }, + { + "cell_type": "markdown", + "id": "8beba2fc", + "metadata": {}, + "source": [ + "The count of samples does not rank the designs. The train takes three times the samples of one satellite (189 against 63 at the median point), but its error is the same (0.075 against 0.076): its satellites pass each point within minutes, and samples minutes apart repeat each other entirely. The three sun-synchronous satellites take the same 189 samples spread through the day, and cut the error by 2.6 times (0.029). The precessing satellite, with a narrower swath, takes 25 samples and has the largest error (0.169).\n", + "\n", + "The effective number of samples (`effective_samples`, the number of independent samples whose mean would vary as much as the mean of the samples) shows the repetition: the train's 189 samples are worth 45.1 independent samples, as one satellite's 63 are worth 44.7. It is not itself the error. The three sun-synchronous satellites' samples are worth 57.5 independent samples, but their error (0.029) is much smaller than that of 57.5 independent samples (0.13), as their samples follow the field's variations through the month.\n", + "\n", + "The revisit statistics show why. The mean revisit hides the clustering: the train's is 3.8 hours, as is that of the three sun-synchronous satellites. Its median revisit is five minutes and its 90th percentile 12.3 hours, and its longest gap (13.9 hours) is that of one satellite. The three sun-synchronous satellites revisit every 3.4 hours at the median, and their longest gap (5.7 hours) is shorter than the decorrelation time. The samples of one point over three days:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "04180688", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-13T23:01:51.926380Z", + "iopub.status.busy": "2026-11-13T23:01:51.926380Z", + "iopub.status.idle": "2026-11-13T23:01:52.026501Z", + "shell.execute_reply": "2026-11-13T23:01:52.026501Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# the samples of one point over the first three days\n", + "point = points.set_index(\"target_hash\").geometry\n", + "where = point[(point.x == 0) & (point.y == 20)].index[0]\n", + "fig, ax = plt.subplots(figsize=(8, 3))\n", + "for row, name in enumerate(DESIGNS):\n", + " samples = observations[name][observations[name].target_hash == where]\n", + " times = (pd.to_datetime(samples.epoch) - pd.Timestamp(START)) / hours\n", + " times = times[times < 72]\n", + " ax.vlines(times, row - 0.3, row + 0.3, color=COLORS[name], lw=2)\n", + "labels = {name: name for name in DESIGNS} | {\n", + " \"train of three\": \"train of three\\n(three samples a pass)\"\n", + "}\n", + "ax.set_yticks(range(len(DESIGNS)), list(labels.values()))\n", + "ax.set(\n", + " xlim=(0, 72), xticks=range(0, 73, 6), xlabel=\"Hours after the start of July 2025\"\n", + ")\n", + "ax.tick_params(axis=\"y\", length=0)\n", + "ax.spines[\"left\"].set_visible(False)\n", + "# the decorrelation time, for scale\n", + "ax.annotate(\n", + " \"\",\n", + " xy=(66, -0.8),\n", + " xytext=(72, -0.8),\n", + " arrowprops={\"arrowstyle\": \"|-|\", \"color\": INK, \"lw\": 1},\n", + ")\n", + "ax.text(\n", + " 65.5,\n", + " -0.8,\n", + " \"decorrelation time, 6 hours\",\n", + " ha=\"right\",\n", + " va=\"center\",\n", + " color=INK,\n", + " fontsize=8,\n", + ")\n", + "ax.set_ylim(len(DESIGNS) - 0.5, -1.2)\n", + "ax.set_title(\"Samples of the point at 20 deg N, 0 deg E\", loc=\"left\", fontsize=10)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "b7666a96", + "metadata": {}, + "source": [ + "The sun-synchronous satellite passes the point twice a day, about 12 hours apart, and the train at the same times. The three sun-synchronous satellites pass about every four hours, and the precessing satellite twice in three days.\n", + "\n", + "## Local Time of Day\n", + "\n", + "A field with a daily cycle, such as afternoon convection, needs samples across the times of day; a stationary model has none. `compute_local_time_coverage` counts each target's samples in intervals of local (mean solar) time. The table gives the share of each design's samples in each 3-hour interval, over all points, and the median number of intervals each point is sampled in." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a76b1aa0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-13T23:01:52.026501Z", + "iopub.status.busy": "2026-11-13T23:01:52.026501Z", + "iopub.status.idle": "2026-11-13T23:01:52.576993Z", + "shell.execute_reply": "2026-11-13T23:01:52.576993Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
local 00:00local 03:00local 06:00local 09:00local 12:00local 15:00local 18:00local 21:00median intervals sampled
one sun-synchronous47.91.00.01.047.91.10.01.12.0
train of three47.81.30.00.847.81.40.00.82.0
three sun-synchronous16.013.17.813.116.013.17.813.18.0
precessing17.111.76.214.917.011.96.314.97.0
\n", + "
" + ], + "text/plain": [ + " local 00:00 local 03:00 local 06:00 local 09:00 \\\n", + "one sun-synchronous 47.9 1.0 0.0 1.0 \n", + "train of three 47.8 1.3 0.0 0.8 \n", + "three sun-synchronous 16.0 13.1 7.8 13.1 \n", + "precessing 17.1 11.7 6.2 14.9 \n", + "\n", + " local 12:00 local 15:00 local 18:00 local 21:00 \\\n", + "one sun-synchronous 47.9 1.1 0.0 1.1 \n", + "train of three 47.8 1.4 0.0 0.8 \n", + "three sun-synchronous 16.0 13.1 7.8 13.1 \n", + "precessing 17.0 11.9 6.3 14.9 \n", + "\n", + " median intervals sampled \n", + "one sun-synchronous 2.0 \n", + "train of three 2.0 \n", + "three sun-synchronous 8.0 \n", + "precessing 7.0 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.analysis import compute_local_time_coverage\n", + "\n", + "coverage = {\n", + " name: compute_local_time_coverage(observations[name], targets=points)\n", + " for name in DESIGNS\n", + "}\n", + "bins = [\n", + " column\n", + " for column in coverage[\"precessing\"].columns\n", + " if column.startswith(\"local \") and \":\" in column\n", + "]\n", + "table = pd.DataFrame(\n", + " {name: 100 * c[bins].sum() / c[bins].sum().sum() for name, c in coverage.items()}\n", + ").T\n", + "table[\"median intervals sampled\"] = [\n", + " c.local_bins_sampled.median() for c in coverage.values()\n", + "]\n", + "table.round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "f4e8358b", + "metadata": {}, + "source": [ + "The sun-synchronous satellite and the train sample each point at two local times, 12 hours apart: 96% of their samples are in the intervals from 00:00 and 12:00 (its crossings at 01:30 and 13:30). The three sun-synchronous satellites sample every interval, though unevenly (8 to 16% of their samples in each). The precessing satellite's crossing times drift through the day, so over the month it samples seven of the eight intervals at the median point.\n", + "\n", + "## Testing the Estimate with a Nature Run\n", + "\n", + "A nature run is a simulation of the field, from which the samples of a design are taken at the times and places of its observations (`sample_field`) and compared with the true mean of the field over the period (`compare_sampled_means`). Here the nature run is synthetic: at each point, a series of half-hourly values over the month that follows the model exactly (a first-order Markov process with a standard deviation of 1 and a decorrelation time of six hours), independent between points. A second version adds a daily cycle peaked at 16:00 local time, as of afternoon convection, whose standard deviation is half that of the random variations." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "09ed8836", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-13T23:01:52.578577Z", + "iopub.status.busy": "2026-11-13T23:01:52.578577Z", + "iopub.status.idle": "2026-11-13T23:01:52.711532Z", + "shell.execute_reply": "2026-11-13T23:01:52.709942Z" + } + }, + "outputs": [], + "source": [ + "import xarray as xr\n", + "\n", + "STEP = timedelta(minutes=30)\n", + "times = pd.date_range(START, END, freq=STEP, inclusive=\"left\").tz_convert(None)\n", + "shape = (len(times), len(LATITUDES), len(LONGITUDES))\n", + "rng = np.random.default_rng(2025)\n", + "correlation = np.exp(-STEP / DECORRELATION_TIME) # between consecutive half-hours\n", + "anomaly = np.empty(shape)\n", + "anomaly[0] = rng.standard_normal(shape[1:])\n", + "for k in range(1, len(times)):\n", + " anomaly[k] = correlation * anomaly[k - 1] + np.sqrt(\n", + " 1 - correlation**2\n", + " ) * rng.standard_normal(shape[1:])\n", + "\n", + "\n", + "def peaked(hour):\n", + " \"\"\"A daily cycle peaked at 16:00 local time.\"\"\"\n", + " return np.exp(2 * np.cos(2 * np.pi * (hour - 16) / 24))\n", + "\n", + "\n", + "day = np.linspace(0, 24, 1440, endpoint=False)\n", + "local_hour = (times.hour + times.minute / 60).to_numpy()[\n", + " :, None, None\n", + "] + LONGITUDES / 15\n", + "cycle = 0.5 * (peaked(local_hour) - peaked(day).mean()) / peaked(day).std()\n", + "FIELDS = {\n", + " name: xr.DataArray(\n", + " values,\n", + " coords={\"time\": times, \"lat\": LATITUDES, \"lon\": LONGITUDES},\n", + " dims=(\"time\", \"lat\", \"lon\"),\n", + " name=\"value\",\n", + " )\n", + " for name, values in {\"stationary\": anomaly, \"daily cycle\": anomaly + cycle}.items()\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "c869f41e", + "metadata": {}, + "source": [ + "The values of the nature run at the point of the earlier figure (20 deg N, 0 deg E) over the first three days show what its decorrelation time means, with the samples of the sun-synchronous satellites there: the 13:30 satellite is the one sun-synchronous design, and with the 17:30 and 21:30 satellites, the three." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "340a57c0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-13T23:01:52.711532Z", + "iopub.status.busy": "2026-11-13T23:01:52.711532Z", + "iopub.status.idle": "2026-11-13T23:01:52.911737Z", + "shell.execute_reply": "2026-11-13T23:01:52.910603Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxUAAAIvCAYAAAACi/Z1AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQW4VNXXxhfS3d1IiCAqIQ1Kh4SAdAoCggiKCvq3UMEuQsAipUNSBKQbFCRVurs753vedb89zh1m5s7c6Zn39zz3Tp05s0/ts3olsFgsFiGEEEIIIYSQePJAfL9ICCGEEEIIIYBKBSGEEEIIIcQrqFQQQgghhBBCvIJKBSGEEEIIIcQrqFQQQgghhBBCvIJKBSGEEEIIIcQrqFQQQgghhBBCvIJKBSGEEEIIIcQrqFQQQgghhBBCvIJKBSGEEEIIIcQrqFQQQgghhBBCvIJKBSGEEEIIIcQrqFQQQgghhBBCvIJKRRjx3nvvyY0bNyQSWbZsmSxYsMDp54MHD5bixYvLI488IiVKlJDx48fH+vzDDz+UBx98UP/+97//uf27mTJlkgMHDogvtyNBggTywQcfWN/bvn275MuXz63v7969WypUqCCFCxeWMmXKyI4dO9z63tChQ6Vjx47iS5588knJnz+/PPbYY9a/3377TYLJtZv3ZOSSM1Lr0z1S/M1d+ojXeD/cr+0+ffr4/Xdu3bolTz/9tF5HPXv2jHOOwTn19ddfe/27zZo1kxw5cui1ceHCBev7V69elbJly8qjjz6qf3Xq1HF6Pc6cOVOvfZyHDz/8sF7nFovF6zkgLrZs2SKTJk1ya1mMPV26dNbXtttbr149+eeff/T56NGj5e+//473mJ599llZu3ZtvL8fjWA+++WXXyScePXVV2XChAnBHgYhbkOlIowYMGBAvJSKe/fu6V98uHPnjoSCUlGsWDFZvXq1bNu2TebNm6cC2N69e/WzFStWyMSJE2Xr1q2yc+dOFXyxTLDIli2bDBkyRM6cOePxd7t16yZdu3aVf//9V/r16+dzRcFTvvrqKxWqzF/t2rWDNhYoDp1+OCiDF52Wo+dvC+RJPOI13g93xSIQbN68WRVXXEfDhg3z2RwTF927d9fzx57kyZPL4sWL5a+//tI/nF+9e/d2uI4aNWrEOhcXLVpkFRL9OQd4olS4Yv78+VKkSBGvlYoNGzbIuXPnpHz58l6PiQTvnucOr7/+uir6d+/eDfZQCHGLqFIqYNWCZcyff7aWM2fAejVo0CB54okn1BI8atSoWJYJWKhhjatSpYrVsoWbMqhcubJ+durUqfusiPguJiCAx6ZNm+pNGhb+48eP6422UqVKUqpUKf3tpUuXOrXovPTSS3rTqlWr1n3WtytXrug2uLM9tkCQwe+XLFlSLY2wLJqb9ogRI+Tnn3/WbXv//ffv+2716tUlbdq0+jx37twquB8+fFhfT548Wdq1aycpU6aUpEmTynPPPacChiNmz54tRYsWVYsnJmxbIGzVr19f9z8+h/XfMGvWLP0erKkQ9l15OLJmzarjsfVWuAOO6aZNm6Rt27b6GscP27hnz577lr18+bK0aNFChRTsU+xbWz7//HM9HtjXsP4ePHgw1vceeughPZegxARbcXGXcavPyfYjjgVevD9uzTmv1n/9+nXdNzg3cZxx7oMTJ07IU089pdcNlNsXX3zRqqRDOISw26pVK/0evEwQap955hk9X7AOXC+212S1atV0/zdo0EDOnj3rcCzOjt+cOXOs1npc1zgvHfHZZ5/pWOGRaNOmjVy8eFHHheeHDh3S748dOzbWdxzNMWDXrl16/cF71qRJE/V2gNu3b0v//v11nFi+efPmcv78eYfjwT7KkiXLfe8/8MADkjp1an2OufPSpUux5hZbsByWB1B8bt68aV3W3TnA02OMffDOO+/oXIltNPto48aNehxLly4tjz/+uEydOlXiAt5KzHU//PCDXucvv/yyrhPKhqtjbs/IkSOldevW1tcYI44LjjXOCXxu+5sYP+ZyzM1mzjXbjGOG38R333rrLYe/t27dOt0v5pwbPny4vh/X/Qf7Gec49jX2FRQhd9d/7NgxnUevXbtmXQ7bbH7b1T0H5yvue7hO8Id7i2HVqlV6fsObZY6l2RacM7jnYgzOrqG4tg3C/2uvvabrwF+vXr2s14ur/eXsusY1g7EuXLjQ4b4jJOSwRBFXrlyxpEyZ0q9/+I24wG7//PPP9fmuXbssqVKlsty+fVtfnzp1yrrcxIkTLbVr1471vfPnz1tfd+jQwfLVV19ZX/ft29fy7rvv6nM8Zs+e3XLixAl9vXfvXku5cuUsFy9e1Ne7d++2ZMuWzXLjxo37xle1alX93Vu3bunr/fv3W9KmTWv9/PLlyzoWd7bHlkuXLll/79q1a5bHHnvMsnbtWut4e/fubXGHRYsWWXLkyGHd108//bRlwoQJ1s/nzZtnqVy58n3fO3nypCVDhgyWHTt26OuRI0fq2LF9d+7csZQqVUrHD65evWp55JFHLBs2bLB+z3z2008/Wb9nz9KlSy2PPvqo5ezZs5bMmTNb9u3bZ9m2bZslb968cW7Xpk2bLIULF471XpkyZSy///77fcu++uqrlnbt2lnu3btnuXDhguWhhx7S8wH8/PPPli5duug2gbFjx1rq1atn/R6Ww/dwPIoXL279nqPzIF++fLo95m/Pnj2WYFHzk92Wh/vvdPqHz71hxowZllq1allf4xiC69ev6zkPsE/r16+v1yYYNWqUJU2aNJaDBw/q67Zt21oKFChgve6w7NChQ63nOM6J48eP6+sXXnjB8vzzz993/rs6fiVKlLCsWbNGn9+9ezfWfGCYP3++ng/mM/xG9+7dY52fznA0xzzxxBN6PWA8FSpUsF5rAwcOtLz//vvWZfG8R48eLvex/foN1atXt2TJksVSrFgxy5EjR6zv161b17Jx40br69WrV+s5mzRpUkufPn30PPZkDojvMW7UqJH1Oxg/5q5jx47p69OnT1ty586t47afK223F3PA5s2brdfWzJkzrcu5Oub24PzCnGJo3ry5pX///vocc1WuXLms8yp+s1evXtZx4lw1+xf7YdmyZfoc8zXm/ClTptz3ew0bNoy1b8+dO+fW/Qe/febMGX3dokULy6BBgxxuj7P1t27dWudogOsJ1445Rs7uOfgrVKhQrPVhu80+b9y4sS6D+w/mNnMtYVtwbWFOjOsacrVt3377rf4O7nP4HZy/H3/8cZz7y9V1PWDAAF2WkHAgUbCVmmgFlg8Ai2WiRInUapQrVy516SN0BhZlWMqcWXfcATG8sPYAhBbB4g1LjAFWP1gtCxUqdN93YS1PnDix19tjbyXs0aOHWuvw27DC43m5cuXc/h1Y5Dt16qSWSVglPQEWMViDYF0CnTt3VksSgEcI+QstW7a0Lo9jAOsuvDz4HrYNdOjQIZaVyxEZMmTQEC1Y/9544w3xNb///ruGJsFiBw8OrHgmHAwhIbCkwvoHbF3ntt+D5RcWN0eeEAOWbdy4sYQCxy7cdvn58Tg+jwtYrmHlxDlatWpVvX4ArkN4p2DlhDwDyzCsieZcgRU4T548+hyWa1jwzXUHrxc8YAZ4wuBlAwhzg4XZHlfHDx4DhAchRwFWdlg27UE4EY6r8S6+8MILGoMfX+B1SZEihT6HZdj2PIP1dvr06foaFll3c4ccjRn7eeDAgfr37bff6vvGim+AJwhzwOnTp9Xrs3Llylhzmr+OsS1r1qyRffv2Sd26dWO9jzmkQIEC8dp+V8fcniNHjljPL7Pv/vjjD6tlG+cU3jPzqvFqwLuK8e3fv1/PDcwFJ0+etK4HHjXjGbcFHhx4XXEewyoPz6g7wNuSMWNG6zVi702Na/04z59//nm9Tr7//nv1BqZKlcrlPQfnI7xYWNaA7TbgusCy+MO1g3PZhJHhGjFes7iuIWfbhu/BIwFvGcD4EWaIc8sVrq5rzBe4DxESDkSVUoEbo+0k6q/fcIdkyZJZnydMmFDjOCHgw+2OmwtcnogPdnXDxMRoe/PBZGo76do+x42yZs2abid92X7X0e+4sz32vPnmmzrBI64b68TNz5P4bUysSDL96aefYt3YINDZhgogLMkIea6wDbPA/oEi4CjuGyFT8QFKBUJGcANyB4R1QYHBvsP+wZhwTsRnW6DI4GbsyfdCnRzpEmsOhTOyp3NfCXYEBC6cY0uWLFHhAOFxOB8gFEDIXL9+vZ7nr7zySqzz1v7cd+dacLX/XR2/L7/8UpVfhONAuYVgZR/G585veIKz7cE4YQAxIUTeAkMDhDAYOYxS4YzMmTOrQoCwI8yR7s4B8T3GtmC7ERYD5cKe+BZ98OSaxT3G1bxpf7wdHT8TpgtDi+3nzuaxRo0a6f7CHA5lC8cnrvuPs/MGgrMxZECxcbZ+KLDYVpzr3333nX4e13bFhavv2I49Pvs0ru+52l+urmssh9wjQsKBqMqpwAUO67Y//7y5gcPKAu9A9uzZddK3jekHsKKYuE5QsGBBTdoDiM22t+rZghhTTMpQVAzmu3EBSwnGY6wl9rHY7oJ4a3gvMLnCIgavjCFNmjSxts0eWBchRODmAuXIFliQxo0bpzktiLOG0uHIwgiLErbfJEhiORPvitwEjME2Nhc3PniKYPHD94wVD5WnzPdcgRvi22+/rTHNtrRv314r2dgDKyPiqU1lK1iAsb9wnB3FqGOsJg7dNn4cngXEERsvFyznUOQALIFjxozR78EyOWXKFAkXmpZO5/rzMq4/jwtYgHH9NmzYUOPbsY/gTcN5i2sAggSsoe7EzzsD16gxbCC2HsfRHlfHD+euifmH9RRCoT1YJ44rzguAGHt3BX/7OcYVGCc8WSbuHY/uViszYH/a5mHAAwmvoCOw7SaXBV5EJGKbZd2dA+JzjO3nJnhLYO23FXKhmLgzJzhbp6tjbg+22dajgOMNSz6AB2fGjBn3zZH2QJiFh+Djjz+2voc8Buwfe/BbyFuAwgeh35xzntx/bJk2bZo12R7WfmfrB7DeY75EfhIMNHGBeRzzru18GJ+CGfG9hvA93B9xLkDRwDVuvudqf7m6rnHvg4eNkHAgqpSKUAcJYbgRYnJB2IS9pa1v3756szBJlLBq4SaCCRcTr6swIkxo8FIgMRcTFL7jbqlIKAGwSMJLgHHhhhcfEAoEQRg3RSR4QsC1DbHATcZZojYSx3EThhvZvrwpEsvhqsb+w3ZhH2GsjqybEDbwW9gHcLcbFza2ce7cuXpDxvhwDBAehZAtCPu4OeDGj9+Fqxs3ZdvkdWdgHUmSJIn1HpI04ZVwBG5e+MMNFDd8Z0nvUFYwNrj+oWzZem5g5YILHkIDthNjhmUWQMGBQIb9BA8KPne1HSaZ1PwhmT5YtKuYQYrncmxVxfvtKmTwav04rhUrVtR9guRbJP7iXIBgAws2zgm850gRcBckiSIcBccNlnUkm9rj6vhB6MI4MD4I0SbR0xaE5SBEEEo0rgkIRh999JFb47OfY1yBaxHzAUrCYj9h/nHk6TNhXyYcEuPHNQvgicM8gO9jrLDU2paLxrmN68UoHLBiY59g2xAy0qVLF4/mgPgcY/wOFBUsh7DH9OnTq0KDY4f1IJwS85knFfYwd+P7JlHb1TG3B5Z+29LOKLcNwRPbju+jnC6OSVzgWobhxJTqhufYUeEAGLfMOYc5/IsvvrBug7v3H1c4W7/ZVhg/IGy7A+ZxJDlj3sQ2YV+a8DxPiO81hH0CwxD+cAwRDmhKRbvaX86uayi98ObgnkVIOJAAiRXBHgQhoQ4EcRNvi/hnhCrgRu4puKlAqLT10gQSKIRwwcMiC6suPFjIK4FAFg6gbCyqPE3feEFzLBASBQ8FFIoUSUPbRgJBAT0LfNH3gUQvELLhLUGfCk/zysINKJSYL2HJN5W/ognkQkLJtu/LREioElU5FYTEF3hqYCmFQI7Qhfha7OEtCZZCARDmASsctgOxuohlRlnJcAGKQ7enMukfIdEIvKQIO0MIlil/GonAC4VSqvASR6NCAeCd//TTT4M9DELchp4KQgghhBBCiFdEp/pPCCGEEEII8RlUKgghhBBCCCFeQaWCEEIIIYQQ4hVUKgghhBBCCCFeQaWCEEIIIYQQ4hVUKoIAmuKg7wFAzXp0cA01li1bpjWyDQcOHHDZJA1dalGDn5BAcOzaBTl+3b3Oz+EAeliYJln+BJ1+0RQODb169uzpcBwoNWxAQzZf9NVAE7McOXLcN0+gGZ1tc0U0C8uQwXETQ/RlMMuhURgaeaIpneHHH3+UQoUKyYMPPqjdmePbpNNdSpcurfOkPdimKlWqaINDlHx97rnntFFlXPvCnpkzZ2rDPWwvGuyhqZ1tscYPP/xQtxV/+MxXoIHhpEmT3FrW/r5gu01oXGg6f48ePVp7TfgSdHDHMTD3UnfL1KLBouk3ZNu5GscS+9od0ETUlBW3v1e6AvvGtou5adyIsRDPwDmFhrThxNatW7WkeyRDpSIIYNI2jdTCRakgJJQY8u9y/SOesXnzZu0kD8F32LBh930+YMCAWEqFr0AnakfdtqHc4H3zB4UH3aUdge7IGzdu1OUwfnT8/vbbb/Uz9GxAl/mVK1dql+iTJ0/Kd999J8EAjSXRJRpC9F9//aVNJj/55JM494U96Optu2/Q38YInytWrJCJEyeqkLJz507tsI0u34FWKlyBTuFFihTxm1KBfYw+O+Ze6g7oeYGu446UCk94//33reept0qFu9y5cyde3yOhs+9KlCghSZMmlSVLlkikQqUiCBhrDiamY8eOaTdjWEgwmc+ZM8dqnYKVa9asWfd9H5MYPnvhhRd0WdyYcXOBVRHPy5YtK0ePHtVl0eTstdde0+Xxh+7JsFYCLA9rX/Xq1aVw4cLSpEkT/QzjGDFihFpiMA6M0/Duu+9KqVKlpGDBgnrTsGfatGlSq1Yt62v8ft68efXGZw8sNH379lWrXp48eVQowDorVaqkFssvv/zSuiwEofr160uZMmV0m3FDMWByh8UK72MZo6QZK1pcYybh56WYfOgPmXRwk0+9FbAm41qEVRgCrDmPcT5BEME5BAv5iy++KPfu3bMKSxD+WrVqpd9Dp2Oc688884wULVpU14EOyMYL0LRpU6lWrZpasRs0aCBnz551OJbPP/9cnnjiCSlZsqTUqVNHDh48qO+7Mz+Azz77TMeK+QDXB5poYVx4fujQIf3+2LFjY30Hwi6oXLmyfg6hHaBzvP0cAeAJ6N+/v44Ty6OJIporOgL7KEuWLC73P5QZzDmdO3d2+HmKFCkkceLE+hxjwPHCXGrmnYYNG0q2bNn0PWwLhG5HvPrqqzqPYMyYe4w1HeC7gwYN0m3Knz+/jBo1yvrZmjVrrPu9U6dOTgUVeEtwjEDChAn1tzAXebIvAIRl0/QN+wZeGbO9aMTZrl077agNIQXeEEfb6+k5jWMOKzys+dhWc05AmcN5i3n28ccfl6lTp8Y5fszhuJdAkEdn7JdfflnXaeZgb8/xkSNHardtgCZ5ZtsuXbqk54lRKnGeY//YegUwhtmzZ+t1gt/BGAGOaY8ePXRfYb9g3I4wHjxX90pHYH/Cs4JlsS8Nq1at0usOXiezz83vYOw4T02jw3Hjxuk9HvsN70NxNTjbp+6cE/aemu3bt+sx9PRe6mz9MBhMmDDBuhyOGbbDlSwC8GhkGKwP22XA3Iq5F/Mc9ue+ffus24Ljh7kE2wSvH44l5mecW9hHq1evdmvboLBjf+J7VatWtcoyrvbX6dOndbsxLnwP84UB48W5G7FYooxbt25ZThw/5rc/rD8usNvPnz+vz/PmzWvZvHmz9bMSJUpY1qxZo8/v3r1rXc6WpUuXWhImTGjZtGmTvn7rrbcsGTNmtOzatUtf9+jRw/Lqq6/q82+//dZStWpVy40bNyy3b9+21K1b1/Lxxx/rZx06dLA88cQTlqtXr1ru3LljqVChgmXChAn62bvvvmvp3bu39Tf379+v4542bZq+/vXXXy2FCxe+b5uwHmzT33//re/PmDHDUq1aNYf7AeNq2rSpfufcuXOWNGnSWHr27Gm5d++e5ciRI5aUKVNa11mqVCnr9mG8jzzyiGXDhg36+tSpU9Z1fvTRR5Zu3bq5NWYSnvTf/Isl58w39e+NLbN8tl6cq7Vq1bK+Pnv2rD5ev37dcvnyZX2Oc7F+/fqWiRMn6utRo0bpeXvw4EF93bZtW0uBAgUsJ06c0NdYdujQodZrKnPmzJbjx4/r6xdeeMHy/PPP33e9/fzzz5YuXbrob4GxY8da6tWr5/b8MH/+fMtDDz1k/Qy/0b17d+vc8eijj7o1N8U1RwwcONDy/vvvW5fFc8w9rrBfvy3Y7pIlS8Z6r3PnzpZZs/47xrimsQ8wNzRv3txy8+ZNff/FF1+0DBo0yLrcjh07LLlz53b4O7bzBY5j7dq1Y43v888/1+eYb1KlSqXzJn4nV65clkWLFulnv/32my6L/emKK1euWIoUKaLnljv7AvPzxo0bra9Xr15tKV68uCVp0qSWPn366NwInn76aetxAPPmzbNUrlzZZ+d0o0aNrN/BGB977DHLsWPH9PXp06d132KOxvFImzZtnPc2zPUzZ860LuftOX7o0CG95xmuXbtmSZ8+vd7nfvnlF0v58uUtzz77rPWaxO/ZjwPn9ldffXXffXXdunX6evjw4bH2nS2237W/V7rCfn+ZMTVu3FjPM2xHvnz5rNuP38H+uHTpkr5etWqVniPYTrBixQrLww8/HOc+deecsJ8btm3bpsfQ03ups/UvXLhQj4uhYcOGOsa45pn33ntPlzXbbK5fM/fu27dPX/fr18/StWtX67YkSJDAsmzZMn2N6xfn7IIFC/T1ypUrLVmzZtVrwNW2nTx50pIhQwbL1q1b9fX48eMtRYsW1evQ1f768ssvrWOx3QcA9wrbczfSSCRRxrmzZ2Ts2J/8tv727Z+TrNmyx/v70NR79+6tcbfQdJ3FeEKbhlYNoKHjNayfAFo4NHOwePFitQLAmgUQa4ywh379+ulrWFRhATTf27t3r0u3PiwIoHz58g6XhWUOlh78xuDBg/URVjBnYDvxnfTp00uBAgXUmgFrXM6cOSVz5sxqRUiSJIns2LFDWrZsaf0erD2wGMAKCOsHrDew5uEvU6ZMHo2ZhJ+XwgBvRa/CVSV78rRerxtWMFjlcf7CIoWYcAALLq4XWBMhN8GaC6uZOR9xXsHTZq5FWPCzZs2qr3F+wstmgCcN1nTQtWtX67lpCyypsAyb6xvePk/mB1zzsBSaWHd4NJ999tl47xdncwTGCQ/I9OnTrRZFY6mLD8iJsPdSGAuyAeuHZRYWyrZt28qMGTNizQvugDCiIUOG6ByCY3vu3LlYn5uwFsyniRIlUqs+lsFzeBkA9j3mK1dgf+A4YFnsQ3ewt/7CsopQL1g+4eVCeBes0/4+p22BhwYWYPtYcHh44toHzvD2HD9y5Ij1GgPJkyfX5WB9xvkPD9orr7yi24lQE3gk3AH3UWM9x3UNy38gwHmC8wt/2A5cY/h9gGvXhHjBa4Pz34wR4NyEd8DVPnXnnIgLd++lztZfs2ZNzRtDCCbypjZs2CBTpkyJc56ZO3euhg8aGQZygQHjgEfRPMd1bcC5id835yq8frVr19bXiIbA+QNPU65cuZxu2/r169XbgD8zNyAXzUSCOKNcuXLy1VdfWSMxbL0rmP/hoYasgt+NNKJOqciQMZMK/v5cvzcg5AcCNNzPHTp00JP49ddfv28525MRQrn9a2eueeM+d7YeV7GHuKjN97Gss0kLigtcn+3bt9f4ZoQlOMOd7YArG5OQozhk3BShvCCJEyEFcGnDfe/pmEl4gDyKW/f+O4Z4jvcGPer8HHMX3ISgqEIIgWCC6w7nHBRjCF24weD8hLBim3cQ32vR0fUIIOS98cYbqnTEd36I6zc8wdn2YJy4iduGO8YX5EQgvt0oKHGRKlUqFYARdoJHKHW2Qg6MEUbRswWhXzByQPhCqAnCRu2F9PjOpbZAsYSgmD17dvnmm2/EWyBIQThD2JEJF7UNbXG2vfE9p23BcUYoCZQLe2zDujzB23Mcwqf9eKHwYRuRb4K8BQiC48ePV4OVUeTjwpNr15e4+l2c67b7DfsEIXqe7FN3zgkoNLb3R/v96+xeivAyE6oMZRChPo7Wj+Pw0ksv6ZwBgR5hXUZRiGsfeLvf4rp+4yMnuNpf5cuX123G9sPwgdBuKFNYN5bDI4ylkUjU5VRAQIUnwV9/JubXXdKkSaPWPgOS2UyMKyyM8U0ks51ocdHDaoYLDpY/d4QA+3F5AiYPJNDB8oA4SVxA3oBkP4zHNr4ZygosNIjhhhUnY8aMuo0RHasY5dh7KQy+yq2A9RM3FijBsFDiJn348GE9xyCU4AYGq7U78eSuLNFIIga4Fo3l2xZUNEGctrGgQ0DFDcnd+QHrhAUQseUA14S7gj+uJXeve4wT1jhU4QF4hDAYH3766SedL1xVmMM1byo64Vo31ZEArPgwKOD44Lhh/zmyumPbMEdD2MdytrlZroDXAvOnqRwEYcGZpRbL4bdhCEFcf3yVOhxrk7sDrwoSsc32wnoN7yySwJFrgf3naHvjc07bz/3wlkDpwzYbIDCZmHd3sF+nt+c47glQimyrauG8h9ca5xByTfAaBiZH15ijMcUXR+uBtwWWeEfLYsye7DtbcByhKEE5Bjg/TN6Hq33qzjkBZQOKKrxiAOeXO8B4aIoJQKFwtn6APCDkKOBebps7Etc2QzE3ld7M+DwB5wv2FbyUAAoyzvu4qn3B4wBPIfIlAAoYIIoCf6721/79+1WpQZ4ZlKh///3XmlsHLw68giZfKtKIOk9FqAHNHZZ9WF6Q9IlEL7jqoMXiveHDh3u1flgtcPNDopFJVHOndCVu8LhIcNHBLYiJwxOwTdgePHoLLAJwgWLcEGJgHUCIE24gcCtiksWkAcUCN5C4XJMkMrwUvvZW4OYBSx9ughAMcQOEEGdCMSDooBSoMyHFHZCMieRSnKNI6MU1Yg8ss3CPmyo1GAusekiQffPNN+OcHxCmgpsgrGW4cWEbTJWkuIC7HmEKWDcSKV2B8Bnc6BGKYQRnvIf9ZA/CvkxCKT7HtptyrLjZYz/YJ46bEqAQKvAHyye8ksYiCcENFkCAGzwqV1WsWNE6z8GgYQ+s1xC+MQbMF+6WpMT+RnI0Qjow/yCsDWEejsBysE5iv+OYAYzLVNtytS/gjcA9AGF0WA/+oAThN3EOYn+Y7YMnxIRl4DlCR31xTmO/QhjEclAoIKhCoUGCO84PCKvwinhSBhX3IXwX8zes7N6e41CGoCjjnMD+BNhnEO4xfoDzGIqJeW0P9gVCg7EdCGlB6FN8sL9Xorwvji/CauyBool7KfYthE5nieCu5o9PP/1UfxP7DMoJth/b7mqfunNOAHgVEHoET0J8S5+6Wj+OJ/YRCtTkzp3brfVhTsE+hQyDawHnq6cFV3Au4ZqEvIXzEOcPijvgGJw5c8alhxDeUBwzbAsMplDAMd9hHM7217Jly9R7Y+YqhN+lTRsTootKYbj2IpUESKwI9iBI5IGbEjRyxEkT4i0nb1yW6r9/IzfvOXaJJ30gkfxevbdkTeZ+eclAg+pPqPrmi74PhEQ78ARAAYPBKZRAaB28g/b5QCQmzwM5H7DeQ0GKNm7duqUKIJRh29zPSIKeCuJzYP2CJs8+F8RXQFnYXv+tYA+DEBIiwEIMqzdCwzzpVeFv4MXCH4kNwhPhKYBFPxoVChMWhXyfSFUoAD0VhBBCCCGEEK+IzEwRQgghhBBCSMCgUkEIIYQQQgjxCioVhBBCCCGEEK+gUkEIIYQQQgjxCioVhBBCCCGEEK+gUhEE0CQHZfAAatajs6M3oNFVvnz54lwOjXbQJAkcOHDAZffaQICys6jbTwghhBBCwpuo7FOBBiTOQAdadHB2Z1kIxejw6CloZ2+AUoHuqNmyZRN/Y7q0EkIIIYQQ4kuiUqn45uvPnH5WoMCD0rRZS+vrb4d9Lbdv33a4bO7ceaRlq3Ye/z6UkfPnz8vgwYO1XT28B8mTJ5fRo0fL4cOHtSU9lBu0dx84cKA0atTIYXdetI9PkyZNrPbw+E79+vXl7Nmzcv36dXn00Ufl+++/l5QpU2rr+D59+sRSakz363///Ve+++47fQ3vQcGCBfW9DBkyxFoWXbKxjuPHj+vrHj16qLLStm1b/QzbBipUqCBvv/22jm3evHk6Xiho+BzdRsuWLRtrvbt379b1njp1Sm7evCldu3aVF1980eN9SwghhBBCAk9UKhWhwjvvvCM//fSTeg8QEgU6dOigQnf58uXl3r17cunSpfu+ByF96tSp8scff2gn0Xbt/lNsEiZMKBMmTJCMGTMK+hpC6B8yZIj079/f6Ti6dOkihQsXlk8//VRDokaNGqWKjL1CAYUF7w8YMEBatWql7505c0a7Q+L3Fi1aJLVq1ZLNmzfL6dOnpU6dOqqYdOrUSVasWCEPPfSQKmjXrl2Ltd67d+/q+saPH6/L4PNy5cqp4sHOpIQQQgghoU9UKhW9+7zm9DN4CGzp0bOP02WNVd6XVK9eXXr37i3NmjVTAd0oG7b8/vvv0rx5c/VSgG7dusmqVav0ORSJr776ShUPKAEXL15Ur4EroEjg96DgvPzyyzJ8+HCHYVL//POP3Lhxw6pQANNuHmMeOnSojnnYsGGqzGD/QNGAcgFlASBcLG3atPetd8eOHdKy5X8eIuSc7Ny5k0oFIYQQQkgYEJVKRZIkSfyyrC/48ssvVcBeunSpei3atGkjr7/+usvv2Co38FIsWbJEli9frkoHQqzwOi5eeukladiwoRQtWlQyZ84sjz/+uEfjbtKkiY4TXorZs2drSJW7QBGCV8Q+LIsQQgghhIQHrP4UZCD4w5tg+Pvvv6VYsWKaT/DCCy/IunXr7vtOjRo1NPwJ1nwI5CYXAiBXA94DrBefI0/DHeBJKFCggMtchiJFikiKFClk4sSJ1vcQ/gSQ3N69e3dVTJ555hlrZanatWvLb7/9ptsFEP5ku71mvRgvwq4Me/bskXPnzrk1dkIIIYQQElyoVAQZeAief/55DXOCpf7NN99UpQKegnHjxmmCsz316tXTcKWSJUtqknSePHmsn7Vv315zEiCoI0m6cuXKbo8F40DIFNbtCCgOs2bNUuH/kUce0STw6dOnWz/v3LmzHD16NJZSgoRvLI9EbiyPPAmEO9mvd+7cuTJjxgwpUaKEbj/WhURzQgghhBAS+iSwwNRNiIgqA1mzZtWqTfFh2rRpmo+BnA9CCCGEEBI9RGVOBYkNytpWq1ZN8xoQqhQfTKWnmTNn+nx8hBBCCCEktKGnghBCCCGEEOIVzKkghBBCCCGEeAWVCkIIIYQQQohXUKkghBBCCCGEeAWVCkIIIYQQQohXUKkghBBCCCGEeAWVCkIIIYQQQohXUKkghBBCCCGEeAWVCkIIIYQQQohXUKkghBBCCCGEeAWVCkIIIYQQQohXUKkghBBCCCGEeAWVCkIIIYQQQohXUKkghBBCCCGEeAWVCkIIIYQQQohXUKkghBBCCCGEeAWVCkIIIYQQQohXUKkghBBCCCGEeAWVCkIIIYQQQohXUKkIAOPHj5ecOXNKOLN27Vp54oknJF26dNKyZUtZsWKFpEqVSi5cuOD2Oh5++GEZNmyYy2Wwzjlz5vhgxIQQQgghJFBEpVJx+vRp6d27tzz00EOSIUMGKVCggDRq1EgFZ2+FW0eCc9OmTWXz5s0SzrzxxhtSokQJ2bFjh4wYMULKlSsne/fulbRp0wZ7aIQQQgghJMgkkiikTZs2cvv2bRk5cqTkz59fTp06JcuWLZNz58755feSJ0+uf8Hm1q1bkiRJknh9d9++fdK5c+dYHpesWbP6cHSEEEIIISRciTpPBcJ11qxZI++//75UrVpV8uTJI6VLl5ZXX31V6tevb/U2gFatWqnHwryGYN2iRQtVRCBQV6lSRZYuXWpdd506deTQoUPSr18//R7+nIU/ff/99/LII49I+vTp5fHHH5eJEyfG+hzfHT16tIYaZc6cWR599FGZN2+e9fO7d+9Kjx49pFixYpIpUyZdh72HpFu3bvr9Tz/9VAoWLKjLfPTRR1KmTJn79kv58uV1n9hz8OBBHQsUrhdeeEGfY3schT9hv9asWVPHU6RIEd2nV69edXos9uzZI7Vq1ZKMGTNKqVKlZMmSJU6XJYQQQgghoUvUKRVG2J87d67cvHnT4TLLly/XR4T5IMTHvIaADCEY3129erXUqFFDnn32WTl8+LB+PmHCBFUe3nrrLf0e/hwxe/Zsef3116VXr16yYcMGee6556R79+7W3zFAAWjSpImsW7dOfxeeAuNNuXfvnuTIkUPGjRsnmzZtkv79+8uAAQNk+vTpsdYBD8zu3bv1N6dOnSrt27eXf/75R/744w/rMn/99Zds375d2rVrd99Yc+XKpduRJk0a+eSTT/Q5wrnsgcL1zDPPSOPGjXW8Y8aM0XCyvn37OtwHGH/r1q3Vc4IxfvPNN/L22287XJYQQgghhIQ4lihk5syZlly5clkyZsxoqV69uuXdd9+1bNu2LdYyKVOmtMyePTvOdZUuXdoyfPhw6+uiRYtahg4dGmuZcePGWXLkyGF9jd/s2bNnrGXatm1radKkSazfHzBggPX1lStX9L2FCxc6HcvLL79sad26tfV1165dLfnz57fcvHkz1nLPPPOMpXfv3tbXffv2tdSpU8fldmL82A7D8uXLdTznz5/X1z169LC8+OKLsb6zevVqS+rUqS3Xr1+/b98sXrzYkjZtWsuxY8esy2Pb3N3vhBBCCCEkdIg6TwWANR3W+ylTpqi3YeXKlVKxYkUN63HFlStX5M0335SSJUuqRwIhULD6HzlyxKPfx3cQbmQLEp/xvi3Fixe3Pk+ZMqV6C5BkbkBOSKVKlSRv3rw6llGjRt03FoRH2edRdOzYUaZNmyY3btzQPAvsB3gwvGHbtm3y888/6zjMH/YzPBIHDhy4b/m///5bvSDZs2e3vofqUoQQQgghJPyIykRtkCxZMqlWrZr+IXSoZ8+eMnDgQGnbtq3T70ChQA4FlkPFKCRfY3kI5v4gceLEsV4nSJBAhXSAUKb//e9/MmjQIClbtqyGdH399dcaCmULlBF76tWrp4oGQqLweOfOHVUAvAEKF8K4kHdhT+7cub1aNyGEEEIICW2iVqmwB+VlbUvIQqBHMrQtyBVA5aiGDRtaBWkkZtsCId3+e/YgiRn5BliX7boxBnfB8lAmunbtan1v//79bn03UaJE+tvwzGC8yJHwtjrVY489pt6HBx980K3lsa3wqpw4cUKyZcum723cuNGrMRBCCCGEkOAQdeFPZ8+eVUv9pEmTNDkZoTkzZsyQr776Sp5++mnrcggpQgLxyZMn5fz58/oeBGZY97du3arhPrDMG8+BAdWkkMR97NgxOXPmjMMxoEcGQoVQAQoVkIYMGaLrfemll9zeDowFvS8WL16soVyo3PTnn3+6/f0OHTpoYviiRYu8Dn0Cr7zyiqxfv14fsX+wXUhox2tHPPXUU1qRCkoR9iX2GRLNCSGEEEJI+BF1SgXChFBSdejQoVK7dm2N4//ggw80z+CLL76wLoewIoQ6wauAfAvw8ccfa0fp6tWra9UnPKLUqy2o/IQyrCgXmy9fPodjaNCggZZ5HTx4sI7lp59+0kpTKFHrLqgEBY8JlAMI6KgK9fzzz7v9fQj08HQULlzYYYlZT0H+x4IFC6xlYrHPPvzww1g5E7Y88MADWkb3+vXrWtr3xRdflHfffdfrcRBCCCGEkMCTANnaQfhdEmRw2KEQQRFBaVtCCCGEEELiS9R5KohoBSl4RhDa5SoxnRBCCCEk2nEWzh7OnPHDNlGpiELQERyhXMjlQEdvQgghhBByPyiCg4qf7hbDieZtYvWnKARVqwghhBBCiGsuXryoRXnwGClc9NM20VNBCCGEEEII8QoqFYQQQgghhBCvoFJBCCGEEEII8YoHoq2M6s2bN/WREEIIIYQQ4huiSqm4deuWDP7mc30khBBCCCGE+IaoUioIIYQQQgghvodKBSGEEEIIIcQrqFQQQgghJCzJkyePHDx4UEKNgQMHyuuvvx7ncitWrJBFixZZXx8/flxq1qzp07HMmTNHNmzYYH39559/Svv27SWQbN++XerUqSMlS5bUv1mzZjlc7uGHH5atW7cGdGzEd7D5HSGEEEKIC+7cuSOJEiVy+jq+rFy5UhuQGUUie/bssZQMXzB37lwpUaKEPPHEE/oaQv3YsWMlUFy7dk1atmwp3333nVSoUEHu3r0r586dk2Dgq+NGHENPBSGEEELCgnnz5qlQXLZsWXnrrbdifbZnzx5p2rSpVKlSRT8fMWKE9bP169er4F6uXDn9DIK2sdpXr15d36tataqsXbtW34f3I2fOnPL2229LxYoVZeTIkWppf/XVV6VatWrSsGFDXe6bb77R72GZxo0by6FDhxxa6fHbWKZUqVLyySef6PuwyP/4448yefJkKV++vHz00UfW3zUsXrxYv4fx1a5dW3bt2mX1cJQpU0b69Omj21S6dGndFnt+++03mT9/vnz99df6G6NHj9bv4rntdr7//vv6O48++qjug379+uky+I0dO3ZY1zdx4kR58sknddlatWrJtm3b4jxmU6ZM0fVAoQAJEyaUzJkzO10eXgzs42LFiln3Fdi7d688/fTTui8wNnhgDKlSpZILFy449GDB+4HjiOPUtWtXPU9q1Kih+w2K1oABA+LcBuImlijixo0blk8/+VAfCSGEEBI+nDx50pI7d27Lzp079fWPP/5oSZkypeXAgQOWO3fuWCpVqmT5+++/9bOrV69annjiCcumTZssZ8+eteTLl8+yatUq/ezu3bv63s2bNy1FihSxLFq0SN9fvXq1JX/+/JbLly/rOrHun3/+2fr7tWvXtjRq1Mhy69YtfT158mRLz5499bfBhAkTLE2aNNHnH374oeW1117T55cuXbLKHdeuXbOUL1/esn79+vuWA/jdHDlyxNrebdu26etJkyZZSpYsabl3755l+fLlljRp0lg2bNign33//feWhg0bOtxvXbt2tQwdOtT6Gt8tV66c9fewnbNnz9bXo0ePtmTJksWybNkyff3VV19Z2rRpo8/XrFljeeaZZ6zbgv1ZqlSpOI9bv379LN26dbM0bdpUf7dLly6WU6dOOVy2aNGilr59++rz06dPW7Jnz245evSovq5atarlhx9+0Oe7d+/WfXPw4EF9jW04f/68dT34DNtm1tmjRw/db+DVV1+1fPbZZ9ZlcS64YvPmzbp+PEYKm/20TfQBEUIIISTk2bhxo1qvixYtqq87dOigngPw77//qhW/Y8eO1uWvXLkif//9t5w+fVoKFSqk1nXwwAMPSIYMGdSDgOewWgNY0rNkyaIeBFjvEydOrGE7tuA13gewlMM7UKlSJX2NsB5HXL9+XV5++WVdL37v6NGj+tyEIzlj06ZNamUvXry4vm7RooW88sorcuzYMX1doEAB9QAAWO8HDx4cr/2aLFkyadCggT6HFyhlypRq1QfwrMCTYrxE8EzAU2E4f/68bl/y5MldhhwtXbpU/xDe9d5776mH5eeff3a4fPPmzfUxU6ZMki9fPjlw4ICkTp1atmzZop4bULBgQfVWrFmzRr0ScdGmTRtJkCCBPsd5AC8Xzo/KlSvLU0895fK7xiMGT1SSJEkkErj1/60VcOx8CZUKQgghhIQdRkgEaGqbPn16a/iSLQsWLIjXOlOkSKFKgC0QuG1/s2/fvvLcc8+5XCfCazJmzKgCMOL5W7VqpY14vQXKgAHjhPAeH5ImTRprPbbrRaiSWS+2F8I5lAJPyJ07t4ak5ciRw6ocQUB3hrPfd3WssJytUme/fxEeZcBvI/RpyZIlGtY2bNgwmTFjhtPxIDxu2bJlqnhly5ZNIoETJ07IqFGjrAqyr6BSQQghhJCQB5Z9xPf/888/UqRIEU02NhbXwoULqzV73Lhx0q5dO2sMPhQNWPHxfPXq1Wqlvnfvnsbf4zt4DuESMfzr1q2TkydPalLz2bNn4xwPhEx4ByCkwvNx+/Zt2blzp+Yl2AJrPsYLhQIeFVjsjXcjTZo0cvjwYYfrhxcC68M2w0MzdepUtfRDOMf2uAv2C5LBvaVevXrSuXNn/YOigH0H7wG8G/Ce1K9fXzZv3nzf95o0aSJjxoyRS5cu6fYuXLhQHnnkEY9+G9vw2GOP6fHt1KmTbj+UtM8++8zqtYFnB3knyMm4evWq03UhpwLLt27dWj0xxlPlDOPJwHZjDJHAli1bVKnwddI6lQpCCCGEhDxI7v3222/V0o8wFCQ/Q5gHEI6mTZumCcZDhw5VqzW8AxCcIIQjwfjNN9+Uy5cvqzUeibsQkidMmCCvvfaavPHGG2ohHz9+vFq13VEqYHHHclgPgEUdpVrtlQqMqUuXLhrukz9/fmtokVFMMDaE8iD5G4Ku7fYikRvJxVh3unTpVKi2tdC7A/ZXt27dNDkd64JAHR+gkH3wwQe6PowHCp0pEwulwpmACgUE+xgWf+x7HI8hQ4Z4/PvYF71791bvAvYBPAxYN0BCN34DCedQLMx54YhffvlFJk2apOcQFCMksRPfkACJFRIlwB02+JvP5aXer8Zy9xFCCCGEkPgBwRyhQfY5KJFi1YdnadWqVRHlqajkh22ip4IQQgghhMQbJF4Twj4VhBBCCCGEEK+gUkEIIYQQQgjxCioVhBBCCCGEEK+gUkEIIYQQQgjxCioVhBBCCCGEEK+gUkEIIYQQQgjxCioVhBBCSISB5l558uTR7sWEEBIIqFQQQgghEQS6BA8cOFDOnTunXYZv374d7CERQqIAKhWEEEJIBLF06VLZv3+/Pt+7d6+MHz8+2EMihEQBVCoIIYSQCOKHH37Qx5w5c+rjRx99JDdu3AjyqAgJT9KmTSsPPPCAPkYKaf20TVQqCCGEkAjh+PHjMn/+fH0+efJkyZUrlxw7dsyqaBBCPCN//vyyb98+fYwU8vtpm6hUEEIIIRHC2LFj5e7du1K+fHl57LHH5I033tD3P/vsM7l8+XKwh0dIWJIpUyaJNDL5YZvCRqn4/PPPpUqVKpItWzbJly+ftGzZUv79999gD4sQQggJCaBMjBo1Sp937txZH9u0aSMFCxaUs2fPypo1a/S9Y9cuyPHrF/X56dOnZdasWZrcTQghUaFUrFq1Srp27SpLliyROXPmaDWLRo0aydWrV4M9NEIIISToLFq0SI4cOSIZMmSQxo0b63uJEiWSt956S5ImTSqPPPKIvjfk3+X6B27duiWdOnWSb775JqhjJ4SEP4kkTPjll19ivR4xYoTGgm3evFkqVaoUtHERQgghocCPP/5o9U4kS5bM+n6TJk3kwIEDkiNHDvVSTD70h77fq3BVTebu0KGDfPHFF/oIhYQQQiJaqbDn0qVL+pg+fXqny9y5c0fdwYabN2/qI9y8dPUSQgiJFOCh+O233/R5x44d77vH9ezZUx/hobh17671+aBHG2rexZgxYzTvAv0tCCHRxQMPPBC9SgUmy379+mkiWrFixZwut37dGlmzZuV97586eUSSJEni51ESQgghgeHbYUP13liu3BOSJnUyOXnisPWzFClSSdp0GWN5KcCkg5vUW5E9Sxb1UiACoGmThpIzZ44gbQUhJBhkz5HXJ+tJYLFYLBJm9O7dW2NH8WfqcLvrqRg5Yoi82OsVjS8lhBBCwh3c62BgQzlZJGo3bdo01ucJEiTQvze2zJJxBzbE+qx9/rLqrUDCdpEiRTRU6rvvvgvwFhBCgknUeipeeeUVWbBggbp5XSkUJkENf452nq92ICGEEBJMRo8erQoFSkSigImj+5u9l+I+b0XmzNK+fXvNy4DhziR1E0KIu4SNZA2HChQKVH6aN2+elpUlhBBCopVTp05J27Zt9d5oysg6C+21zaWwBe+ZSlBvv/22JE6cWB8JISRilYqXX35Zu4P+9NNPkjp1ajl58qT+Xb9+PdhDI4QQQgJqZJs2bZqULl1aKyMmTJhQ8wz79+/vcPmTNy7LnKPbJHnCxA7/Zh/ZqstkzJhRy8suXrxYli5dGvDtIoSEN2GTU5EqVSqH7yOxDJYad0BOxeBvPpeXer/KnApCCCFhx5UrV+T5559Xrz1AmBLug48++qhP1n/hwgUpUKCAPPzww7JixQqGChNCIi+nAhMpIYQQEs18++23qlAgXxDeib59+/q0mmG6dOlUaRk2bJh6K6pXr+6zdRNCIhuaIAghhJAwYfnymPyHjz76SPtL+KM8+tWrV/Vx1apVPl83ISRyoVJBCCGEhAG3bt2SDRtiSsI++eSTfvudkiVL6qP5LUIIcQcqFYQQQkgYsGXLFi1OkiFDBnnooYf89jtly5bVx02bNmkPDEIIcQcqFYQQQkgYsGbNGn2sUKGCNrPzF0WLFpU0adJoGNTOnTv99juEkMiCSgUhhBASRkpFxYoV/fo7qPiEcrVg/fr1fv0tQkjkQKWCEEIICXHu3bsna9eutXoq/I0JgaJSQQhxFyoVhBBCSIiDMKTz589LypQpfdaTwh2lgsnahBB3oVJBCCEB5ti1C3L8+sVgDyPqOX36tPz4448ydepUCZfQpyeeeEJ7VPgbE/60b98+OXXqlN9/jxAS/lCpIISEVUlNdPk9fPiwhDND/l2ufyTwoGP0+PHjpVGjRlKwYEHp3bu3dOrUSfbs2SOhzOrVqwOST2HbBA8J24DeCkKIO1CpIISENHfv3tXOvj179pQCBQpIvXr1pHHjxhLOXorJh/6QSQc30VsRYAYOHKjnUPfu3eX333/Xc8s0j/vzzz8lVLFYLLEqPwUKhkARQjyBSgUhJGQFKQiBhQoVkgYNGsiYMWPUygz++ecf6/NwAx6KW/fu6h+9FYHjypUr8sUXX6i3Cz0e3n77bfnrr7+kQ4cO+vnWrVslVDlw4IAcP35cEidOLGXKlAm4UrFu3bqA/SYhJHyhUkEICUn+/fdf+eijjzSeG82+EKIyf/58yZYtm36+e/duCVcvhYHeisCxbNkyVSjy588vGzdulH79+smDDz5oTXoOZaXCeClKlSolyZMnD9jvIn8DbN68WW7fvh2w3yWEhCdUKgghIYkpZQnBZu/evTJkyBCpUqWKFClSxKp0hKuXwuAvbwXKjz7zzDNSp04dOXTokM/XH44sWLBAH2vXrh2rcVyJEiX0EV4LeMdCOZ8ikKFPAF7C9OnTaxfvbdu2BfS3CSHhB5UKQkhIYuK4K1WqpGEfhsKFC4elUmHvpfCnt+LYsWOyaNEiWbVqle4/WOmjGSgLCxcu1OdQtGx5+OGHJWHChHL27FkNMQpFgpFPYZrgGW8FQ6AIIXFBpYIQEvKeCluMUoG8inD2UvjTW2FbHevcuXNa6Wjo0KEha4n3N7CyQ9FKkSKFKlm2JEuWzOr9grci1Dh58qRWpoJ3pVy5cgH/fXP9MVmbEBIXVCoIISHHxYsX5e+//3aoVIRj+NPJG5dlztFtkjxhYod/s49s1WV8rVSg10Dr1q21ylH//v2lS5cucu3aNYnW0KennnpKlQh7TAhUKOZVGC9F8eLFtcxroDHXHztrE0Liwv8ddAghxEM2bdqkVnUk1WbJksWhpwJNuZA8ahsaFapkTZZattd/K2C/d+TIEX1EH4aRI0fKY489Jm+88YZMnjxZTpw4IfPmzZNo4rffftPHWrVqOfwcydqTJk0KSaUiWPkUBiimCIOCoorwsOzZswdlHISQ0IeeCkJIyGFCLey9FCBHjhySMmVKuXPnjuzfvz8Iowt9jFKRK1cuDZvp0aOHzJ07VxWw5cuXh3yjN19y5swZ6/mEJG1HPPLII/oYikpFsPIpDKlTp5ZixYrpc3orCCGuoFJBCAk5jBDoqCY/rKaoShNuIVB9+vRRrwseQbVq1fQ1Eqr9pVTkzp3b+l7lypWtgqlJWo4G0OQOXi+ED0HJcoQJf4KSitC7UAFjMVWXAtVJ21W/CnulAmF1qDRGCCGASgUhJKSAkII+ArbCjD3hVgHq6tWrGl6DfIZnn31W38uaNau+RrlcX2NyKmyVCtvwn8WLF0u05VPYV32yBX1QzL4KpdKpqNoFhQj9NEx/lmBg21kb40H38ddee027k2Ns8AYRQgiVCkJISAFFAd2y0eQL1uVIUCpmz56tHZ2RI2K8Bfny5dPHgwcP+jX8yZYaNWro44oVK7T3QKSDEDmjQDkLfQrVZG14TXr37u0yFyRQmDBEKBPwHqJfzPDhw7UM7+nTp2Xp0qVBHR8hJDSgUkEICcnQp5IlSzpNwg43pWL8+PH62KZNG2vjtbx58+rjgQMHfPpbly9flvPnzztUKtCTIWfOnHLjxg3tYREN5xL2BRq4OQqlC1WlAmWAmzRpoh4AJJG/++67QR0PPBKZMmXSwgioyoYKWs2aNbMqO8y1IIQAKhWEkJBUKpyFPtkrFaHeewEdrZEcDWUC5V0NxlPha6XCeClQfjRNmjSxPsMYatasGTV5FabqEzw0iRIlCgul4ubNm9KqVSvZvXu3KoXTpk2TVKlSBXVMOG8GDRokTz/9tAwbNkxD9kaPHm09n6lUEEIAlQpCSNgkaRtQKhWCDsKkTp06JaEKSnC+8847+rxq1aqSJ08e62fGU4HwJ18qRs5CnwzGuuyPBPFQVSpc5VPYKxW7du2SW7duSTDAefDCCy9oGVkohFAoQqWEKxQI5AV16NBB0qZNq++ZZnxQxJA3RAiJbsJKqYC7HkmOEChguZkzZ06wh0QI8XG1Gwh1zsrJGhB+YSz9oRgChdjzzp07S9GiRVUwBGg8Z4tRKi5dumQNV/JnkrbhySefVKs9ysqi10ekAuVq+/btWi3M5JK4AgofvDsmxCcYvP/++zJlyhQ9Pj///LPTnKJQAYorwulQBQrnPCEkugkrpQKVUjDJfvnll8EeCiHED/zxxx9qrYXCgOpIrgjFvAoI6ggvQiIrGs0hUbh8+fJq4W3cuHGsZVOkSGHdRl8maxulwpmnAhZwjCnSQ6CMlwLKacaMGeNcHp6vYPargHfis88+0+dDhgzR7t/hgLNys4SQ6COslAq47ZGw1rBhw2APhRDiB4xg4spLEcpKxcsvvyxr165VS3PLli21yhLCjBCL7gh/5FU46lERjSFQcXXRdgSSosFff/0lgcZUUHrmmWekXbt2Ei5QqSCEGFxnroU5sBLCLWubAGfq4LNhD4k2UFFm+vTp0rx5c2tMdKhhBBPkU8R1jZoGeP/884/LZWGBNhWXHAHPiC9yGpA/gb4CpgvyQw89pM9djQ0hN9hmKBW+mpOMpwJhKc7WiXCgt99+W5UeeIARThZJIIQJyfEAniN3960JN4KnItD3CKPIQEgPp/uTyX3CeYz7ratrjRASmiBM1BdEtFKxft0aWbNm5X3vnzp5RJIkSRKUMRESLHr37ivzf10gM2dOlx9/GOmzScRXQJAySdoPFsgjJ0/ECMfOyJQxnT7+/fcup8tmyJhFkiZNLtdu3pNxq8/J9E0X5NiF25IjXWJpWjqdtKuYQVIkfUBu3boh5856l/A96qfRqpyUKvm4pE+XMs7x6zZkSq+Pu3Ztd2t5dzBej5QpkjhdZ8YMqTX06uTJkzJ3zkypXLmSRBKbNv2hicMoJZslczq3923OHFmsAv7xYwcDeo1s2bJZH3Pnzu6zcyEQZM2SXpImTapGi/XrVkn+/DHeN0JI+JA9R0yOn7dEtFJRtlwFKV2mbCxPxcgRQyRL1lw6CRISLSAhd8FvMfHzq1atkSlTf7E21goVEMaEpGU0vav6ZA2nPSoM5con18ejR49J6jQZNUfBHgiFUCg6/XBQth+5YX3/6PnbMnjRaVmy67KM6pJXUiRNLlmzOQ8XQr+An376STp27ChZssQInvb8uiBm/7Zt197lumwpViym4tDJk2fc/o4rYCmGogBKPFpKsmZznFdhmsGNHTtWNm7aIs2ebSWRxF9bx+kj8hI8uVlmyJhNDU5oVHjj5j3Jn983N9q4QBO548dP6POqVavfVwo41ClVqpR65/buOyTlylcO9nAIIUEiopUKxDU7qk0OQSPUrLSE+JOhQ4eqJyBbtmxy4sQJGTBggFSuXFlKly4tocLGjRv18fHHH3dL6c+cObNkyJBBLaToPmySbO2Bh8JWobAF749bc066PZXJ5Zzw4osvyvz58zWRfOrUqfd9jopVsG5jvkHTMnfnF5NTgV4WvpiToFAg9CdhwoSSI0cOl+tErgGUCnScjrT50IShVatWzaNtw3mHBoFbtmyRbdu2yYMPPiiBAFWqTJM5VKAKNxCyBaUCIVDhlA9CCPEtkXUnIYTcB/o4mI7OsLYjERT5Rp06dVLPQKjlU7hqemcLYrdNsjbyKpyBkCdXTN94Ic4EWigU4Ndff1XFwh5UejLWf3cqDdkrFaj+5Is4epNPAYUirmZvsOJjGTRZg1IWKeCcNgpqfCoomWTtQFaAMvkUpldGuMFkbUJI2CkVcEljojeTPW7EeG5upISQ+xkxYoTcuHFDvRLwTqBcJRKEIUgiBCoUOlIj/AOWTncrP3lSAQo5FK447uJzhBO98cYb+tx0NUZnYVugDBjvBZLgPQFlX+FVQLM1eJD8XU7WFiTrG2EwkqpAoZ8Rjhu8DKYXiCcYjxc8FYFWKoxCE26Yaxb9PdCQkhASnYSVUoHmOhUqVNA/0L9/f33+4YcfBntohISsIv7999/r8z59+qh1H+EVo0aNUmEWwrDxYgQSNHubMWOGvPLKKyqQQPgzioGvlQokZbsiu4vPER6E0BTsMzTbxD5DqVJjCQfr1q1TA0fq1KmlXr164gnwFJjSr74oK+tOOdlILy1rSrOiyV98MN6CQJaVDXelAnlGUOJgoNi0aVOwh0MICRJhpVSgoRSEJPu/kSNH+tRi+tZbb8nmzTGVOAgJZ8aMGaMCPLrQN2jQwPo+LNQ4z0Hfvn0dhvT4A1j1f/jhBy3d2b59e/nuu+9k586d+hlKsA4cODDOpneeKhWo8uSKpmXSOQ2jQYdjAG8FSme2bt1aX2Oc9qFPjRo10iRzTzHWdF80wIurm7Y9ptP0ypUrw6qMqSuWLFmij/FtHmc8FceOHZPTp0+Lv0GVKoSghbNSYWsMgJJNCIlOwkqp8DeoDoWGVV9//bU2sSIknEHCLkKdwEsvvaRWdlvgJYA1F30KTNKuP4HygN+Bx+TixYuq6HTv3l09JQjFgoXT04pURqmAUOZMKEbZ2OK5HPdhwPvtKqS3GhRs+fzzz1WoxDiff/55fe/1119X7wKSmxE/jrClmTNn6mctWrSQ+ODLBnjGU4EeFe5QrFgxVYRgnEE38HAHigDya+CRgxEqPsDjhGMeqLwKeMJg4Ycy7YlCHWqYUDpTFpoQEn1Qqfh/MKlDoEE3XAABx9ygCQlHpk2bpucwqiQZC7stUDJ+/vlnDdmBQt2jRw/p1auXtUmkr7h+/bq89957GqoIKyZyEz755BP1jkBwb9y4sY4xvgI5Ss/iN5xdr+hDMapLHnmpVmbJmT6xoDcXHvEa76dImlCt27ASI5EdygkEfFTMMjkUpq9N/vz5pU2bNlZvBcKGUH0KVbXiK8QaT0Uwwp+gIBnLPCoeRUrVp5IlS2plsPjy2GOP6WMgPNbhHvpkKFeunD4iNNC26SwhJHqgUvH/DB48WC2mKD9okhxnz54d7GEREm8l+auvvtLnUBacdUxGsu6kSZPknXfeUesuci3gTfCVQg1Lft26dVV5QMWp+vXrq8Les2fP+zwn8QFCsSn76SwECgnQUBxQNnbh6wVl+6Ci+ojXeB9W+i+++EITTOHRgZIFbwrGDk8Oxm+L8VZAEcF+A88++2y8t8eXngpPw58CLUAHKp8ivqFP9vskEIqW8YaEa+UnQ9GiRdXLc/nyZS2xTAiJPqhUiGi5SBNfDgsqatIDKhUkXIEFHeFG8Ap06dLF5bJQpCEoI4wH1l14ECpWrBinkInr480331QhwhlffvmlKhHobAyvCBQYdyoTeUJcZWUR5gVPDRoAOgL7CNuCax8N9FA9yPRu+Pjjj1XZsvcstG3bNtZvxjf0yazPFzkVCGMzIVye7GP0BYkETwUUaW+TtA3GaxCIZO1wLydrgFJt+t4wr4KQ6CTqlQrEsz733HN6Q8IjYrwbNmyon6HEJWr8ExJumIpPHTp0UIHe3aRdJOzCSgvhFGFJzqz/EydOVEEdHj7kGzjKZ4BSA0EdwBOARGZ7Ad0XuErWhhdi4cKFqjTguSuBCN4T5EkYgbRr166aUO4IKGGm4zd+35vQFeOpOHr0qHpH4ovxLsFaDA+Up1Z5CLfhnKwN6zi8UvDKmVCc+GKOJ3J9UOjAn3lPO3bsiPWb4QzzKgiJbqJSqUCMNPInOnbsqIIThI2qVauq4AOhBzX8Yb3DDXbevHnBHi4hHierouwpgKLsqdUcnjuc/1AsoAhA2LVl1qxZ0q1bN+vruXPnyqeffhprGVw7CLuC0IRwIoQH+YsiRYroo6kiZQsUCvToQKdiZx23bUHOBErHIiTls88+c7oc5gjjAcI+9kZZQjlOJEvDsOFNzx2jVMBL4cl4UHULnaRR7cqZNyccMF4K5O44C/dzF3jsjAfJn8na8HRBkYQiiHMv3DHKHAxyUPKglB0/flznEhjooPgj5wKeQOR8mU7irmB+BvElmOPiuqaPXbsgx69fDNiYJNqVCsRGYwL/8ccfraEPmDhcWQJDCVTEwdgxqcGyhZjscePGWS2PAMKUEaAICScQZgShvnz58laB2xPSpEmjPSQKFSqkQi6uBRNWg7AqKONYf7t27WTYsGH6PnImILzbhuJg4sa6UE3NHx4K+/AdFFkYPnx4rM/M9euJlwTLQQmJa3mERiGvAsqTN+B3fBECFZ98CoB5zyhc4ZBXgX5FKPFrn4NikrSrVavmk98JRAiUEW6w/xFuF+4g/AnnM44NSjBjuzCP4PzGNYUEeuS7wJiHeQTGPFdhd2imh1wN5HnZV2cj4QMMJlAwg91o9eTJk1pQo1KlSrJ69Wqnyw35d7n+Ec/xeBY7dOiQ1qNGDDFilc+cOWONnUZ8dTjQtevzOlaEZiBMZPny5fdVCjEhULhRsUMoCSVchajgMyjIAH0g4guqMUEgz5Ejh97YmzVrplb/Vq1aqfehSZMmWh0J4VUIf8JvwTpsLDzIU8BnH330ka7Dn8DSbnKiXnvtNZkyZYo+R0WoBQsW6HMIMb4GIVOYC30hDPoiWduTbtrBTEz2FlQSg2EIoTZQInHO45xE6J4vkrQDmWsSKZWfDGgSiZxEXPMZM2bUeQBFDQwIy4OXD8oGPDOoNIdqaqig5uzaRi8bzEfwePqi63yogKa9UKqiQVlC0RAcc1/2FIsP7777rspzmDPgaXYk2+EeNvnQHzLp4CZ6K+KDxUNatGhh6dy5s+XmzZuWrFmzWvbt26fvL1++3FKiRAlLKHPjxg3Lp598qI/uULp0aUvKlCktEyZM8PvYCHGHLVu2WLJkyWL54IMPHH6O6xDnLK7Ny5cve/17O3bssOTKlUvXaf6aNm2q178Bz0+dOqXP+2/+xfLGlln6/PTp05Z79+5ZAgF+p2/fvjq+tGnTWn777TfLnDlz9PVDDz0UsHHEl1deeUXH+vbbb8d7Hd26ddN1fPrppx5/d/To0frdevXqWUKdggULxjofa9SoYRkzZow+z507t+Xu3bs++Z2FCxfqOh9//HGLv6hdu7b+xrhx4yyRzO3bty137tyJ9d65c+csxYsX1+1v3bp1nNfo77//bilXrpzl4MGDlnAH52i2bNl020eOHGmJZC5cuGDJkSOH9VoK1ly8bt0665xRoEABfezUqdN9y+EelnPmm/pn7mXEfTw2sSFWEkmKpm67Ae5NxHJHEsZbwRAoEiogxwcdeJHDgDAQe0wDO3gWYCX0locfflimT5+uVZEAXMfwhNhe/3gOS6K9hSdTpkx+DXuyBb+DfdK8eXMNz4T1EzlSwF8J4r7El54KT8Of7JO1gx2i4Ao0TUSorekTgnMcYW8mBA1J9r4KIzLVmNBY0R+hvdjP27ZtiyhPhTPgrbAvuYwCEhMmTNC5pXPnznqNXrt5T0YuOSO1Pt0jxd/cpY94jfcR1oZjXrt2bWsH8nAFuSUmdNzkv0UqiAbBdWu221+eP4TfOvP6IC8HkTUAXnWcdzgf4dWePHmydTlzDzPQW+E5Hs++cBs5SpxCMqcvhJhQwoRMIKksXPJFSGSDUCRzHaLYgO21CFfuL7/84nXokz0I8UEY0fvvv6+TMJKKHYEY1Fv37upfMOJRIUyOGDFC468R+oSEUNv8qFDGFzkVtonanoK4dSiHOIcQ+xyqmApf2bNn1/MfVYaqV69u/dxXoU8A3a0RxgPh3x/J2lAgIWxhvyPMJxpBSAyMFlAYrt28K51+OCiDF52Wo+dvC3RbPOI13jeKBcLScI0bhSwcQdluA8KvkYMWicAAhlBFYLrF2wrxvgLXaNOmTdU4g4qE9oYRNDWFwQTheQifROhk//799bN+/fqpIcr2HmYI1r0sqpQKXNQmORPAugCB21gQIgmUk0TcJzRgJKgSEipKhUmqNaVjwdSpU/VchYCCJElfggRLWHqcGQ5CxcIDAQ2eFFPaEp2uzfNI9lRAyfS0m7b9fjPlc0M5Wdv0BTEFCBCfD0Ua1wFye+Cp8iX+zDUx+RTwBtoWCYk2KleurI/jVp+X7Uf+K/ZgC94ftyYm7+Lll1+W06dPayNNd6pHhbpSgTkbikUkMnr0aPUeQI5CwQ5znzJCvK9AXxTsQygTyJdFXo8pz428XxjEAHLvUG3P5N+hWtkzzzyjnjT7e5iB3go/KxVIvMQBLFWqlF4MKKeISRGhT+bARQpQmIyVk43wSLDBRGzc/saVO2DAAGs4iAl9QlWVQIf7hJKFJ2XKlHrjQiIerGThUFXHeCpwA4aRBscaSamwkLtT5hVCFpJecdzjmxgfDsna9koFwDajgACSQXHsfYk/K0BFWpK2t0zf5LogyvSNMZ/DYIKywUjufvrpp8Oye7dRKuBxA7/++qtEGjB04Nhg/sX9qk6dOloQBxWYfK1EmQRwGNTwe2PGjLFWLYRnAr1m4BWzbQQLReKHH35Q5cLRPcxAb4VneHy3zZkzpyoVOBDQBhF3CmUCuRZGA4zEvAqEf+Cm7QhXcaCE+AoIl6hyA8HpnXfe0fKNiMuFGxehALAww+LZsmXLgI4rFC08uHnBMla3bl0JB1AVx1Sgg5EG8eYFCxZU4QnhHr///rvL7xsvBYSU+Fq9w6GztlEqTMNDf+NPRcuEVIV7J21fcezCbZefH7f5HGGYODawQkOxCKccC8gRJnTr1VdfteZVhHIuU3yAcI8KgVCY0CgV8xJClHwdAgWjmgn7RasAGJTQ9wXV4FA6FgoGQI6dbSUy4yGGEebkjcsy5+g2SZ4wscO/2Ue26jIkbmLvYTfBgQm04BIsILjhpIMnBr05oG3bAsUB8Z62blsTB7pk12UZ1SWvpEga+pZSEj6hT7DS4hr85ptvNHQAMckmFh8hAUiQDiRxWXgGPRqjmJO4Q8yQv2XKa+KmjJsj4u7hfVqxYoXTBmneJGk7EqAh4IRicrsjT4U/MYoWrj3k6TjLJ4oP9FTEJke6xHrvdEb2dP8py4iNRwEVEwKFRwjm4dBAEONFaA6MCMh9Q0gOclLxvjsNOkMRyEHjVp9TbxOUQxzLpqXTSbuK6aVixYrW5SA3IlQRkR++8ixCkYBnF32ZcC3hD/MoGq6iBQKAJxMGGmdkTZZattePKUtOvMNjaRdZ867+Ig3c2Bs0aKDP4ZnBNtr2CcCF5E4cKCG+UipMUicmzxdeeEGfb9q0SR/RGyKQ0MLjO2BRQ3dyVDPau3evuuzhnUK4B57jhozER18naRtMbD9+y5uEcX+BcFuTRB6oxGZ4flDZDAURduzY4bP1IgQE4W1Q3EwuS7QDIdTl52Vif44+GBBOcS7A6AfFwgiR4RD6hBByKKmmuEC4hkAZw6rjBPtDsSI2UPQDih9CPFHJ0FugnCEJG3Tr1s36frFixbTHWI0aNXReQ08QEqKeCpSTtQXhGKhcgEQ/lIaDmyvSQJURJGrjBt+1a1dNPkIjMHfjQLs9FVjLMYkOpQLAyjVz5ky9qUKg9FU3YXehhce3IVAoiWoLyh6iQzrc+BBqUToV84+9F8EXnoqkSZPqzRieCoTSmeTxUAGKFgw62E+mkoy/wX6GBwfzP/YLPNe+DH1CiFukVU2ML+0qZlDvviMjXfFcyaRdhdgNagFCrqGII4Jgz5490qdPH5kxY4aEi1IBUOBm/vz56mmxl6/CAXcMq0YGwvWEYgpoPIwQKG8LK+Ded+rUKVX+7av84dwwYVHesHPnTp2XER2AeTFQc0/UeCpgEbP9g8UFOxqup1GjRkkkggojKE+J3BHcAExZQ0/jQAkBsDYjDhgV07xVKhAeg7hVCFrIc7KvBU/CH4Rfjh8/Xm9qCHVD2Jsvu2mHS7K2behTIEOzTHiSL/eJESxNeBURDRNGuPBLtTJLzvSJBYcYj3jtKowYFd5M3Pzq1asdlrwPZaXChFSjPDIKLkRqgr2hRYsW+ogQJW+3FyXEAfqc+KuCGjwdMLZcunRJJk2a5JffiCR8EuwPawsEbpNFH4nAiocKBrixQCA0IHbQFbZxoIQAxMbDNYtmbe5OqrhRGmXWPp4cNdsRk4uJlUQmiAfG+QKQpI8bsm1iJ46/t56KcFEqApWkbb9PYLH0FaZxpREsSQxQHGDVXvh6Qdk+qKg+4nVceYkIIYPBDwYb27LbwQAVj5AvYEqa2oLCGuY8Rg6VKX6DZH1cz7iuww1PDau4frHtuKfBSOKNcgZjL6JkOnXqJP7E9H2C8hppCfW+xmcZxLCiIUY00oFVBJZhaK3xiQMlxCgHmFThvnUHxLgjphzKbaiFpZDAgD4MuLkhBAiNORFTXqBAAbV2m2oy3ioVxnIO73Oo3TwDnaRtr1T4SgHAfjU5UFQqfAM8tOY42faACDRI5m/WrJm8/fbb8u233973ubmucJ3ahtGYHl/hmFcRH8Oq8VZ4UwXKlJFt0qSJ30OSULUK4f24d69fv96vvxV1SgWSa2z/EM+IWr+wkqKRSLSQJk0aaxwo4j0d4SwOlEQ3tuFzKH/nDsb6BisPQ5yiE4T8fPnll+qZArCEIp4Y5TTxHJVUvFU44eaHgQgVqExIVbQrFeghAmMS4vV9AbxKOG64jllO1neYfJdgKhXo5myKHCAc3Laoi6PQJ4MpfY3S0chTDSfiY1iF4oXzH54G5Ep5Cq6fadOm3Zeg7U95D8qLbT8o4iOlAhVIbP+QmD1o0CB1Pw4fPlyijfjGgZLoxQhHAJV+3Km04yifgkQfyZIl00RU1GZHmAXOHyR5oiodQuqMscOb9SOGONQ6a8OrZ3oRBFqpgDLXt29fDVNBTxZve68YwRL7GdZP4huMoB4spQI5puiFYKpGQli2b/LmTKnAa3geUT4a13Q4ER/DKjwLpupVfKqGolgFDCnYb6iOFwjatWunj0j+DjUvbijhscSLmEDbP4QBoSoStHJYc6KR+MaBkugDk5FRKkznY3e8FVQqiC1I0EcIBeraV6lSRZt0Fi1a1Cfrtg2BChVQKjSY4X+mqiH6rnjbXZf5FP7B7E/0e8C5EmhQiQ+VMFG05rnnnrP2UHBHqYDV3oRAoQpUNBhW27Rpo48oQuFJcj1CzEzoU/fu3SVQQHmBFxcyrynhTe6HUq+fQKM8dP0kxBYkZqMPAKyfSPw3caVxWT6oVJBAVzsyzdlCKWQQRUGCEf6H6mqmc7y3neKZT+EfoGSjpwgaoZmSvYECVacQjoN5/fPPP5cuXbro+wgPR4VMgEeEFGIZR1W/TBWocMyriI9hFf2/0qdPr+GAS5Yscfu3EH6EfYnjbTp0BwIkhGP+AcEuBhD2fSr69+/v9go//vhjiXYgJCLHBO5tb+swk8jCCEcoU4zwwTfffFPDWNCDwFkTLMTlGu8GlQrib0xVGljUQ6WzdrAqPznrHB/fTvG4lo0HiEqFb8F5irwKCOVQ3NBoLRDAyv7qq6/qc1QhMkp52bJlNal33Lhx+rnxUCF8D55Ge6pXr66WcNwjDhw4EPEFORBqiYRtlIVFVaWaNWvG+R2EPH399df6HDlOEPQDCe6/UCjw5854oxG3PBWwWLnzFwjrANxeENYRf4iGJMbqE0ogkRKTA0oQxicJiUQutsmm6dKls7q8XZXWg6sVpRJRhxvVfgjxJwipwrl29uxZFW6iOUnbYLwUhvh6K9CgDeET6KTsq3A14lgh9ofygOOH8Bv7+H5UX8N8jnLPBhMCZRK2nYU+2XrDjEISzGRzb+jZs6cqQ/DWuEOHDh30EUV/3Cmvjj4R8PYgJ8OUeQ0k5pqFIZB4oVRA83fnDwmD/gTuxTfeeEP/Vq1apZZdlFZEJYBQAi69ypUr6/M5c+YEezgkBD0VxuJqSuu5sgYbVytcr/5q8EOIAXkLpipRqBhtgq1U2HopAJ7HJ7fCCIsQHnkth1cFKFjIUbYWuXAwaPbr109DnAcMGKCf/+9//5NMmWI6RwNUC4KigUIcqOoUl1IBzHUX6PAtX4F71ZkzZ9w2fsGAgVAwVLyKq7wswtpMInzv3r1VMQ80JlKA4U8RklOB/hAdO3bULHxojCjfhhML7sVQA/GCgEoFscW+gR3iaBEH7KpxHfMpSLRV0nFW3CAY14C9l8Ibb4XZn8aiTnyL2a+oFHbhgutOz55iEqghAEPZHjZsmHojUH4Z8gj6yNgC2cQk+CNh2x2lIhTzmTzBVGgrVKiQ298xHgd4fFzlFqLqHSI/MmTIYPUCBctTgXsyK0B5kVNhD1yLOMBwQ9l3jZw4caL4A/wOYlFR2s+Asm0oS4b29s40W9uqAjdv3tRHuCLt60f7mnr16mkiLmIqjx07FrWVsUhsjHCESRfnIGJCUZLZlKuExyJ78rSxzk/jaoUi4u/zlhBbwQd15IN9zsETbYobwAIaqPHg9/Bn76Ww91YgtwIChjtChhEsYZ0N9n6NRBAlgPAbhO1hX5uypd6CY2W8B/BOoPQr7u2QPdD095tvvlF5xP6YIscCTfCQsA0w3yN829mxN54KKBWQXUIhn8ldEC4JBQvkz5/f7fMbydaIPoGgjn3qKBcG6/rss8/0eY8ePbQUczCuH8w/KBRhKkDhvu1rbt68qedJoI89zt+gKBUof9m1a1epUaOGuvSQXIQ4Q0z8xjrvrxMWF1mWLFlivY/Xts3EbFm/bo2sWbPyvvdPnTzi9wSfhA/A6lBC/vprq0ycOF5at4oJcyHRC2JxURoTpE+XSk6eiGku1qhRI32EgIKJJEZIuSenTh7V97dti7mZZc+W2fodQvxJvrwxN8stW7bIkcP7ghqqs359jNEIN/BLF8/IJe/aRLhFihSpJG26jHLyxmWZc3SbJE/oePtnH9kqvYs8JVmTpZZLF8/JtWtXZP78BZI9R3Z5/LEYq7OtYcxYoLF/eS37h2LFiqpSsXzZEnm4aEy1Hm/Zv/+AXLlyRUMDHyleRHMmn6xaIdYyjo5nurQppHTpUrJpU4wy+VCRwnLhvPNw7cyZ0qrQivyCbVv/lKxZY8s7ocyff8YUIMiRI7tcvnRW/9ylTu1a8sus2fLdyOGSN0/2+z5fuHCxGtdSpUolzzSuH9RrB80w0UZh7dqVUrlSRZ+ue9XqNdK5czd5uc9L0r17bM+Xv8meI29wlAok4KDCE7oYwvr+6aefqmWgV69eIWeNL1uugpQuUzaWBjhyxBDJkjWXTg7+pkmTpqpULF++Sl5+OaY6BIlejEAB923Rh0vEshDYhlj0KlxVvRVZs+VW6+e+ffv1/bLlKup7hPibzFlyauIoLLJnzl7SWPJgcep0TNgJLLyBOv+NlRDKwvb6b7n1nTRpM8iOnf9I7z59tboPkndxrRugoEGxQJz9E2UrhpUVOpyoWLGyzJv3q/zz7x6fnS8rV6235gDkzJXfo+927/6CtcRs2XLl4xwT8u0gQB89dkpKPBo+FcLOnovJMSpS5CGP93vXbt1VqZj/62/y9TdDVHkw4B74/Q+jrH0pChUuJsEE5wCUihMnzvh8PpoyZYZ6YL7/4Sd5pe9rDquEhToeKxX79++31lOGtR9VaTA5vvjii1K/fn1tAOMPUO0JGrx9UjZeoxKAI2BNwJ89Z06fCkgpsooVyuvjihUrZO+e3V53u3WHFClT6uO1q1f9/lvEMzZt2mh1oZ4+FVO7PFPmLE7LVWIy3bF9m7pace6nSZ3K+j1C/M0jxYvLqtWrZfmypZIzx/3Ww0Dx119brCEVZ06fVi+eP0mePIWkSZvW4+/hPmiq/aEx7GeffSqvvPyy9fPly5fpY7FiD+s9iPiHBwvECP3Ie7CfL+EtnjxlitSqWdPafNQd1q5do49FChf2eA6uUL6chmUhhK9QoYJxfr/I/ysV+M3SpcIn9+avLTHXaa6cOT3eR4ULFVQPAJLax40dI82aNbN+tmDBAlXIkaPSovmzQb8H5s6dSx8xJl+O5dKlS7J48WLr8+9GjpT27WO6eAeCrNmyB0epgJUFEybInj27lk1FFSZYtOxLrfkSKAGIQ122bJk1zAoaHV7Da+IJkyaNl0CROXMmOX36jLz/wXtS4hHHfQh8xeOPl5IaNWMUvnVr18iWLcFPsiT/sXTpCn28e/e2jB37k/V4OSpXabwVO3Zs1/fSpUsrkyf/HLSxk+gjQYKYHIHpM6bLnTs3gjSGBJI0aRKNSUfFHcPBg/tly+Y/ZPfuf32eMAkF3ll88blz52XEyB/1876v9IoVFoYcvi+/Gmp9/cMPP0rKFEmsVWpmzZ73/9uEBl4/+XTM5D/gDcJ5gwZpQ4d+I2nS/GftnTP3V/nzzy1amr7r853cbqT4n7B3Pl7HrlatavLPP7vlwvnTcX4fIXRgwYJfJW2aFBIuLF8RozSfPnMyXvvowQfzqVIxdNgwOXr0kGzfsVN27NglJ0/GKOCPPvqIzJ37iwSb48djummvWbPap9fxli1btQgAzl3MaUOGDhGLJeZcDgSvvf6/wCoVaM5VrFgxqVixonaLhiLxzDPPyOuvv66WeHRErFq1qvgTeEOgQKDCAxIJUX3h2rVr0rZtW4/W07Jl24A1TYELEzeXpElTSPv2/q1YYKzeoFr1mlKiROyYXhJcNm6MseTUrVNPzwVHXgr7BND6TzeUJEle0vPd3+cPIbbkzJlXVq5aI1evXAvKuYebadp06R2GqubNm1//ENJ68cL5gFViwe9MnDRNjh8/LgUKFJZKlSrFsqjCwogwYBjfkHh67fpt6datp34+afIMfWzTpq1ayon/mPnLPN3/hYs8bN3XSKoe8P5H+vzUqdNy9dotebFnzLGJ65h//c23+rxLl25SvLh/w28KFXpYFi76Xa4E6bqLLxMmTNXHFs1bSZUqMSX1PaF27fpSaVkVOXz4iAweMtz6PhT3GtWry6BBAwMS7eFOsZXp02fJxYuXpF27Tj4T+pcui6kA2aVLZ5k0abIaMPLkKeCzYgOBwm2loly5cirYPP3006pMACgUOODI2EeyKV77E7jEUAP5ww8/VCsEKiXMnDnTafiTM7JkzRaQnArw5JNPqVKxY8dOn7mXXGFbQSgQv0fc58DBg/pYqnRp67FxVa5SvRVp0mrJPbjPeTxJIKleI0YY27N3ryRPkTJoN/RrN+/KuNXnZfqmC3Lswm3JkS6xNC2dTtpVzCApkibV+TyQ4CY/YcIE2bZ9hzRt9qz1/V8XxOR+oIwo7pVt2rSRsWPHSb9+/dWIZcptVq9eg9eyn4G8AqVi7959krVddrlx44a88+57+hkMotu3b5dhw75VBS+uMsWwniMSA7JOpcqV/S47PPn/QiSqCyVJmkzn/lAHRXQO/n8RkifKlo3X+Y3vIIQeZfghw1SpUkWeffZZadiwYazcpGCTLn0G9XAhYsciCSSbD67ls2fPypo1MSF2L7zQQ5IlSy7fffed3Lh5K+zmCrdrSMEKgxq9aD6CCRMVoNauXaslXlFi7aOPPgrIyY9EHcQbonQZQp/KlCkjoYwZHzw9yD/xN7Bwx6cpE/EvphurfQOvuMpVgldffVW9hIQEEhhrcueOKRaAct7B4NrNe9Lph0MyeNFpOXr+tsAhgUe87vTDQf080EDYAfDQ2woFpo9By5YtNUQX1yw8F/Coo0gDwnURMuxJLD/xriSyad6IAjNQ6nBOo1Fv7dq1NUwKBWbiKk2K2HmA4xkIYyS8XCh+E4pN8LAvHMkxqGqI/Yn9gzkjvuBaGTt2rB4rdNlGX7JQUigAttE09/NVZ+3Zs2dr+CSSwJGoj4gcbDv+wg23lQqEPQ0fPlwFI1yg0N6RsI2qIF9++aV6Dsj9oAwibiSYuPx9YzZW7/g0ZbIFk24oNL2KJHC9YNJNliyZ5MmTR9+zLVfp6A/lKrFMrly51PJGSLA6FAers/a41edk+xHH+Rx4f9yamLr4wVAqMEea/EL0bUI8NLznqFKFnAvU3ge4b6L8elyNz4jvMPsZ91wY9EwnZvQ6gPET3bFRYQiG0e+//94tpSKQFdBs+1WECghxR7gfwtDtMV64Bx980Kt+B1Ag0Ik81CqJ2mO8W75SKqZPn27t2QGgVL755psSjnh89FOmTKkdrWGVwcXWuHFjddNgJzdv3tw/owxzAnVjNlZvWyu3bfM/d4BbGC5HHEt2jPR90zsjcNiWq9zd4D2Hf/gMywBaN0k4zF2YM7Asct18AUKeXH6+0bddk90BRgFUosLcakIWJk2apI+tWrWyLoewDVzvCJ356quv9D120g4MiKpAgjz2PcLRoPChIa0J3YY1fcCAAfr83Xff1Ua+cSkVptt1IAjFztqIDAG//PKLtcmdN520wxnTWdsXSsXJkyetXk+jVJiKpzAUe2MgDgZetdCDVvraa69pLgXq6SJEityP6RCJ7rT+wlEFIZyM7la3MMDlaE50ep98h2nQ2LlzTDJWsLpdEhIfi6+7nstp06ZplSZf5dchh8IVx+P43F+YoiTLly/XmvXIK8Q1CoOMAa/79++vz+GlBPRUBAbkPxjPAsr8wiuBiArbpNrnn39eypcvr03t+vTp49CIZhv6F0hPRSgqFSYUCwrarFmzolqpMJ4KYyz0hlmzZmkkCwwOMFaEezh7vCWVVatWadwXFAv0poBVxpRdI4H3VDirIAQ8aWdvqxgi0Y34BjP5nDhxwu3v4HpC6JMRTAgJNCjjrc0Zjx3TP3fd+CigAeHDW5CU7YrscXweiLwK46VAArd92AY8+caqafYnCQy2XiF4IzCX2oLzeujQoZpEj8gLKMT2oMoXisPAOIcE70ArFTBG+crr5y1o5mhAHm00KxXwQBoZyduIjul2oU++Dmd3lLeCEDZ/yaMeKRW4wBCTCI29bt26aqHBa5xQuDiNRZ44vjEfPXpU96GvcVVBCCeju1ZuNBK0PdF8oYW7Cy5MuJk9DdcKN08FlHB3qVGjhvaBQREEQoIBwl3NDTSumxDKu6LcOEDYiQkN8gZUeXL5eRnXn/tbqYAlGYml9qFPBtvcCuzHUEs6jWRMXxPIJSgs4wgUzUAhDIC8C3sB0YQ+YTnTbyQQQDnNnDmzGgSRExJsIBsgcsF4emBUtjUymCIk0aJUFCxYUK9tNDT0JqLj+PHj1nkSuSRxhbP7gsmTJ8vo0aP9Jt+5rVQgFhEWlxEjRmhlC7jDFy1apPkVuPEQ58D1am7M/giBcqeCkDvaNI6n7XKBVCqGDBmiSWADBw6USAP71OzLuMoX2oMynoFqfkOIN55W3BxtK8P4Ihy2XcX0UjxXMoef4f12FYIjpEPoQ5UWXNso/ZkiRQott+7s3vnzzz/LmDFjAj7OaAaFZFB0BOElrsKAX3jhBVUYkE+4bt26oCdpA8z55jdDIQQK+8YI0wgZw3lvLOy45mEwNZ9HAyi4YgyE3uRVzJgxQ/dl2bJlY1XNchbO7gvl8M8//9Tn1atXl6AqFYhRHD9+vFpcP/jgA51QSfBDoNytIOSOYIoJGOTNmzegSgVKqcElB0aNGuWTsIlQ4vTp02rRwDHwxFNBSDjNXUaJQLU72/kkviBPIUXShDKqS155qVZmyZk+sXajxiNe4/0USYOXa2S8FQDhvzAeOQLXPfo42YZBEf+D/V65cmXN93QFqkGZIjMoOmOLEegDmaRtML9pFJtQyKdACJjZVyYEyngpkFgcTZ44UxreW6XClZfC4CtvhfEko7qYvypsuT0j4wSCJcbTxF8Su1+Frz0VnlQQcuWtQCIhSsYBUzLOhOz4GwgjxtIBATzScnOMcoYycYF0oRPiS6UCCauuwhNNnwbEr8MIBWHDxFp7CkIrkI+AOQmKQ7enMsnC1wvK9kFF9RGvg6lQ2CZrm94UJHxB0rapbGQbzmIE+mDkwpiysqHQq8LkU6CPAjxviRIl0vkAMoK5xqPN0GyMBPHNPT18+LAaTqD82ioVcYWzewOiUUDN/+8y7w9YUibAN2a4noKVN+DKW4HQBTRqQhynuUEi3g+x0f7mxx9/1EdjUUKoQCRhlLNom3RJZICQPYT3oCeDM+8lFAj8QZmA1R6hjN54K6BM4Pc+/PBDCVWgVMAyC4ulid8n4QlCjZB7AS+5CVNDqAiMXbhvQpgOlqcCORXB9t4bpQKKTqZMmayhM1OnTrUqFdES+uSrsrKzZ8/WR4STGe+uu+Hs8QH5OcZgi3xNf0GlIoA3ZrjHEX/oq4YptqDBUpYsWfRmbu+RQJ4CPkNyvTNvhQldQKdRuIONa8zf3or9+/dbT3Tk64D58+ffVwc7nDH70LaTNiHhAqySxlLrrLSs8VJUqFBB84Aw13ijVJg5IZSFdSgUsNZCAcI+IuGNSeaGkQshuTCoodQshMe4Qqj8AcqL4ndRACGQ+Y323Lhxw3oPM8qVCYGyVSqiJUnbYPIj41sBatH/ew3q16/vcTh7fEAoHyqZ4ZxCDoe/oFIRIBA2ZmqU+zoEChMgEp1Reg59EOw9El26dFHvyMqVK2X16tUuhQIoFbYCsL8nM+RQ4IKE5oy4Y8RsIhTLUXm/cMXsQ3oqSKTmVSxcuDDW/GGUCnhAkU/kqUXNhGL6K5nQVyCOPG3atMEeBvEBCLfD8YR3AlX3ICTDU+aog3QgQHUhI8QHMwQKQjNkDCjRpgkrBGGE8sI7aWSHaFMqsL2mAhS8Wp5w/fp1raBlH4rkSTh7fJUYeFhRRtlfUKkIQl6Fr5O1586dK4cOHdKL3lFsb9asWbWrKDCdXW0xsc+wtpmbeCCUClhgjKvZNIVr27atPk6YMEEiBXoqSKQoFfAiIizJFjQPg8HCVqmAlRWWPBgzPM2RgkUNnkpY1FimnASyok/Hjh0ladKkVuEZmC7cwSBQFaBwjSJqwFXoEwx+xmCJqAt0KAcmRDrawp+gVJlmdZ5Gn6xcuVI9QDlz5gxYAYdA5FMAKhVBuDH72lOB0CcjmDtLBO7du7dq1bAqmBwGg7E0VKxYUUMXAqVUoNTf2bNndQI3lk10pIVXB4pXMF2+vgLhblD4AD0VJJzLc6LQAPKsPv7441ifoas0vIv43PYcN0KHpyFQRgmBRQ05GoQEiueee046dOigeQNImEVibDBCnwJZAer3339XLw3uvY7CeGzzKWwxIVAAskWBAgUk2ohvsvbC//fsQsB3t2Q8jg/C2H/44QeHnyMUrVixYlYDjy0XLlyQDRs2+D2fAlCpCIKnAlqtvbXPG2s/KgiA9u3bO10OVoQ333xTn7/yyis6kRjMTd8I9oFSKszFAeuQiUmGV6VWrVoR462AwGW2C651QsIRGCvQHAyg0altQy4kkcKdDi+F7Q0SioixkCF8wl3M3FStWjUfbgEhcYNy6v/73//0OZJifdl0zBulAoI9wgL9wffff28VjE0/CltM6JV9sjoEYuRfAhgU4OGJNkxehaeeikX/7zUwso47wGuLEHdTFtYWeITfe+89OXjwoBqQ7efbZcuW6TIw+piWAf6CSkUAgWCJBiewBpgGJN6CsCWcQIjrxYXtin79+mnXV5xcaFqIuFFUfDKxfUYIsL1Y4BKFm87X4LcRbw2vBJQKW9q0aWNVKsK9w/bIkSP1kSUnSbgDpQGNT3FNvvzyy1arJqycsO7azh8AyYAIyUTMsX1TMWfA2GKW9bdFjRBHwPhjynr6qulYfIFxD8I67tPxLV3qihMnTsTyJJq+CQZc40bRsFcqYEhAHmQ0hj7Zeyogz7jL3r179Q+GVE8KUaDnCoC8Zq9gQkmBQmHCre0bbRrvr79DnwCVijBvgmdOZnTsjsuNhs9hZUSFFkxSzZo1k0mTJqlSgknBdmKAAoRQKJy8prmNLzEhWAiRsI1fNR4TWEAQagENO1zBxQ2rK/Y7kuUJCXc+/fRTLS+LKlBINjS89tpr1jKyBhgMTI6FuyFQcN1jPkKscjSGU5DQwJT19FXTsfiC8D/TD2XevHk+Xz/Kt8NIYMKm0afDNgQK3eIROgMB2FFOYN++feWpp54KWjJ7sDE5L2vXrpVPPvnEIy9FuXLlrOHm7oBCP5h7ETJur8QYb5MxLKPAgImGwfEMVD4FoFIR5k3wTBgClAp3gNVj4sSJ2tkZsf6YFIC9lRGCsJlEfF1WFnkGGINt0yH7MSJ+MNx7VpgLHfvWJHQREs7A09q/f3/1TOAGZ+LOYRhwlM9l5hV3lQqGPpFgY998LNjeCngHTUGW+GCuUXtgMDQW7QEDBuh9F5EPtqGNJp8CkQuOwptwX5szZ07UXq+Qkd555x19/sEHH+hfXOVl4xP6ZBRM9LQAtnkTiCYxORrIq4BshybCX3/9tTU0CxXNUIgAebP+hkpFED0V8alt7MpT4Yl7FyVbEZpgxmAsirb4K68C1hB4SnDyO3P/mRAoTFiBaMDna2AlMApR9+7dgz0cQnwGrJIIpXQn7hwhTLBywjABl7+7SgVDn0iwsG8+FmxvBbz5MPLBOwjh0FOcXaMrVqyQffv2qbUcRgJjxbYNgXKWT0H+4/XXX1dlAnzyySea2+BMtkMoOfZ7fJQK2xAoW6Xip59+0t9D5U6EY73//vv6/uDBg+XYsWPW0Cd811khH19CpSII7jLcZBHLGJ8JwplSgax/T2ssQ+hFXCRCnRxpsP5SKozggPArVI1wRMmSJfX3EWIxfvx4CTcQVgbFCfsZ7mFCIgUzZ7gTd45cLzO3oJy1qwIVBw4c0FBLhE1VqVLFb+MnxF0vRSh4K3CtIVQmLm8FBEt7YdbVNWq8FIgKSJkypbV07syZM63rMZ4KKhWuQY6ZCX/64osv5I033nCoWKBPGGQadND2VGZzlFcBJcUcRxP10bBhQ/Vo4Heg7BjPSKAMNVQqAgxCBlDv2RchULhBm+QcTzwVticoPCbQnB01Q3GlVKAz49NPPy3Dhg3z6DdxoZnEcHOBOAKWGdPhFJq/rUs21ME2mgRtXOjOFCdCoiHu3BQpGD16tN5Iv/zyS+1tYcDNEVZYU6oWVU7YUI6EgpciVLwVuNcaz70jIEBCeU+XLp1W+Dl58qTLaxRx+SjpDjp16mTNZTQhUMZY6SxJm9xPz549dW4DyF1FmKi9YhGfUrL2xlYogOjjg2MEBRDPc+XKZQ01xXoHDRqkz2GQNV6NQORTAEo7QQAnhi9qT5syZtB6EcoUH5AMiQYsjjBKBSYZ+ypMyBdAEjViMW0FhLiAuxUuOSgxcTW2gkCOCwETJpriefI7wS4ji0oduPhNGBch0Rp3jmsX5aNRCAI3QMQgQ7mAsQACDeKykYxqPJL2+V2EBIKTNy7LnKPbJHnCxA7/Zh/ZqssEU6mAgOioQz0UdoQq4T6NZW09iY6uUSgL6C2DkrUm2RhhUMaaDWEVRksTsmgMocQ1Xbt2VYUCwOBqnjtSKuKDbV4FjMEmbxP9VUxZfpO726RJE1VqUPgCZWQD1fGcSkUQME1kTLxioJK0PQWVBCD8w8VmGrgBTFzG5Ya6yZ5UpTBeCuSWwGvjClj4cdEgCRSKzUsvveSTPBRfgQnj7bfftlqFDMZLgfK9tLiSaI87h+UM3gp4Rb/77jvNpYKl9PPPP9fEQjxHgzEIQ0OGDInaSjIkuGRNllq2139Ldjd4z+EfPsMywQDXDO7zuPcuWLAg1mdQDkxS7kcffWQNw3F1jSLxGvd2+3LutiFQRr6A0TJz5sx+3sLIoWPHjjJw4EB9jt5gyCE14Z2QYxDe6U1ItInwgGyEhnZQNJATYw8MvqZ5KJTF+HhG4gOViiA2tPnrr7+Ckk/hLjj5TZlZ2xAoxOih1Jxt/oC7GFecfflJZ6CzKRQYjGXKlCkyatQoCQUwQcC9iThxHE+U2oRH5fDhw1Yly4RvERJJxDfuHJa01q1ba6gTlAtUtUEp2t9++02NFphH4LmIxiZahLhbBco+BAr9nJCfmS1bNi0KAkEyrmsUngyUObftim1CoKBs4H4PhR8w9MlzXnrpJY20gBEU+xkNik1uA/r3IEzNW6UCCorpE4TjaQ88wG+99ZZGTLhqjOxrqFQEASgBsMKfOnVKE7YDWfnJUxzlVaDaAKhfv7418dreWu8IXGBGqXCVT2EP3H0IlQAQQrz18PgC0z8DxxFhWai4ADcyJhPEiCPR1J/HhZBwjTs3ygXKSr/77rsaC24saoQQ10oFqvmYHjEIbTFx/EgWNteRO9cojGL2nnS8NiFQ5j5PpcJzEiRIIJ999pkqaYj0QDK8Ce+MT9UnWx5//HFVFAyOyvIb0DIAMiZ6XASKsFEqYAlGySy44ZzlAIQLCPsx8W3eCMj+Dn8C9r0qYBEx7lcI0ojdgxA9ffp0t6z7+D4mPmjrnoDW87hAb968qd3AUVkpFJSKV199VSdf1O/HthlrRLdu3YI6PkKiLe6ckEgGHnHcZxByvGTJEn0P913kKSKn0jRYdfcadZaHaUKgbt++rY9UKuJHokSJNNcFSgByyeCh9UXCNOQnNDA2BmqTY+GMQIU9Gf7L7AhxEDeIkx3JvWPHjpVImCBg/UcIVHw0V3g5UIEJJwziIwPlqUAoEpQIhC/hM7hPUcVq8uTJ0qNHD5frMl4Kd/Ip7IFHALkKsGoieQzxhKZxn6/BxQ9lz1TFcORxQTI2QNMf7AtYkZCYhXJyiH81XhxCIjHunBASWHCvR97R8OHDtbQsjGywhhujmwkb9PYaRV8MhEBB5gJUKuJPypQptScYcigQ4okwJZNT623eBrp4I7wp0EpDxHgqsPOQwOev/IFwy6swXgpUb/JUQPcEo7BAqYCr1SRoo9oAaNq0qeY7QBCPq/O2SdKOb1dHWFaMImGfrOZL4CpEtQQkljrb9+hYif1uKlihqQy8Fsg1Wbp0aaxKDIQQQoivqkAhbw8JwKgyiJCluAx6noD1ISrE3NdMXiWJH1mzZtWGgojOQMiZL5SARo0aaViTCYkLJSJa8oEQbFsKFaEzAJZ2/AUTU6INSkV8xmIb+uTPbYHSgosAZewQE4gQHwj3OJnxu0ikxgSEUmlItITy506SdnzHbCY7VD2ASzE+CU/YHvxdu3lPxq0+J9M3XZBjF25LjnSJpWnpdNKuYnr1QEBJcjRO43qG2xHKg+0yWC+UrGCfX4QQQiIL3HPSp0+v9z54J0xMPbwUvrznICrk119/1TxB3NN4P/OOwoULW0OjQ3Vf+qqfVkQrFevXrZE1a/5rZ244dfKIw2ZvgSR7tkz6uH//ftmzZ5ekTpXKo+//+UdM47w8eXLKyROHxZ+gsQqqGg0YEJMs/UzjhnLh/Cnr53Xq1FClAlUounRuLylTppa06TLqZxcvnJVr167IkSNHdR0QwvPni/+YkyV9QBUdxJH+8ss0qVuntmffT5ZC0mfIrApFpx8OyvYjN6yfHT1/WwYvOi1Ldl2WUV3y6ERw9sxJuXXrv2XAwoW/6WOpUo/5fd8TQgghhiefrCIzZ85SQx88Cc82a+zz+1DVKuVl4IcDpGTJx3mPixKy58gb/koFmiCZygXOQFiNiev3lLLlKkjpMmVjeSpGjhgiWbLmCnrZwqzZcquwjnCZU6fOS8GCRT36/r79MZ20n3iivK7LnxQtWlQVgtOnz+jrHj17xfrN1q3byzvvvK/bcujwCSlb9r+TM03aDJI6TXpZ/PsKa+O//AXidzwNiCVF/sLGjZulY8eY5DR3Ma5HeChsFQpb8P64Neel21OZJGGipJI1w381upG8tmlTTMLV00838vu+J4QQQgzNm7dUpQJ07txZij7sfYy+I3q99LJf1ksim6AqFb169Yqz4zBq7cYXWMUdxbbDzeMrV4+3eRUQxJEU7G7fBuM+QyylbXlaf4K8CtMJEqVg7ZW8VKlSaTgUSkRie8qVK6d1siHAZ0+eVh9Xr16ty6LUqrfjrV27tioVKK1nQpk8BSFPLj/feEGVCvvwqs2bN2sJWYSAwTUcCucRIYSQ6MBUwUSpUoRA8R5EQomgKhW4MKK5UyOqKiDhatu2bR59D1UEINgihAuVhvyNrRJhErTtQcdcJCOZJGzUwoawP+jRhvp63bp1+uiJ8uQMlFNDkvTx48c1t8Tkp3gCcihccdzmc+TlIE/CtpSsL5QjQgghxBNw70PRE9yX0O2akFAibKQihN/Aoo9HXEx4jj8I19FWAco0vYOwH4imUWacSMpu2DBGSbCnatWqWp0Lk5zp5mnbYRcl1SCYw4vhLcmSJVOhHhgPiqcgKdsV2W0+R+k2g1EqnnzyyXj9LiGEEOIN6NWVJ0+eYA+DkPBVKj788EO1UA8cOFAVCTzH359//inhihHWd+3aZa0JHSqdtG1BmM+oUaO0hJ2zXBSEmb3yyiuxunnadu9EuVWUVEOolC8wDWRMRQVPQZUnl5+Xifkc5WFNYz80HULVKUClghBCCCEkDJUKND6DMmH/ZyzW4Qi6Y6I8HJJ/oVh4Wk42kD070GYeykVc9a2Nl8JgvBWwrCCHxlcYpQJehPh0125XMYMUz5XM4Wd4v12FmG6jaLIHZQreMfwWlD8k2Aci7IwQQgghJFwIG6UiEkHOgelWiVCuUPVUeILxUhhsvRXetqe3BWVl0ZQHvUhMSJInpEj6gJaNfalWZsmZPrEg1xuPeD2qS179HAnxSDBHozvEsNqGPoVaF0tCCCGEkGBCpSLM8irg1TCdq0Otu7i9l8LeW4FcCF/iKgQKHoU9e/Y4/e7evXslRdKEWuFp4esFZfugovqI11AoABKxTQdTJKEbpQL5IYQQQggh5D+oVASZEiVKeKRU7N69WxWL1KlTaxhOKHspHHkrfEmtWrWsSoXFYrG+f/HiRalRo4aGa6HsrCM6deokrVu31lb3rmjatKlVqdiyZYs1KZ0QQgghhPwHlYoQUSq2b9/uVvt2k0+B0KdQCsE5eeOyzDm6TZInTOzwb/aRrbqML0F5Wng/0BvD5KQgzwaKgEng/+yzz+77HsKZ8Pns2bPj3IfI2UFPCnQvheKCnh3ZsmXz6XYQQgghhIQ7Qe1TQWLKwqKi0uXLl2X//v1xJgCHaj5F1mSpZXv9twL6m8mTJ9dmfPBUwCOBRoktWrTQnhhoWnf16lXNidi0aZOULl3a+j0TxoT+FlmzZnX5G6hq1ahRI61+BVj1iRBCCCHkfuipCDIQWk1uhDshUMYiH2pKRbAweRVoItiuXTtZvny5lq2dOXOmNG/eXD8bPHhwrO8sWbLE2pnUHZo0aWJ9TqWCEEIIIeR+qFSEUAhUXBWgUNYUVvdQTNIOtlIBj8SCBQvUezFt2jQpU6aMtYQtSsIeOHBAnyOEySgV1apVc+s34A2BRwlejXAuYUwIIYQQ4i+oVIRQBai4lAoIzkgsRmgPGskR0bKyCHsCSZIkkYkTJ2quhQlvQsI2clWGDRum7/3zzz9y9OhRDTlD80R3vUnwgCAPI02aNH7cGkIIIYSQ8IRKRRhVgJoyZYo+Nm7c2Gln62gDidbdu3eXzJkzy9ixY1WJsKV37976OGbMGDl37pzVSwGFAl4Nd0FIFZr7EUIIIYSQ+6FSEQLAog7h+OTJk/rnCPRdmDVrlrW7NfmPnj17yr59+6w9JWxBDgQaDF67dk1+/PFHj/MpCCGEEEJI3FCpCAFSpkwphQoV0ucbNmxwuAyqG6Gsafbs2a3hPeQ/nJWGxfvGWzF8+HBZuXKlPqdSQQghhBDiO6hUhAgmbAeVimwbudmHPqEHQ8KECQM+vnAG+yxHjhxy6tQpLTOLUCkmuhNCCCGE+A4qFSFCnz59NE9i7dq11hAdAxq6oWQqMGVSifskTpxYQ6QMqPr0wAM89QkhhBBCfAUlqxABlvTOnTvr8w8//DCWtwIKxfXr17XS0eOPPx7EUYYvHTt2lNSpU3tUSpYQQgghhLgHlYoQom/fvlqRaOPGjbJw4cL7Qp+QoO0sd4C4BpWbkFPx3HPPaTgUIYQQQgjxHVQqQgg0V+vatWssb8WZM2fk999/1/dY9ck7UIoXOSvJkiUL9lAIIYQQQiIKKhUhmFuBalCbN2/WsCd0g75z546GPRUuXDjYwyOEEEIIIeQ+qFSEGKhM9MILL1i9FZMnT9bnTNAmhBBCCCGhCpWKEKRXr16aVLx9+3atBoU8CuYBEEIIIYSQUIVKRQiSMWPGWCVQK1eurNWhCCGEEEIICUWoVIQoL774oqRLl06fM0GbEEIIIYSEMomCPQDiGCgUY8aMkWXLlkmbNm2CPRxCCCGEEEKcQqUihKlevbr+EUIIIYQQEsow/IkQQgghhBDiFVQqCCGEEEIIIZGvVBw8eFB69OghxYoVk0yZMskjjzyiPRxu3boV7KERQgghhBAS9YRFTsW///4r9+7dk8GDB0uBAgVk586dWh3p2rVrMmjQoGAPjxBCCCGEkKgmLJSKmjVr6p8hf/78snv3bvnhhx+oVBBCCCGEEBJkwkKpcMTFixclffr0Lpe5c+eO3L171/r65s2b+givB/4IIYQQQgiJZh544IHoVSr27t0rI0eOlIEDB7pcbv26NbJmzcr73j918ogkSZLEjyMkhBBCCCEk9MmeI69P1pPAYrFYJEi888478uWXX7pc5o8//pAiRYpYXx87dkzq1KkjlStXlmHDhnnsqRg5Yoi82OsVSZo0qQ+2gBBCCCGEkPAlIjwVvXr1irNbNPInDMePH5d69epJ2bJlZciQIXGuP1GiRPrnaOf5agcSQgghhBAS7QRVqcicObP+uQM8FFAoHnvsMRkxYgSVAkIIIYQQQkKEsMipgEJRt25dyZ07t1Z7OnPmjPWzrFmzBnVshBBCCCGERDthoVQsWbJEk7PxV7hw4VifXblyJWjjIoQQQgghhIRJR+22bduq8uDojxBCCCGEEBJcwkKpIIQQQgghhIQuVCoIIYQQQgghXkGlghBCCCGEEOIVVCoIIYQQQgghXkGlghBCCCGEEOIVVCoIIYQQQgghXkGlghBCCCGEEBL5ze98hcVi0cebN28GeyiEEEIIIYSEBEmSJJEECRJ4tY6oUiquX7+mjyNHDAn2UAghhBBCCAkJevTsIylTpvRqHVGlVCRLllwfu3V7UZImSyaRDLwxUJ66de8lSZMmlUgmmrY12raX2xq5RNP2clsjk2ja1mjb3mjc1oQJE3q9rqhSKh54ICaFBApFpJ8kBmwntzUyiabt5bZGLtG0vdzWyCSatjXatjeatjWBl6FPgInahBBCCCGEEK+gUkEIIYQQQgjxiqhSKhAvVqFCZZ/EjYU63NbIJZq2l9sauUTT9nJbI5No2tZo215ua/xIYDF1VgkhhBBCCCEkHkSVp4IQQgghhBDie6hUEEIIIYQQQryCSgUhhBBCCCHEK6hUEEIIIYQQQryCSgUhhBBCCCHEK6hUEEIIIYQQQryCSgUhhBBCCCHEK6hUEEIIIYQQQryCSgUhhBBCCCHEK6hUEEIIIYQQQryCSgUhhBBCCCHEK6hUEEIIIYQQQryCSgUhhBBCCCHEK6hUEEIIIYQQQryCSoWbrFixQlKlSiUXLlxwudzDDz8sw4YNk2BQp04def311+O9TePHj5ecOXNKqBLq47OlW7du0rJlS5+uc+DAgVK+fHmfrjNSCMa+ic+1fvDgQb3mtm7d6rdxEUIIIcEg6pSKH374QbJlyyZ37tyxvnflyhVJly6dCuWOhO59+/ZJuXLlZO/evZI2bdqwE3CdYb9NJPJxV9lZtWqVPPvss1KwYEG9BubMmeNwub///luaN28uOXLkkCxZskiVKlXk8OHDLte9fft2qVmzpmTMmFGKFCkiX3311X3LzJgxQx5//HFd5oknnpDffvtNImFf58qVS685KCSEEEJIJBF1SgWEHigRf/75p/W9NWvWSNasWWXTpk1y48aNWEpF7ty5pUCBApIkSRJdJkGCBBIpROI2Ed9w7do1KV68uHz55ZdOl4GyXatWLSlcuLD8+uuvsm7dOunXr58kTZrU6XcuXbokDRs2lDx58sjKlSvlww8/lEGDBslPP/1kXQbr6dSpk3To0EFWr14tTz/9tArnO3bskHAnYcKEes0lSpQo2EMhhBBCfErUKRUQgOCpgEBjwPP69etL3rx5ZcOGDbHehxJiHyqE5927d5eLFy/qe/hD+IWtQPbCCy/o7zz00EOxBCZHLFq0SC238HxA2GrWrJkKbK64evWqPP/88yqgPPjggzJ48OD7lpk4caJUrlxZxwHFCILaqVOn3ArpQphG6tSpYylfAOEeRYsWlXv37jkc182bN+Xtt99WC3SGDBmkRIkSMmbMGLFYLPr8m2++ibU8wkAwBlhvAcbSq1cvyZ8/v1qpy5QpowKrM+bOnSsVK1bUZSEEQ0C19UI5sx5jORzv7Nmzy0svvSS3bt2yLoNt+/zzz6VYsWKSKVMm9ejMnDnT+vndu3elR48e1s9hUY8rDOaPP/7Q3zNCOrazZ8+e1jHUq1dPtm3bFus7X3zxhe4HHD/8HvatK+IaF87Rn3/+WfeZOW9xDjgCysK7776rCoAzBgwYoMtBMXj00Uf1HMN1BI+FMyZPniy3b9+W4cOHq7Ue3hBcK0OGDLEu8+233+r10KdPH71+3nnnHXnsscdk5MiR4i44hh999JFe7zgPERqF68yWo0ePSseOHdVwgDHjWtm4caN+huuvRYsWuv9xjWEeWLp0qdu/72xf24c/mWtw8eLFUqFCBT1uOBdwnS5cuFBKliyp5weuXcwr7p6jhBBCSKCJOqUCQECwFabwHAJFpUqVrO9fv35dPRdGqbAFN/BPPvlE0qRJo8Iw/nr37m39HAISBDpYWSH4Qzj6999/XSoIL774ov42hJAHHnhAWrVq5VRwB//73/80RGXSpEkya9YsVYD++uuvWMtAeIOAv3btWl3u0KFDqgy5A4Tdp556SsaNGxfrfbxu06aNjtER2N6pU6fKZ599poI0lIiUKVOqN6Rdu3YO1welAIoRtrdJkyZqqf7xxx91/7///vtq3XUE9m/Xrl1VkMayUKwgyH366acut23ZsmXyzz//qLIyatQomT17tioZBghrEyZM0LFDyMSx6dKli1URxTgR7oOx43f79++vAvb06dOd/h6Ecwjpr7zyir6HfXH69GkVBLFeCM0QyM+dO6efY10Y03vvvafnBQTb77//3uV2xTUunKPYvxDYzXmLczk+4LcQkoTwqEaNGkm+fPnkySefvC9MCkqcbVghlHYcb3jJDNWrV5fdu3fL+fPnrcvg3LMFy9gq/HEBxQTXIYR7nE81atTQMK09e/bo5/BWYlzHjh1TRQfXCK5Tc83hmoTChOsR5xm+DwUortAug6f7GscaSuTvv/+uyk779u1VIcT5OW3aNH1/xIgRbp+jhBBCSMCxRCGjRo2yZMmSxXL79m3LpUuXLGnTprWcOnXKMnnyZEutWrV0maVLl1pSpkxpOXTokL5evny5vj5//ry+HjdunCVHjhz3rbto0aKWzp07W1/fu3fPki9fPsv333/v9vhOnz6tv7V9+3aHn1++fNmSPn16y/Tp063vnT171pIpUybLa6+95nS9f/zxh64X33dnm6ZNm2bJlSuX5caNG/p68+bNllSpUlkOHDjgcP3//vuvrm/JkiUOPz927JglTZo0lo0bN+rrW7duWfLkyWMZP368vl68eLElderUuh5H2I+vfv36ls8++yzWMhMnTrQ8+OCDTvdB165dLblz57ZcvXrV+h6OTdasWS13797Vbc2cObNl3bp1sb7Xo0cPS8eOHZ2u9+WXX7a0bt061u+0aNHCMmvWLF331KlTrZ+tXr3akj17dut+NTzyyCOWH3/8UZ9Xq1bN0qdPn1ifP/nkk5Zy5co5HYMn4/IEHNPZs2fHeu/EiRP6PvbVkCFDLH/99Zfl888/1/NjxYoV1uXeeecdS5cuXayvGzRoYHnxxRdjrWvnzp26rl27dunrdOnS6bVoy8iRI/U6csaHH34Ya98ULFjQ8umnn8ZapkqVKtZ9iv2cLVs2vW7cpXTp0pbhw4fHutaHDh3qdHlH+xrXDrYV+8v2GrS9ZrAf8d6+ffus7/Xq1cvSqFEjfR7fc5QQQgjxJ1EZ2AuvBCyRsKQjDAXW1syZM+v7CMVAXgUsfgh9QGiEpyAMxwALPazMsEo7A9ZThJDAunz27FmrtfTIkSMa3mDP/v37NVwHoUEGhHgUKlQo1nKbN29WCyjCarCdZr2wtiKEKS4aNGiglnVY8mGlRXI6PDfwYjgCIR3wKsDj4wiEccA6PHbsWCldurTMnz9ft+OZZ56xfh8hYPbb4QxsF6zQ8IrYhgDh+CFUJEWKFE6Pj+1nZcuWVcs19jce8V37sB+MEyE+BoTiwCOAfYnfw+cI77IFFmR4Q7DfsC9tx43fQaibLfCO4dgCeFI6d+4c63MkLDsLV/JkXL7AnEvwrsBKDvA769evVy8TriUAT0mgQd7G8ePH7/MM4LUJMcO5hvHiunEEjg+unQULFsjJkyc1pA7HB+eIP7CdMxCKhfMT84/te5ivALwe7pyjhBBCSCCJSqUCoTYQXiGgQdg2QjCEXlRngaCKz6pWrRqv9SdOnDjWaygWrkKZILBDwES4BsaAZSFA2sb5ewqUJoSlIGwDQh7iriEQ4T2ERbkDQlRat26tQjG+N2XKlFgCvD3JkyePc51IvkWIFMLHsN6mTZtaBfxkyZJ5vI0IA3MU9+/pumzXCRByglAiW0wCMsK78LsQOqGQICb+66+/VqXQFuQYQGiFkA9lypwX+A3kSTjKFfGmEpe74/IFyGFBsjFyHmxBLg1CiZzhSME2eT74zNUy5nNfENe5+uabb2oOBcKncByxfNu2bb26Jt2dMzBfuJpD3DlHCSGEkEATlUoFgMUd3ggoFbb5EIj3RkInrIIQfl0J3LCKews8E4gnHzp0qP62qUblClgwIXTAEm48KYhHh8fDKEjI4UB8PnISoCgZz4WnQAmAgoN4fmyvq8RdeFUg+CDXwz4m3lC7dm1VIlDaF/vZtlQorLWIJ8f+cMdbgTwELAsl0RNQ0hRWZyNYIlYfAjj2U/r06VUwgwJmrO32QOmE0I58DoPxMNgL3sjxqFu3rjWfBMcN44b1G0K5M68PhHMcXyh1BpNE7Ax3xoXf98V5i/O/VKlSuv9twWtX3j2cSzgnodgawRnCO4439r1ZBnkoSGQ3YBm87w7IdYJyjv1hewzxGmM25xoKCOAaceStwLLIHTLnOzwXyEnyBF/ta3ugyMV1jhJCCCGBJioTtY1SAYsqwiBsw3XwHNWaYJF0lKRtgGcBggaEnTNnzsSqzOIJEKQg1CAhE2ENEKbeeOMNl9+BAIxEzrfeekuXR6lNJGDbJk9DQIbgh+ROCJbz5s1T70B8BBgIc0j4RlUqVxZeCMgQxBBChoTdAwcOqMfHNoEZ4VFYBknLUAYgBBsgIEGxwudLlizR76MCjn3VHgMSkZGsCsv8zp07tWcCrPVxhdzg2CK5e9euXarUwBqNhGLsP1S8QjUolEaFQoAqQFu2bNFqRXgNMG4oaKjYAyEaQrJ9lSzbsBWEeUHJQ6UhhNFA4cI+RRUqJOCiIhCEWCRlm/VgH0IJwR9+A+FxGK8r3BkXjhGUKowH560zrxXObVwbpkoRxojntonKUMZxbM25i3MN3hdbZRzH2fY1kqUhbGP/45jB2o6kalT8MuAzHHMk3iMMDMcH24Fj5C5Iukb/C6wf24oKUhg/1m28g/B84BhgHsA18ssvv2j4ltmXCPvDdxAy9dxzz7n0NjrC3X3tKe6co4QQQkjAsUQpJmHy8ccfj/X+wYMH9f3HHnss1vv2Sc3gpZde0qRfvI9EUWfJm0ggNZ87AkmaJUuWtGTIkMFStmxZTXR1lBxrC5KtkRCOhM38+fNbvvrqK0vt2rVjJWoj2fXhhx/W9SLxd968eQ6TRONKPh8zZowut2nTJktcXL9+3dKvXz9NlkYyeYkSJSxjx46NtQwSULE+jNkeJM52795d92vGjBktZcqUsfz6669Ox7do0SJL9erVNUkdyc9Vq1a1/PTTT3Emz37wwQf6G0ii7tmzZ6ykaSTX4xjiHEDScN68eTVJduXKlfo5lu3WrZuOJWfOnJbevXtrQrJtorB9ku7x48d1fe3atbPcuXNHCwT07dtXE4rxG0WKFLE899xzlsOHD1u/g0RjJLJjjFjfW2+95TJR251xoSABkqWxThwDnAOOMOeG/R/GYX9u4BjjWOF35syZc9/+xnlpy7Zt2yw1atTQ87JQoUKWL7744r7fRxEC7C+cQ0iQXrBggcUV9onaSLofOHCgrh/7F58tXLjwvmsdSew4b3AdVa5c2VpEAPND3bp19bzCsRkxYsR911dcidqO9rWzRG3becXReW6/fXGdo4QQQkigSYB/gVdlSDjx8ccfa+lTY8X1FtPQDJ4FX8bJuwOs3egvghK7hBBCCCHEN0Rt+BOJG4TAILQKFYXc7W/hCjRvQ84EwpVQ8SnQCgUhhBBCCPEPVCqIU/r27at5DvhDDoe3IN8BpWzhKUCOACGEEEIIiQwY/kQIIYQQQgjxCnoqCCGEEEIIIV5BpYIQQgghhBDiFVQqCCGEEEIIIV4RVUoF0kdQgYhpJIQQQgghhPiOqFIq0El58Def6yMhhBBCCCHEN0SVUkEIIYQQQgjxPVQqCCGEEEIIIV5BpYIQQgghhBDiFVQqCCGEEEIIIV5BpYIQQgghhBDiFVQqCCGEEEIIIV5BpYIQQkhUcu7cOWnevLlUr15dbty4EezhEEJIWJMo2AMghBBCAs3+/fulSZMmsnv3bn29adMmqVSpUrCHRQghYQs9FYQQQqIKKBDVqlWzKhTgr7/+CuqYCCEk3KFSQQghJGqYO3eu1K1bV06fPi2PPvqodO7cWd/fsmVLsIdGCCFhDZUKQgghUcHYsWOlVatWcv36dalVq5b89ttvUqdOHf2MSgUhhHgHlQpCCCERz927d+XNN98Ui8UinTp1kilTpkiqVKnkscce08//+ecfuXbtWrCHSQghYQuVCkIIIRHPrl275MKFC6pIfPXVV5IoUUydkmzZskmWLFnk3r17sn379mAPkxBCwhYqFYQQQiKe1atX6+MTTzxhVShAggQJ5PHHH9fnDIEihJD4Q6WCEEJIxLN27Vp9rFChwn2fIWEbUKkghJD4Q6WCEEJIRIM8ijVr1ujz8uXL3/e5yaugUkEIIfGHSgUhhJCI5tChQ3Ls2DENeypTpoxTpWLnzp1y8+bNIIyQEELCHyoVhBBCIhrjpUDuRIoUKe77PHfu3JIhQwa5c+eOKhaEEEI8h0oFIYSQqFAqHOVTmGRt5lUQQoh3UKkghBAS0bjKpzAwr4IQQryDSgUhhJCI5cyZM9rYDpQrVy5OpeKvv/4K2NgIISSSoFJBCCEkYlm3bp0+FilSRDJlyhSnUrFt2za5ffu2hDtXr16VGTNmRMS2EELCAyoVhBBCojafwpA/f35JkyaNVn8yno1wpmvXrtK+fXv56KOPgj0UQkiUEDZKxeeffy5VqlSRbNmySb58+aRly5by77//BntYhBBCwrTpnS0PPPCAlChRIiLyKlatWiWzZs3S56NGjZJbt24Fe0iEkCjggXCaJGF5WbJkicyZM0dduo0aNVIXLyGEEGIP7g+bN292S6mIlGTte/fuyf/+9z/r69OnT+s9kxBC/E3YKBW//PKLtG3bVh5++GF55JFHZMSIEXL48GHrDYMQQgixZdOmTdp7ImfOnJInT544l4+EZO1p06bJH3/8IalSpZJOnTrpez/++GOwh0UIiQISSZhy6dIlfUyfPr3TZXAzuXv3rvW16ZQKSw7+CCGERC6rV6+2Vn2yWCz65woT/rR161b1hidMmFDCievXr8u7776rz19++WUNEx4zZoysWLFC/v77bylcuHCwh0gICUEQ/hm1SgUUgn79+mnN8WLFijldbv26NbJmzcr73j918ogkSZLEz6MkhBASTJYvX6aPjxQvKidPHI5z+TSpk0ny5Mk1bGr9ulXy4IMFJJwYOfJ79eAj9/DZZo0kSWKRJ5+sIkuWLJNhQwfLm2/2C/YQCSEhSPYceX2yngSWuEw3IUjv3r1l0aJF+ge3tieeipEjhsiLvV6RpEmTBmi0hBBCAg3mf4Q8XblyRStAFS9e3K3v1axZU9avXy/ff/+9tGjRQsIF5E4gfOvy5csycuRIadWqlb7/22+/ybPPPivp0qXTqlZQmgghxJao9VS88sorsmDBAp0oXSkUIFGiRPrnaOf5agcSQggJPbZv364KRdq0aVWhcHfOh2AOpQIhUEYwDzVlafHixbpd6L2RIUMGfR+lY6FQPP744zpus721atVS5erQoUNaEap169ZB3gJCSKQSNpI1HCpQKFDFYt68eVpWlhBCCHFVShb5FJ4YkUK9AhSKlDRr1kw9KlAWChQoIHXr1tXSsWDQoEGxthd5ISZhe+zYsUEbNyEk8gkbpQJJZ5MnT5affvpJUqdOLSdPntQ/JKYRQgghjpK03Skl66wCVCgW9Jg+fbo+IpwJnDp1SlauXKmhvk8//bRUrlz5vu+gCR689qieCI5duyDHr18M8MgJIZFO2IQ//fDDD/oIi4y91QalZgkhhBDj2d6wYYPVU+EJDz30kObcocLggQMH1BMQKhw/flw2btxoLZebMmVKbQKLyk4nTpyQDh06OPxe1qxZpUmTJtK3b199PeTf5ZIgQQIZ9GjDgI6fEBLZhI1SgdhYQgghJC6OHTumQjZCf4znwV0SJ06sFn30QEJeRSgpFfPnz9fHMmXKaIUnUKpUKf2Li/79+2seIrwUkw/9oe/1KlxVsidPK++88440b97c7WR2QggJ6/AnQgghxB1gxQdQDmDN9xTbfhWhxNy5c/URYU6eUqhQIauX4ta9u/qH56Bbt27yySef+Hi0hJBog0oFIYSQiOLPP//UR3cs+I545JFHQk6pQDjW8uUxSkD9+vU9/j7CnWy9FGDSwU2aWwEPRqZMmWT37t0+HTMhJLqgUkEIISQiPRWlS5eO1/cfffTRkFMq0Jfp1q1b6nFAKdn4YLwUBltvBfItvv32W5+NlxASfVCpIIQQEjGgYpO3ngrkFqhl/9gxbSoXCqCUuvFSYGyeYu+lsPdW5MqVS3NQUFWREELiA5UKQgghEQOqIaEJHDpHFy1aNF7rQNnyBx98UJ9v27ZNgs3t27e14Wt88ykceSkceSv69Okj3333nZejJYREK1QqCCGERAzGS4GqT+jNEF9CKa9i1apVcvHiRcmcObNWfvKUkzcuy5yj2yR5wsQO/2Yf2arLwFtx7do1VlskhER2SVlCCCHE3/kUthWgZs6cqU3wQqXqU7169TREyVOyJkst2+u/5dayPXv2lHHjxskLL7zg8e8QQqIbeioIIYREDH/88YdX+RShlqyNRn4mnyK+oU+eAG8FunQj5IqQSAOeOFRSI/6BSgUhhJCI4ObNm1YlwFulwvSqQJlVCCLBAp6SI0eOSIoUKeTJJ5/062/duHFDe3sMHjxYZsyY4dffIsSXoFnl6NGj5e7d+/OGDGiIWbZsWS3EAMWZ+B4qFYQQQiKC7du3q4U9Q4YMki9fPq/WhY7VWbJk0WpSO3bskGAxZ84cfaxRo4Ymn/uTZMmSSceOHVU5++qrr9RLQkioc+fOHe0I/+KLL0qPHj30mrUHeULNmjWT/fv3y7lz51iQwE9QqSCEEBJx+RTxKbsaip21Axn6BLp06aJdyKGgrV69OiC/SYg3oDLa8ePH9fnPP/8sL730UizFAt6LTp06yZYtWyRJkiT63vfffx9UD2SkQqWCEEJIROCrfAr7vIpAJWvD4ooQDZSxXbJkifz0008q3CM5u3bt2gEZA7w8devW1edr1qwJyG8S4g1jxozRx3LlyskDDzygYVCvvPKKetrw99prr8mvv/6qnjgUPcibN6+cPXtWJkyYEOyhRxys/kQIISQi8FXlJ/uysoHoVbFz506pWbOmlo61p0KFCpIxY0YJFChbO23aNOv+JCRUQYPKBQsW6PNhw4ZpbsXzzz8vP/zwgyROnFjy5MmjoU7wXOI9XEuocPb666/L0KFD5bnnnlNFhPgGKhWEEELCHgjjaHwHSpYs6ZN1mvAneAsQQhGfcq7uMn36dN0GCDhQINCTAn/I7UBTukBiPD1QKmDp9UUoGSH+AOFOCHUqX768FClSRP+QV4WSyMOHD7cuN3DgQGncuLE+b9++vQwaNEj27Nkj8+fPD1hoYTRA9YwQQkjYAwslQGgDhHFfgK7ayC+4fv26VoHyJyZ/4ZtvvtFk0g0bNmg+xY8//mj1mAQKhH2hcSAq5KDyFCGhCJQJ9FQBKDBgaNeunVYwM8Bz0atXL+vrVKlSSefOna3XG/EdVCoIIYSEPb7OpwDwTKD8pL+TtVFtaePGjfq8YsWKEmxQZcpsN0OgSKiycuVK2bdvn6RJk8bqhTAgrGny5Mny0UcfyWeffXaft6179+4aHrV27VrrtUe8h0oFIUHgn3/+kTNnzgR7GIREDL7OpwhkBSiMHYoFStgWKlRIQgHbEChCQjlB+9lnn1WPoj3169dXDwW8bvZkz55dy9ACW68GOHbtghy/fn9uE4kbKhWEBBhYVlClomnTpsEeCiERgz88FbZKxa5du8TfoU/wUoRK/oJRzqhUkFAEvSZmzZp1X+iTJ5iQKKzn4MGD1veH/Ltc/4jnUKkgJMAgVhqJZBCC9u7dG+zhEBL2oEY9qsAgyfmxxx7z6bpNWVl0mg6EUhEqGOUMuSoodUtIKIHQJnj3kG8U32seIX7Vq1fX3AxTPhleismH/pBJBzfRWxEPqFQQEmD+/vtv63NTCs9dkMCJkniTJk2K129TOCCR7KUoWrSowzAIb8A6U6RIoTHY/gDX5Lp16/R5pUqVJFRAFZ3UqVNrgzDbOYuQYIOKZOhFATp06OCVd693796SNGlSqVKlir6Gh+LWvbv6R2+F51CpICTA2N6g0ZDHE6BMILb73Xff1RKXnoCSeihVidKVhEQS/sqnMEnLr776quTMmdMvsdbo8nv16lVJnz69X70h8UlSf/zxx/U5Q6BIKPHnn3/Kjh07VBlo0aKFV+t66qmntF+Fub7hpTDQW+E5VCoICUKStmHVqlUOm105w3T2PXr0qKxYscLt76EpEKpgQBHBIyw9hIQ7iIPu16+ftR69r/pT2NOlSxe/xVqb0Cd4IEOtCRfzKkgoYrwUqPgEZdwb4OVo1apVLC+Fgd4KzwmtGYyQCAcxoCaPArX0Efrw+++/e2TVNLgbAjVlyhQVvACEFnhKli1b5vHYCQmlcCeEPSCeGgozLP147q8mVhkyZPBbrHUo5lPYKxUmvIyQYINrHd3eAeYAX2HvpTDQW+EZVCoICSDo4ImksLRp01qtI+7mVZw+fTpWI6pffvlFJ1hXLF68WLp27arP0WHUNPwZMWKEhBMnT56UmTNnahgK3NXwtoQzLFkYf1BzvmrVqhrGh2sJ5wOuBSRaZs2a1W+/649Ya3gOTYJoKCsVCDWJa64hxBknTpyQAQMGaEEFb8F94PLly9qYsnLlyuIr7L0UBnorPINKBSFByKd46KGHpG7duvr8t99+cys/woQ+oY59gQIF9CY/Z84cp8sjZKFNmzbqDUEd708++cSabDp//nxN+g5lEKL14Ycfalw3biDokgplCI2KIFh6mlMSSrBkYfzBuWtq0EMgxzVQo0YNv5Zi9Ves9c6dO+XChQva4ddUmQolcuTIofX8obzZekkJ8YT3339f52wYtbwNvTW9Kdq3b++za/7kjcsy5+g2SZ4wscO/2Ue26jIkwpQKxJ9DOCpYsKBOwq4EKkJCXalAr4p06dLJ2bNn3eroaW7qKJ/XsmVLfT5hwgSHy+7evVuaNGmiigdK5o0cOVJDn1DRBQIYJvbvvvtOQhn0Bfj44491W3DzQHhLt27dNDnv1q1bseqKhxMsWeh9nxfwv//9z9pDwt/4K9Ya9zSAucBRg65QgCFQxBtg1Jo7d64+Rx7gjBkzvLp/ogM2igjAYOYrsiZLLdvrvyW7G7zn8A+fYRkSYUoFStuhrvCXX34Z7KEQ4hII7baWdLw+dOigWiYBhPvEiRNLzZo13Q6BQr14o1SY0KmlS5dqfX5b0APjueee0+ZAqDX/888/S5IkSayfIwwKjB07Vq5cuSKhiimzWbZsWTl8+LDeTL744gs1KgAoG+FIIEoWwrIMS/6TTz4ZUcLgpUuXVAkH+fLl8/n6r127KgcO7JeNG9fLgf37/B5rbZSKUAx9MjBZm3g7j+NeZHjzzTfjfd/BPQvAy58tWzZ9DgPTkSOH5c8/N8m6tatl9+5/5OLFCyxGEiTCSqmoVauWltJs2LBhsIdCyH1cv35dVq9aIZMmjpehQ76STRvXWz9DiMPkSeNl7dqY+OkzZ07JX1v+lNq1a1tzH9wNf0KYRP78+aV8+fI6caIJkC2ffvqpKiCoijFx4kT16tkCRQaCOapO4fNQVyoQPw+PjgHhX+Dff/+VcCNQJQuhaC5fvlwFQeQcvPPOO3Ljxg0Jdw4cOKCPKI2cJk0ar9enTSg3bZCpUyfKt8O+lmFDv5apUybIyhVLJWOmTH6Ntca1G8pJ2vZN8KhUkPhgvBTwnOfNm1crF37++ecerwfKAwxkAKGwhn1798jECWPl98W/ycqVy+SXmdPku5HDZPA3X8iECWNl8+b4G1XOnDmjeVpZsmTRvD4SN6Hpb/Wh283WWozKO8aKhz9CfMGtWzflzz82qXUTzw2nTp20nmdXr16WlClTyZkzMVbWu3duycKFv0qixEnUlfvEE09Yv+fo3Dx//rxVoELIB5aBtwLWe4RAvfTSSxoihPrdUCoArPqw5jhaH5K3X3/9dS3FCa+GP+PR4wu2zXgqbLfBVqkIl+sY+xd/zsJoBj3aUIVMX1nXDh06pI8IecM+gncXN3dUSsL+DFdM5TQo1b449ocPHZQlSxbFei9duvTyxBPlJHXqNLFirR2BWOveRZ7S0AhPx4PzF0JLsmTJNG8oVM9leEZx7uKcQsItBCxC3AHzmQlTb9asmYav4771zTff6KOZy90B64GXEsaErFkyWa+XTJkzS6rUqSVL5iySNGkyOXPmtJw9e0bvxUePHJZSpcrE+9pC1bfChQurkQ6GPxMhEIn4qpx1RCsV69etkTVrVt73/qmTR2KFgxAS3wkTMZ7bt2+3KqywqCO0CZZUVHg6eeKwvp/wgZibMyY3CBFVq1bRfhWwHhfIn0/69u1rs957curk0Vi/tXZtjNU+d+7ccvPGZTl54rJUrFBGz2PkHixdukgeLJBfOnd+ThXpenXrSOVKZa2/b0+NGlW18zAEmxkzpkilihUklICwhURyCDP58uaItR1Zs2TUx+3btzndvlAiRYpUkjZdRpdhNL0KV5XsydPKpYvn5No170PSdmyP8WqVKlVSnuvUQd55d4Aea3h7X3m5t3Tv/ryEI1u3xoQAZs+eNV7HHtcsPHTG85UsWSINo8L1milTJn0fYYlZsuaMFWvt3rrvv25d8ev8GGHr0UcfkQvnT0ko8+CDBWTPnr3y+++/SbWnngz2cEiYsGvX35r7hnte8WKF9bFK5UqyYuUqeblPb/nhhxFxGrRwzUKZ/eijgfq6RInisnnzJsmRI6v1u40bNYr1HdwDESqJv9SpklvnCsyB8HiY8GN3eKJMKVUqfp0/T6o9FTod731N9hx5fbKeiFYqyparIKXL/GeVg+A3csQQyZI1lyZ7EuIt6zds1PMK1s0KFSvLQw897HSS3LgpRtArWrSo1KhZT6pWrSF/bv5DBRjTzRPfhXCZNVvuWN89eGiGNRTBfJY1W0wFHJTYW7hwiVoa9u7dp+7aYd8OV0HJGSi8aaopTZ48XZo29a4rqa/ZsHGLdV8VKlws1mely5TTx4MHD923n0IRcz7EFUYDb0WatBkkdRrvmjmBy1eu62OBAg9Km7YdpF79hvLGG2+oV+vLr76Rni++pEJ0uHH27AV9xHXm6bG/cuWyzJ49U86dPSNdnn9BkiVLru83bZbHJ1a7hAkTeTSmrdti8quefLJayJ/HZcuWU6Vi796D0qpVaI+VhA4/jRqvjygWki9/YX3+1dffaGECKBZ/bt4u9erVc/p9KAC/LZgnGzasl7//jgl37dSpkzRo0EgVFFfkyGm/rpuybdt0DVPGudyg4TOSw34hBzRo2FhGfveDrF23XmXHUPTqhxIRrVSgmoajihq4YYRa51ISPsByYiaWypWflAIFCkrx4iU0jMmdTtqo/ITzL2myZFK+fEUpXTom9AmCJdZrQmFs12fyKeDtsD13W7durUrFuHHjrMlv3377rTbWiwuUl4VSgZK28AqgbGuosH59TD4Kbj721yqsTODUqVNqibLNtwhVPAmj8cVNy/QzgWcL+w8KJqp9wau2detWWbRokU+rpwQKUwYZ56onc/ixY0c11vrq1SuSJElSOXP6tOTJ63miN0ILEQ+O+PBuXbvI+vVr5caN65I1W3Zp2bKt22OyzaeoVKlSyN+PkKyNeHYk/Yf6WEnoMG/ePH1s0KCB9bzB/I1wXYTn9u/fX6sROlIQEPL7y8ypGs7019Zt1mulRYv4hSAhNKpa9VqyatVyuXjhgkyZ/LPUrFlHHinxmMvvIXcxRYoUmlOBqAAUCyJRqlQQ4ksgCGBCunH9utSsFdNjIlOmzPrnSTlZIxQb4Ia1DY0xoTAnT56QrHBH2CgViL22BRMyLM4IFwIdO3a0Jn/HBZK1sSyUivfee08Vk1BUKuxJnTq11s5HIyVUgCpTpoyEOp6E0fgCJEOCXLlyxXofVVOgVKDXQzgrFZ5Uftq6dYssXrRAQyJwrTZ+5lktYhAf4ClEFUIoBFDICxYqLL/OnyvVqtf0SBlESAiS6WH0CoccF3ONQanAXIRmeFBQ8Yi4c5SsZkgxsT/HMddAmahTp06sz5DPN2nSJM0TRP+Kt99++77vX7p0UXMjkidPIf/+G5NLhfy/+ILr8+GHi0vBBwvJ/PlztErUggXz5OSpk/LUUzWcGgUR1YJCCjDEoNoilQrXhJXJAZZYnKT4sz1pUW6SEH9y8+YNmTljipas27LlTzl69L/O1u5i66lwp8worCNqVbl40Vo+1b4uPxSS5s2b63NU1vC00zSqqWEyjQmhWiihAPJMTPlcR0oFQPJcuFaACgRmTrRXKkyowe+//27NAwoXUKnJbBeaP8YFlIhFixZo+ASeFypURNq06RBvhcJY7CGcQLmB5RLJ3M1btI5lWEBJWozVFajMZZQUXOehTrFixVS4QhU7CFgo9DB48GA9j6ZOnar9BwhxVPWpQoUK94VaIp8PPYgAikjAA2BP3rz55OmnG0vevA+qAo7r1heVP5MkTSqNGjeVihWr6OvNf27Sim+umqkifAvgfCcRpFSgsg1OUPwBuM7wHF13CfEXCJmY8PNY2bt3j1oWEZ+eM2dsYS0ukKBtlAp7T4WzMqMQWK5fuy7Dhw+1CoiOwppg9enZs6fe3GHF9wQoKT169NDnL7/8slphQ+E6Rywtqsygyo8jTNWQcOpVAWsdtgkWboAQGryeMmWKz3/LhD/ZKxXwdCHnBgYa0yMhXIBCgRs/QiVMjXpXQCHf8v/lJCtVqqqCBAQKb0DxBeT5gA0bNjgY4yGZPm2Slo+GIcIZS5Ys0Uf0EQkHYLxA/haAZwJhKAifNF4Wd5p3kugCymejRo2cKgKNGzdWIwcUcIRD4dpeumSxnPv/PjSgwIMFZfCQIfocDV/jyqNwFxgGkAP5zDPPqocte/acLsOXUZYbwEMZCaW5/UlYKRVVqlTRm6H9H1yvhPhLoZg86WeN60S/h1at20uxYo94vB6UY0SCGCYwe0HZVbfecuUryOY//7T2p3AErECffPKJPPzwwxIf0JkYwic8f8Z6FAqhTxBYnIWUGE+FUdRCHYwTQjy8A88884y+hxAuKHGmTKqvQBd102wKORW2IBQBIVAAIVDhGPoEj5w7cf3ly1WU/AUelGeaPCvlK1TyWYKlEaTNeWrP2bPn5Z9//papUyY6VCxgYEAYha0FNBwYPXq0hqtgnkCzTuSWGC8plQpiD/L/kIeDxGpH4HqElwL3VZQPf+3VvrJp03qZNWu6XiMIN37xxRf1MywDJdbXIHyxQ8cuUrmKa+Ue91YYMnAPN/2TSAQoFYQEEghnUCgQ15kqVWpp2aqdZMuWPV7rMsIvLOy2xQPi6tYLb4WpYOYobMoXYMJG0hxASAPipIOJmbSRIOcMo1SEi6cCVZcASrrCU2CEYwAhzR9eCnitYFm3x4RA/frrr2HVddYoFa5Cn2zr0cMr0axZSylYMOZc8RUmJM+RUnHy5CkZ9u1IGTtuoiaHT5066b4wM+QkQOnD8QmHfCADFDkYMGyVM9NfB0pFOJ1LxLdcu3lPRi45I7U+3SPF39ylj3h97eZdSZ48psqaI2DMQgguGDN2nFy+ckXKlq2g5xpCeTFvwoOAfD9/FRJB5UZjpEBvM4RLIuTYFpzz1apVi+VlJI6hUkGIE44fOyrnzp1Vobtlq7aSPn2GeK/LWZK2O91627Vrrx4OV0K2tyC04emnn9ZJtXfv3kFrxAXBxCgVzvIpbJUKWPkx5lAGbn2jVNgmR5tkYyMs+ztJ24CQG4QRwHsWbAXSE8x+chYSh/Ng+vTJsnaNf8O6jCBtwvRs+eCDD/R4nz17Tk6dOqNzCLp12yoWRiipXLmy27XyQxUkreJcQqWePXv2BHs4JEgKRacfDsrgRafl6PnbAt0Sj3jd6YdD+rmr+T5fvtySM0d2vUY2b94uDxcrrh6OQYMG6TJfffWV1KxZMyDbsuT3hVrYAeGLSBS3hUqFe1CpIMSFa7RBwybSsmU7rxQKW6XC1ttgW2bU0R/KjGIZuF3bt2+v7mSAUCx/CP0IZ4ACBaEeoQ7BAIIJuqYiKdRZuJcRmGEBQzyury39vmbZsmVaqQqJhib0yFap8PX4nSVpG5AYbGKE4a0IF/bt2+e08hMUipkzp8qB/ftk/fo19wkEvgRV05BXACHIVGUDa9asiZXIefPWHRW4oVhMmzrRqoAYocQIKeEMlCJTkY4hUNHJuNXnZPsRx3kGeH/cmphQTEcKBaqybd/2lzRoUE89EggLRCUohD0BNIX1puKTpyBMEp6LixcvyKSJsRUL5BGBbdu2xVmIIZqhUkGIDYiBtk1WLlLkIUmfwTuFwjb8yTbvwZQZ3d3gPYd/+AzLgH79+qlyceTwIRk/bpR24/V1uAGEUFPa75133tHqNoHGeClKlizpskEl3NUQ7kK5AhSUI+S6dOnSRV8/++yzsbbJhD/Bs2Bv8fZHkrYtRrkJJ6UC8fyOwp+gYM+eNV0VCgi5aOSYJs39YV++AqEQjkKgTMEQU0Rg4cJFGn4FxSJDxowa9oi5BTHikaJU2HpuHCWuk8hn+qYLrj/f6Pjz9evWaCVF0LFTZy0UYjwTENqbNm1qDY0KFAg3RlSCUSwQ/mz6P+XIkUMNWfBEwstLHEOlghBba+eMaTLh5zFaOtFXQPg3ngpzA/YUJPWC6zeu6zh37twuy5b+7nPFolu3buoRwfYjlCMU8ylCvQIUxoMQMnilsA9Pnz6tCgQqnNiCyk/wGuAY+rIstm3ju7iUCliXg6E8egr2kaPwJ7y/8Lf51spsTZq2kNx5YpQ1f2KuY6NUoEQsyqoiTNFUYYOyeOjwEWnX/jmpU+dpVYRRPQYKJBQ+c/6GOyYvhJ6K6OTYBddW++NOPn+kxKOao1i37tPaPBaGM2MwwPyPAjzBaLQIxaJFy7aSNm06uXDhvFZzg7ERYzFzj/GakvuJ1xGDUAM31Y8//iiXL1/W9+DeNxodIeEGhJP582bL4cMHteKTq3KQnoJrA52f4d5FZ2N3hFIInPhDJ1I8mqpMqLVfp+7T+hyVMjZs8G0lCghmaEYExowZo67eYCgV7jQEC8VeFePHj1cvC+ZGVAqBgvbTTz/Jli1b7gvbgcU7T548sazwgQh/MkoqwlZw3qP5YagDxQz3F+wz4+EBq1etkG3b/tL3GzR4RvIEQKGwPT9xvmIfGi8Fmk/Cg2aUNvR/gdXTJDeb8Ch4KXxVjSrYGAULzfBQ3IJEFznSuc4Lyu7k85QpU0mbth2l+CMxYa7wAsyaNUsNMSiz7avysfEhTZo08mzz1pIiRUo5deqkzJ0zS983Sg+VCh8qFXD7YBJp0aKFvPLKK9ZOvigN9uabb3q6OkKCDoSCJUsWyT//7FJrRONnmlk7WfsCE/qECclVSI8BFkwk0yJUAso7HtF8ygCrTtUnY0pRrli+RGNSfQmsROihgP3yxhtvBKyqCyrimH3liVIRKmVlsZ8Q7oRHlApFydaVK1dq2U1nCbnG8uVLpSKuRG1DOJWWNfsHIQhG2Dhx/JisXRuTlI0O98iBChRoWgcjAQwGY8eO1ZAmjOu1117Tz03Z4F9++cWa/4TzAkITyJ7dd/NLsMExyZkzp4aFmKaVJHpoWjqd68/L/Pf5/v37ZPv2mObFwN4TgfkQYVDeNKj0FRhDs2dbagU95FoAKhV+UCrQaAuWOLjYbUuFwaJquoQSEk7A2v/nHzGu+3r1GkrevI6ry8QX0y3UvvKTK3r16hXrtUnSNjzxRDkpUyYmrnvBgnmyZ49vrfXvv/++hnIgyThQcfcmlARKlX0HVm/Lyjoveei7hHfElCNEB8nuEydO1L46cVmjfV1W1jaUKi6lwpSWReJwqDd0chT6lC17DqlVq65UrFRFHn00Jlk4UCBszXS3f/XVV/URuTMmTLFGjRp6HuA+uWnTJn0PYWbm2Ny7e1M2bXTc5yIcYQhU9NKuYgYpnsuxVwHvt6sQk5OICmGzfpmu+YB7doeOd9kVMC527vKC5MiRU19TqfCDUoEKF1AsIHDY3xzRSp2QcGLHjm1q7QdPPlVDij78n0fAVziq/BQXqDRhqqogZMqRgFj1yWraiA+C5PZt/1l/fAFCdUwFDjTHC0S1C6NUuCola4tJ1Ia31DR787zk4UGfKRaTJ0+2GlggdLqDCYnylacCyeFGQYD12BWorgUrMzxhyAcIZcxN3L6c7KOPlZQKFSoHZUzGm4YwNxxvk2gKYHCzDYECpuFdoUIFdfmlSxfr/BMJMFk7ekmR9AEZ1SWvvFQrs+RMn1hgR8EjXuN9fI77x8QJY+X27VuSJ28+bUoZLth22s6QPsbr4uuGpVGtVMCVCzenI5c7LDOEhAs4j9etXa3P0WCuzP83mfM1JjynaNGibn8HFm5jAa1atapDizfeq12nvjz1VA1p0DAm3MKX4PfhMYAn4Pvvv3co6MHI4C1QiiDYIonVE6UC840RnF15K+Jb8tAWWPMhhDvLP8BNc/r06focoaHuYjwVvlIqTJI2GuzFFWqH86dOnTphEQJl9k/WrFlk2rRJsSq0BQvbED0UODBNDQ22IVAxIZYxxosGDRpKqVIxlv0Fv86Vffv2RIynAkoFm+BFH1Acuj2VSRa+XlC2Dyqqj3iN93Gf/Xn8aM1VzJIlqzRu3CyWoB4uXLlyWbZu3Wz1nDqSg0k8lAokmA0bNizWjQkJdAMHDpTatWv7enyE+A1MbCgfB0vnk/+fo+APnDW+i4tGjRrJqlWrZMiQIS63AQqRmaRxQ79x47r4KlnNlJhFd1PjDYAA//zzz2tIFjpET5s2ze11orY/hCzkGaBxFhKVEbuKZHRTatNdpcLdZO34ljw0wBINrw2sU6ib7shrgwRceAkyZ86s+TDu4uucCndDn+xDoBYuXCjh4Kk4fvyI7N+3V638waZixYqaK4PrBNW+7EHDLii+OCYICzKeCtxDn6pWU4oWLfb/5XBnaPftcAZzAYo8IMTLKLaEGA/F6dOnNDehabOWbuUVhiKpUqWWatVraB4ItmvlSob7+0SpgHCBihdIVIObHY1JUHsfoU+IwyYk1LG1MKACBWKy/VWJ5dSpUypsYv1GAPb0Zo3J2B0goCxe/Jv8PH6Mzyy5HTp0UA8L4mFR8q9r16567SNnwCSgIpnbVeU3KDpI4IRAjnyJtm3bqmUcgjQUFdMRG5M1BDFPSm26U1Y2viUPDUOHDrXWJceYTXdsR6FP6EUB4cpTTwX2g6mk5+8eFfZhdtjv2L5QLi1rlIrk6PmQIaNUq1Yj2EPS0DEoY/BAOMoBQgiU8QShO/CJEyf0PRRCwHxQt14DyZe/QIwh4LpvDAHBAttlckwYAhW9fPvttxrSifwi3B9m/TJNjh8/JsmTp5Bmz7YK+2iWypWf1H5RYOqUyXLgQEyuF/FCqUC4AZQKVLmA9Q4TCZQJhEHA2khIKIOSh6NHfe/ziknOmDNnjj5CMHc3zj6+wKK+b+9uOXfurNbW9kVDNQjIppwtFAkI1LhZIF580aJFamlHBRxUPXLmmWjWrJlUrlxZ645DeIYwhtAqCGSw4MLLgHVcvHhR4889qU3ujqciviUPAQRBdBoH2Abw6aefxtq3UAbmzp3rcegTQD8DdGf2VbK2p0oFbvLGg/bHH39IKIJyzEbhwXZBOIGQEiphP65ypUwI1OLFi61KnLHUwrvYqFFTadWqnRR4MCY/KJwpXbq0PjJZO3rZs2eP5rhBToTijGIK8OY1adpcjQHhDrYJHnYAY+EvM6dpFTriZZ8KCBotW7bU2txff/211ua2rQQVziBWrl27dtabAIkcIAhC2IbQvWbtqoAkH6PXA8A55W9Spkz5/wJXcjlx4rhW2vBF3CfKoyIUC8DyiqReNPiCxRUCtrHm21u6YYHt06eP5iFAkIIVHyU1UQ3rvffekwoVKqiyBSUDwnV8vEXuKBWelDy0Z8CAAaqIQnhEzgTi5iH8ox+FAQoFFDokjqMynqeYZG1T4cjfje+cCYOhqFRAgR03dpQ+T5YsqbRr38ltz10ogPBAXJcG+y7aKHgCwcuAZls4l8I5WZtKRfRiDCPwwGI+r1SpqjzXubu1elIk8OCDMUnmd+7c08Tz6dMnqyefxOC+n/7/ceT6t6V169YSriBUBcITXO1IrkVZQBIZIMQGQvbJkwhBSCHPNmvltHeAr9i6dav8+eef+jutWrWSQJAxYybtKjxl8s9y4MA+Ld9X/+lGXod3QTmCZcY+GRUeCygaiBe3T75D7tW4cePU84DwIH9cT0apwDULJdHRMUXJwyW7LjtM1o4peei4JjpCtozyAE8MPE3ozYMwMDQIRBgXhEIT+oQ8kfjsZygVOE+C4akAUIRwnEJRqVi1arm190H+/AV82j8mEJgQKJPE/9RTTzldFk22pk6dKOnSppPmLdr4fX7yV7I2Gj3CQxmusfMk/pjcMNvKc8g5iiRMWdlEiZPofIT7gq3hINrxWKlAOVlbcCNH/DZurti54apUICYcYRomdnfnzp2amGm0UhK+wNo5d+4vKmTjRt20WXNJ//8hJ/5k9OjR1hKj7vRd8BWwCjVq3FRmTJ8iu3btkOQpUki1ajW9UizgnbRXKAzwVgwfPly38di1C/o72ZOntZbdg0DuLwUdXg7MO5iDcENzlI8RU/Iwj4xbc16TspFjgZAoeCigUKRImlDj4qEYoXwumpjBywLl4f/aOws4KasuDl+6u7u7kVQpKREEPgFBRQTFVrD9/CzsDkIEFEVRBBEQEKREQAEpkUa6pBvpmO/3nOUO7w4zu7O7szt1np/j7O4MM2/d+95T/8MzKU3WC0sN2UcffSTFtzQ949xaVZ+Epj4lh6xsQgu1gRoZwLBhf0Op03O1ajXNmTPDEiV0ECrQSBKjglxsZxNLTzC+L128KEXbkyaOMx3/0yWsVHJYbJHKR4rjqlWr3BEwJTpg7rDR1nXrVklULtwM44QYFczXXW69zaRPnyGsxmnIpT/hCXM+SHnAk0QqxJdfxoSpww0Mox49eshNlUmxWrVqsfLhlfCe6KZPm2I2bvhbBj436kKFkj8USwqD9WCTHpjSlCpVxrRpc7P8vPzPpeIFTc5J1qpEDdwwVx5A3QSF3Q888ECyfTcLMWtI+EqBYpGD4eBd8jCNOBDuuOMOMRZIyaLQFIUq6sTwNJMCZeF3Cs6BaIWtMcFLm1gHRKAa4DGPUQOS0PQncoRxCnGcApGCFUhQBsuXv2Csm3m4geGJOuIXX3wRp8GWN28+iTJiwG/ZslnmrXCSZ2XftF9F9IIkOCnGXAdVqlRNkGBFOOFsgJcxY6ZYyourVq1IkbTqiKup8IRcYoq1Kd4ON7gQ+vTpI0WjLBiQx+zVq5e8pkZF+LNhw99m9eqVMtHRy6FkycB2y/YFi1IKj1kwJkRiNJBUrlLVNG/RSqIWyZ02QoibKMWYHcvM6O1LzZ7TxyQEzsI7uT3f8SlAUb9BBNX2C/EE9brPP/9cIjEYJkRVbEdzakI8vf7MD0RI6M3z2muvuVOfEkugaioodsfAwTuItK2/YFBY5Z5QSIH6668/zeZNV86lVd6yxyncwPBFcpYO6/FRpEhR077DLTJmaIw3d05MFCxc0M7a0cnWrZvN2O+/czdrbdGidUhFPAMJ93TGNNFxZx3hvHm/St+Znyb/6FZGjEYCYlQAVqn1koU633//vajMYEj873//c+d9kzeOp6Vdu3buDr/hsk+Kd8qXr2AaNrxO5BvLlUu59Amb+kQELCFqRoGmdu26sfY7OT2fRCjOXbooDxutSImwcFzF2tTSTJo0SR4YAb5o27atLIQQoOCGcPToUTEcMCo8IT3KRivwzLGPnTp1SvT228Uyi+eknB9nPUVCrzmbAhVso2LtmtVm5oyfzY8//uCOrtmU1GhJRS1Tppy5sU3MPWjJkj/M4sV/mHDBRiq4d8YlM61EDrt27RQVpMNHYvoYIb4RqQaFdcLQX8k5N0Hp0mXlXrBp0wYzY/rUsIoyBpIEx6emTJkS63cOHAtv5CIT0rQqmOA18pTb7N+/v7sRFIsJ8kGXLl0qyi5oLivhBQtDFlaiQNEoZSMFLG4JBfP9KaH65C8slCdMGCv1FSVKBNbra6MUFqIVj5ZvIrUVKWVUkMftWRNA80AkDklrtJKwvuA9RCyQAR0+fLgYFL4K8Ehp+/DDD8VQQR0rKXLapCqxzXi+EIvwVbvir1HhLJIMJ6Niw4b1ZurUSfJzjZq1Tb58+UW9jCgKqWl0lo8Wqlatbk6dPGnmzp1tNvy9Tjpwh0PeNkX/XMsYyNSQEDFDdhrDmTHCPuCAtM/k3YfLukG5GuRUx/0w5nKvodRhHVFMaAoUNRUYFaTMQrFixSUbAkEY0qAQhGncpFlEG1gBMSrw5DnhgFGgyYRPY7xwoFmzpub48RNyEyf/7Z577nGnPDnzYDEqSIFSoyJ8YFG5cOHvZufOHabT5fzklIYCXqDDPAZqqLDoj/nm4IH9Zvy4MZIShWcl0FEKi41WvFmjvUlucABgwFHbRVH4f//731hpaHY8+1s0SNSCR1ygbEP/CiKdNmqRFM8XhgBGAXUVSTUqElJP4WlUoNzDAiGlx826tWvMlCkTZfxWqVLNNG/eSu4tzM9WljnaqFe/ocmYKZOpWLFyWBgUgNwv6cRE/6nROXDggDx81VjQAwdHpS+Dn9o0appIcUQkIZIWaKRr0tcBBb1wJW26dCZNmtSmaNHiZtPmHbFqxCIZDGWwYiSWcuUqmFat2pjp06eaxYsXmosXL5hmSRRJCTcSfOcIRNfXYDNq1Hfxyt2xCHn55ZfN3LlzxcObM2fcWvdK8GFBQl7j4kUL5fdNGzeYipUqp+g2EAH79ttv3d2oQ4nmLVpLz4XNmzeaCePHilelfHnfjbsSG6VI6WgFnjGiBkQW6J3DoprCa7zcpD05m5AFEuYIHoGAGzFGAd4vm0KSEspPFhZt1MXQaG79+vXuBk8pwcqVf0lRMmBQkPpjb8Kkmp06e9GMnH/EjFvqUO6qk1OkglH2imSqV68Z6/d//tkldRehDEXpPKgps95c6oW4jzImMVp5Xr16tUQScej5ap5rJXk/++wzub65J0fKAo3UWKKrU6dO9aveJhRBXKDbbXea7Nmym69HjoqaSIVNxXSmP1mq16hlLl66aGbNnG6WLVsi13rLVuFrOCaUyJ6Rk5hSgYQhEyDNu5TQNyh++WWG26Bo1qxFihsUwA0Czxyhf26GoQTeZyIUFSpUkvSwSRPHSw57oKMUFmdtRXJDNJEeEvDwww+LPCwLFdKJUBAK9dQZ6/lKiqxsYnpUWIj01KpVS34mQptS7Nix3W1QkPJE7ZOzHgSDotfnO8yAmQfMP0fOG9KUeeb3Xp9vN6fORk9BJHPbqG+/MvPnzwuLfG2iFjVq1BCDnrGJmAvGBtFEonzI7NKNnPRpohu+9gmhCxw1LLyJWoTDvscHBhYGBVjHR7iAiMKO7dtiGRbpM2Rwz13RYFQ4FaC8UatWHdOmTTuZy4oUSXjkOOIjFc50gvggnBkp4IVEMYYUqMRq0CvJDwtkCqPIYwS8AjVrJryzcUIhbE9xL95UeiXw/N13MQoYNEYLRUk90ija3dxRUoFQxSLl5PyF86ZGjZgFZULZd+aEmfzPKpMpjffUokm7Vpq+FZqZAhmzmeQGlSdyuVFwI1JRv359+TvCC6Gulx4IWdmkpD/ZFCgis9RVpJQMMnnI1A+Q5tO0afOrvNBEKLw1LQT+PnLBYZEGjgYuuWIMqAXzf5O0sCZNbghrrz31SqSK0hAQ6WmpKzp7yYycf9hLVCqXuxs5KpMpoSqXnJBm6HREhcv+/L1+nfR84j5yR/eeUvcEXI9WCCPajApfvX2qVqthihUvYXLkiK4sF79WPStWxCzW4iMlBgUF4RRVI+VFPwk8HsnVZKd9+/by+TNnzpTcTkKxSmhButHUKZPMxo1/y/WHp5MUiuSGfGEWrjEFat5D26EK3hNSTMiH/Wv5MrNyxXJTrVqNRKlUYSysbvuCCQXYfuYHpFUplGfcQseOHU2oE4gGeEkp1E7JYm2cAKQEYOgxZq3Skbf7B4vLuKCZYbQYFQ0aXGfSpU1nZs+eaZYs/sOcPn3KtGzZJiSdF/6CnDNqjEQSbVTKaUTaqNTsdSekgSWGBWIKRDZYBwRTWS8p0BPLgiNkzZo1KZpymFBYOC9fvtTM/mWm/Ey0O3fuPO7XSU1jXONYS2xNWDhhI8uk+LEWQEbXGzkcBsW/J06Y33+fa5o0bR7Ra0m/ZqOff/7ZhAJ4IJ977jmZTDAkPvnkE1kwMECTor7iC9IBSCXgZk06hVWHUkKHU6dOmp07t4vnpG27DjLZpQQsvDAoECnAE37mzBkp/OeZcH2oN+piAYeWeNasWcVTHK43Z0+olSJaRK8JVLhIwcATGurYSEVijQrkO48cOZLkSAWwwEkuJwrjY/LkCSZtmrSm4386y3UYlzMKb3Vc7Inn9Ujjmjr1xBmA7O7qVSvNkcOHJaUxS5asJlyx9QTxR6WOiAF57733ShYBhumgQYPCcu6yhjvXPot0ot6halRwnGfNmi7OJ1vnQzaA87jbCCvzWDhEXJIKcyMiLLt375ZohS+jwsI5RiZ7z57dIiJzS6dbTZ48kekMCavRyARCWB6ZTrSQBwwYICcXpYnkgMFhe1ZoI7zQJGfOXKZDh06ma7fuKWZQgFUzYfHKdYn3jO7K48ePFy9aOMD13bDh9SZbtuzuv61YsdycOHHchDNIw3IeMO4o7ERdKVw8XzgwnNGvs2fPykLc3ygFRhQF14mBCAfOGRYR/kanE8Lhw4fMt9+MMNu2bjHbtm0xBw7sj/ffkP4SF4XieT0SIVWxU+euYkBTuP3tN1+FdRdfuwj1JyoFOAlINyV16qmnngrLGguU6pxNM0mBClWn3fdjRrkNClLuWrW+6SpDzjbujIbUJ3/rKjyvcY5b9uw5zNGjR8w3I0eYLVs2mUgkUXFTIgPctAl5efZ7sDnlgYbvYSA65Ru5sJlgfMnVWZUJ5w0aCNP52/EQo2LIkCHiSWAbPEPN8XnamPDCcdILZaidyJY1mylZKmZQFy0W04gmJbtY2o6xRMwipXsmfQKoTcmcOYt4PwsXTlwaTShAcyJbABkO5wc9fxaJzFFIZ5LeSdQCTxhGAv1yKHr1he06jWGQlP0lWkFkmmLtxKpQeQMj4qfJE83Zs2dM1mzZTMeOnaXA09e22nmVfHrSX3zRqW7OqJxnS5QoZW6/4y7z44SxpmbNayRSGw7XuTfsAjUhUalPP/1UHIzDhg0TA4MC7nDxkNM3h/HK9j777LOS/kXkgpqEQoUKmVDiz2VLza5dO0z69BlM23btRYbc21izEVbm3XC9DhNjVKBehqysP/ucN28+c8cdd5lJkyeYf3btNOPHfW8aN24m0cdQuHYDFfFLsFExduxYKarCQ/vLL79I4ye0llFZCZS8ojcOHTokBoJnmhO/e+ukC4v+WGAWLPjtqr/v37fLb+9lmdLFTK6cOSVvbuqUiaZ+/Ss32tx58psMGTLFUVwWI3l47twZc/hQ/F45JW7wxjH5cr2Rj43B56s5WXLChLpkSYwhW7pUMbNvb4yUZ7iTJrVLpJNRJhkz+htJ/0OdJRQmvGigePFiZuPGTeKwcULebpcuXcy4H0ab/Pnzef2369bGKMnky5c3Sddj+fJlDNmu8+f/ZjrdkvT5nJst0qG2MaHtaWRc5+PczowZM5tcufNJgS759N7SYqoWzWjuvDa3/Hz0yAFz5sxpE23QCweDwh5LJN9ZZIdLXwsoVDgm9Y/7JjUU/kSlrm1Yx7z6ykvmxZdeMR9//LFxuS6YRx5+0IQDc+bMc0cns2XNYKpXr2ZWrFgpEYFu3WIiF6FCqVLFzYEDZSUzJEvmDD7HLAXckDdPzoi5H8ZH/nwxcw8KignZ58aNrhenJOsYmltu27ZZREWCHVG34zDFjQoKl1F4uv/++0U2891335WQ16OPPiq/hxL1G1xr6tSNUYABvIBDhww0+QsUjbdPhZOb2rYVSbv3P+gvHpIqVaq4LTsMCqQNfReXlTCZM2QyBQpGl6xYoCEPcdrP08zx48fkd85rqdIVgrLgpWnRsWPHpSitcZPmQZ8MAgXldcWKs6icLD0+MOD27TtgbmzTNuoULILBRx99LAYFubrMqTyIYJAigQrdo32ekCiCt1qHY8dPynOZMmWTNNeQ3tC//yCzdu36gMxZqIutX7dWfkZAoUXLG/0uLCYyjWFLgS759KS/uJ02dXOKQYHTBmMlR868Jvl7t4c258+dk4hW6tRpRLCiYMHQ8nr7wqrnJCQqxbXZ97EnTdp0GS/XWQ4yBQoUNo888ogJdbZui1mA1q1bV/ajQ4eOYlT8Pv8P2adgQm0WTdvwoNtx2qFj/IvNPXv3yXPVajWjZq1TrXqMYuLuPXsTvM/tC5cwy5cvM3N+nWVOnz5jChcpGVaOgIAaFeTOWf19FlM002JCYDDThfaFF5JHCYZCGA46EREn/O5LbYBB4e0GhjGQkFDPQw89ZCZOnCgycNdff70YUIRbgQiFP5KH4VhMFgqQwvbbvDlm6dJF8js5idwwixcvEfQiu5o1a4phEUmwP6SmUFvBhEfo+6sRw02r1m1M5cqhWUgYKVADwsNbdJi/k3bKXDRixIirjGnSpGyRdlLmGlusTUifCAk9PpJCnTr1RNP+hhtaSd8Yf50ARDiQ8Sb1FMUf5lBfKk/xpaBGC0ePHTXnzp83p04elX4W1Es1aHhd2CxWiOz7E5Vynm/uxYgK0AOD7vasE1DlC4d6CsYaY5V1E9s/Z84c2ZdgRN9h/fq1ZuaMaRLxS58uvWncxH+BC1uoTfQlWtY6ZcuWdddUJGaf69SpJ40sybqwkudk41y8cEH6fkSNUUF6hO2qTf7f2rVrRbWAGxADIrnAgMFrxcCzaVbcePidqElC2L9vb4K8ywUL5DfTfp5qXnv9dTN9+gyJVtC5N6GSh/v27knQdkY7nF88nVbVpmzZ8jIQOXfBPJbz5sY0dKtcqVLEntNCBQuZdu06SBrM/v37RA4vUvc11MmSOZMZNHCA6XFXT2kYVqxoEVlMOcEIgOzZsiX5PJEXTc737F9miRMlIVCEyKNkyZh6p9SpUouRinOHeddf2B8MpW7dupl1a9dKHYYzukzU+fSpU1KjoVyhXdsOZtGiBWb79m2S+vv332tN/frXSdpZKJMzF1GnDBLZxxHnKyrFeT965HCsf3tXjzvN3r17zLBhn0ljvRbNY/pZhCIxqbMx9XilSpaUsZondy5TrFhRs3PnLjN+/DjTqmXLFC/GXrp0sdm2LabYGqnY/PkLeJ1Hjh8/brJlyxbLiCe6QXo6ZM6UMWruE8zLtkaGyD7HJaGkTpVKjAh7zIhebN1KOlRDU7hw0RR1lhQIUGTTb6MCmUHSfq677jqRV8WQoFPmM888Y+bNm2dmz56d7F1riYZgQNSuXVusfCRlkfGk0VhCGD36m0R9f4P615jcubKbPxZd0XFPSHHZ2LGjRVtcSRybNm2QR7D5ZfYv8nz8+BHz9ddfmGiA3E8luLRp08pMnjzVfNx/gNm4aYMpXKigGN4sVNauXSPvWblyuTl+POYGn1iyZ4vxlI746kuzZUvixtu8eXOStA0rVsTUiOTNk9t88cVQ+RmPOwWj586djSXAofiGxd7UqaHfsRlHEeIQGKO+olIU+0/8cdxV4jCQPVtmt9d42LDBQY0gnzx5yuza9Y8pX77sVYtCFuUsQvn78uWLzerVMVGLwoULilExdOgQs3dPcGsSUGlD9tmTf/7ZbT4f/pWpXbumubldG/ff9+2LyR7JlCmjmTBhrIkmsmTJLOd78OCBplChpKf/k5mx/K+VZs+evSZbtpSViX76medT1qho0KCBLOQpjsWYAAwKwjaLFi0yHTp0kN+Tk86dO8uAJEqAOkr16tXNhAkTEtxspVu37knKg3dGZBJSXNalS7dEf2c0wHEl7aZChYomV66YULeV0wyVNCO2540335Of+/R5LNGNxsIV9n/ChB/k52rVqptKlSqbNGnCt/lWOEE/xfz5CprhX3xhpkyZ5vU9PXveLZGGpHDhQiqzes06kyZNetOjx93xiiesWbPKrF272i2FS2oiEcWsWRPfRf3ll/vJc8uWreLdBsU7ONz+/HOJ2bJls5wTOpaHOkePHDGZMmf2GpXKlDGT3Lt9MXrMOJFWrlqtlrm2YUMTDDDy/3NLJxEnePutN0Vgwcn0GTPkuWLFCuaee65kWJQtV8ksWtTD7NixSxSCUiJlbeHC383GjTFOAzpj163bIM6I1qBPPpHnP//8y7zS7xVpXAgzZ84yxgyXeq5oG6uTf5ouaanVqtUyN910xdBKLO+8+66ZOnW62bx5i+nWtbP8rXTpMqLwRk+pcMDv1cC0adPMN998Yz744ANpKY8Rcdddd8WSeE0JHnjgAXkkhfwFCiaoUDsu/C0uC2R4KdIgXeLPP5ealSv+MufPn5NH5y63mVBk4cKFsnjCkK1V+5qoy+U+ePCAyZkrpzmwf7+cM25Kta+pa6pXr2EyZozcLqGhwocffWTSpE17uSA3pjaMBQgPFETq1E26PGHTZs3MG2++aVauXClzpbfPY6G3bNliCdefOhlTJI4EMd1iixZNeqHm2nUxajKNmzTReTMJlCpdxuzbt1fud/T0gUOHDoohWKvWNbF61IQqbLs/92sKnzEqtmzZav7zn1tMMGCNhEEBo74bbR5+5NFY44dtg/r1G8S6rtu1u1l6zKAyuXPXPzKWA825s2fN2XNn3ee8abMW5sjRo+b66xtLanF88waRCsugTwZLKiYcO37cXWMQbWO1QoUKYlQcOnw4yft+8uRJM3ZsjMNu8+atpmjR4lLTiFOAdMb27W8xZcuVN6GO39UlpD1RS4AMFgpQFOZQsE2x6ocffiiRg2iE4jKKyLzhLC5TYkPKxvbtW82E8d+bz4YNNsuWLhZjolChwqZ+g+tMqGLzYbmBRZtBYbW2e/S4R4rlySGlUd7cOb+YIZ8ONDNm/Bz2jfNCHYwH5ltktNevXy81bci1IiIxdOjQgFyTzOlEoBHBiKvD9+JFf4hBwWK1fYdbpG9CIAwKomHsk+0DoySNAgUKug0K+HPZEpFbHzpkkJk0cbw00IuEHh/2WrFCGikNtQU027RglHv20GIBCtSHOmG8tWrVKlka4eG0mz17pvn004Hm19lEFWLgmujZs7cpV84/FUUU6CzTp083CxYskJ/tHGEbeEYTCWmAFx80z7X1ozguT585b7rf2csUK1ZcxqdTzY0oZKiO2QSXrKNMQEdrLipuZB07dpQGNOjZ2+6Q0QTFYxSX9WmVzxTJlc4wNnnm9xg52ehQQkgoU36aKLrcmzZtlN9LlSotXWLv6N5TBlEwWbdundQJxWdURCt4x6tWrW7u6f2gaX1jW5M3X35Jg7FdVy3R0gQp0kCy1i56SG1lsbR8+VIzfdoU940Mz3Gjxk1N23YdzN333C/d7ANlZLMY43pCTjepqVzK1dDAzC5U/v57nShFjfz6C7N0ySLJ+Q9XqLUMplFBFgfO1TJlyrjXQp999pn7dY63U/nJk5tuukmeabSbVBAwIBpFbxvrtKMWiUizsx4pIWpsth+YVajDgGKfrFFRokTwFBmDBec6EEbFpUuXzODBg93RD6ApIk7Wrt26m5697hWxCstPP/1oPv/sU7Ng/m8SeQwl0ib1gD799NMy8ffr109SpKIRDIe4JA+jnSNHDpsNf683NWrWcqfI4D2j6LpK1eqmdu06Jk+e0Dh2eArwGPE8c+ZM09AjN9fZSTvawbtWvXpNU61aDekjgrqPM51i7PejRDOfGpmy5SpIUy4lPMCowMs6cuRXZueOGGUpYLzaaMQ11ySPYe0cY9EYDUxuypQtJw/Soqi5WLd2jfzMY9myJea++x8Oy+PONYvDg87Ue/fuTdG+WailDRgwQH5+4403RBmTRSF9Z+jrRa0CcvzcV6jntPUITlq2bCkqaUQgWajTpyYxzJv3qxiITuOhZKnSMl5LlSqTqHPL/lHzyLaTscKxJhV4xowZbqMisdsbCbKyK1askKaxOXMmrp8TTnr6X5ECRwodTsv58+fLtUzdpnN9hNjP3j17xHCcP3+ePMggKF+hojh3eG8wx2+ijQrak48cOVL6NzCQb7nlFtODSkJFQCGLEH6fPn1MtIG3a8eObWbnzu1m547tIjcMWbJmFQ83VKtew1SrHnp9Hvr37+8OQXJzIHfdwo2KnF0GrPWKKTHeLgpBnb1DyA/dsWO7W7Vl+vSpJl/+/KZ4sZKmWPHi4inVGozQY/OmjaL0deRwTJ3Y+vV/m6ZNrhePWfkKlWKl0SQX1tPszZurBA4cO23a3CwND2lQSNSiUKEi7gUJKRjfjPzSFCpcRMZ2sWIlQrpYlG3Dy0ukmWuI/g8pBf25qDNCAZPvtfcI0p1YJz3++OPu6xqBGW9CMSxIST1cunSpGNbxLdKpkdj1z06zc8cOU6t2HZM9e4xDJ3PmLGJQsLhkoVm5UlWTO0+eJO2fTX1iEU0vHOpa6WSOM9n2qIhGo4LzRZYOhiDpp88++2yiPmfQoEHy3LNnT+lefu2110p6GXUrnmvITJkymwcefNRs+HudjFmkgIlA8SByUaNmbdOqVUzRuI0sp6SRkSCjYs+ePWJF0V0aHXEUoSjaxqAIVsOWUIRJgV4aTHJI4AaqKDzU4IIlbGeVKvB0Ifl37Fjs3h1c0MWKlzBZMl+5RkJxQUkOOV4YCz1QfvvtN9OoUaNYHlS8TInRpI4mmA96935QJr31f6+Vwm77oMC3UqUqpt3NHeW93AB3/7PL5C9QwGTIEFpGZiSCx3H//r1m/759Zt/+faZy5SqSEgNp06WVcHrRojGqZvv3HzDdbrszRVMSmT+jPcUwJWERitgCD2eeNr0fDhzYLw+b2ogqH8YIYxWvN/0MQgmiWyltVLD4IyKBc5U+GXYB17t3b2lWOXz4cFkY2nqKuBxS1qjA8+1UjiIdkPsrPYP22+f9+9zni6Z/VavVkJ9pUlqyZCnxXgcKa1TY1ByMpC+++MJd+yT3+GLR0UnbCecc1dO7775bWhw89NBDCV4bcAznzp0r6ygrQsS557oi2uXNMY1RyvnmQbNC+mRwr6Wgu4BjTDKX/zB2tClQsKApkL+gjFfENzx7jQTFqEBGFu87F+/tt98udRXly4d+Jbo3zpw5JScluQ4qkwbhT4wwFqatW7c24QqTFs0O//33RExjqyNHzBF5Piwe/Ro1appGjWM6b2JEYVBwXLnxFC9eUjxcdI0Mhw6RhK/xsHP+CO9yM0C+mLQ+9knrKRJGrty5paMvD/Lyd+3ccTmCtSNWVAMPi+0dQ/oUXZzxiNMQi5/xkoeDSk2ogKGPoWa7tBI5XDB/noxfUhE5F04Yt9aooOES/QJQHhk/YbKkNmzYsDHFjAr6Ktj8ZI0GpjzOeyILkP/c0kUijkScWcRy/fCg+zJS0taoYPGyeNFCkzNXLpMrZ26TPUcOWbhkyZI1RTssc80QGUiOugoWfzhRWTzXqFFD7hEUJ1vvNGqY9O9ySuDT5ZsxNGvWrDiNCu6zpLWUKRNT+Msic/fuf0RRDTj+48aNuerf5ciRU+ZS5koLaaaBTjX1NCpYB/bt29e89tpr8nvhwoUj1nkaH506dTJvvfWWpC999tln5oknnkhUlIL6ZGuYsd6mtIC6ZWpZ4lpr46C1BgbGp9MxwNhFPIUHhoelRcsbRf0tqEYFNyiiFG3atEkRDeXkZNjQwbIP6KhT/EJhImk45KPZmyuhzH/+2SknLGOGjCZDxgwmXbr0kvMY3yTJ63hJPv/8czN58uSgGxWeEQUWHHt2/2POId967rxYuqd5nDotE1uhwoVNrVp13CoDQ4cM9PnZ3Ggs3EAoKsKgCMcJBgOiRYsWJnfu3DJpcr2T14hh2KxZMzUqkgAL14qVKssDnBMfnvPs2XOY48ePuSdAmzoFNzRv5c7fx1s3c+Y0kzlTZhmzPDLIc8wYLlyoiBgzwDXPJMuYDbc5i+ND+gmNvnigjMb+cZyAMUtPF44dY5axS2dcHAAnT/5r6tSpb5o2u9KXYNWqFbE+H6MtxmtVwJQoUSrWPF++fEX5mUg0CyJyp5s3b+63UUAqSK9evUy9evUSvN924VWuXDkxKJXggeMNqVEewLW2d89ut5fc2aOHcbl69UqvRgqRkOYtWsn91ToRSLfyNn55kN7BmE0MttaN64gxFEjHIQYFEQknrB04LhhQL774osw5qJcxXhm3HTt2MCNGfCVF3LZI2xoVRw4fNlN/nmz+vey049/S9AyItmymweVlo4JxyhyaH29zgQLyjBoQOfgpgadRAQ8//LAZMmSIOXDgQFQWaVu4tzz11FOSlTJgwAB59jdzh8L+sWPHups7W6jBQV2VdLOdO3f67cC3jiQL6eZErGx0i8j0oYMHpC9JcuH3yCUME0mwsMar7kzVyZMnn9uoOHz4oBn3w9WeAWs0XHd9Y9PgsvQpk8OkSeNFPz5tmrQmdZrUJmfOmBAYk9D9990rNQTADf+3eXPck51zceUyLukoSmoIsFiY/cvMy6/Jm+VnJh8ehDhrXrY2mdgojL3IaxcvmouXLpoL58+bc+fOywRHMe2NbdrJey9cOG+++26kz2PDYsYaFXg8uFCZPLNnzxnjRb7sjeI5d+7YuZpOD3Q4YpUt4MEHH5S8UWorSIGyCx4t0k46zps91/H9Dzwi1zDdXK1HXaJiRw7HKn6jGA6D2BctWrZ2GxW7du00Yy5HQPg+Fipp06a7/JxWIii2xoeFzpxfZ8nYTkX/h1Spr/ycOrWpUL6iFLcCc8bCBb+7x+zl/2JwuURL3C7MYyR3Z8s4Z865dOmiuXgxJpLAGKV5YO3aMQYTRtW334xwj1lPyUDSU5o3j5GdvHD+gpk391efx4FFioUFD/MVhkSuy2PWnzQztPJHjx4tClD+ghIgnmI8bBgjCcUa7lpPEXpwD6DvBQ9PWKRcf30TiWIzZk8cPyYRMa5h7nlOo57FDY3XfHFT2/amSpVq8vOWzZukI3iMYyCtSZsunUl3+Wc+s27d+u7twbDZumWj3K+Ion/55eemSOHC7s/lvlq8REl3ZGXRooXue6q9v9pnnB/WmOK9SLL+/vtv8nv16lXN8eMnpIjWNsJ97rnnTP78+c2+vXvM119/4f7OrFlinGtWfjXGeXl5YZ7KSNqnkxIlipu0adOIYXL27IUrn5M1m3nwob4mGMSohMUYFdQPXNmmrGJIkZ6DAyKaQe2LgvytW7dKWtijjz7q93yJ8cnx83RWEqmw82BiDWQcA571jqzvkjN6GJWtcB96+DHxYHLj5XHm9Glz5uyZWDmBqUwq8eRRYR8zwM+6X2NBnyrVlZPCe5wee8iYIZ146yX1YMF8t1ERo8Ee22vohJu9NSrOn78gnWrjmuTd25sqZlL1BftrIeJCbiwXHD+znRgPGTNlEi8RUo5XPjeV6fvY02GpBhIfp85eMiPnHzbjlh41u4+el+7oNDOk9wiKXkyYDPo//vhDQpSkRonH3TGxKoGD65lUOR6+wDtKeg4ddhmzjCcZn5efnYXEjEsLkzJjwDkOmMwtLA62bvUtC0jkyhoVfHdcY5hogjUq+I5169b4fC+pXVdIdVVqErBISpc+JkpqYayy8GK8ctzkkTmzGBAsQIgauj81VSpz7bUxdUEJwSqfsdDnRuSP95gaJJsqgjQsRakJwaatqOEeXmBUeHo/uU8S6eYe6xyX/FyzZu2YsXv2ytiNeZwWw9/C+LELd29UqhxzrwS+Z/PmjSZ//nzSqG3OnF9NtapXXhehiMtGBXP5Gi+RlSvvLWAuC/uY8+fOSWSF+iJo3aq53C/Zv4MHD5kSJUubhx+OWUSmTx9jRDBWuL/myJnTVKxY3qxfH5N6UrFCBbeBxTiloRnZEpI1kTWrvPbDuEkS1Th+4opjINi1hhhpzCNW7chCLQE9zKKxSNtzjqYR9COPPCKOSOppnOszb3Bdk81ioz6eOHuZcN/yVtyfGBIbBfT7800UwkElPBWX/FfBQoXNXT17X5WOgJefZxbjFjyjnbt0u/z6BZlseP/iJX+J5Nradevd72URgL67GCa4KuS/K88FC11pcJIxQwbTtOnltINU8q6Y51SpTJrUqWMVYjGZ0ecBCU/bYZcHF2LM40o6ElZq73sf9Pt4RapB0evz7Wb1risLz3+OnJfu6LPXnbjcYySDNBqjeAqVC8BzEG6pNJEEN1+7YI8PPI2PPf6MuXjxgnj2z18evxcvj1Nu+BaMbBr6uS5HAS+5eHa5fy/qqClgEdCoUVMZs2DH7+WfTGGHUUTqR7MbWsrfUzvGZZrUaSSiyfdamJN69Lhbxmq69OlM+nTpxZjwNv6Yw/DoJieokKAog2OEJnvxGQgsCp3NvohYkDLiL8yZKtkcOXCfYaHsqRhFSo9N6/HEMzpHFKLX3fe5763OezDjErUqC/dDInmrVq8348dPMKlMGomeCKmMpEY6DZvGTW5w31Mvv8V9n3U2cWSeKFEyZjFNrWT37j1jjWVn0SvR+yefei6WJ7hgwWJShwqNGjeOtRCtUDEmJcyzWBujgmJtRHCCjY1SYDh4Wyg7U6KiGc7xO++8I+lKI0aMkEyHuEDZiXRRWjIg7OMJ19DuUzE1qoUypUyaWyCISqMiMXBixWPokbNmowsoYXiCxC5GxezZv7rDV3g4bNpUfFDcXLeef2FFLkCbuqXEDxEKp0HhhL+PXHBY+o4Q1qTwCo8baD1FmI7ZeLJ9WPjYVCh/DBtSp/yBm3CdOv7VFrBAKeDomhpsYtJL6ppffvlFUpniMyowCDAsmItY8I0ZM0ZSB/31sFG/cfjwYXl/tWox6S9KdOFpQBNFz5DBPxUjipZJEWzT5iYxKnbv2WsaXnu91/diLNevH7sHkS9wBJLuZJ1KNmLpa/s994GmdkRYSZfyx1jGqABbgxFsvNVTKFfDvPXEE0+IMtZHH30kUZy4akup2QTe5yt6MHDDXLme3qzRPuA1QsmFtntORij65aIiz27NGt8pEErKQ8pTnK8vOeqeKJwFVGpUKNEEdRXgT12FTX1q3769eHQxEBLSENVGKTBewlHoQQkNbB46dT1ENJysXr1aRDd++OGHBH0mn+Vc8CcEFoxE7RAw6NChQ7zvt2kvfKdn5CYYqFHhPz169BAlrN27d8s5j8uBQq83jITbbrvN63uIUozZscyM3r7U7Dl9LCwMClCjIhnB+3nDDTe4OyYqvpk3b56kW6CWlRJQQxEXexyvk++IygZe58Qo2ihKuGLrKqgr8teoYNFmb5TWGxcfRDasGIgWaStJgbx/IhHkrKOi5MxLv/fee8V4xVFEl+iUMCqA+8Z///tfv/LZ6YPE+zDKSaUJNmpU+E+GDBnMY489Jj+TOu2s4XPy3XffuYVhnCpqnlGKc5cuyoOfwwU1KpIZz8ZpyQ3WLVZtuMEAZAJl4vX0LiUHFGXHRSHH6xTpohtOnxZnEbuiRDqka5DOxAIM75s/9RTMeTaHHGcKsonxQS4yUQ0ig3j7FCWxcL1a2VbbSBEGDhzobtaGIAJ9FvyJBJD6Sq+ApBgVCQGFKAwLpzETTNSoSBi9evWSdQJzpreIGNecNSruuOOOOKMUFhutCAfUqEhmbA4lRkVKhDKxaMPJqgV0rlmww/bt26/SAk8OUHmK8/W6Oa/yfjkbGylKNEARqr3u44pWYFCgkFegQAHpMYFCGqmCSOfGJ0f+008/Se0FoJxCYzFFSQo22mXVxDZv3mzefPNN+ZmeAniUZ86cKXU/8UHKFJE0ru2CBQualCBU6ioQabDOBDUq/CNTpkzulOn3339frh0n1KfR4JNMFm8F2s4ohSWcohVqVKTA5EDBI966Xbtia1IHGs8cvMSAB6dx48budvEpwYQJE2TxYXMGiVoktwGGbGzVot6rd/n7nddeUeVRlGjGn7oKm/pElMKO4+7du8szucW+xjPpKcgvAk2jNEqhBNqo4NojKkE0jXSTl19+WSLi8Mwzz4hkanKmPiUG+10oQAUTG6HBoIpLLVOJTe/evSUFjyjPlClTYr327bffurtme2uS5xmlCLdohRoVyQxqT9bTl9wpUN5y8BK6OEetiiZvo0aNilMfPJDYjpI0e8F6xzOEFyk5oQ/Fl72Lmz6t8pkiudKJqiDP/B4jJ6tDQ1GcdRX+GBU4JCydOnUSjzBytN7SONC+79atmzgyMEZoHqUogTQquPaGDx9u5syZI2lF/fv3F6OXvHcUxqhbwLCIC7uwT8kImjNSkdwOthMnTkgN1NChQ696TVOfEkeOHDnMfffd545W2HNIKp3NxLApovFFKQIdrWAsTJo0Sc57cqArpxRMgXLmdwYaXzl4CVUMwKgAQnabNm0yyQ11FIQD2U6se+TV4IMPPkjW7yUykjlDGpGNnfFMWbP6zUryzO9qUCjK1ZEKDAMrrewED7B1mNgaMsCzacP7ngXb1E2Re0xaCjrtX3/9tVe5bkVJDCjwkKrEPE+6k+16XaZMjPQ719rgwYOl/oK896lTp4ZUpAKDhwwHUoP37NmTrN9FChgCKf/73//k+5yoUZF4HnroITFkiZaxkLepnizmS5QoIU0DPdl35oSZ/M8qkylNOq+PSbtWynuSAimmGDS28V6g0dVTCmBlSJPTqIgrB89fTweGhDUqYP36K037kgsawAADjBsBuYhM+PPnz/dLxjKxEI1hYCHrpiiKb1j0IxGLIcC48YRxSj0FizjPjrs2BYpoJF2MqZ3CS8wiZdasWZJ/PHr0aBVAUAIKTirrzOO6ZZHep0+fq6RbSYsCrsljx65OLeG6JtqR0kYF48Iu5JO7rgKvtd1XmrY5UaMi8eTPn9/07NnTHa1wpj4RGXI2SLQUyJjNrG77gtl4cz+vD17jPYmFqDBKm9CmTRuTHKhRkQLYyc2bbnYgiC8Hz99oBWFeZ35pShgVNvWpc+fO8oxhYcOCNJBJLvAeMJkm53coSiTA/GGjFd6Ktb3VU1iQl2VMk2ZCR14iF3jIqDEjkvHFF1/E21RPURKDVYBi8TZo0CCvkTC880QvKEZ+9913vdb8IAuaO3duU6zYlS7bKYGzX0Vywbi0i0z47LPPYsmgqlGRNPr27SvywKhHTpw40S1I4yv1Kbnh+8+dO2dKlSqVbOdUjYoUoHz58pJjR+qA9XoEEn9y8PyJVtheGnZhYCeU5CwCw5Bh0HXs2DHWQGQbCBU6dcYDifW42huPoijx11UwR3iqmRChQArWWU9hIYXDyiZSo4U8M947xBlQQPGlfqIoSYWaHqJsL730ks/eJ0QE3nrrLfn5q6++uiq9zy7oqadI6eZjtoYjOY0K0r5wdLLAJFqIceWMXDBGATU3JeEUK1ZM6saAHinMncylpUuXTvBnUdhN9COupnrxYZuR3njjjcl2PatRkcK62YEu1vY3B8+fC8gWR9sbfXJHKqyGMw0C8+bNG8sIs9tA/l9yYFPRbBRJURTftG7dWgwH6p+sNKeFWqi77rorVj2Fk2effVYigj///LPUUOA1btmypXyeoiQXRCBw4tmaCl+wwMJze/To0avkj4NRT5GSkQq859YAu+eee+TnIUOGyDM1lSyCUTFKKSndSOTxxx+X9Zc1WH31pogPrkE+g9TwxMC5tEZFcqU+Ca4o4syZM65333ldnlOafv36ubJkyeJ64IEHXKHIgQMHXFmzZpVtXLhwoTznzJnTde7cuWT5vkuXLrlq1qwp3zNq1KirXl+yZIm8liNHDtf27dsD+t3Hjh1z7+v+/fsD+tmKEqmMHDlSxgyP8ePHx3ptz549MqYVJRz5+OOP5bpu2LBhrOu4adOm8vexY8em+DadOHHCfZ/au3dvwD//+PHjrly5csnnr169WsYw91t+X758uWvcuHHyM8dASRq33367HMs8efK4jh49mqjPmDZtmnwG66bEsGzZMvn3BQoUSNY1sEYqUrhYO6U6ayeU2bNnS4oU8rfkTyPtSm6lDX8GmpUrV5qNGzeKOkLbtm2vep0IQpMmTSQ027x5c1GnCBRWpo/QuBaIKop/UHT96KOPxqqtoJ6Lui08mSmdHqIogeLOO++UexH3JSsQwr3HduAORkNG7sFE7ZMrWoHXmvx6mlXSwZsxfMstt7ijFVpPETief/55WWugCEUqfFLWkKybDh486DXThLUSkvzeIFJsM0OQ+k4uwsaooIiKA8aJKVKkiAk3bJoNA5UulYEGFSPy7SiGRP/dCaoXvEaKQnz1FKQ5sDiwk1lypUDZAm2+j/CqN5CVRU0GST3UEljUUOCZVGyXVa2nUJSE8frrr5ubbrrJraRDzVa4dHpVFF9QiN2lSxf5ediwYe57NXLJLO6tFG1Kk5ydtW3qU4cOHdwOgQcffFCeSQOzaTZqVCSdypUrm61bt5pXX301SdeoPReLFy+O9RoOYBTMMIhJN/VGiqQ+hZNRgUVNoYrtvhpusKhHmxgPuV3UBhLylMm3Y4LIlStXrNewjimSRL7VW+EzWt62nqJVq1axCrOSo1ib3D5bT2Encm+wDeRwkxNLweePP/4oBXcU1CWlIZA9/lpPoSgJg3HI+MOxY1XnwqXTq6LEhW1WhogAzivWHCzUuOd4k/8M57oK1gpWPr59+/axvOHcF9l321tBjYrQoUGDBvLsKbePk3b79u3yM0pTnip9OGatYWrXeCbajYoXXnhBehhUqVLFhCvJ1QRv27Zt7lbw1tPguThv166d/OxNQpVFNtJyhOWsdKSdSJIjUsEFv2vXLpMtWzaJVMQF6hz9+vUT2UomWIrpHn74Ybfec2JQ5SdFSTyMSafqXKA6vSpKMOH+wqIary+qhPxOZC6YjsxAKEDZFEUnv/zyixgWpABbw8XywAMPxPpdjYrQob4XaW+ctLYPhhW8ee+997xmorAGLVCgQLJuY1oTwZATiRfegkSaPQmesogpAR4PogXUVQTy+8l/xHNPrhxpS94++4knnpC6BBpNYWBYI8MZFiO9DI8M/95OJEQqAn2s7AVOGI7cPn8+n1oPJkJ0xdlf9LQTo/VMHw66eBPuZcIOxnWgKOEMc4RnbxyiFY+Wb2IKZcqhY0oJWzAgqKtw9k7Bsxusa5qmfYATDrnXhKgwcY/jgcHP85s12ss6gQdRf0Bl0f7NQrYD91nuldyfMTx0TIcG9erVczuCWc/Se4VziTw/fX+IsjVt2lTWWLzHGox2jYcT19e5DFQ0LqKNikV/LDALFsQ0ZnKyf9+uoMgZlildXJ4XL15k9u7ZEZDCRiaD7777Tn7u1rWz2bd3p9f3FS2S33Tt2sWMGTPW9OrVy3w14nNzzTUxnvqpU2OiHPXrXeP+93lyZ3cbFXt2bw9o+HfevBivZo3qVXxury/u6nGbGBQMmAXz55oyZRKm9zz715iQLv/u1Mmj8lAUxT/yF6CeLfVVvXFstCJm4XLJ7N/3T1C3U1ESw3XX1pVoP4t3DGfu0YWy5DDHjh4yp079G5Rtqla1ilm1eo357rtvzO23dfXr32TOnNXkyJknlvFvjf7Dhw9IfwpodH0Dr/fgrrd2NgMHDTalSpYwBw/sDvAeKYklW9YMJmfOHObo0WNmzq8zTbVqVc3bb8f0Wbnjjm6mYIHc5uZ2bc2PEyeZ119/zQz+pL8YH7Nn/yLvqVu3ls81V6HCJUzYGxU0pfnwww/jfA+Lx8SG3+o3uNbUqRsTLgIO7tAhA03+AkWTtfrdF02b5ZVGbwcPHjLnzhtTvHjSO3SS+3no0CFZ9Hfo2MmdmuCNTz8dalCZOFwAACvMSURBVI4dOyFW6wMPPip1FFi3q1evkdc7de4qtR+QJ28hOUYUqp095zIlSwammyih5VWrYtQJWrW+yRQomLDP5f1o3LMPM2b+avpd18Tr+4jIkGdIWBANcsuWLTvkuV69+gn+bkWJdrxFKbxFK3RsKeHK008/Lc9OD3/2HLlNtuyxaxVTilu7djOrVr9oZs+eax5/PO6eG+TOkyps04qdxr81+rNkyS5rIdJgbmxzs1eH4TPPPmeOHjshGQ06lkOL+vUbSCRi46Zt5pIrjVm7dp3JkiWLeeqpZ6W56PMvvGgmTppsZs6cZQ4dPiERrlOnTptChQqZZs1aJrtKX1CNCuQJ42sE4lwQJhQW8Dw8YRAFo/CKE084k4IZjCWUmpKKrXlAnYLPjwuiM19//bVMFKgHIB9H1MLWFzhDq7wX5aU1a9ZIaC0xHSC9gUQfhopVMkjMeeCawajAcHj55ZeleNQJ6lcUd6OyRVOfWbNmuXMNbbFSMIvvFCWc8YxSeItW6NhSwhVqC715+IMlmYxAzYsvvijGAlKi1vHnmeqNOuJPP/0kBed0cY4rRRElSLIcvK2PALGXTz/9NFn3S0l8sTZGBWs4m8ZG40Irj1+pUiXTsWNHSYXCqYqhYZs8eq6VkoOgzvwcBBaWcT0iretqoIu1WfTbC8kfMmfOLHJxaFNTW2AlzrwpAiSHApQtMKLgKLELDyQtmfSwwFE68OSTTz5xy/bSFZQJFvUrJlF73DEqFEVJGPvOnDCT/1llMqVJ5/UxaddKeY+ihDOhJEKA85H7FbnwkyZN8voe6iUxKMgu+O9//yt/85WiCE8++aQsPJXwLdaeMmWKrKc451bi2/LMM8/IMzW8Vr4/uaVkLWHjTmIBTAEVzxRf8zOPf/8NTp5jYrENTAJlVKxdu9atg+wveO2xcJ0qAN5UmOJSgOIcDBgw4Cq95IQYFYmFQUQEAjxVoIhSDB48WH7Gu4PXie+89957RScalSuKm2wBnKIo/lMgYzazuu0LZuPN/bw+eI33KEq44s3DH2zJZKIVMH78eK+v23veyJEjJZIRV4oi+1K0aFHTqFGjZN5qJTnAwCTiYIWHaNzoWcDP+gbnK45U1jw0dqSAOyUIG6MCabdrr73WvPHGG2JI8DMPKw8abpEK0nCoLwiUUZFQqV16ZmBY4PEnauFNXjWuSAXRDhQiSEUi9OoPXODWqLB6y4nFps3huTlx4sRVUQqOB7mxFLET7WJfGXx2wAWjpkZRFEUJbeLy8AfbqKDJrWcDWORm6edEFoK3Wgonzn1JiVQYJfCQ5m7VyTiHjz/+uNf32WgFNGnSRK6PlCBsjIqhQ4eKMeH5aNy4sQknqFOgOJq6Apu6lFgIh9pmdgmJVFhYXNPSfcGCBV4nGGekwrPZHLUZtjCMmgV/oDnL3r17JY8zqelHGGcYQ6Q12bxCZ5Tiueeek/Qqrg8kaAHtcdD+FIqiKIon8Xn4gwVOQO553lKg7P3tgw8+kPu4pihGPo0uR5luu+02uTa8wfVi09qRCU4pIlpSNhRhocuCmp4LpEDVrFkz0Z/FIv3kyZPidadQOzGQHhSXAcQkhecf46Fw4cLyd9KIKBpzGhgUAcWHjVKwz3GpVPkDRXNEK2iMRwoUUQhnlMLZJfTWW2+VtDmKukE7aSuKoiiJESEIZrSCNQMpUKTzAr0kyBogGt+1a9dYKYpK5PLMM8/Ims+ec198+eWX4jSOr8lwVEYqIgnbkMR6zpOa+kREwZeKQ1LAWLGqT84UqG+++UaeiRQAmtdMbvERqNQnC1Y6xgUhYY6ljVJQqOZZBE7zv2effVZqWlKqYElRFEUJD0Ldw29ToObPn+9OgRoxYoQ5d+6c1A9GmqiN4huyXVB8ypo1a7xOY9Y7KanGp5GKIGCLhJFXTeki7YSCwbJx40ZJs2rWrJmEX0eNGiWvUVMxaNAgkccdM2aMSASnpFFRpEgRKT769ddfTZcuXSRKwbHwFurD+GDi5aEoiqIoTkLdw09na6LsRCsmTpwocvA0ggUKrxUlFNBIRRCoUaOGPFPP4G+Rc7CMCs9ibSRcSSXCUr755ptNjx495O9fffXVVXUXTo4dO+auIQmUUeEs2EZe1llLoSiKoiiRBL2lgBQoDAvSklFxTMmceUWJC119BQFSighbUaxNY7nEYhfpKWFUWFlZJOugc+fOIlPGM/URvB6XTO6SJUvE6EBz21P+LClg2NgQoK8ohaIoiqKEO7a3BClQ77zzjvxMGoymPimhghoVQQBPelJToMijtAZJQuVkExupOHr0qFt5wsqzkrNnJzqiFSmV+uSUV2NS5ZjSyE+jFIqiKEokQgoUdYE46EhJpucS9z9FCRV0BRYkrM5wYou16RRN6lS2bNmSNZ/SFmMfPHhQZH2JrtC92ynLag0MujeiRpWSRgW89tprooTljwKVoiiKooR7ChTQBNbZxFZRgo0aFUGuq0isUeGsp6AIObkgEmB1kD/++GO3EeH8TjSTSemiCZ3dLvS+ra433bdJf0ouo4LoBE38FEVRFCWSsZkB8OCDDwZ1WxTFEzUqghypIP0prgLnYNZTeDbBw2igb4WnNjIGRvfu3UWClpoJQNPbdu7EqKB7ePbs2SXKoSiKoihKwilWrJhkDXz00UdJbiKrKIFGJWWDBItrekscPnzY7Nq1SyaKhJCUTtqJqauYMWOG/IzmsbdwKypMaGfny5cvVlfSR8s3MYUy5TB33XWXNM3z1rlbURRFUZSEqR4qSqihkYoggVffeu0TkwKVEnKynpEKICLhq2cEfSucXUltF1J46qmnzHXXXZfs26ooiqIoiqKkPGpUhEAK1MqVKxP07yiGxuufUkZFzZo15ZkIRVzt3vPkyRMrSgGjty+V2gqMjvbt2yf7tiqKoiiKoigpjxoVYWhU0BOCOoz8+fNLulFKFJV/88030mwHCbu4sFEKizNaYZWkFEVRFEVRlMhCjYowlJVNydQnp+JE1apV43yPZ5TCM1qhPSQURVEURVEiE13lhYBRsXPnTinYDmWjwh88oxTeohWKoiiKoihK5KFGRRChG3WpUqUSnAJljYrk7KSdUPadOWEm/7PKZEqTzutj0q6V8h5FURRFURQl8lBJ2SBTrVo1KbrGqGjatGnI9ajwlwIZs5nVbV8I9mYoiqIoiqIoQUAjFSHSWdvfSMWhQ4fM3r173f0jFEVRFEVRFCXYqFERIkaFv8XatuldiRIlTLZs2ZJ12xRFURRFURTFH9SoCJFi7Q0bNpjTp0+HZT2FoiiKoiiKEt2oURFkChUqZPLmzWsuXrzorpUIt3oKRVEURVEUJbpRoyLIpEqVKkF1FaEqJ6soiqIoiqJEL2pUhFETPHpZLF26VH6uVatWimyboiiKoiiKosSHGhUhZFTEF6mYOHGiOX/+vMjQlitXLoW2TlEURVEURVHiRo2KEMCmP61evVpqK3zx/fffy/Ott96aYtumKIqiKIqiKBFhVGzfvt089NBDonhEUTOe+tdff92cO3fORAJlypQxmTNnFvWnjRs3en3P7t27ze+//y4/d+7cOYW3UFEURVEURVHC3KhAbvXSpUtmwIABZsmSJebtt982w4cPN/369TORQJo0adwpUDNnzvT6nnHjxhmXy2UaNmxoihUrlsJbqCiKoiiKoihhblS0bNnSDBkyxDRv3tyUKlXKtG3b1vTt29dMmjTJRAq33367PH/00Ufm1KlTV70+duxYedbUJ0VRFEVRFCXUSGvClGPHjplcuXLF+Z4LFy7EqlE4e/asPBP14BFqRsUHH3wgqV7Dhg0zffr0cb+2adMm8+eff0pEo0OHDiG37YqiKIqiKEp4kjp16ug1KjZv3myGDh1q3njjjTjft+iPBWbBgt+u+vv+fbtM+vTpTajxwAP3mueee0GMi7Y3tTJZs2aRv48YMVyer7/uWnPxwmmzb+/OIG+poiiKoiiKEgkUKlwiIJ+TykWifpB46aWXzIcffhjne5YtW2YqVKgQq2D5xhtvNI0aNTKffPJJgiMVQ4cMNI88+oTJkCGDCTXY3jp16pgtW7aYl19+2Tz55JNSR8HfKODGkLrtttuCvZmKoiiKoihKhJA6QJGKoBoVBw4ckIZucUENhY0q7Nmzx7Rp08bUrVtXFtgJPQgYFQP6v2/69H0qJI0KGD16tOndu7ekdiExu3XrVnP99debjBkzys/ZsmUL9iYqiqIoiqIoSuikP+XLl08e/kCE4qabbjI1a9aUou1AWVWhRpcuXcy7774rileDBw82//77r/ydfVeDQlEURVEURQlFwqKmAoOCCAVSqm+++aY5ePCg+7UCBQqYSIJi7P/973+mZ8+eZuDAgdK/whobiqIoiqIoihKKhIVRMXv2bCnO5lG+fPlYr1lPfiRxyy23mPfee8+sWbPGHD9+3OTIkcO0atUq2JulKIqiKIqiKF4Jixyi7t27i/Hg7RGJkNr1/PPPu39HRjZUa0AURVEURVEUJSyMimjk5ptvloL0VKlSmTvvvDPYm6MoiqIoiqIo4Z3+FI1gTPz4449m586dpmrVqsHeHEVRFEVRFEXxiRoVIQy1FDwURVEURVEUJZTR9CdFURRFURRFUZKEGhWKoiiKoiiKoiQJNSoURVEURVEURUkSalQoiqIoiqIoipIk1KhQFEVRFEVRFCVJRJX6k8vlkuezZ88Ge1MURVEURVEUJSRInz69tDNIClFlVJw+fUqehw4ZGOxNURRFURRFUZSQ4KGHHzNZsmRJ0mdElVGRMWMmeb7//kdMhowZTSRDNAbj6f4HHjUZMmQwkUw07Wu07a/ua+QSTfur+xqZRNO+Rtv+RuO+pkmTJsmfFVVGRerUMSUkGBSRfpFY2E/d18gkmvZX9zVyiab91X2NTKJpX6Ntf6NpX1MlMfUJtFBbURRFURRFUZQkoUaFoiiKoiiKoihJIqqMCvLFrr22UUDyxkId3dfIJZr2V/c1comm/dV9jUyiaV+jbX91XxNHKpfVWVUURVEURVEURUkEURWpUBRFURRFURQl8KhRoSiKoiiKoihKklCjQlEURVEURVGUJKFGhaIoiqIoiqIoSSJqjIqhQ4eaypUrmzx58pimTZuapUuXmkhl9+7d5p577jHFixc3efPmNfXq1TN//vmnCXd+//1306VLF1O2bFmTNWtWM3nyZPdr58+fNy+++KLsa/78+eU99957r9mzZ4+JtH2Ff//91zzxxBOmfPnyco6vueYa8/nnn5tw5P333zeNGzc2BQsWNCVLljTdunUzGzZs8PpedCX+85//eD0m4cJnn31m6tevbwoVKiSPG264wcyYMcP9+pkzZ8zjjz8u47dAgQLm9ttvN/v27TORuK+waNEic9NNN8m45T2tWrUyp0+fNuHOBx98INfpM888I78fPnzYPPnkk6ZWrVoyZitWrGieeuopc+zYMRNp+wpcs7179zalS5eWc3vdddeZH3/80YQjb7zxhuyf88F5jMT5yZ81BPv52muvmTJlysjr7dq1M5s2bTKRul5av369ufXWW03hwoXlWuZ+tXPnThNuVK5c+arrmAf3m0DNT1FhVPzwww/mueeekweLtapVq5qOHTua/fv3m0jjyJEjpkWLFiZdunRm/PjxYjy99dZbJmfOnCbcOXXqlJy7Dz/80Otrf/31l3n22WflHI8aNcps3LhRJoJI21f473//a2bNmiWGxLJly8zDDz8sE8KUKVNMuMH5uu+++8zs2bPlRoyB2KFDB3Py5Mmr3vvJJ58EpOtnMClSpIh59dVXzW+//WbmzZsnN6iuXbuatWvXyutcwz///LP5+uuvzbRp08zevXvNHXfcYSJxXzEoWIQ1b97czJkzx8ydO9fcf//9JnXq8L41MSa/+OILGcMWHBw8WKAuXrzYDBkyRMbwQw89ZCJtXwGnDnPw999/L+e5ffv2pkePHmbFihUmHKlUqZLZvHmz+zFz5syInJ/8WUN89NFHcv32799fxm2WLFlkTYVDJJzwZ1+3bNkijg4ceMzLf/zxh8zR4dhle+7cubGuYWv4MgcHbH5yRQFNmjRxPf744+7fL1686Cpbtqzr/fffd0UaL774oqtFixauSCdLliyuSZMmxfmepUuXyvt27NjhirR9rVOnjuutt96K9bfrrrvO1a9fP1e4s3//ftnn3377LdbfV6xY4SpXrpxr7969fp3/cKJo0aKuESNGuI4ePerKmTOna/z48e7X1q9fL/u7aNEiVyTtKzRt2tT1yiuvuCKJEydOuGrUqOGaPXu2q3Xr1q6nn37a53vHjRvnypUrl+v8+fOuSNvX/Pnzu0aNGhXr/cWKFXN9+eWXrnDj9ddfdzVo0CDO90TK/BTfGuLSpUuu0qVLuz7++GP335i3cufO7fr+++9dkbZe6tGjh+uee+5xRSJPP/20q1q1anJOAzU/hbc7yA/OnTtnli9fbpo1a+b+G14wfscaizTwVNeuXdt0795dUkmuvfZa8+WXX5po5Pjx4+I1ypEjh4k0SCmZOnWqhG4JReOBIPyMxzcSzhvkypUrVuSmV69eErkhJShSuHjxohk7dqxEZQi7M1cRqXHOVxUqVDDFihUL+/nKc1+JFC9ZssTky5dPrttSpUqZ1q1bmwULFphwhrRE9sN5DuO61rNly2bSpk1rIm1fmaPGjRsnaRWXLl2Sc48nu1GjRiYcwbNLOioRmbvvvjtW+kskzU/xrSG2bdsmqW3Oc849tk6dOmE3R8W3r1y306dPl/NO9Jz3kD4fzqltzrXx6NGjzZ133ukzupaY+SnijYpDhw7JzYw8OCf8Hq55ynHBgCclhkEwceJEyWl9+umnzbfffmuiCW5e1FhQl5A9e3YTaZDDTM4jIVkW34QvuaFdf/31JpxhEie03LBhQ1OlShX33/lbgwYNJHc3Eli9erUsPnLnzm0ee+wx891330l6BQvt9OnTX5WuGM7zla99Za4C0g169uwp+fY1a9YM6/xsFs6kYb7yyivxvvfgwYPmnXfekcVoJO4r6XsYyOSqc+779u0r5548/HCjbt26kg7CNfrxxx+b7du3S0rMiRMnIm5+im8NYeehSFhTxbevBw4ckPpF7q0tW7Y0kyZNMjfffLPUuZHSGc5MnjxZ6iUwqAI5P4Wne0SJc1GG5d2vXz/5vUaNGpK/PHz48LDNy04o3MjI3cWDzw0gEuEGh5eXfGVu2tQl4DWk0NUfD2moQsEY16szXxlvEvn48+fPN5ECxiAeeTxBLFSoKaF+IhLxta/MVYDXF2+Zna/I0R45cqRfC/NQYteuXVKozM06Y8aMcb6XY9G5c2dxDDz//PMm3PBnXynkZdHCeyj85Jl5Gc+vZ/1FqIMBYWHb8cpT9EoePvsWSfNTNK0h4ttXO0e1bdvWPPLII/Jz9erVpUaI94Rr1M0a/VzXrBkCOT9FvFGB2lOaNGmuKsrm93APU3oDBR0uBCekT2CFR4tBwQJlx44dshiNxCgFyjhMgnj9brzxRveNbtWqVVI4F65GBUYRi00WHRT4WkjtoljO+Tdg0idcHY6LcaIR1mOL2gbFroMHDzadOnWSsPTRo0djRSvCeb7yta8IC4C3+SoclVVIXcOzicqRhSg5i03UB0kD4l6Ed9sqBDGGKRKNtH3ldZ5Jh2HxDdWqVRPjctiwYWbAgAEmnGFs4t1mXlqzZk1EzU/xrSHsPMScxHst/M6CO5L2lfUjqT/e3rNw4UITruzYscP8+uuvImjjSVLnp4g3KrihcSPD+0XYCrA++R2VkUiDEKynHCepBHizo8WgIPeVegMmhEjdTx6eCjn8bj0r4QQRJRaYeDJR1yBv1Qmv3XXXXVfla7/99tsiRRoJcN4wJpirmMSZn1BTAcYzi2zqECJpX0uUKCFeMm/zldMzHC6Qa40H08mDDz4okRoicBgUeAA5r9yXiDLGF9EI132lxgA85yiOQTjOUZ6QErN161aRv8YREEnzU3xrCOZnDAvmKGtEcF2jnET6UCTtK+MUuXZUzJzwO3Vu4crIkSOlls06JS0BmZ9cUcDYsWNFmeCbb75xrVu3zvXII4+4ihQpIioNkQaKRzly5HC9++67rk2bNrnGjBnjypcvn2v06NGucAelERQ2eKCuMXDgQPkZdadz5865br31Vlf58uVdK1eulHNrH2fPnnVF0r4CSisoQM2dO9e1detW18iRI1158uRxDRs2zBVu9O3b11W4cGHXvHnzYp23U6dO+fw34ayu8tJLL4my1bZt21yrVq2S37Nmzer65Zdf5PU+ffq4Klas6JozZ47rzz//dN1www3yiMR9HTRokKtQoUKidsV8hRIU1/HmzZtdkYBTEenYsWOidlWvXj3ZP+e1fuHCBVck7SvzcfXq1V0tW7Z0LVmyRPa3f//+cu6nTZvmCjeee+45mZ+4jhcuXOhq166dq3jx4qJUF2nzkz9riA8++EDWUD/99JOM665du7qqVKniOn36tCvS9nXixImiyPfFF1/Iez799FNX9uzZXfPnz3eFIxcvXpT7C8pXTgI1P0WFUQFcCBxI5LGQmF28eLErUpk6daqrbt26YkjVqlVLBkMkwAKaydrzcd9998lk7+01Hvy7SNpXYKDff//9Io3MIqxmzZquAQMG+JSGC2V8nTcMpbj+TbjetB988EFXpUqVZC4qUaKEq23btu5FNnBjfuyxx0R6lRtct27dwtYBEt++AtLeOAPYV4yncL1Zx7fQ9jWmeTB/hTuekrIbN2503Xbbba6SJUvKua1fv/5VErPhArKiZcqUkesY2Vh+j8vwDef5yZ81BPeZV1991VWqVCl5D+N6w4YNrkhdL3311VdiJHOvRVp48uTJrnBl1qxZcn16nq9AzU+p+F/ggiqKoiiKoiiKokQbES8pqyiKoiiKoihK8qJGhaIoiqIoiqIoSUKNCkVRFEVRFEVRkoQaFYqiKIqiKIqiJAk1KhRFURRFURRFSRJqVCiKoiiKoiiKkiTUqFAURVEURVEUJUmoUaEoSkBZuHChqVevnsmZM6fp1q1b0LajcuXK5pNPPgna94cSp06dMrfffrspVKiQyZo1qzl69GhAPvfGG280zzzzjIlkNmzYYEqXLm1OnDghv3/zzTemSJEiKboNiT3OnOvJkyebaGf79u1yLFauXBnsTTF33XWXGTBgQLA3Q1GSBTUqFCVI3H///V4X3fPmzQvowi+lee6550z16tXNmjVrzJAhQ8wbb7xhGjZsmGzfF4xFXkosXAJ5HXz77bdmwYIFZtasWWbz5s0mR44cIXEcV61aZXr27GkqVKhg8ubNa2rXru3VEORYXHfddSZ37txybbGtTt5//33TuHFjU7BgQVOyZEkZVxgDngtzjqfz0adPn3i38eWXXzYPPPCAyZYtmwlVfI0xznWrVq1MqJGQsbJz507TqVMnky9fPjm3zz//vLlw4YIJRbguPa8xHnny5HG/B+PwvffeM8eOHQvqtipKcpA2WT5VUZSQ5/z58yZdunQB/9wtW7aYe+65J+AL1HPnzpn06dObaDk3gWTr1q2ycK9SpYoJJZYvXy6Lxc8//9wULVrULFq0yDz66KMmTZo0spCHbdu2mc6dO8s1NXz4cDNnzhzz8MMPiwHRokULec/vv/9u7rvvPjFKLl68aPr162c6dOhgli5darJkyeL+PgyYF1980f17pkyZ4l3QTps2zXzwwQcmHClQoIAJZziXGBTsxy+//GL27t1r7r33Xpm3OMehSPbs2eW69gVjsFSpUmb06NHiWFKUiMKlKEpQuO+++1xdu3a96u9z5851ZcmSxXXkyBH33yZMmOC65pprXLly5XJVqlTJ1b9//1j/hvdPmjQp1t8KFy7sGjlypPy8bds2ec/YsWNdrVq1cuXOnVte2759u6tz586uIkWKuPLlyyffMW3aNJ/bPGrUKNf111/vKlCggKtUqVKunj17uvbt2xfrO5wPvsPb34D9e+ihh1zFixd3FSxY0NWmTRvXypUr3d/1+uuvuxo0aOD68ssvXZUrV3ZlzZrV57FyPvh3wHF69913XQ888IBsb4UKFVzDhw+P9e937tzp6t69uxyrokWLum699VbZD18cPnzY1atXL9nmPHnyuKpXr+76+uuv3efA+WjdurX8fenSpa527dq5ihUr5ipUqJAc/+XLl191/oYNG+bq0qWLnAeuDc/P42++iOv6YDu8bZcnnBeOQ1zX59NPPx3r3/Mzf4M333zTVadOnas+l3P4yiuvuPzlsccek2vB8sILL1z1uT169HB16NDB52fs379f9vW3337zuq3+8vHHH7saNWoU53ECzl3VqlVdOXPmdNWsWVPGiROu9UceecRVsmRJGXvsz9SpU+W1gwcPuu666y5X2bJlXXnz5nXVrVvXNWbMmFj/Pq5tj2uMOecFOz5/+OEHV4sWLeT6Zd82bNgg1yjjOn/+/K6OHTvK8XPCGKxVq5ZsO/s3dOjQOI/bjBkz5Ds4Tlz3nTp1cm3evNn9uq+x4sn06dNd2bJlc+3du9f9t88++0zG0dmzZ31+/5IlS1wNGzaU7WW/Jk6cKN+zYsUK93tWr14t+8o+c17uuece14EDB9yvHz9+XMY647F06dKugQMHxnsNebs2vMFY4fgoSqSh6U+KEuLg9erRo4d4a/Hk/u9//zOvvfbaVSkg/kAqx0MPPWSWLVsmXt4nnnjCnD17VryxfDaf6/TsevOg4+mlbgJP244dO9weZTzNpFvgqXvnnXfkZ7yMpJhUqlRJfrd/gzvvvNMcOHDATJgwwfz222+mZs2apm3btubw4cOxoh4TJ040o0aNku/0pEGDBvJdfKf9/L59+7pfHzhwoKlVq5aZP3++eDgfe+wxd1oM+4I3m7SW6dOnm5kzZ8q+d+zYUaIi3uD4rF+/XraZY/jxxx+7Uxvmzp0rz+Swsx1sM5CLf8cdd8jnz54925QtW9bccsst7hx9y5tvvmluvvlmOQ+keJCyZM8/n/fuu+8m6vpgO/DQ169fP9Z2BRq24e+//5bjYlmxYoVZvXq1nGt/OX78uMmVK5f7d/apWbNmsd7Dtbt48eI4PwOcnwNjxowxxYsXN3Xr1pWxQK1JXJAyxvUTF5MmTZKUFiIsbNPdd98tY8JeD5cuXZLz/ccff0ikhejJq6++KtEYYPzxHePGjZN/36tXL7lWeZ8/xDXGfKVKPfvssxLdSZs2rWzvCy+8INfXjBkzZMy9/vrrsY4Zv3O8OLdECPjdXp/eOHnypHnkkUckbe2nn34yqVOnNrfddpsci7jGiiecezz7zogL557zu27dOq//5t9//5WxULFiRZlXGA+MJyekFDLX1KhRQ7bxxx9/NPv375dr2JnGyTlj/znHzCFcz4GgTp06ciw594oSUQTbqlGUaAVPcPbs2cVT5nzgQXRGKvCW3XzzzbH+7fPPPy+e6YRGKgYNGhTrPfXq1XO98cYbid6HZcuWyeeeOHHC6/c6Iw5O5s+fL97GM2fOxPp7tWrV3NEE/h2eX0+vqb/eQTz2eB8tly5dEo8knk747rvvxOvK3y14P/EWz5o1y+t3EUkg8uENe4yd3lBvXLx4USIz1lMN/Ltnnnkm3oiVN/y5PjwjDMkRqYD//Oc/rr59+7p/f/LJJ1033nijy18WLlzoypEjR6zjX6NGDdd7770X631E0zg2p06d8np88Yx7eoK5rmbOnOlatWqVa/To0a5y5cq5unXrFuf2cN2+9dZbcR6n5s2bux5++OFY7yH6dcstt8jP7AvediIC/sL2P/fcc+7f4/OQextjviIVI0aMcL/+/fffy99+/fVX99/ef/99GRfOMekZOXn77bddN9xwg9/7QwSA7yE6kJCxwnFt3759rL+dPHlS/i1RDG9wnomOnD592v03xrzz+9h+z8/dtWuXvIfzRJSCuWf8+PHu148ePSpRi/giFXyG55xORMQJ1yDvI1KsKJGE1lQoShChuBRvtxM8lOSPW/D+4lXz9NBT0ErOsfV4+gM5504efPBB8d7jQW/atKl46atWrerz3+MVx6NOgS3ePut5JPccT6m/8O/xKOI1dnL69GnJ/7fwOjn3icW5L6lSpRKPJ9ERuw14ZcnNd3LmzBn5e/Pmza/6vN69e0vU4a+//pLX27VrJ+ciLvbt2yeRA7ymfDfnDA85xyyuc+Mvgbw+kgoRESJhb7/9tninv//+e4kk+QOF/V27dhUPsbdj7y+PP/64Wbt2rUSGnOCRd14XXAucP8416k7e4FrImDFjvMef6ILn8f/000/lZ4qRqS8qV66c13/POaJwd/z48WbPnj0SJcODHV+9RyDGRP78+eXZWWvD3w4ePOiOOHB8qGEhEmOhUJrooC82bdok0QzmskOHDrnniV27diV7XQ/ng310njeidE4Y+0QovNWcMP9w3olkElGwIG7g6xw6IfJJFMiJ57m02xZfpExRwg01KhQliJBuU6ZMmVh/++effxL8OSyYXS5XvMW+nqlNLAJJJyD9iUJIClIxGjA2PGGBQboQ7yeNA7UeFgn8LaGFxXwWi/mff/75qtecykSZM2c2ScGzEJ3jZBc4GDWknbAvnrBv3kBJhwUraSIYYixKKRDmmPmCYkxSukgvKVasmMmQIYO54YYbrjpmSd3XQINR4M815eSmm26SYnrSRXhm8YmhGh+ksnAsWZyTmuOERS6pKU74nUWt52KNdD6uZdLZ4hMKIAUK4jIqSG1LqvpWfEYJToXBgwfL9cGCm+uAYxDoYn1vY4Lx4O1vzjECgwYNirXAhriM1S5duohDgPRDZIz5PGSmfaUV+oJFvzOdDuy1kJQidOafNm3aiLHvCfMS10RSxo3nnO7JkSNH4pxnFCVcUaNCUUIcVHvI7XXC7+Tm2xs7NyeUUZyeQn+9YNRC4IHnQd70iBEjvBoV1CKwOCYfnH8DcamcWFhc4o11Qv0EHnxyukuUKOHXdibk8/2BbcA7TCQkLq+rJ7yfaAWPa6+9VvLRMSqsMpXntnCuPvroI9O6dWv5HUMM760/++Xt8xJzfSQGrikMKE8PL+fMF7zGcaGeg+0ntz8+jzvfQaSFf+dN0QcvM0aCEww6FqkWjJ8nn3xScvQxVJEejQ8rZ+oZqXKCfC01NPEdf+p92H7n8SenH/Ca4yjYuHGjV08378WgsvLSLMAZv/bfJ+cYiA8W7hgFeO+JIvkD1zb7iiGCDLCtTfHcXohvmzn3RHEwJGxUhXPPePV1fDgf3333Xawok2f9DbUU1Gox93i7nrl+MLQwaHAEABKwnBe7T0mBax6jV40KJdLQQm1FCXEowkRGk5QSbtYUSA4dOjRWQXKTJk3kbxQS/vnnn/KaP3KxFJjSuwDZTlJ6SAngpuwNDAkWA/SeYJExZcoUv1JbuHGjS88ijrQKUjsovGVRyEKKCAmvs7hiUcn2JwQ8onhUf/31V/l8f40pFkl4onmmCJNjwP4/9dRTPqNFeDYpPKW4lIUBXnF7vDA2WECTdoPBZHXo8VqyyGFxumTJEknD8Se1hf3Ca8x3kDZlvcaJuT4SA9cU54IiWpvO4mlk+GruRSEux8FZ+Oor5YnoBulOpNdw3HjYFDUgFZBzg/FGasuwYcPEGKQQ2JnyREHtF198Iekn9nNIpwM8zxwfjGCuNa5dIkwsEONK9yMqR7FwXItfjjPH/LPPPpPjhHeeSI3tgdGoUSP5HowOFsTsC5Eum57F9cHfuf65Rvh3npGZxIyxQEGRMxFMoilcXxTejxw5UvbTGxTH00/kyy+/lHHCtUlKmxNfY8UTrguMBwrXMWiZq3BqcO6I+Hnj1ltvlXHD9UEEDIPUs9kc0UOiBURqMRy4PvhsCuw511xDnC+uOa5lrnvS+ohC2OiOLzBw7fXnfNjojzWykpLipyghS7CLOhQlWkmMpCzFgxUrVhSpSye7d++WwkOKAilspYjRW6G2Z2HkE088IYWYSC+WKFHC1bt3b5G49AUFm8i78n4KNadMmXLV53oWalOMffvtt4tsrVPukmJICnmR0mS/kHy9++67ReY1ruJTb/Tp00eKMz0lZT0L0/k8+zogVXnvvfeKRCz7hCwoxaHHjh3z+j0UeNauXVuKufk+zt/WrVtjSW+yHxTm2oLmv/76S6Q7KcDn3FD86blt3grtgSJh5CyR0/VHUtbX9eFPofZXX30l++TktddeE+lgzumzzz4r10tchdqWli1bepWX9YRz4SkvyoPj4zkmkAhFMpdz5Ly+wNtnOK81rimkfNk/zjNSwBSz+zrPlvPnz8v1SYF3UiRlDx06JAX+fD/XAbKxP//8s/s1riNkjxESQH6Xa9I5N8RXqO1rjHkr1HaOVW9zjbf9Y9zb44/0MscSmVZfzJ49W8YJx7p+/fquefPmXXWNexsr3qCYGQEAxhzjlAJ2zktcLFq0SMY628t2//jjj1ft+8aNG6VQn2PGZyOZi1iCFW7wJinbpEkT10svveTze73J+9qHlcWlgJzjyzYqSqSRiv8F27BRFEVRggveaGSCiaYkBW4ppJfgXXYW94YrRH2mTp0q6TJK9EIdRvny5SXVkWhcYiGiRZoe0SxFiTS0pkJRFCWKIV2MehnqIFq2bJmkzyJt6YcffpB0j+7du5tIgPQr0nPoK0JajBIdkEpKuh0F6vTFIH0OPJXWEgppqe+//36AtlJRQguNVCiKokQxSM+yYEJSuH///pIPn1iyZs0qdSoU15LbrijhbFQgpUsdCbVkCDu89dZbcdbgKEq0o0aFoiiKoiiKoihJQtWfFEVRFEVRFEVJEmpUKIqiKIqiKIqSJNSoUBRFURRFURQlSahRoSiKoiiKoihKklCjQlEURVEURVGUJKFGhaIoiqIoiqIoSUKNCkVRFEVRFEVRkoQaFYqiKIqiKIqiJAk1KhRFURRFURRFMUnh/0Nmk0+rEY9XAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from tatc.analysis import sample_field\n", + "\n", + "# the values over the first three days, with the samples of the sun-synchronous satellites\n", + "elapsed = (times - times[0]) / hours\n", + "shown = elapsed < 72\n", + "three = observations[\"three sun-synchronous\"]\n", + "three = three[three.target_hash == where]\n", + "SAMPLES = {\n", + " \"samples of the 13:30 satellite (one sun-synchronous)\": (\n", + " three[three.satellite == \"13:30\"],\n", + " COLORS[\"one sun-synchronous\"],\n", + " \"o\",\n", + " ),\n", + " \"samples of the 17:30 and 21:30 satellites (with it, three sun-synchronous)\": (\n", + " three[three.satellite != \"13:30\"],\n", + " COLORS[\"three sun-synchronous\"],\n", + " \"^\",\n", + " ),\n", + "}\n", + "TITLES = {\n", + " \"stationary\": \"Stationary field\",\n", + " \"daily cycle\": \"With a daily cycle peaked at 16:00 local time\",\n", + "}\n", + "fig, axes = plt.subplots(2, 1, figsize=(8, 5.6), sharex=True, sharey=True)\n", + "for ax, (field, values) in zip(axes, FIELDS.items()):\n", + " series = values.sel(lat=20, lon=0)\n", + " ax.axhline(float(series.mean()), color=GRAY, lw=1)\n", + " if field == \"daily cycle\":\n", + " daily = series - FIELDS[\"stationary\"].sel(lat=20, lon=0)\n", + " ax.plot(elapsed[shown], daily.values[shown], color=GRAY, lw=1.5, ls=\"--\")\n", + " ax.plot(elapsed[shown], series.values[shown], color=INK, lw=1.5)\n", + " for samples, color, marker in SAMPLES.values():\n", + " sampled = sample_field(samples, values)\n", + " at = (pd.to_datetime(sampled.epoch) - pd.Timestamp(START)) / hours\n", + " ax.plot(\n", + " at[at < 72],\n", + " sampled.value[at < 72],\n", + " ls=\"none\",\n", + " marker=marker,\n", + " ms=8 if marker == \"o\" else 9,\n", + " color=color,\n", + " markeredgecolor=\"white\",\n", + " markeredgewidth=1.5,\n", + " )\n", + " ax.set_title(TITLES[field], loc=\"left\", fontsize=10)\n", + " ax.set_ylabel(\"Value\")\n", + " ax.grid(True, axis=\"y\", lw=0.8)\n", + "# the decorrelation time, for scale\n", + "axes[0].annotate(\n", + " \"\",\n", + " xy=(66, 2.6),\n", + " xytext=(72, 2.6),\n", + " arrowprops={\"arrowstyle\": \"|-|\", \"color\": INK, \"lw\": 1},\n", + ")\n", + "axes[0].text(\n", + " 65.5,\n", + " 2.6,\n", + " \"decorrelation time, 6 hours\",\n", + " ha=\"right\",\n", + " va=\"center\",\n", + " color=INK,\n", + " fontsize=8,\n", + ")\n", + "axes[1].set(\n", + " xlim=(0, 72),\n", + " xticks=range(0, 73, 6),\n", + " xlabel=\"Hours after the start of July 2025 (local time at 0 deg E)\",\n", + ")\n", + "handles = [\n", + " plt.Line2D([], [], color=INK, lw=1.5, label=\"nature run at 20 deg N, 0 deg E\"),\n", + " plt.Line2D([], [], color=GRAY, lw=1, label=\"its monthly mean\"),\n", + " plt.Line2D([], [], color=GRAY, lw=1.5, ls=\"--\", label=\"its daily cycle\"),\n", + "] + [\n", + " plt.Line2D(\n", + " [],\n", + " [],\n", + " ls=\"none\",\n", + " marker=marker,\n", + " ms=8,\n", + " color=color,\n", + " markeredgecolor=\"white\",\n", + " markeredgewidth=1.5,\n", + " label=label,\n", + " )\n", + " for label, (_, color, marker) in SAMPLES.items()\n", + "]\n", + "fig.legend(\n", + " handles=handles,\n", + " loc=\"upper left\",\n", + " ncol=2,\n", + " frameon=False,\n", + " fontsize=8,\n", + " bbox_to_anchor=(0.07, 1.0),\n", + ")\n", + "fig.tight_layout(rect=(0, 0, 1, 0.9))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "b00d8ade", + "metadata": {}, + "source": [ + "The field wanders above and below its monthly mean over hours. Its values half an hour apart are nearly the same (a correlation of 0.92), values six hours apart are loosely related (0.37, or `exp(-1)`), and values a day apart are nearly independent (0.02). The 13:30 satellite's samples, 11 to 13 hours apart, are nearly independent of each other, but they miss the variations between them, such as the rise to 2 near 45 hours; the train's three samples a pass, minutes apart, would repeat each of them. With the 17:30 and 21:30 satellites, the samples are 3 to 5 hours apart and follow the variations.\n", + "\n", + "With the daily cycle, the 13:30 satellite sees the cycle near its trough (at 01:30 local time) and on its rise (at 13:30), never at its peak. The two average 0.06 above the cycle's mean, so the satellite's monthly means are biased high. The three satellites see the cycle at six times of day.\n", + "\n", + "The predictions use the model's standard deviation (1) and decorrelation time in both cases, as a study would from the field's random variations. If the predictions hold, the actual errors divided by the predicted ones (the standardized errors) have a root mean square of 1, and 95% of them are within 2. The table gives these for each design and field, with the root mean square of the predicted and actual errors and the mean error." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "ede859c6", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-13T23:01:52.913840Z", + "iopub.status.busy": "2026-11-13T23:01:52.913840Z", + "iopub.status.idle": "2026-11-13T23:01:54.228077Z", + "shell.execute_reply": "2026-11-13T23:01:54.228077Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
pointspredicted RMS erroractual RMS errorRMS standardized errorwithin 2 predicted (%)mean error
fielddesign
stationaryone sun-synchronous756.00.0760.0771.01594.5770.003
train of three756.00.0750.0761.01594.5770.004
three sun-synchronous756.00.0290.0280.96896.4290.001
precessing756.00.1620.1631.01395.767-0.002
daily cycleone sun-synchronous756.00.0760.1151.51581.2170.057
train of three756.00.0750.1211.61677.6460.069
three sun-synchronous756.00.0290.0301.03394.8410.001
precessing756.00.1620.1931.28287.566-0.000
\n", + "
" + ], + "text/plain": [ + " points predicted RMS error \\\n", + "field design \n", + "stationary one sun-synchronous 756.0 0.076 \n", + " train of three 756.0 0.075 \n", + " three sun-synchronous 756.0 0.029 \n", + " precessing 756.0 0.162 \n", + "daily cycle one sun-synchronous 756.0 0.076 \n", + " train of three 756.0 0.075 \n", + " three sun-synchronous 756.0 0.029 \n", + " precessing 756.0 0.162 \n", + "\n", + " actual RMS error RMS standardized error \\\n", + "field design \n", + "stationary one sun-synchronous 0.077 1.015 \n", + " train of three 0.076 1.015 \n", + " three sun-synchronous 0.028 0.968 \n", + " precessing 0.163 1.013 \n", + "daily cycle one sun-synchronous 0.115 1.515 \n", + " train of three 0.121 1.616 \n", + " three sun-synchronous 0.030 1.033 \n", + " precessing 0.193 1.282 \n", + "\n", + " within 2 predicted (%) mean error \n", + "field design \n", + "stationary one sun-synchronous 94.577 0.003 \n", + " train of three 94.577 0.004 \n", + " three sun-synchronous 96.429 0.001 \n", + " precessing 95.767 -0.002 \n", + "daily cycle one sun-synchronous 81.217 0.057 \n", + " train of three 77.646 0.069 \n", + " three sun-synchronous 94.841 0.001 \n", + " precessing 87.566 -0.000 " + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.analysis import compare_sampled_means\n", + "\n", + "\n", + "def compare(field, name):\n", + " \"\"\"The actual and predicted errors of the monthly means of the points a design observes.\"\"\"\n", + " sampled = sample_field(observations[name], field)\n", + " actual = compare_sampled_means(\n", + " sampled, field, START, END, targets=points\n", + " ).set_index(\"target_hash\")\n", + " predicted = estimate_sampling_error(\n", + " observations[name], START, END, DECORRELATION_TIME, 1.0, targets=points\n", + " )\n", + " merged = actual.join(predicted.set_index(\"target_hash\")[[\"sampling_error\"]])\n", + " merged = merged[merged.samples > 0]\n", + " merged[\"standardized\"] = merged.error / merged.sampling_error\n", + " return merged\n", + "\n", + "\n", + "compared = {\n", + " (field, name): compare(FIELDS[field], name) for field in FIELDS for name in DESIGNS\n", + "}\n", + "results = pd.DataFrame(\n", + " {\n", + " key: {\n", + " \"points\": len(m),\n", + " \"predicted RMS error\": np.sqrt((m.sampling_error**2).mean()),\n", + " \"actual RMS error\": np.sqrt((m.error**2).mean()),\n", + " \"RMS standardized error\": np.sqrt((m.standardized**2).mean()),\n", + " \"within 2 predicted (%)\": 100 * (m.standardized.abs() <= 2).mean(),\n", + " \"mean error\": m.error.mean(),\n", + " }\n", + " for key, m in compared.items()\n", + " }\n", + ").T\n", + "results.index.names = [\"field\", \"design\"]\n", + "results.round(3)" + ] + }, + { + "cell_type": "markdown", + "id": "42f14f91", + "metadata": {}, + "source": [ + "When the field follows the model, the predictions hold for every design: the root mean square of the standardized errors is 0.97 to 1.02, 95 to 96% of the errors are within 2 predicted standard deviations, and the mean errors are near zero. This includes the train, whose samples repeat each other, and the precessing satellite, whose samples are few and irregular: the estimate accounts for the times of the samples, whatever their pattern.\n", + "\n", + "The daily cycle does not change the predictions, which model a stationary field, but it changes the errors of the designs that sample few local times. The sun-synchronous satellite's monthly means are too high by 0.057 on average, as its local times of sampling suggest, and its errors are 1.5 times those predicted. The train's are 1.6 times those predicted. The precessing satellite's means are not biased on average, but each point is sampled at different local times, and its errors are 1.3 times those predicted. The three sun-synchronous satellites sample every local time, and their predictions still hold (1.03).\n", + "\n", + "The predicted and actual errors of each design, for the stationary field (filled) and with the daily cycle (hollow):" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "cf5e7dd0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-13T23:01:54.228077Z", + "iopub.status.busy": "2026-11-13T23:01:54.228077Z", + "iopub.status.idle": "2026-11-13T23:01:54.344223Z", + "shell.execute_reply": "2026-11-13T23:01:54.344223Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "MARKERS = dict(zip(DESIGNS, [\"o\", \"s\", \"^\", \"D\"]))\n", + "fig, ax = plt.subplots(figsize=(6, 5.5))\n", + "limits = (0.02, 0.4)\n", + "ax.plot(limits, limits, color=GRAY, lw=1, ls=\"--\", label=\"actual = predicted\")\n", + "for name in DESIGNS:\n", + " for field, filled in ((\"stationary\", True), (\"daily cycle\", False)):\n", + " row = results.loc[(field, name)]\n", + " ax.plot(\n", + " row[\"predicted RMS error\"],\n", + " row[\"actual RMS error\"],\n", + " marker=MARKERS[name],\n", + " ms=9,\n", + " ls=\"none\",\n", + " color=COLORS[name],\n", + " markerfacecolor=COLORS[name] if filled else \"white\",\n", + " markeredgewidth=2,\n", + " )\n", + "# direct labels at the stationary points (one sun-synchronous satellite and the train coincide)\n", + "LABELS = {\n", + " \"one sun-synchronous\": \"one sun-synchronous\\nand train of three\",\n", + " \"three sun-synchronous\": \"three sun-synchronous\",\n", + " \"precessing\": \"precessing\",\n", + "}\n", + "for name, label in LABELS.items():\n", + " ax.annotate(\n", + " label,\n", + " (\n", + " results.loc[(\"stationary\", name), \"predicted RMS error\"],\n", + " results.loc[(\"stationary\", name), \"actual RMS error\"],\n", + " ),\n", + " xytext=(10, -6),\n", + " textcoords=\"offset points\",\n", + " va=\"top\",\n", + " color=INK,\n", + " fontsize=9,\n", + " )\n", + "# legend: the designs by marker and color, and the fields by fill\n", + "handles = [\n", + " plt.Line2D(\n", + " [], [], marker=MARKERS[name], ls=\"none\", ms=8, color=COLORS[name], label=name\n", + " )\n", + " for name in DESIGNS\n", + "]\n", + "handles += [\n", + " plt.Line2D(\n", + " [], [], marker=\"o\", ls=\"none\", ms=8, color=GRAY, label=\"stationary field\"\n", + " ),\n", + " plt.Line2D(\n", + " [],\n", + " [],\n", + " marker=\"o\",\n", + " ls=\"none\",\n", + " ms=8,\n", + " color=GRAY,\n", + " markerfacecolor=\"white\",\n", + " markeredgewidth=2,\n", + " label=\"with a daily cycle\",\n", + " ),\n", + " plt.Line2D([], [], color=GRAY, ls=\"--\", label=\"actual = predicted\"),\n", + "]\n", + "ax.legend(handles=handles, frameon=False, fontsize=8, loc=\"upper left\")\n", + "ax.set(\n", + " xscale=\"log\",\n", + " yscale=\"log\",\n", + " xlim=limits,\n", + " ylim=limits,\n", + " xlabel=\"Predicted RMS error of the monthly means\",\n", + " ylabel=\"Actual RMS error of the monthly means\",\n", + ")\n", + "ticks = [0.02, 0.05, 0.1, 0.2, 0.4]\n", + "ax.set_xticks(ticks, [str(t) for t in ticks])\n", + "ax.set_yticks(ticks, [str(t) for t in ticks])\n", + "ax.minorticks_off()\n", + "ax.grid(True, lw=0.8)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "992afab0", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "* **Spread, not count.** The error of a sampled mean depends on how the samples spread in time relative to the field's decorrelation time. Samples minutes apart add almost nothing (the train), and samples spread within the decorrelation time reduce the error faster than independent samples would (the three sun-synchronous satellites). Rank designs by `estimate_sampling_error` rather than by their samples or mean revisit.\n", + "* **Revisits explain it.** The mean revisit hides clusters of samples; the quantiles of the revisits and the longest gap (`compute_revisit_statistics`) show them.\n", + "* **Calibrated for its model.** The estimate is exact for a stationary field with an exponential correlation. When a field follows it, the predicted errors hold for any pattern of samples.\n", + "* **Daily cycles.** A field with a daily cycle sampled at few local times has biased means and errors larger than predicted. Check the local times of the samples (`compute_local_time_coverage`) for such fields.\n", + "\n", + "The predictions need the field's standard deviation and decorrelation time, which may differ between targets (mappings by `target_hash`, such as a field that decorrelates faster over land). A study takes them from climatology or another period. The validation notebook `ValidateSamplingErrorIMERG` tests this with real precipitation: the statistics of one month predict the errors of the next, and the daily cycle makes the errors of one sun-synchronous satellite up to 25% larger than predicted. The trade space examples (from `SearchTradeSpace`) use the relative error in an objective: the share of points whose daily means a design estimates within half the field's standard deviation." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/index.rst b/docs/examples/index.rst index 2bd4a470..51e313b0 100644 --- a/docs/examples/index.rst +++ b/docs/examples/index.rst @@ -20,6 +20,7 @@ The following provide examples of TAT-C use in a Jupyter notebook environment. CollectRO.ipynb CollectLimb.ipynb CollectSpace.ipynb + AssessSamplingSufficiency.ipynb RunOSSEMonsoon.ipynb RunOSSEHurricane.ipynb SearchTradeSpace.ipynb @@ -32,7 +33,7 @@ Note that running the above examples in a local Python environment requires addi pip install tatc[examples] -using the pip package manager. The trade space examples also require:: +using the pip package manager. The AssessSamplingSufficiency example also requires xarray (``pip install xarray``) for its nature run. The trade space examples also require:: pip install tatc[tradespace] From 1742dd63acda94188040f987e4303b8bedaca4f3 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Fri, 13 Nov 2026 17:10:32 -0700 Subject: [PATCH 41/52] restructure the trade space examples as a tutorial of eight notebooks, each adding one idea, in docs/examples/tradespace --- CHANGELOG.md | 2 +- docs/api_reference/tradespace/index.rst | 4 +- docs/examples/CompareScenarios.ipynb | 869 -------- docs/examples/PlanMissions.ipynb | 1815 ---------------- docs/examples/RankUncertainDesigns.ipynb | 1878 ----------------- docs/examples/SearchTradeSpace.ipynb | 1416 ------------- docs/examples/TradeCostAndUtility.ipynb | 999 --------- docs/examples/index.rst | 11 +- .../tradespace/CompareScenarios.ipynb | 527 +++++ .../tradespace/EvaluateTradeSpace.ipynb | 587 ++++++ .../tradespace/ExplainTradeSpace.ipynb | 678 ++++++ docs/examples/tradespace/PlanDeployment.ipynb | 470 +++++ .../examples/tradespace/PlanForFailures.ipynb | 1006 +++++++++ .../tradespace/RankUncertainDesigns.ipynb | 1284 +++++++++++ .../tradespace/SearchTradeSpace.ipynb | 412 ++++ .../tradespace/TradeCostAndUtility.ipynb | 788 +++++++ docs/examples/tradespace/index.rst | 46 + .../{ => tradespace}/trade_space_example.py | 171 +- 18 files changed, 5894 insertions(+), 7069 deletions(-) delete mode 100644 docs/examples/CompareScenarios.ipynb delete mode 100644 docs/examples/PlanMissions.ipynb delete mode 100644 docs/examples/RankUncertainDesigns.ipynb delete mode 100644 docs/examples/SearchTradeSpace.ipynb delete mode 100644 docs/examples/TradeCostAndUtility.ipynb create mode 100644 docs/examples/tradespace/CompareScenarios.ipynb create mode 100644 docs/examples/tradespace/EvaluateTradeSpace.ipynb create mode 100644 docs/examples/tradespace/ExplainTradeSpace.ipynb create mode 100644 docs/examples/tradespace/PlanDeployment.ipynb create mode 100644 docs/examples/tradespace/PlanForFailures.ipynb create mode 100644 docs/examples/tradespace/RankUncertainDesigns.ipynb create mode 100644 docs/examples/tradespace/SearchTradeSpace.ipynb create mode 100644 docs/examples/tradespace/TradeCostAndUtility.ipynb create mode 100644 docs/examples/tradespace/index.rst rename docs/examples/{ => tradespace}/trade_space_example.py (55%) diff --git a/CHANGELOG.md b/CHANGELOG.md index c08b3337..f5c7102b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -37,7 +37,7 @@ Added: - Searches with Optuna accept categorical options that depend on earlier decisions (a parameter for each set of options), use TPE with a constant liar in batches by default (which spreads the trials of a batch), and stop after `max_designs` designs evaluated (trials that suggest designs evaluated before are told their objectives without evaluating them again). A design infeasible in some of its replicates violates its feasibility by their share (`Evaluations.infeasibility`), and the first design evaluated in a search is evaluated alone, to check that evaluations give one record each. `Study` records errors of evaluations as infeasible, without storing them, with `errors="record"`. Enumeration walks the items of unordered repetitions in one order only (the same designs, in the same order, four times faster for three sun-synchronous planes), and `DesignSpace.size` counts designs without keeping them. Pareto fronts are found by a vectorized sweep in lexicographic order that compares designs only with the efficient designs before them, and fronts with tolerances by comparing designs only with the efficient designs without tolerances (which dominate every design that any design dominates within the tolerances), in blocks of bounded memory: 20,000 designs in 0.05 s (0.11 s with tolerances) rather than 17 s, and the bootstraps of `pareto_probability` (and so `refine`) about 20 times faster. - Studies of the observations of constellations (`tradespace.ObservationStudy`): the targets of each replicate (`Targets`, fixed or generated from a seed of the design), the observations of each satellite, cached on disk (`Observations`), the metrics of the observations, and, with a `MissionPlan`, the costs of the deployment and the summaries of its phases or of the histories of its `Failures`. Plots of the results of studies (`plot_designs`, `plot_progress`, and `plot_means`, with matplotlib, now in the `tradespace` extra), and the hypervolume of a search as it proceeds (`hypervolume_progress`). - The steps of trade studies share their arguments and outcomes: `tradespace.refine(study, criteria, results)`, `confirm(study, criteria, results)` (by default, the front of the results), `screen(studies, criteria, designs)` (with criteria for each stage, in place of a `tolerance` of its own), and `attribute_variance(study, metrics, designs)` take designs as `Design` objects, their keys, or rows of a summary or of results, and `Refinement`, `Confirmation`, `Screening`, and `Search` give their `results`, the `summary` of their designs, and the `designs`. `DesignSpace.designs_of` rebuilds designs from rows of their values, which summaries keep (also those of `pareto_probability`, `confirm`, and `screen`), and `DesignSpace.extend`, `DesignSpace.design(design, **overrides)`, and `Study.replace` make variants of design spaces, designs, and studies. `aggregate` takes criteria, a mapping of objectives, or metrics (as the other functions do), and other `statistics` by name; `pareto_front`, `pareto_ranks`, `hypervolume`, `sensitivity`, and `main_effects` raise an error given the results of a study (a row per replicate) rather than a summary. Studies with a mission plan record the years by which it is `deployed`, and the parts of observation studies that refer to values of designs are typed as a `Reference`. Columns: ` se` (rather than `sem`), ` mission` for the mean over the phases of a mission, ` histories p` and ` histories std` for statistics over the histories of failures, and `pareto_trace` and `max_regret`. Package `tradespace` exports the functions and classes of trade studies; the parts from which they are made (such as `PhaseCache`, `Layout`, `configure`, and the fingerprints) are imported from its modules. - - Example `SearchTradeSpace`, which searches a hierarchical trade space of constellations for the designs that sample points sufficiently: by evaluating every design, finding what drives the objectives, screening, and searching with Optuna and pymoo; and examples that take its trade further, importing its design space and study (`trade_space_example.py`): `RankUncertainDesigns` (the probability of efficiency, refinement, confirmation, and requirements on statistics), `CompareScenarios` (fronts, regret, and searches across scenarios), `TradeCostAndUtility` (cost at a confidence level, correlated cost risk of components, and utility), and `PlanMissions` (deployment, staging, failures, and the attribution of variance). + - Trade space tutorial (`docs/examples/tradespace`): eight notebooks that follow one trade of constellations, each adding one idea to those before it: `EvaluateTradeSpace` (design space, study, and Pareto front), `ExplainTradeSpace` (sampling error, revisits, and sensitivity), `SearchTradeSpace` (hypervolume, screening, and optimizers), `RankUncertainDesigns` (probability of efficiency, refinement, confirmation, and requirements on statistics), `CompareScenarios` (scenarios, regret, and searches across scenarios), `TradeCostAndUtility` (costs with uncertain growth, budgets, and utility), `PlanDeployment` (phases and staging), and `PlanForFailures` (failures, restoration policies, and the attribution of variance). Each notebook defines what it introduces, and imports what earlier notebooks defined from `trade_space_example.py`. - The `RunOSSEMonsoon` example declares its constellation trade as a design space, caches the looks of each satellite, evaluates its replicates in parallel, and finds its Pareto-efficient designs. Changed: diff --git a/docs/api_reference/tradespace/index.rst b/docs/api_reference/tradespace/index.rst index bc9c1fae..0ec8a3ff 100644 --- a/docs/api_reference/tradespace/index.rst +++ b/docs/api_reference/tradespace/index.rst @@ -5,8 +5,8 @@ Trade Space .. automodule:: tatc.tradespace :no-members: -The examples :doc:`../../examples/SearchTradeSpace` and the notebooks that -follow it show each step on a study of the observations of constellations. +The :doc:`../../examples/tradespace/index` shows each step on a study of the +observations of constellations, one step at a time. Steps of a Trade Study ====================== diff --git a/docs/examples/CompareScenarios.ipynb b/docs/examples/CompareScenarios.ipynb deleted file mode 100644 index a4dbb032..00000000 --- a/docs/examples/CompareScenarios.ipynb +++ /dev/null @@ -1,869 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "f99e557a", - "metadata": {}, - "source": [ - "# Compare Designs across Scenarios\n", - "\n", - "This example demonstrates how to compare designs under conditions that are not known in advance (scenarios) with the `tatc.tradespace` module: the front of each scenario, the share of the scenarios in which each design is efficient, the regret of each design, criteria that judge designs across the scenarios, and a search for designs robust to them.\n", - "\n", - "It continues the example `SearchTradeSpace`, whose design space and study it imports from `trade_space_example.py` (beside the notebooks). The evaluations of every design are taken from the study's store if `SearchTradeSpace` was run before (or are evaluated again, in a few minutes). Its objectives here are the numbers of satellites and of planes and the share of points accurately sampled (whose daily mean is estimated within half the field's standard deviation)." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "30b9fb03", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:18:24.143529Z", - "iopub.status.busy": "2026-11-12T17:18:24.143529Z", - "iopub.status.idle": "2026-11-12T17:18:26.859265Z", - "shell.execute_reply": "2026-11-12T17:18:26.859265Z" - } - }, - "outputs": [], - "source": [ - "import time\n", - "from datetime import timedelta\n", - "\n", - "import pandas as pd\n", - "\n", - "from trade_space_example import ACCURACY, REFERENCE, describe, designs, study\n", - "from tatc.tradespace import pareto_front, summarize\n", - "\n", - "# the evaluations of every design, and the designs efficient by accuracy\n", - "results = study.run(designs)\n", - "accuracy = summarize(results, [\"satellites\", \"planes\", \"sufficient\", \"accurate\"])\n", - "accuracy[\"description\"] = accuracy.apply(describe, axis=1)\n", - "accuracy[\"pareto\"] = pareto_front(accuracy, ACCURACY)" - ] - }, - { - "cell_type": "markdown", - "id": "f275da1c", - "metadata": {}, - "source": [ - "## Compare Designs across Scenarios\n", - "\n", - "How accurately samples estimate a daily mean depends on the field: samples hours apart estimate the mean of a field that varies slowly (one that decorrelates in 12 hours) better than that of one that varies within the hour (such as rain rates). Which field the mission will serve is not uncertain as the sample of points or the failures are, which the replicates average over: it is a condition under which to compare designs, a scenario. The `scenarios` of a study give fixed values or uncertain parameters of the design space other values: here, the field's decorrelation time (`decorrelation_time`). The study evaluates every design in each field, with the same samples of points, and records the field as its `scenario`; the field of 3 hours, that of `SearchTradeSpace`, takes its evaluations from the store. Criteria `by` the scenario judge designs in each field, and `robustness` judges them across the fields: the share of the fields in which each design is efficient (its Pareto trace) here, and its regret below:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "209d04e1", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:18:26.859265Z", - "iopub.status.busy": "2026-11-12T17:18:26.859265Z", - "iopub.status.idle": "2026-11-12T17:21:01.727173Z", - "shell.execute_reply": "2026-11-12T17:21:01.726172Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "16440 evaluations (3 fields) in 155 s\n", - "efficient designs: {'1 hour': 14, '3 hours': 13, '12 hours': 6}\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
descriptionsatellitesplanes1 hour3 hours12 hourspareto_trace
design
33b006848799800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.026.234.260.40.67
b85daf65c3a4800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...3.01.08.017.095.60.67
c576e2e2dbd1800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:003.02.040.860.685.80.67
3690f1194419800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:004.02.069.085.493.00.67
cb6bd361b577800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.096.696.697.80.67
5529c21520be800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.897.80.67
de505bc89299800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.897.80.67
679ca275c8fc800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.897.80.67
\n", - "
" - ], - "text/plain": [ - " description satellites \\\n", - "design \n", - "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 \n", - "b85daf65c3a4 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... 3.0 \n", - "c576e2e2dbd1 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3.0 \n", - "3690f1194419 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4.0 \n", - "cb6bd361b577 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 \n", - "5529c21520be 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", - "de505bc89299 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", - "679ca275c8fc 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", - "\n", - " planes 1 hour 3 hours 12 hours pareto_trace \n", - "design \n", - "33b006848799 2.0 26.2 34.2 60.4 0.67 \n", - "b85daf65c3a4 1.0 8.0 17.0 95.6 0.67 \n", - "c576e2e2dbd1 2.0 40.8 60.6 85.8 0.67 \n", - "3690f1194419 2.0 69.0 85.4 93.0 0.67 \n", - "cb6bd361b577 4.0 96.6 96.6 97.8 0.67 \n", - "5529c21520be 3.0 97.8 97.8 97.8 0.67 \n", - "de505bc89299 3.0 97.8 97.8 97.8 0.67 \n", - "679ca275c8fc 3.0 97.8 97.8 97.8 0.67 " - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from tatc.tradespace import Criteria, aggregate, robustness\n", - "\n", - "# fields that decorrelate within an hour (such as rain rates), in 3 hours (as in SearchTradeSpace), and in 12 hours\n", - "FIELDS = {\n", - " \"1 hour\": {\"decorrelation_time\": timedelta(hours=1)},\n", - " \"3 hours\": {},\n", - " \"12 hours\": {\"decorrelation_time\": timedelta(hours=12)},\n", - "}\n", - "began = time.perf_counter()\n", - "fields = study.replace(scenarios=FIELDS).run(designs)\n", - "print(f\"{len(fields)} evaluations ({len(FIELDS)} fields) in {time.perf_counter() - began:.0f} s\")\n", - "\n", - "# the efficient designs of each field (by accuracy), and the share of the fields in which each design is efficient\n", - "BY_FIELD = Criteria(ACCURACY, by=\"scenario\")\n", - "by_field = aggregate(fields, BY_FIELD)\n", - "by_field[\"pareto\"] = pareto_front(by_field, BY_FIELD)\n", - "print(\"efficient designs:\", by_field[by_field.pareto].scenario.value_counts()[list(FIELDS)].to_dict())\n", - "field_accuracy = by_field.pivot(index=\"design\", columns=\"scenario\", values=\"accurate\")[list(FIELDS)]\n", - "traced = accuracy.set_index(\"design\")[[\"description\", \"satellites\", \"planes\"]].join(field_accuracy)\n", - "traced[\"pareto_trace\"] = robustness(fields, ACCURACY).set_index(\"design\")[\"pareto_trace\"]\n", - "traced[traced[\"pareto_trace\"] > 0.5].sort_values([\"satellites\", \"planes\"]).round(2)" - ] - }, - { - "cell_type": "markdown", - "id": "6ef8bf46", - "metadata": {}, - "source": [ - "The 10,960 evaluations of the other two fields take about two minutes here. Which designs are efficient depends on the field. For the field that decorrelates in 12 hours, one plane samples well: three satellites in one plane (inclined 75 degrees) sample 96% of the points accurately, and four of the six efficient designs have one plane (the other two, four satellites in two planes, sample 98%). For the fields that vary within hours, the samples must spread over the day: the same three satellites in one plane sample 17% (3 hours) and 8% (1 hour) accurately, against 61% and 41% for three satellites in two sun-synchronous planes. No design is efficient for every field: of the eight efficient for two fields, seven are efficient for the fields of 1 and 3 hours, and the other, three satellites in one plane, for those of 3 and 12 hours.\n", - "\n", - "A design need not be efficient in any field to be a good choice when the field is not known: its regret in a field is how far it falls behind the best design there. With the numbers of satellites and planes as objectives, regret would count mostly satellites and planes (a design matches the cheapest efficient design by dropping some), so here regret is in the share accurately sampled alone, among the designs of at most a number of satellites (a `Requirement`): the points below the best design of each field with as many satellites at most. The design whose largest regret over the fields is least (minimax regret) is the robust choice:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "881decea", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:21:01.729172Z", - "iopub.status.busy": "2026-11-12T17:21:01.729172Z", - "iopub.status.idle": "2026-11-12T17:21:02.159338Z", - "shell.execute_reply": "2026-11-12T17:21:02.159338Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
descriptionsatellitesplanesmax_regret1 hour regret3 hours regret12 hours regret
at most
2800 km, 60 deg FOR, Walker 75 deg: 2 x 1 (spac...2.02.011.07.66.411.0
3800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:003.02.09.89.80.49.8
4800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:004.02.05.00.00.05.0
6700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...6.03.00.40.40.20.4
\n", - "
" - ], - "text/plain": [ - " description satellites \\\n", - "at most \n", - "2 800 km, 60 deg FOR, Walker 75 deg: 2 x 1 (spac... 2.0 \n", - "3 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3.0 \n", - "4 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4.0 \n", - "6 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... 6.0 \n", - "\n", - " planes max_regret 1 hour regret 3 hours regret 12 hours regret \n", - "at most \n", - "2 2.0 11.0 7.6 6.4 11.0 \n", - "3 2.0 9.8 9.8 0.4 9.8 \n", - "4 2.0 5.0 0.0 0.0 5.0 \n", - "6 3.0 0.4 0.4 0.2 0.4 " - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from tatc.tradespace import Requirement\n", - "\n", - "# the designs of least maximum regret (in points accurately sampled, below the best design of each field), among those\n", - "# of at most a number of satellites\n", - "robust, robust_design = [], {}\n", - "for budget in (2, 3, 4, 6):\n", - " within = Criteria({\"accurate\": \"max\"}, requirements=[Requirement(\"satellites\", \"<=\", budget)])\n", - " regret = robustness(fields, within).set_index(\"design\")\n", - " best = robust_design[budget] = regret[\"max_regret\"].idxmin()\n", - " described = traced.loc[best, [\"description\", \"satellites\", \"planes\"]]\n", - " robust.append({\"at most\": budget, **described, **regret.loc[best].drop(\"pareto_trace\")})\n", - "pd.DataFrame(robust).set_index(\"at most\").round(1)" - ] - }, - { - "cell_type": "markdown", - "id": "d814d0a8", - "metadata": {}, - "source": [ - "The robust choice depends on the budget. With four satellites, two sun-synchronous planes of two (crossing at 09:00 and 15:00) are the best for the fields of 1 and 3 hours and fall 5 points behind the best for the field of 12 hours (93% against 98%, by four satellites in two other planes): a mission that does not yet know its field loses little by choosing them. With three satellites, two sun-synchronous planes of two and one fall 10 points behind three satellites in one plane for the field of 12 hours (86% against 96%) and three in three planes for the field of 1 hour (41% against 51%), and less than a point behind the best for 3 hours. Two satellites fall at least 11 points behind somewhere. Six satellites in three Walker planes (at 700 km) fall at most 0.4 points behind the best of any field, though they are efficient in none: a robust choice need not be the best in any scenario. Regrets of a point or two are within the sampling error of the means of five replicates (standard errors of one to four points, see `SearchTradeSpace`), so the robust designs of four and six satellites are as good as the best of each field." - ] - }, - { - "cell_type": "markdown", - "id": "d8b216ed", - "metadata": {}, - "source": [ - "Criteria `across` the fields (`Across`) judge each design once, by its worst or its mean share over the fields, rather than in each field, which is what a search for designs robust to the field needs (see below). Here every design is evaluated in every field, so the fronts of both are exact:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "a26f4db4", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:21:02.159338Z", - "iopub.status.busy": "2026-11-12T17:21:02.159338Z", - "iopub.status.idle": "2026-11-12T17:21:02.328481Z", - "shell.execute_reply": "2026-11-12T17:21:02.328481Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "the field in which each design is least accurate: {'1 hour': 1028, '3 hours': 68}\n", - "efficient by the worst: 15, of which 12 in 1 hour\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
descriptionsatellitesplanes1 hour3 hours12 hoursworstmean
design
9b3481aea973800 km, 60 deg FOR, SSO: 1 at 12:001.01.03.04.227.0TrueFalse
12765c7a29fc800 km, 60 deg FOR, SSO: 1 at 15:001.01.03.03.628.0TrueTrue
24a159fbc4b7800 km, 60 deg FOR, SSO: 2 at 12:002.01.05.69.470.0TrueFalse
c9cacc08010d800 km, 60 deg FOR, SSO: 2 at 15:002.01.04.810.073.0FalseTrue
33b006848799800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.026.234.260.4TrueTrue
d5d3fa915ca7800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...3.01.010.211.467.6TrueFalse
b85daf65c3a4800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...3.01.08.017.095.6FalseTrue
c576e2e2dbd1800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:003.02.040.860.685.8TrueTrue
92ff9cd17e00800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...3.03.050.659.863.6TrueFalse
1af5f2707be3800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.011.226.867.2TrueFalse
104e33a3c842800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac...4.01.09.228.695.0FalseTrue
3690f1194419800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:004.02.069.085.493.0TrueTrue
64cf6542c326800 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...6.03.090.295.897.4TrueFalse
e641bd5c978e700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...6.03.089.896.297.6FalseTrue
6df0f1709edc800 km, 60 deg FOR, Walker 60 deg: 2 x 4 (spac...8.02.070.280.289.2TrueFalse
cb6bd361b577800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.096.696.697.8TrueTrue
5529c21520be800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.897.8TrueTrue
679ca275c8fc800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.897.8TrueTrue
de505bc89299800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.897.8TrueTrue
\n", - "
" - ], - "text/plain": [ - " description satellites \\\n", - "design \n", - "9b3481aea973 800 km, 60 deg FOR, SSO: 1 at 12:00 1.0 \n", - "12765c7a29fc 800 km, 60 deg FOR, SSO: 1 at 15:00 1.0 \n", - "24a159fbc4b7 800 km, 60 deg FOR, SSO: 2 at 12:00 2.0 \n", - "c9cacc08010d 800 km, 60 deg FOR, SSO: 2 at 15:00 2.0 \n", - "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 \n", - "d5d3fa915ca7 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 \n", - "b85daf65c3a4 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... 3.0 \n", - "c576e2e2dbd1 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3.0 \n", - "92ff9cd17e00 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 \n", - "1af5f2707be3 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 \n", - "104e33a3c842 800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac... 4.0 \n", - "3690f1194419 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4.0 \n", - "64cf6542c326 800 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... 6.0 \n", - "e641bd5c978e 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... 6.0 \n", - "6df0f1709edc 800 km, 60 deg FOR, Walker 60 deg: 2 x 4 (spac... 8.0 \n", - "cb6bd361b577 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 \n", - "5529c21520be 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", - "679ca275c8fc 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", - "de505bc89299 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", - "\n", - " planes 1 hour 3 hours 12 hours worst mean \n", - "design \n", - "9b3481aea973 1.0 3.0 4.2 27.0 True False \n", - "12765c7a29fc 1.0 3.0 3.6 28.0 True True \n", - "24a159fbc4b7 1.0 5.6 9.4 70.0 True False \n", - "c9cacc08010d 1.0 4.8 10.0 73.0 False True \n", - "33b006848799 2.0 26.2 34.2 60.4 True True \n", - "d5d3fa915ca7 1.0 10.2 11.4 67.6 True False \n", - "b85daf65c3a4 1.0 8.0 17.0 95.6 False True \n", - "c576e2e2dbd1 2.0 40.8 60.6 85.8 True True \n", - "92ff9cd17e00 3.0 50.6 59.8 63.6 True False \n", - "1af5f2707be3 1.0 11.2 26.8 67.2 True False \n", - "104e33a3c842 1.0 9.2 28.6 95.0 False True \n", - "3690f1194419 2.0 69.0 85.4 93.0 True True \n", - "64cf6542c326 3.0 90.2 95.8 97.4 True False \n", - "e641bd5c978e 3.0 89.8 96.2 97.6 False True \n", - "6df0f1709edc 2.0 70.2 80.2 89.2 True False \n", - "cb6bd361b577 4.0 96.6 96.6 97.8 True True \n", - "5529c21520be 3.0 97.8 97.8 97.8 True True \n", - "679ca275c8fc 3.0 97.8 97.8 97.8 True True \n", - "de505bc89299 3.0 97.8 97.8 97.8 True True " - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from tatc.tradespace import Across\n", - "\n", - "# the efficient designs by their worst and by their mean share accurately sampled over the fields (with equal\n", - "# weights), and those of the field that decorrelates within an hour\n", - "fronts = {}\n", - "for rule in (\"worst\", \"mean\"):\n", - " criteria = Criteria(ACCURACY, across=Across(rule=rule))\n", - " combined = aggregate(fields, criteria)\n", - " fronts[rule] = set(combined.design[pareto_front(combined, criteria)])\n", - "fronts[\"1 hour\"] = set(by_field.design[by_field.pareto & (by_field.scenario == \"1 hour\")])\n", - "print(\"the field in which each design is least accurate:\", field_accuracy.idxmin(axis=1).value_counts().to_dict())\n", - "print(f\"efficient by the worst: {len(fronts['worst'])}, of which {len(fronts['worst'] & fronts['1 hour'])} in 1 hour\")\n", - "compared = traced.loc[sorted(fronts[\"worst\"] | fronts[\"mean\"]), [\"description\", \"satellites\", \"planes\", *FIELDS]]\n", - "compared[\"worst\"] = compared.index.isin(fronts[\"worst\"])\n", - "compared[\"mean\"] = compared.index.isin(fronts[\"mean\"])\n", - "compared.sort_values([\"satellites\", \"planes\", \"mean\"]).round(1)" - ] - }, - { - "cell_type": "markdown", - "id": "701f624a", - "metadata": {}, - "source": [ - "The field that decorrelates within an hour is the hardest for 1,028 of the 1,096 designs (that of 3 hours for the others), so a design's worst share is nearly always its share in that field: 12 of the 15 designs efficient by the worst are efficient in that field, and the worst adds little to it. A worst case suits scenarios that are hardest for different designs; here, the mean and the regret (above) say more. The mean over the fields weighs the field of 12 hours as well, in which one plane samples well: three and four satellites in one plane inclined 75 degrees (96% and 95% in that field) are efficient by the mean, where the worst prefers one plane inclined 45 degrees, about two points better in the field of 1 hour and 28 points worse in that of 12 hours. Eight designs are efficient by both, among them the robust choices of three and four satellites above (in two sun-synchronous planes); the robust choice of six (three Walker planes at 700 km) is efficient by the mean, but not by the worst, by 0.4 points in the field of 1 hour." - ] - }, - { - "cell_type": "markdown", - "id": "1c07a5c4", - "metadata": {}, - "source": [ - "## Search for Robust Designs" - ] - }, - { - "cell_type": "markdown", - "id": "d82e00b3", - "metadata": {}, - "source": [ - "A search for designs robust to the field evaluates each design that it proposes in every field, and judges it by criteria `across` the fields: here pymoo's, by the mean share accurately sampled over the three fields, with as many proposals as above. Its evaluations are those of the comparison of the fields above, retrieved from the store:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "5d5e9a37", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:21:02.328481Z", - "iopub.status.busy": "2026-11-12T17:21:02.328481Z", - "iopub.status.idle": "2026-11-12T17:21:04.338094Z", - "shell.execute_reply": "2026-11-12T17:21:04.337622Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "147 designs evaluated (in 3 fields each): 99.3% of the hypervolume of the true front, and 8 of its 12 designs\n" - ] - } - ], - "source": [ - "from pymoo.algorithms.moo.nsga2 import NSGA2\n", - "\n", - "from tatc.tradespace import hypervolume, hypervolume_progress, optimize_pymoo\n", - "\n", - "BUDGET = 200 # proposals of the search, as in SearchTradeSpace\n", - "# a search for the designs most accurate on average over the fields, against the true front of every design\n", - "FIELD_MEAN = Criteria(ACCURACY, across=Across(rule=\"mean\"))\n", - "ACCURATE_REFERENCE = {\"satellites\": REFERENCE[\"satellites\"], \"planes\": REFERENCE[\"planes\"], \"accurate\": 0}\n", - "field_search = optimize_pymoo(\n", - " study.replace(scenarios=FIELDS), FIELD_MEAN, NSGA2(pop_size=20), (\"n_gen\", BUDGET // 20), seed=1\n", - ")\n", - "field_progress = hypervolume_progress(field_search.results, FIELD_MEAN, ACCURATE_REFERENCE)\n", - "true_mean = hypervolume(aggregate(fields, FIELD_MEAN), FIELD_MEAN, ACCURATE_REFERENCE)\n", - "evaluated = set(field_search.results.design)\n", - "print(\n", - " f\"{len(evaluated)} designs evaluated (in {len(FIELDS)} fields each): \"\n", - " f\"{100 * field_progress.iloc[-1] / true_mean:.1f}% of the hypervolume of the true front, \"\n", - " f\"and {len(evaluated & fronts['mean'])} of its {len(fronts['mean'])} designs\"\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "70bf569f", - "metadata": {}, - "source": [ - "The search finds 99.3% of the hypervolume of the true front of the mean with 147 designs, and 8 of its 12 designs; each design costs three times as much as in a search of one field, as it is evaluated in each field. Its designs and results refine and confirm its front as for any study, with the same criteria. A search by the worst would search mostly the field of 1 hour here (see above)." - ] - }, - { - "cell_type": "markdown", - "id": "2235c5f8", - "metadata": {}, - "source": [ - "## Summary\n", - "\n", - "* The `scenarios` of a study compare designs under conditions rather than averaging over them (here, fields of different decorrelation times, a value of the design space): each design is evaluated in each scenario, with the same replicates, and the evaluations of each scenario are kept apart in the store.\n", - "* Criteria `by` the scenario give the front of each, and `robustness` the share of the scenarios in which each design is efficient (its Pareto trace) and its regret in each, whose least maximum is a robust choice (here, six satellites efficient in no field but never half a point behind the best).\n", - "* Criteria `across` the scenarios (`Across`) judge each design once, by its worst or its mean over them, as a search for robust designs needs: here the worst is mostly the field that varies fastest, and pymoo's search by the mean finds nearly all of the front of the mean." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/examples/PlanMissions.ipynb b/docs/examples/PlanMissions.ipynb deleted file mode 100644 index ff5a44d3..00000000 --- a/docs/examples/PlanMissions.ipynb +++ /dev/null @@ -1,1815 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "e7977fc4", - "metadata": {}, - "source": [ - "# Plan Missions\n", - "\n", - "This example demonstrates how to account for the deployment and the failures of constellations in a trade study with the `tatc.tradespace` module: the phases of each design's deployment, staged deployments that rules decide on during the mission, simulated failures of satellites and launches restored by policies that are decisions of each design, and the attribution of the spread of the replicates to their uncertain parameters.\n", - "\n", - "It continues the example `SearchTradeSpace`, whose design space and study it imports from `trade_space_example.py` (beside the notebooks). The evaluations of every design are taken from the study's store if `SearchTradeSpace` was run before (or are evaluated again, in a few minutes)." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "1e32ed92", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:21:41.323187Z", - "iopub.status.busy": "2026-11-12T17:21:41.323187Z", - "iopub.status.idle": "2026-11-12T17:21:46.509314Z", - "shell.execute_reply": "2026-11-12T17:21:46.508316Z" - } - }, - "outputs": [], - "source": [ - "import time\n", - "from datetime import timedelta\n", - "\n", - "import pandas as pd\n", - "\n", - "from trade_space_example import ACCURACY, OBJECTIVES, PLAN, START, describe, designs, space, study\n", - "from tatc.tradespace import pareto_front, summarize\n", - "\n", - "# the evaluations of every design, the efficient designs (by sufficiency), and the efficient designs by accuracy\n", - "results = study.run(designs)\n", - "summary = summarize(results, [\"satellites\", \"planes\", \"sufficient\", \"accurate\"])\n", - "summary[\"description\"] = summary.apply(describe, axis=1)\n", - "front = summary[pareto_front(summary, OBJECTIVES)].sort_values([\"satellites\", \"planes\"])\n", - "accuracy = summary[pareto_front(summary, ACCURACY)]" - ] - }, - { - "cell_type": "markdown", - "id": "63cac933", - "metadata": {}, - "source": [ - "## Account for Deployment\n", - "\n", - "The shares of points sampled so far are those of each design's full constellation, as if its satellites flew for the whole mission. They are launched over months to years, during which fewer satellites sample the points. The launches of each design's deployment divide its mission into phases, in each of which a set of its satellites flies (`Deployment.phases`); each phase is evaluated over the same representative day with the observations of its satellites (`evaluate_phases`, which filters the observations of the full constellation, from the cache), and the phases are combined over the mission (`summarize_phases`): the mean of each share weighted by the duration of the phases, over the five years from the first launch (`sufficient mission`), and the time from the start of development until half of the points are sampled sufficiently (`sufficient time`, infinite if never).\n", - "\n", - "The phased study (a variant of the study with the phases, `study.replace`) evaluates the efficient designs of `SearchTradeSpace` (the most sufficient of each number of satellites and planes), with the years by which each is `deployed`." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "3451a5b5", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:21:46.513316Z", - "iopub.status.busy": "2026-11-12T17:21:46.513316Z", - "iopub.status.idle": "2026-11-12T17:22:04.704273Z", - "shell.execute_reply": "2026-11-12T17:22:04.704273Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
descriptionsatellitesplanesdeployedsufficientsufficient missionlostsufficient time
design
163120bf9590800 km, 60 deg FOR, SSO: 1 at 18:001.01.03.23.23.20.0inf
f7413b1f8466800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...2.01.03.516.616.60.0inf
33b006848799800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.03.830.227.32.9inf
d5d3fa915ca7800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...3.01.03.838.038.00.0inf
1af5f2707be3800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.04.568.263.54.74.5
6ba50f2632cd800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.04.069.664.35.34.0
6bef11e40977800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.04.597.887.110.74.5
\n", - "
" - ], - "text/plain": [ - " description satellites \\\n", - "design \n", - "163120bf9590 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 \n", - "f7413b1f8466 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 \n", - "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 \n", - "d5d3fa915ca7 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 \n", - "1af5f2707be3 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 \n", - "6ba50f2632cd 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 \n", - "6bef11e40977 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 \n", - "\n", - " planes deployed sufficient sufficient mission lost \\\n", - "design \n", - "163120bf9590 1.0 3.2 3.2 3.2 0.0 \n", - "f7413b1f8466 1.0 3.5 16.6 16.6 0.0 \n", - "33b006848799 2.0 3.8 30.2 27.3 2.9 \n", - "d5d3fa915ca7 1.0 3.8 38.0 38.0 0.0 \n", - "1af5f2707be3 1.0 4.5 68.2 63.5 4.7 \n", - "6ba50f2632cd 2.0 4.0 69.6 64.3 5.3 \n", - "6bef11e40977 2.0 4.5 97.8 87.1 10.7 \n", - "\n", - " sufficient time \n", - "design \n", - "163120bf9590 inf \n", - "f7413b1f8466 inf \n", - "33b006848799 inf \n", - "d5d3fa915ca7 inf \n", - "1af5f2707be3 4.5 \n", - "6ba50f2632cd 4.0 \n", - "6bef11e40977 4.5 " - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from tatc.tradespace import Requirement, aggregate\n", - "\n", - "# a study of the phases of each design's deployment, and of the years until half of the points are sampled sufficiently\n", - "phased_study = study.replace(phases=[Requirement(\"sufficient\", \">=\", 50)])\n", - "PHASED = [\"sufficient\", \"sufficient mission\", \"sufficient time\", \"deployed\"]\n", - "leaders = front.sort_values(\"sufficient\", ascending=False).drop_duplicates([\"satellites\", \"planes\"])\n", - "phased = phased_study.run(leaders)\n", - "deployed = aggregate(phased, PHASED, design_columns=[]).set_index(\"design\")[PHASED]\n", - "leaders = leaders.set_index(\"design\")[[\"description\", \"satellites\", \"planes\"]].join(deployed)\n", - "leaders[\"lost\"] = leaders[\"sufficient\"] - leaders[\"sufficient mission\"]\n", - "leaders.sort_values([\"satellites\", \"planes\"])[\n", - " [\"description\", \"satellites\", \"planes\", \"deployed\", \"sufficient\", \"sufficient mission\", \"lost\", \"sufficient time\"]\n", - "].round(1)" - ] - }, - { - "cell_type": "markdown", - "id": "f6b53a96", - "metadata": {}, - "source": [ - "Deployment costs the designs of several planes or launches. Six satellites in two planes sample 98% of the points once deployed, but 87% on average over the mission, as the first plane flies alone for three quarters of a year while the second is produced, and they sample half of the points only 4.5 years after development starts, when the second plane is launched. Four satellites in one plane need two launches (of up to three satellites) half a year apart, and lose 5 points of their 68%; four satellites in two planes lose 5 points of their 70%, and two satellites in two planes 3 points of their 30%. The designs launched at once lose nothing. Over a five-year mission, the loss is the share of the mission before full deployment times the shortfall of the partial constellation: a shorter mission, slower production, or fewer launches a year would weigh deployment more, and could reorder the front." - ] - }, - { - "cell_type": "markdown", - "id": "c84d572c", - "metadata": {}, - "source": [ - "Each phase is evaluated over the same day of July, as if the geometry of the satellites and the season were those of that day throughout the mission (quasi-static phases, see `evaluate_phases`). This misses the drift of the relative nodes of planes of different inclinations or altitudes (which precess at different rates), the drift of the local times of planes that are not sun-synchronous, and seasons. Here, the planes of each design share an altitude and an inclination, which keeps their relative geometry, and the shares do not depend on the sun, so the day should represent the mission. Drawing the start of the day for each replicate over a year (the `epoch` of the design space, which `Observations` and the metrics read, as an `Uncertain` parameter of a design space that extends the other, `DesignSpace.extend`) averages the replicates over the drift and the seasons, at the cost of analyzing the satellites again for each day:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "9a399192", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:22:04.704273Z", - "iopub.status.busy": "2026-11-12T17:22:04.704273Z", - "iopub.status.idle": "2026-11-12T17:22:06.223072Z", - "shell.execute_reply": "2026-11-12T17:22:06.221072Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
descriptionsatellitesplanessufficient mission (July)accurate mission (July)sufficient mission (year)accurate mission (year)sufficient mission se (year)accurate mission se (year)
design
163120bf9590800 km, 60 deg FOR, SSO: 1 at 18:001.01.03.22.83.23.00.70.6
f7413b1f8466800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...2.01.016.64.016.22.01.00.7
33b006848799800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.027.330.925.828.81.61.6
d5d3fa915ca7800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...3.01.038.011.437.89.80.50.7
1af5f2707be3800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.063.524.561.722.51.80.8
6ba50f2632cd800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.064.359.362.158.01.51.3
6bef11e40977800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.087.171.186.770.30.20.8
\n", - "
" - ], - "text/plain": [ - " description satellites \\\n", - "design \n", - "163120bf9590 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 \n", - "f7413b1f8466 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 \n", - "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 \n", - "d5d3fa915ca7 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 \n", - "1af5f2707be3 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 \n", - "6ba50f2632cd 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 \n", - "6bef11e40977 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 \n", - "\n", - " planes sufficient mission (July) accurate mission (July) \\\n", - "design \n", - "163120bf9590 1.0 3.2 2.8 \n", - "f7413b1f8466 1.0 16.6 4.0 \n", - "33b006848799 2.0 27.3 30.9 \n", - "d5d3fa915ca7 1.0 38.0 11.4 \n", - "1af5f2707be3 1.0 63.5 24.5 \n", - "6ba50f2632cd 2.0 64.3 59.3 \n", - "6bef11e40977 2.0 87.1 71.1 \n", - "\n", - " sufficient mission (year) accurate mission (year) \\\n", - "design \n", - "163120bf9590 3.2 3.0 \n", - "f7413b1f8466 16.2 2.0 \n", - "33b006848799 25.8 28.8 \n", - "d5d3fa915ca7 37.8 9.8 \n", - "1af5f2707be3 61.7 22.5 \n", - "6ba50f2632cd 62.1 58.0 \n", - "6bef11e40977 86.7 70.3 \n", - "\n", - " sufficient mission se (year) accurate mission se (year) \n", - "design \n", - "163120bf9590 0.7 0.6 \n", - "f7413b1f8466 1.0 0.7 \n", - "33b006848799 1.6 1.6 \n", - "d5d3fa915ca7 0.5 0.7 \n", - "1af5f2707be3 1.8 0.8 \n", - "6ba50f2632cd 1.5 1.3 \n", - "6bef11e40977 0.2 0.8 " - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from tatc.tradespace import Uncertain\n", - "\n", - "# the leading designs, with the day of the analysis drawn for each replicate over a year\n", - "EPOCH = Uncertain(lambda rng: START + timedelta(days=float(rng.uniform(0, 365))))\n", - "epoch_space = space.extend(epoch=EPOCH)\n", - "year = phased_study.replace(space=epoch_space).run(epoch_space.designs_of(front, leaders.index))\n", - "MEANS = [\"sufficient mission\", \"accurate mission\"]\n", - "over_year = summarize(year, MEANS).set_index(\"design\")\n", - "july = aggregate(phased, MEANS).set_index(\"design\")[MEANS]\n", - "leaders[[\"description\", \"satellites\", \"planes\"]].join(july.add_suffix(\" (July)\")).join(\n", - " over_year[[*MEANS, *(f\"{m} se\" for m in MEANS)]].add_suffix(\" (year)\")\n", - ").sort_values([\"satellites\", \"planes\"]).round(1)" - ] - }, - { - "cell_type": "markdown", - "id": "c99a6486", - "metadata": {}, - "source": [ - "Over the year, the means of the leading designs are within 2.2 points of those of the day in July (and within three standard errors of the year's means), most a little lower: the one day represents the mission well here. A constellation of planes at different altitudes or inclinations, metrics that depend on daylight, or a field that varies with the seasons would call for drawing the epoch. The phases also assume that a satellite operates until it fails or is replaced: a design life does not retire a satellite whose replacement is not launched, and a planned replacement whose launch fails is not flown again (see `DeploymentSchedule`)." - ] - }, - { - "cell_type": "markdown", - "id": "8579c533", - "metadata": {}, - "source": [ - "## Stage the Deployment\n", - "\n", - "A deployment need not commit to every plane at once. A stage of a deployment (`Stage`) is a set of planes produced and launched only if a rule decides to, at times during the mission, from what it knows then (a `Decision`: the satellites operating, what they achieve, and the history so far) and from the values of the design, such as its uncertain parameters and its scenario. A stage that is not deployed is neither produced, launched, nor paid for, so that a staged deployment is an option: it saves the cost of a stage where the mission does not need it, and loses what deferring the stage costs where it does (as above, the capability of the satellites not yet launched). Whether and how to stage is a decision of each design (here, a value `staging` of the design space), and the `stages` of a `MissionPlan` are a function of the design.\n", - "\n", - "Here, the design of four satellites most robust to the field whose daily mean is estimated (see `CompareScenarios`: two sun-synchronous planes of two) deploys its second plane at once, never, or only if the field turns out to vary within hours (to decorrelate within 6 hours), as decided at the first launch or a year later. These rules read the field from the scenario, which a mission does not know; the last rule reads what the first plane achieves once it is launched (`Decision.capability`, by the study's metrics), and deploys the second plane if the first samples fewer than half the points accurately. Each staging is evaluated in each field by the phases of its deployment: the mean share of points accurately sampled over the mission, and the present cost:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "7463c0ff", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:22:06.227071Z", - "iopub.status.busy": "2026-11-12T17:22:06.227071Z", - "iopub.status.idle": "2026-11-12T17:22:07.662228Z", - "shell.execute_reply": "2026-11-12T17:22:07.661222Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
accurate missioncost present
scenario1 hour3 hours12 hours1 hour3 hours12 hours
staging
at once62.677.991.0156.4156.4156.4
first plane4.810.073.0118.8118.8118.8
decided at launch62.677.973.0156.4156.4118.8
decided a year later49.762.873.0154.5154.5118.8
measured at launch62.677.973.0156.4156.4118.8
\n", - "
" - ], - "text/plain": [ - " accurate mission cost present \\\n", - "scenario 1 hour 3 hours 12 hours 1 hour 3 hours \n", - "staging \n", - "at once 62.6 77.9 91.0 156.4 156.4 \n", - "first plane 4.8 10.0 73.0 118.8 118.8 \n", - "decided at launch 62.6 77.9 73.0 156.4 156.4 \n", - "decided a year later 49.7 62.8 73.0 154.5 154.5 \n", - "measured at launch 62.6 77.9 73.0 156.4 156.4 \n", - "\n", - " \n", - "scenario 12 hours \n", - "staging \n", - "at once 156.4 \n", - "first plane 118.8 \n", - "decided at launch 118.8 \n", - "decided a year later 118.8 \n", - "measured at launch 118.8 " - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import dataclasses\n", - "\n", - "from tatc.tradespace import Categorical, Stage\n", - "\n", - "# the fields of CompareScenarios: decorrelating within an hour, in 3 hours, and in 12 hours\n", - "FIELDS = {\n", - " \"1 hour\": {\"decorrelation_time\": timedelta(hours=1)},\n", - " \"3 hours\": {},\n", - " \"12 hours\": {\"decorrelation_time\": timedelta(hours=12)},\n", - "}\n", - "STAGING = [\"at once\", \"first plane\", \"decided at launch\", \"decided a year later\", \"measured at launch\"]\n", - "staging_space = space.extend(staging=Categorical(STAGING))\n", - "\n", - "\n", - "def stages(d):\n", - " \"\"\"The stages of a design's deployment: its second plane deployed with the first (at once), never (first plane),\n", - " or if the field decorrelates within 6 hours, as decided at the first launch or a year later, or if the first plane\n", - " accurately samples fewer than half the points, as measured at the first launch.\"\"\"\n", - " if d.staging == \"at once\":\n", - " return []\n", - " if d.staging == \"first plane\":\n", - " return [Stage(1, 0.0, lambda decision: False)]\n", - " if d.staging == \"measured at launch\":\n", - " return [Stage(1, 0.0, lambda decision: decision.capability[\"accurate\"] < 50)]\n", - " when = 0.0 if d.staging == \"decided at launch\" else 1.0\n", - " return [Stage(1, when, lambda decision: d.decorrelation_time < timedelta(hours=6))]\n", - "\n", - "\n", - "# the design of four satellites most robust to the field (see CompareScenarios), with each staging of its deployment, in\n", - "# each field\n", - "(four,) = space.designs_of(summary[summary.description == \"800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00\"])\n", - "staged = phased_study.replace(\n", - " space=staging_space, plan=dataclasses.replace(PLAN, stages=stages), scenarios=FIELDS\n", - ").run([staging_space.design(four, staging=option) for option in STAGING])\n", - "staged.groupby([\"staging\", \"scenario\"], sort=False)[[\"accurate mission\", \"cost present\"]].mean().unstack(\"scenario\").round(1)" - ] - }, - { - "cell_type": "markdown", - "id": "502d3883", - "metadata": {}, - "source": [ - "Deciding at the first launch is worth the most. Where the field varies within hours, the second plane is produced and launched as if it were deployed at once (63% and 78% of the points accurately sampled on average over the mission, for 156 million dollars), and where it varies slowly, it is not, which saves 38 million dollars (24%) for 18 points of the mean (73% against 91%): a trade that the rule makes, and that a mission might not. Deciding a year later costs the fields that need the second plane 13 to 15 points of the mean (50% and 63%), as the first plane flies alone for a year more, and saves only 2 million dollars, by discounting the later production. The value of the option is that of knowing the need when it is exercised: the earlier the field is known, the more staging saves at less loss. The rule that measures makes the same choices as the rule that reads the field, in every field: the first plane alone accurately samples 5% and 10% of the points where the field varies within hours, so that the second plane is deployed, and 73% where it varies over 12 hours, so that it is not. A mission knows what its satellites achieve, not the field, so this is a rule it could follow; a measurement takes time, though (the rule reads at once the capability that the study computes), and one that waits a year to measure loses what deciding a year later loses above. A rule may also read the satellites still operating (see `Decision`), for a reserve plane launched only if satellites fail, or their capability, for one launched only if those in orbit fall short." - ] - }, - { - "cell_type": "markdown", - "id": "b8848349", - "metadata": {}, - "source": [ - "## Plan for Failures\n", - "\n", - "A design that needs every satellite to work is fragile, and what failures cost depends on how the mission responds to them. A `FailureModel` gives the life of the satellites from their launch, here a bathtub curve of infant mortality, random failures, and wear-out (`Bathtub` of `Weibull` and `Exponential` lives, illustrative), and the probability that a launch fails. Each replicate simulates the mission of a design with failures drawn from its seed (`Deployment.simulate`, with common random numbers: the satellite at the same position of the same plane fails at the same age in every design), and a `RestorationPolicy` responds to them:\n", - "\n", - "* **degrade**: fly the satellites that remain;\n", - "* **produce**: restore each failed satellite by producing a new one (after half a year of procurement, on the production line) and launching it;\n", - "* **spare in orbit**: a spare in each plane, launched with it, takes a failed satellite's place within months (others are produced), and is produced again;\n", - "* **spare on ground**: a spare, produced after the first satellites and stored, is launched at the next slot (others are produced), and is produced again.\n", - "\n", - "The policy is a decision of each design: a fragment of the design space (`policy_space`) decides whether to restore failed satellites, and the spares in orbit (in each plane) and on the ground (here, none or one of each, and none without restoration, which would never use them), and configures the policy of each design (from a base policy of half a year of procurement and spares that are produced again). The efficient designs by accuracy, each with each of the five policies, form a design space of both (one that extends the other with the policy, `DesignSpace.extend`), in which each history gives both the cost of what is produced and launched (the restorations and spares, and the launches that fail) and the phases in which its satellites operate, evaluated as in the previous section: the share of points accurately sampled on average over the mission, and in the worst 10% of the histories, and the cost at 70% confidence.\n", - "\n", - "The failures are cheap to simulate, but each phase's share is expensive to evaluate, and most phases repeat the same sets of operating satellites. Each replicate (a sample of points, the expensive part) therefore simulates 20 histories of the failures of its mission (`Failures` of the study, with `Deployment.simulate_many`, stratified: a Latin hypercube over the histories in which each satellite's life and each launch draws from its own stratum of its distribution, which estimates means several times more precisely than independent histories), evaluates them together (`evaluate_missions`) with a cache that evaluates each set of satellites once (`PhaseCache`, shared by the histories, policies, and designs of a replicate), and summarizes them (`summarize_missions`): their mean share, and their worst 10% (the risk of the mission), and their cost at 70% confidence. Five replicates of 20 histories measure the risk of each mission with 100 histories, at a fraction of the cost of 100 replicates. Without restoration (degrading), the satellites fail independently, so that the mean share over the failures is computed exactly (`expected_missions`, from the probability that each set of satellites operates), without sampling error; its worst 10% and cost still come from the histories." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "75613a88", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:22:07.664250Z", - "iopub.status.busy": "2026-11-12T17:22:07.664250Z", - "iopub.status.idle": "2026-11-12T17:22:23.155533Z", - "shell.execute_reply": "2026-11-12T17:22:23.155533Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "37% of the satellites fail in 5 years\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "65 designs x 5 replicates x 20 histories in 10 s\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
descriptionfull constellationaccurateaccurate p10cost p70
policydegradeproducespare in orbitspare on groundspares in orbit and on grounddegradeproducespare in orbitspare on groundspares in orbit and on grounddegradeproducespare in orbitspare on groundspares in orbit and on ground
base
9b3481aea973800 km, 60 deg FOR, SSO: 1 at 12:003.43.23.94.04.14.00.43.53.73.73.7110.2130.6147.6146.3162.2
fac5d43a19c7800 km, 60 deg FOR, SSO: 2 at 06:0010.07.09.29.69.89.72.17.38.38.68.7128.9153.4170.3170.0184.3
b85daf65c3a4800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...16.710.914.814.716.014.94.612.212.914.313.3146.2188.2211.1204.4223.3
104e33a3c842800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac...29.316.122.324.424.424.96.118.020.421.021.9170.2218.9237.7235.8249.8
33b006848799800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...33.017.726.128.228.928.50.619.525.125.625.6136.5159.4192.7175.2206.4
c576e2e2dbd1800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:0057.033.147.350.751.751.27.138.544.744.946.8153.9198.1229.3212.4240.1
f216ec70e160800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac...60.432.944.948.048.148.39.537.743.042.443.5161.2201.0247.9216.8260.4
3690f1194419800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:0082.850.768.568.872.569.310.856.261.362.263.1170.4218.3246.8235.4260.7
cb6bd361b577800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...96.075.881.276.381.576.260.473.869.873.969.6246.8326.4376.7347.0389.6
716cb479efda700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...97.064.278.074.279.674.338.970.167.371.566.9209.5278.8316.7294.4329.0
5529c21520be800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...98.379.382.876.882.876.966.478.171.678.271.6253.5340.0394.6355.7405.7
679ca275c8fc800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...98.379.583.076.883.076.869.078.772.178.672.1253.5340.0394.6355.7405.7
de505bc89299800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...98.379.582.976.983.076.968.078.771.778.471.7253.5340.0394.6355.7405.7
\n", - "
" - ], - "text/plain": [ - " description \\\n", - "policy \n", - "base \n", - "9b3481aea973 800 km, 60 deg FOR, SSO: 1 at 12:00 \n", - "fac5d43a19c7 800 km, 60 deg FOR, SSO: 2 at 06:00 \n", - "b85daf65c3a4 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... \n", - "104e33a3c842 800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac... \n", - "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", - "c576e2e2dbd1 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 \n", - "f216ec70e160 800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac... \n", - "3690f1194419 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 \n", - "cb6bd361b577 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... \n", - "716cb479efda 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", - "5529c21520be 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", - "679ca275c8fc 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", - "de505bc89299 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", - "\n", - " full constellation accurate \\\n", - "policy degrade produce spare in orbit \n", - "base \n", - "9b3481aea973 3.4 3.2 3.9 4.0 \n", - "fac5d43a19c7 10.0 7.0 9.2 9.6 \n", - "b85daf65c3a4 16.7 10.9 14.8 14.7 \n", - "104e33a3c842 29.3 16.1 22.3 24.4 \n", - "33b006848799 33.0 17.7 26.1 28.2 \n", - "c576e2e2dbd1 57.0 33.1 47.3 50.7 \n", - "f216ec70e160 60.4 32.9 44.9 48.0 \n", - "3690f1194419 82.8 50.7 68.5 68.8 \n", - "cb6bd361b577 96.0 75.8 81.2 76.3 \n", - "716cb479efda 97.0 64.2 78.0 74.2 \n", - "5529c21520be 98.3 79.3 82.8 76.8 \n", - "679ca275c8fc 98.3 79.5 83.0 76.8 \n", - "de505bc89299 98.3 79.5 82.9 76.9 \n", - "\n", - " accurate p10 \\\n", - "policy spare on ground spares in orbit and on ground degrade \n", - "base \n", - "9b3481aea973 4.1 4.0 0.4 \n", - "fac5d43a19c7 9.8 9.7 2.1 \n", - "b85daf65c3a4 16.0 14.9 4.6 \n", - "104e33a3c842 24.4 24.9 6.1 \n", - "33b006848799 28.9 28.5 0.6 \n", - "c576e2e2dbd1 51.7 51.2 7.1 \n", - "f216ec70e160 48.1 48.3 9.5 \n", - "3690f1194419 72.5 69.3 10.8 \n", - "cb6bd361b577 81.5 76.2 60.4 \n", - "716cb479efda 79.6 74.3 38.9 \n", - "5529c21520be 82.8 76.9 66.4 \n", - "679ca275c8fc 83.0 76.8 69.0 \n", - "de505bc89299 83.0 76.9 68.0 \n", - "\n", - " \\\n", - "policy produce spare in orbit spare on ground \n", - "base \n", - "9b3481aea973 3.5 3.7 3.7 \n", - "fac5d43a19c7 7.3 8.3 8.6 \n", - "b85daf65c3a4 12.2 12.9 14.3 \n", - "104e33a3c842 18.0 20.4 21.0 \n", - "33b006848799 19.5 25.1 25.6 \n", - "c576e2e2dbd1 38.5 44.7 44.9 \n", - "f216ec70e160 37.7 43.0 42.4 \n", - "3690f1194419 56.2 61.3 62.2 \n", - "cb6bd361b577 73.8 69.8 73.9 \n", - "716cb479efda 70.1 67.3 71.5 \n", - "5529c21520be 78.1 71.6 78.2 \n", - "679ca275c8fc 78.7 72.1 78.6 \n", - "de505bc89299 78.7 71.7 78.4 \n", - "\n", - " cost p70 \\\n", - "policy spares in orbit and on ground degrade produce spare in orbit \n", - "base \n", - "9b3481aea973 3.7 110.2 130.6 147.6 \n", - "fac5d43a19c7 8.7 128.9 153.4 170.3 \n", - "b85daf65c3a4 13.3 146.2 188.2 211.1 \n", - "104e33a3c842 21.9 170.2 218.9 237.7 \n", - "33b006848799 25.6 136.5 159.4 192.7 \n", - "c576e2e2dbd1 46.8 153.9 198.1 229.3 \n", - "f216ec70e160 43.5 161.2 201.0 247.9 \n", - "3690f1194419 63.1 170.4 218.3 246.8 \n", - "cb6bd361b577 69.6 246.8 326.4 376.7 \n", - "716cb479efda 66.9 209.5 278.8 316.7 \n", - "5529c21520be 71.6 253.5 340.0 394.6 \n", - "679ca275c8fc 72.1 253.5 340.0 394.6 \n", - "de505bc89299 71.7 253.5 340.0 394.6 \n", - "\n", - " \n", - "policy spare on ground spares in orbit and on ground \n", - "base \n", - "9b3481aea973 146.3 162.2 \n", - "fac5d43a19c7 170.0 184.3 \n", - "b85daf65c3a4 204.4 223.3 \n", - "104e33a3c842 235.8 249.8 \n", - "33b006848799 175.2 206.4 \n", - "c576e2e2dbd1 212.4 240.1 \n", - "f216ec70e160 216.8 260.4 \n", - "3690f1194419 235.4 260.7 \n", - "cb6bd361b577 347.0 389.6 \n", - "716cb479efda 294.4 329.0 \n", - "5529c21520be 355.7 405.7 \n", - "679ca275c8fc 355.7 405.7 \n", - "de505bc89299 355.7 405.7 " - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from tatc.tradespace import (\n", - " Bathtub,\n", - " Exponential,\n", - " FailureModel,\n", - " Failures,\n", - " Integer,\n", - " RestorationPolicy,\n", - " Weibull,\n", - " policy_space,\n", - ")\n", - "\n", - "# illustrative lives: about 9% fail in their first year, 3% a year at random, and wear-out after about 8 years\n", - "FAILURE_MODEL = FailureModel(\n", - " life=Bathtub(infant=Weibull(shape=0.5, scale=100), random=Exponential(0.03), wear_out=Weibull(shape=4, scale=9)),\n", - " launch=0.05,\n", - ")\n", - "print(f\"{1 - FAILURE_MODEL.life.survival(5):.0%} of the satellites fail in 5 years\")\n", - "BASE_POLICY = RestorationPolicy(procurement_years=0.5, replenish=True)\n", - "POLICY = policy_space(orbit_spares=Integer(0, 1), ground_spares=Integer(0, 1), replenish=True)\n", - "\n", - "# the design space with a policy, and the efficient designs by accuracy with each policy\n", - "policy_trade = space.extend(policy=POLICY)\n", - "with_policies, base_of = [], {}\n", - "for base in space.designs_of(accuracy):\n", - " for policy in POLICY.enumerate():\n", - " design = policy_trade.design(base, policy=policy)\n", - " with_policies.append(design)\n", - " base_of[design.key] = base.key\n", - "\n", - "\n", - "def describe_policy(row):\n", - " \"\"\"A short description of a policy.\"\"\"\n", - " if not row[\"policy.restore\"]:\n", - " return \"degrade\"\n", - " orbit, ground = row[\"policy.orbit_spares\"] > 0, row[\"policy.ground_spares\"] > 0\n", - " return {\n", - " (False, False): \"produce\",\n", - " (True, False): \"spare in orbit\",\n", - " (False, True): \"spare on ground\",\n", - " (True, True): \"spares in orbit and on ground\",\n", - " }[orbit, ground]\n", - "\n", - "\n", - "# 20 histories of each replicate, restored by the policy of each design, with the mean share accurately sampled over\n", - "# the mission in the worst 10% of the histories, and the cost at 70% confidence (over the histories)\n", - "FAILURES = Failures(\n", - " FAILURE_MODEL, BASE_POLICY, histories=20, seed=\"failure_seed\", quantiles={\"accurate mission\": 0.1, \"cost\": 0.7}\n", - ")\n", - "failures_study = study.replace(space=policy_trade, failures=FAILURES)\n", - "began = time.perf_counter()\n", - "trades = failures_study.run(with_policies)\n", - "print(f\"{len(with_policies)} designs x 5 replicates x 20 histories in {time.perf_counter() - began:.0f} s\")\n", - "# the means over the replicates of the histories' mean share, worst 10%, and cost at 70% confidence\n", - "ROBUST = {\"accurate\": \"accurate mission\", \"accurate p10\": \"accurate mission histories p10\", \"cost p70\": \"cost histories p70\"}\n", - "traded = aggregate(trades, statistics=ROBUST).set_index(\"design\")\n", - "traded[\"policy\"] = traded.apply(describe_policy, axis=1)\n", - "traded[\"base\"] = [base_of[key] for key in traded.index]\n", - "traded = traded[[*ROBUST, \"policy\", \"base\"]]\n", - "\n", - "# the shares of the full constellations, without deployment or failures, for comparison\n", - "nominal = study.replace(replicates=20).run(accuracy)\n", - "full = aggregate(nominal, [\"accurate\"]).set_index(\"design\")[\"accurate\"]\n", - "descriptions = accuracy.set_index(\"design\")[\"description\"]\n", - "ORDER = [\"degrade\", \"produce\", \"spare in orbit\", \"spare on ground\", \"spares in orbit and on ground\"]\n", - "table = traded.pivot(index=\"base\", columns=\"policy\", values=list(ROBUST))\n", - "table = table[[(metric, policy) for metric in ROBUST for policy in ORDER]]\n", - "table.insert(0, (\"full constellation\", \"\"), full.reindex(table.index))\n", - "table.insert(0, (\"description\", \"\"), descriptions.reindex(table.index))\n", - "table.sort_values((\"full constellation\", \"\")).round(1)" - ] - }, - { - "cell_type": "markdown", - "id": "d52db10b", - "metadata": {}, - "source": [ - "The 6,500 histories (100 of each of the 65 designs and policies) take about ten seconds here. The shares accurately sampled over the mission fall short of those of the full constellation under every policy, by the phases of deployment and the failures of launches as well as of satellites (37% of which fail within five years), but for the single satellite, whose shares differ by less than the sampling error of five replicates (the full constellation's are of 20). The response to failures matters most for the designs of several satellites in several planes, and in their worst histories:\n", - "\n", - "* **Degrading** is cheapest, but loses 12 to 18 points of the mean against producing replacements for the designs of three to six satellites in two or three planes, and more in their worst 10% of histories (39% against 70% for six satellites in three Walker planes; 1% against 20% for two satellites in two planes, which can lose both). Nine satellites in three planes lose only 3.5 points: a failure leaves eight. The means of degrading are exact (`expected_missions`); those of the other policies are estimates from 100 histories.\n", - "* **Producing replacements** restores most of it, at 17 to 34% more cost at 70% confidence than degrading.\n", - "* **Spares** cost 28 to 56% more than degrading (up to 62% for spares both in orbit and on the ground), and pay off in the worst histories of the small designs of several planes: two satellites in two planes keep about 25% in their worst histories with a spare, against 20% by producing replacements. A spare on the ground costs less than a spare in each plane for the designs of several planes, and restores as well or better.\n", - "* **A spare in orbit can hurt**: for six to nine satellites in three or four planes, the spares delay the deployment (each plane waits for its spare to be produced, and a fourth satellite in a plane of three takes a second launch), so that they sample less on average (74% against 78% for six satellites, 76% against 81% for eight, 77% against 83% for nine) at a higher cost. Spares in orbit and on the ground together cost the most, and sample about as much as a spare on the ground alone, or less." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "20cc9f3e", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:22:23.155533Z", - "iopub.status.busy": "2026-11-12T17:22:23.155533Z", - "iopub.status.idle": "2026-11-12T17:22:23.171508Z", - "shell.execute_reply": "2026-11-12T17:22:23.171508Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
descriptionpolicyaccurateaccurate p10cost p70
design
2a310c00151b800 km, 60 deg FOR, SSO: 1 at 12:00degrade3.20.4110.2
bc2076a0d3d8800 km, 60 deg FOR, SSO: 2 at 06:00degrade7.02.1128.9
bb6574900ac3800 km, 60 deg FOR, SSO: 1 at 12:00produce3.93.5130.6
638697713902800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...degrade10.94.6146.2
43f50c8bc38a800 km, 60 deg FOR, SSO: 2 at 06:00produce9.27.3153.4
ad99c42082ab800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...produce26.119.5159.4
cc2e14e787ff800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...spare on ground28.925.6175.2
eeb7c70a720b800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00produce47.338.5198.1
3a902b976460700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...degrade64.238.9209.5
6d54bdbf4648800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00spare on ground51.744.9212.4
1afde0569e34800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00produce68.556.2218.3
e7721a705c31800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00spare on ground72.562.2235.4
46932f795a5a800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...degrade79.569.0253.5
6e4564d2ae2c700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...produce78.070.1278.8
570a452fdb8f700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...spare on ground79.671.5294.4
2b499d154a98800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...produce81.273.8326.4
a37619256b26800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...produce83.078.7340.0
\n", - "
" - ], - "text/plain": [ - " description \\\n", - "design \n", - "2a310c00151b 800 km, 60 deg FOR, SSO: 1 at 12:00 \n", - "bc2076a0d3d8 800 km, 60 deg FOR, SSO: 2 at 06:00 \n", - "bb6574900ac3 800 km, 60 deg FOR, SSO: 1 at 12:00 \n", - "638697713902 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... \n", - "43f50c8bc38a 800 km, 60 deg FOR, SSO: 2 at 06:00 \n", - "ad99c42082ab 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", - "cc2e14e787ff 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", - "eeb7c70a720b 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 \n", - "3a902b976460 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", - "6d54bdbf4648 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 \n", - "1afde0569e34 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 \n", - "e7721a705c31 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 \n", - "46932f795a5a 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", - "6e4564d2ae2c 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", - "570a452fdb8f 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", - "2b499d154a98 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... \n", - "a37619256b26 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", - "\n", - " policy accurate accurate p10 cost p70 \n", - "design \n", - "2a310c00151b degrade 3.2 0.4 110.2 \n", - "bc2076a0d3d8 degrade 7.0 2.1 128.9 \n", - "bb6574900ac3 produce 3.9 3.5 130.6 \n", - "638697713902 degrade 10.9 4.6 146.2 \n", - "43f50c8bc38a produce 9.2 7.3 153.4 \n", - "ad99c42082ab produce 26.1 19.5 159.4 \n", - "cc2e14e787ff spare on ground 28.9 25.6 175.2 \n", - "eeb7c70a720b produce 47.3 38.5 198.1 \n", - "3a902b976460 degrade 64.2 38.9 209.5 \n", - "6d54bdbf4648 spare on ground 51.7 44.9 212.4 \n", - "1afde0569e34 produce 68.5 56.2 218.3 \n", - "e7721a705c31 spare on ground 72.5 62.2 235.4 \n", - "46932f795a5a degrade 79.5 69.0 253.5 \n", - "6e4564d2ae2c produce 78.0 70.1 278.8 \n", - "570a452fdb8f spare on ground 79.6 71.5 294.4 \n", - "2b499d154a98 produce 81.2 73.8 326.4 \n", - "a37619256b26 produce 83.0 78.7 340.0 " - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# the efficient designs and policies, by their cost and their accuracy in the worst 10% of the histories\n", - "efficient = traded[pareto_front(traded, {\"cost p70\": \"min\", \"accurate p10\": \"max\"})]\n", - "efficient.assign(description=descriptions.reindex(efficient.base).to_numpy()).sort_values(\"cost p70\")[\n", - " [\"description\", \"policy\", \"accurate\", \"accurate p10\", \"cost p70\"]\n", - "].round(1)" - ] - }, - { - "cell_type": "markdown", - "id": "30d0967a", - "metadata": {}, - "source": [ - "The front of cost at 70% confidence against the share accurately sampled in the worst 10% of the histories chooses designs and policies together. Along it, degrading is the cheapest policy of a design and restoring buys robustness: two satellites in two Walker planes keep 20% of the points accurately sampled in their worst histories if they produce replacements (159 million) and 26% with a spare on the ground (175 million); six satellites in three Walker planes keep 39%, 70%, and 72% if they degrade, produce replacements, or keep a spare on the ground, for 210, 279, and 294 million. Nine satellites in three planes degrade gracefully (69% in their worst histories for 254 million), and producing replacements raises them to 79% for 340 million. A spare on the ground is efficient for designs of two to six satellites, but a spare in orbit is not efficient for any design here, as it delays the deployment. The policy that a design deserves depends on the design, which is why the policy is a decision of the design rather than of the study." - ] - }, - { - "cell_type": "markdown", - "id": "06e6d4fc", - "metadata": {}, - "source": [ - "## Find What Spreads the Replicates\n", - "\n", - "The replicates of a design differ by its uncertain parameters: here, the sample of points (`points_seed`), the histories of failures (`failure_seed`), and the growth of the cost of development (`cost_growth`, see `TradeCostAndUtility`). Which of them spreads an objective says what would sharpen it: the spread from the sample of points and from the histories is noise of the estimates, which more points or more histories reduce, and that from the growth of costs is a risk of the mission. `attribute_variance` finds it by evaluating each design again with one parameter drawn as in other replicates and the others held, which works for parameters whose values do not relate to the outcomes in any order, such as seeds. The total share of a parameter is the share of the variance between replicates that it causes, alone or with others (near 0 if it does not matter), with its standard error (`se`, by a bootstrap of the replicates); its first share (`summary(\"first\")`) is the share that knowing it would remove. Here, for the efficient designs and policies of the study of failures, from 20 replicates, 20 more, and 20 with each parameter drawn as in the second 20:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "1b38f451", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:22:23.171508Z", - "iopub.status.busy": "2026-11-12T17:22:23.171508Z", - "iopub.status.idle": "2026-11-12T17:23:12.742254Z", - "shell.execute_reply": "2026-11-12T17:23:12.741355Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1700 evaluations in 50 s\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
accurate missionaccurate mission histories p10cost histories p70accurate mission seaccurate mission histories p10 secost histories p70 se
parameter
points_seed92.430.40.06.43.30.0
failure_seed3.667.035.80.76.57.1
cost_growth0.00.081.80.00.019.0
\n", - "
" - ], - "text/plain": [ - " accurate mission accurate mission histories p10 \\\n", - "parameter \n", - "points_seed 92.4 30.4 \n", - "failure_seed 3.6 67.0 \n", - "cost_growth 0.0 0.0 \n", - "\n", - " cost histories p70 accurate mission se \\\n", - "parameter \n", - "points_seed 0.0 6.4 \n", - "failure_seed 35.8 0.7 \n", - "cost_growth 81.8 0.0 \n", - "\n", - " accurate mission histories p10 se cost histories p70 se \n", - "parameter \n", - "points_seed 3.3 0.0 \n", - "failure_seed 6.5 7.1 \n", - "cost_growth 0.0 19.0 " - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from tatc.tradespace import attribute_variance\n", - "\n", - "# the shares (%) of the variance between the replicates of the efficient designs and policies that each uncertain\n", - "# parameter causes, alone or with others, from 20 replicates, 20 more, and 20 with each parameter drawn as in the\n", - "# second 20\n", - "began = time.perf_counter()\n", - "attribution = attribute_variance(\n", - " failures_study, list(ROBUST.values()), policy_trade.designs_of(trades, efficient.index), replicates=20\n", - ")\n", - "print(f\"{len(attribution.results)} evaluations in {time.perf_counter() - began:.0f} s\")\n", - "attribution.summary().mul(100).round(1)" - ] - }, - { - "cell_type": "markdown", - "id": "d87e67ee", - "metadata": {}, - "source": [ - "The attribution takes 1,700 evaluations (85 of them those of the study above), under a minute here. The sample of points spreads the mean shares accurately sampled (92% of their variance between replicates), and the failures hardly do (4%): the means of degrading are exact, and those of the other policies average 20 histories. The share in the worst 10% of the histories is spread mostly by the failures (67%, and 30% by the points), as a quantile of 20 histories is a noisy estimate. Both are noise of the estimates rather than risks of the missions, and they call for different remedies: more points would sharpen the means, and more histories in each replicate the worst 10%, which is cheap (the 6,500 histories above take about ten seconds). The cost at 70% confidence of a replicate is spread by the growth of the cost of development (82%), a risk of the mission, and by the failures (36%), which cost replacements and spares for the policies that restore satellites; these shares are the least certain (standard errors of 19 and 7 points). The total shares of each objective sum to about 1 within their errors, so the parameters hardly interact." - ] - }, - { - "cell_type": "markdown", - "id": "58faf51f", - "metadata": {}, - "source": [ - "The order of designs on the front is settled by their differences, in which the parameters that act alike on two designs cancel (with common random numbers, the designs of a replicate share its parameters). `differences` attributes the variance of the differences between pairs of designs, from the same evaluations: here, between the designs and policies adjacent along the front, by cost at 70% confidence:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "f396b1dc", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:23:12.742254Z", - "iopub.status.busy": "2026-11-12T17:23:12.742254Z", - "iopub.status.idle": "2026-11-12T17:23:13.026475Z", - "shell.execute_reply": "2026-11-12T17:23:13.026475Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
accurate missionaccurate mission histories p10cost histories p70accurate mission seaccurate mission histories p10 secost histories p70 se
parameter
points_seed92.130.40.06.44.50.0
failure_seed2.973.0105.80.56.54.7
cost_growth0.00.00.00.00.00.0
\n", - "
" - ], - "text/plain": [ - " accurate mission accurate mission histories p10 \\\n", - "parameter \n", - "points_seed 92.1 30.4 \n", - "failure_seed 2.9 73.0 \n", - "cost_growth 0.0 0.0 \n", - "\n", - " cost histories p70 accurate mission se \\\n", - "parameter \n", - "points_seed 0.0 6.4 \n", - "failure_seed 105.8 0.5 \n", - "cost_growth 0.0 0.0 \n", - "\n", - " accurate mission histories p10 se cost histories p70 se \n", - "parameter \n", - "points_seed 4.5 0.0 \n", - "failure_seed 6.5 4.7 \n", - "cost_growth 0.0 0.0 " - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# the shares (%) of the variance of the differences between the efficient designs and policies adjacent along the\n", - "# front (by cost), from the same evaluations\n", - "ordered = efficient.sort_values(\"cost p70\").index\n", - "attribution.differences(list(zip(ordered, ordered[1:]))).summary().mul(100).round(1)" - ] - }, - { - "cell_type": "markdown", - "id": "049b3f94", - "metadata": {}, - "source": [ - "The growth of the cost of development cancels in every difference: all of these designs fly the same imager, whose development grows alike, so that it is a risk of each mission but not a reason to prefer one of them to another, and the failures alone unsettle the order of their costs (all of the variance of the differences, 106 ± 5%). The shares accurately sampled differ by the parameters that spread them: by the sample of points for the means (92%), and mostly by the histories for the worst 10% (73%, and 30% by the points). More points would settle the order of neighbors by their means, and more histories their order by the worst 10% and by cost." - ] - }, - { - "cell_type": "markdown", - "id": "5a85b602", - "metadata": {}, - "source": [ - "## Summary\n", - "\n", - "* A `DeploymentSchedule` plans each design's deployment from rates of production and launch, which divides its mission into phases of the satellites that fly, evaluated with the observations of the full constellation (over one day, which an epoch drawn for each replicate shows to represent the mission here) for the mean capability over the mission and the time until a requirement is met.\n", - "* A `Stage` of a deployment is produced and launched only if a rule decides to, from what is known then (a `Decision`) and the values of the design: an option whose value the analyses of a study measure (here, deciding at the first launch whether the field needs a second plane saves 38 million dollars where it does not, at no loss where it does, and deciding a year later loses 13 to 15 points of the mean where it does). A rule may read what the satellites in orbit achieve (`Decision.capability`): here, a second plane deployed if the first accurately samples fewer than half the points makes the same choices without knowing the field.\n", - "* Simulated missions draw the failures of satellites and launches from lives whose failure rates vary over the lifecycle (`FailureModel`), and restore them or not (`RestorationPolicy`, by spares in orbit or on the ground, or by producing new ones), for both the cost and the capability of each policy (exactly, without sampling, for missions that do not restore failed satellites); the policy is a decision of each design (`policy_space`), on the front with the design.\n", - "* `attribute_variance` finds the uncertain parameters that spread the replicates of each design (by drawing each again with the others held): here, the sample of points spreads the mean shares and the histories of failures their worst 10%, which says what would sharpen each, and the growth of costs spreads the costs of designs alike, so that it cancels in their differences (`Attribution.differences`) and does not change their order." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/examples/RankUncertainDesigns.ipynb b/docs/examples/RankUncertainDesigns.ipynb deleted file mode 100644 index 7b13c9c6..00000000 --- a/docs/examples/RankUncertainDesigns.ipynb +++ /dev/null @@ -1,1878 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "5f89aadc", - "metadata": {}, - "source": [ - "# Rank Uncertain Designs\n", - "\n", - "This example demonstrates how to rank designs whose objectives are uncertain with the `tatc.tradespace` module: the probability that each design is Pareto-efficient given the uncertainty of its replicates, replicates added only where they settle it, new replicates that confirm the selected designs, and statistics other than means that state how reliably a design performs.\n", - "\n", - "It continues the example `SearchTradeSpace`, whose design space and study it imports from `trade_space_example.py` (beside the notebooks). The evaluations of every design are taken from the study's store if `SearchTradeSpace` was run before (or are evaluated again, in a few minutes). Its objectives are the numbers of satellites and of planes and the share of points sufficiently sampled (at least four times a day), estimated from five replicates (samples of points) of each design." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "1b487226", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:17:26.254890Z", - "iopub.status.busy": "2026-11-12T17:17:26.254890Z", - "iopub.status.idle": "2026-11-12T17:17:29.338186Z", - "shell.execute_reply": "2026-11-12T17:17:29.338186Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "5480 evaluations: 1096 designs x 5 replicates\n" - ] - } - ], - "source": [ - "import pandas as pd\n", - "\n", - "from trade_space_example import OBJECTIVES, describe, designs, study\n", - "\n", - "# the evaluations of every design\n", - "results = study.run(designs)\n", - "print(f\"{len(results)} evaluations: {len(designs)} designs x {study.replicates} replicates\")" - ] - }, - { - "cell_type": "markdown", - "id": "a64b6506", - "metadata": {}, - "source": [ - "## Rank Designs with the Uncertainty of Replicates\n", - "\n", - "The means of five replicates are uncertain, and so is the front of the means: a design just behind another in the means may be ahead of it in other samples of points. `pareto_probability` estimates the probability that each design is efficient by a bootstrap: it resamples the replicates (the same replicates for every design, which keeps the correlation between designs of common random numbers) and counts how often each design is on the front of the resampled means." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "f030cd39", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:17:29.340647Z", - "iopub.status.busy": "2026-11-12T17:17:29.340647Z", - "iopub.status.idle": "2026-11-12T17:17:30.653695Z", - "shell.execute_reply": "2026-11-12T17:17:30.653695Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
descriptionsatellitesplanessufficientparetopareto_probability
1017800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac...1.01.02.8False0.38
776700 km, 60 deg FOR, SSO: 1 at 12:001.01.03.0False0.20
1048800 km, 60 deg FOR, SSO: 1 at 09:001.01.03.0False0.12
1050800 km, 60 deg FOR, SSO: 1 at 12:001.01.03.0False0.10
1052800 km, 60 deg FOR, SSO: 1 at 15:001.01.03.0False0.12
1054800 km, 60 deg FOR, SSO: 1 at 18:001.01.03.2True0.54
960800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...2.01.016.6True0.98
963800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.030.2True1.00
961800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...3.01.038.0True1.00
972800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...3.03.037.6False0.32
971800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...3.03.037.8False0.29
962800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.068.2True1.00
965800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.069.6True0.92
1026800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.6False0.32
1025800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.8True1.00
\n", - "
" - ], - "text/plain": [ - " description satellites planes \\\n", - "1017 800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac... 1.0 1.0 \n", - "776 700 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", - "1048 800 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", - "1050 800 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", - "1052 800 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", - "1054 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", - "960 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 1.0 \n", - "963 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", - "961 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 1.0 \n", - "972 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", - "971 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", - "962 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", - "965 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", - "1026 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", - "1025 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", - "\n", - " sufficient pareto pareto_probability \n", - "1017 2.8 False 0.38 \n", - "776 3.0 False 0.20 \n", - "1048 3.0 False 0.12 \n", - "1050 3.0 False 0.10 \n", - "1052 3.0 False 0.12 \n", - "1054 3.2 True 0.54 \n", - "960 16.6 True 0.98 \n", - "963 30.2 True 1.00 \n", - "961 38.0 True 1.00 \n", - "972 37.6 False 0.32 \n", - "971 37.8 False 0.29 \n", - "962 68.2 True 1.00 \n", - "965 69.6 True 0.92 \n", - "1026 97.6 False 0.32 \n", - "1025 97.8 True 1.00 " - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from tatc.tradespace import pareto_probability\n", - "\n", - "probability = pareto_probability(results, OBJECTIVES, n_resamples=1000)\n", - "probability[\"description\"] = probability.apply(describe, axis=1)\n", - "candidates = probability[probability.pareto_probability >= 0.1].sort_values([\"satellites\", \"planes\", \"sufficient\"])\n", - "candidates[[\"description\", \"satellites\", \"planes\", \"sufficient\", \"pareto\", \"pareto_probability\"]].round(2)" - ] - }, - { - "cell_type": "markdown", - "id": "9b971b54", - "metadata": {}, - "source": [ - "Four of the seven efficient designs are efficient in every resample: two satellites in two planes, three or four satellites in one plane, and six in two planes; two satellites in one plane (efficient in 98% of the resamples) and four in two planes (92%) nearly so. The single satellite is not settled by five replicates: one in a sun-synchronous orbit crossing the equator at 18:00 (efficient in 54% of the resamples) samples about as many points as one in a Walker orbit inclined 75 degrees (38%) or crossing at other times (10 to 20%). Likewise, three satellites in three planes (29% and 32%) sample about as many points as three in one plane, and six satellites in two planes with another relative spacing (32%) as many as the efficient design. Designs that are efficient with a probability between 0 and 1 are equally good candidates, given the uncertainty of the estimates: more replicates (samples of points) would separate them, or a tolerance of the share (see `pareto_front`) would treat them as ties." - ] - }, - { - "cell_type": "markdown", - "id": "72111ecf", - "metadata": {}, - "source": [ - "## Refine Uncertain Designs\n", - "\n", - "Five replicates settle the efficiency of most designs, but not of all. More replicates of every design would settle them, at the cost of evaluating every design again for each. `refine` instead adds replicates only to the designs whose efficiency is uncertain (efficient in more than 5% and fewer than 95% of the resamples), five at a time, and estimates their probabilities again, until none is uncertain (or a design has 40 replicates). The added replicates are the next ones after each design's own, which keeps common random numbers between the designs refined together.\n", - "\n", - "Some designs differ by less than any number of replicates could separate, such as those that sample nearly every point: a difference of a tenth of a percentage point does not matter to the trade. A tolerance of 1 percentage point of the share, part of the criteria by which designs are judged (`Criteria`), treats designs within it of the front as efficient (see `pareto_front`), so that refinement does not spend replicates on differences that do not matter. A design about one tolerance below the front stays uncertain instead: more replicates settle which side of the tolerance it falls on only slowly, though it does not matter. `refine` stops refining such a design once the standard error of its share is less than half the tolerance (`precision`): it is then `indifferent`. A `budget` would limit the evaluations, refining the least settled designs first." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "628dcbf7", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:17:30.656445Z", - "iopub.status.busy": "2026-11-12T17:17:30.655442Z", - "iopub.status.idle": "2026-11-12T17:18:02.798337Z", - "shell.execute_reply": "2026-11-12T17:18:02.798337Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "215 evaluations added, 0.6% of those of 40 replicates of every design\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
rounduncertainindifferentrefinedevaluations
0031229145
111611525
221411315
331412210
44141315
55141315
661412210
77131200
\n", - "
" - ], - "text/plain": [ - " round uncertain indifferent refined evaluations\n", - "0 0 31 2 29 145\n", - "1 1 16 11 5 25\n", - "2 2 14 11 3 15\n", - "3 3 14 12 2 10\n", - "4 4 14 13 1 5\n", - "5 5 14 13 1 5\n", - "6 6 14 12 2 10\n", - "7 7 13 12 0 0" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from tatc.tradespace import Criteria, refine\n", - "\n", - "TOLERANCE = {\"sufficient\": 1.0} # percentage points of the share that do not matter\n", - "CRITERIA = Criteria(OBJECTIVES, tolerance=TOLERANCE)\n", - "refinement = refine(study, CRITERIA, results, step=5, max_replicates=40, precision=0.5, n_resamples=1000)\n", - "added = len(refinement.results) - len(results)\n", - "print(f\"{added} evaluations added, {added / (len(designs) * 35):.1%} of those of 40 replicates of every design\")\n", - "refinement.history" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "25bbdcdf", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:18:02.798337Z", - "iopub.status.busy": "2026-11-12T17:18:02.798337Z", - "iopub.status.idle": "2026-11-12T17:18:02.846133Z", - "shell.execute_reply": "2026-11-12T17:18:02.846133Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
descriptionsatellitesplanessufficientreplicatesparetopareto_probabilityindifferent
500600 km, 60 deg FOR, SSO: 1 at 09:001.01.01.8010False0.12True
230500 km, 60 deg FOR, SSO: 1 at 15:001.01.01.9010False0.14True
498600 km, 60 deg FOR, SSO: 1 at 06:001.01.01.9010False0.19True
504600 km, 60 deg FOR, SSO: 1 at 15:001.01.02.1010False0.18True
502600 km, 60 deg FOR, SSO: 1 at 12:001.01.02.2010True0.40True
506600 km, 60 deg FOR, SSO: 1 at 18:001.01.02.2010True0.32True
1017800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac...1.01.02.4010True0.57True
774700 km, 60 deg FOR, SSO: 1 at 09:001.01.02.5010True0.76True
780700 km, 60 deg FOR, SSO: 1 at 18:001.01.02.5010True0.79True
778700 km, 60 deg FOR, SSO: 1 at 15:001.01.02.5315True0.70True
776700 km, 60 deg FOR, SSO: 1 at 12:001.01.02.8010True0.95False
772700 km, 60 deg FOR, SSO: 1 at 06:001.01.02.9010True0.98False
1052800 km, 60 deg FOR, SSO: 1 at 15:001.01.02.9010True0.98False
1046800 km, 60 deg FOR, SSO: 1 at 06:001.01.03.1010True0.98False
1054800 km, 60 deg FOR, SSO: 1 at 18:001.01.03.1010True0.99False
1048800 km, 60 deg FOR, SSO: 1 at 09:001.01.03.2010True0.99False
1050800 km, 60 deg FOR, SSO: 1 at 12:001.01.03.2010True0.99False
960800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...2.01.016.605True1.00False
963800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.030.205True1.00False
961800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...3.01.038.005True1.00False
972800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...3.03.037.0240False0.19False
971800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...3.03.038.4825True0.89True
962800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.068.205True1.00False
965800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.069.605True0.96False
1026800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.605True1.00False
1025800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.805True1.00False
479600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.405True0.97False
480600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.405True0.97False
753700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.605True1.00False
754700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.605True1.00False
1027800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.805True1.00False
1028800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.805True1.00False
768700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.605True1.00False
769700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.605True1.00False
770700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.605True1.00False
1043800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.805True1.00False
1044800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.805True1.00False
1045800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.805True1.00False
761700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.096.805False0.39True
487600 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.405True0.97False
762700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.605True1.00False
763700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.605True1.00False
1035800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.805True1.00False
1036800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.805True1.00False
1037800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.805True1.00False
\n", - "
" - ], - "text/plain": [ - " description satellites planes \\\n", - "500 600 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", - "230 500 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", - "498 600 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", - "504 600 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", - "502 600 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", - "506 600 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", - "1017 800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac... 1.0 1.0 \n", - "774 700 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", - "780 700 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", - "778 700 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", - "776 700 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", - "772 700 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", - "1052 800 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", - "1046 800 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", - "1054 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", - "1048 800 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", - "1050 800 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", - "960 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 1.0 \n", - "963 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", - "961 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 1.0 \n", - "972 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", - "971 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", - "962 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", - "965 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", - "1026 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", - "1025 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", - "479 600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "480 600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "753 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "754 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "1027 800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "1028 800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "768 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "769 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "770 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "1043 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "1044 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "1045 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "761 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "487 600 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "762 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "763 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "1035 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "1036 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "1037 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "\n", - " sufficient replicates pareto pareto_probability indifferent \n", - "500 1.80 10 False 0.12 True \n", - "230 1.90 10 False 0.14 True \n", - "498 1.90 10 False 0.19 True \n", - "504 2.10 10 False 0.18 True \n", - "502 2.20 10 True 0.40 True \n", - "506 2.20 10 True 0.32 True \n", - "1017 2.40 10 True 0.57 True \n", - "774 2.50 10 True 0.76 True \n", - "780 2.50 10 True 0.79 True \n", - "778 2.53 15 True 0.70 True \n", - "776 2.80 10 True 0.95 False \n", - "772 2.90 10 True 0.98 False \n", - "1052 2.90 10 True 0.98 False \n", - "1046 3.10 10 True 0.98 False \n", - "1054 3.10 10 True 0.99 False \n", - "1048 3.20 10 True 0.99 False \n", - "1050 3.20 10 True 0.99 False \n", - "960 16.60 5 True 1.00 False \n", - "963 30.20 5 True 1.00 False \n", - "961 38.00 5 True 1.00 False \n", - "972 37.02 40 False 0.19 False \n", - "971 38.48 25 True 0.89 True \n", - "962 68.20 5 True 1.00 False \n", - "965 69.60 5 True 0.96 False \n", - "1026 97.60 5 True 1.00 False \n", - "1025 97.80 5 True 1.00 False \n", - "479 97.40 5 True 0.97 False \n", - "480 97.40 5 True 0.97 False \n", - "753 97.60 5 True 1.00 False \n", - "754 97.60 5 True 1.00 False \n", - "1027 97.80 5 True 1.00 False \n", - "1028 97.80 5 True 1.00 False \n", - "768 97.60 5 True 1.00 False \n", - "769 97.60 5 True 1.00 False \n", - "770 97.60 5 True 1.00 False \n", - "1043 97.80 5 True 1.00 False \n", - "1044 97.80 5 True 1.00 False \n", - "1045 97.80 5 True 1.00 False \n", - "761 96.80 5 False 0.39 True \n", - "487 97.40 5 True 0.97 False \n", - "762 97.60 5 True 1.00 False \n", - "763 97.60 5 True 1.00 False \n", - "1035 97.80 5 True 1.00 False \n", - "1036 97.80 5 True 1.00 False \n", - "1037 97.80 5 True 1.00 False " - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "refined = refinement.summary\n", - "refined[\"description\"] = refined.apply(describe, axis=1)\n", - "refined[refined.pareto_probability >= 0.1].sort_values([\"satellites\", \"planes\", \"sufficient\"])[\n", - " [\"description\", \"satellites\", \"planes\", \"sufficient\", \"replicates\", \"pareto\", \"pareto_probability\", \"indifferent\"]\n", - "].round(2)" - ] - }, - { - "cell_type": "markdown", - "id": "8c6de013", - "metadata": {}, - "source": [ - "Refinement adds 215 evaluations, 0.6% of those that 40 replicates of every design would take, to the few designs whose efficiency is uncertain. With the tolerance, the designs that sample nearly every point (six to nine satellites, about 98%) are efficient candidates, with probabilities of 0.97 or more, rather than uncertain: they differ by less than matters. The designs that remain uncertain lie about one tolerance below the front, such as single satellites that sample 1.8 to 2.5% of the points against the best single satellite's 3.2%, or nine satellites that sample 96.8% against 97.8%: whether they are within the tolerance of the front is a question that more replicates settle only slowly, and one that does not change the trade. They are indifferent once their shares are known to within half the tolerance (a standard error of 0.5 percentage points), after 10 or 15 replicates of the single satellites (and the first five of the nine satellites); without a precision (`precision=None`), refinement would refine them to the limit of 40 replicates, for 555 evaluations. The shares of three satellites vary more between replicates: three satellites in three planes that sample 38.5% are indifferent after 25 replicates, and those that sample 37.0% remain uncertain with 40. An absolute tolerance suits a share near saturation better than one near zero; a tolerance proportional to the objective would treat both alike." - ] - }, - { - "cell_type": "markdown", - "id": "08774ef2", - "metadata": {}, - "source": [ - "## Confirm the Front\n", - "\n", - "The efficient designs were selected for their means over their replicates, so they are selected in part for the luck of those replicates: among a thousand designs, those that look best are likely to have drawn favorable samples of points (the winner's curse). `confirm` evaluates the selected designs (by default, the front of the results it is given) with new replicates, which played no part in their selection (the same for every design, which keeps common random numbers), and finds the front among them by these replicates. The difference between the means of the replicates that selected the designs and those of the new ones measures the optimism of the selection." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "ccdbfb35", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:18:02.846133Z", - "iopub.status.busy": "2026-11-12T17:18:02.846133Z", - "iopub.status.idle": "2026-11-12T17:18:20.616576Z", - "shell.execute_reply": "2026-11-12T17:18:20.616576Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "optimism of the selection: -0.02 percentage points\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
descriptionsatellitesplanessufficient selectedsufficientreplicatespareto
4600 km, 60 deg FOR, SSO: 1 at 18:001.01.02.202.2520False
3600 km, 60 deg FOR, SSO: 1 at 12:001.01.02.202.3520False
23800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac...1.01.02.402.6020False
15700 km, 60 deg FOR, SSO: 1 at 15:001.01.02.532.8520True
16700 km, 60 deg FOR, SSO: 1 at 18:001.01.02.502.8520True
13700 km, 60 deg FOR, SSO: 1 at 09:001.01.02.502.9020True
14700 km, 60 deg FOR, SSO: 1 at 12:001.01.02.802.9520True
12700 km, 60 deg FOR, SSO: 1 at 06:001.01.02.903.4520True
35800 km, 60 deg FOR, SSO: 1 at 09:001.01.03.203.5020True
38800 km, 60 deg FOR, SSO: 1 at 18:001.01.03.103.5020True
37800 km, 60 deg FOR, SSO: 1 at 15:001.01.02.903.7520True
34800 km, 60 deg FOR, SSO: 1 at 06:001.01.03.103.8020True
36800 km, 60 deg FOR, SSO: 1 at 12:001.01.03.203.8520True
17800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...2.01.016.6016.1520True
20800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.030.2028.9520True
18800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...3.01.038.0036.7020True
22800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...3.03.038.4835.6020False
19800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.068.2066.5020True
21800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.069.6066.4020True
25800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.6097.8020True
24800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.8097.9520True
0600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.4097.7520True
1600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.4097.8520True
5700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.6097.9520True
6700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.6097.9520True
26800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.8098.1020True
27800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac...8.02.097.8098.1020True
9700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.6097.9520True
10700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.6097.9520True
11700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.6097.9520True
31800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.8098.1020True
32800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.8098.1020True
33800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.8098.1020True
2600 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.4097.8520True
7700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.6097.9520True
8700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.6097.9520True
28800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.8098.1020True
29800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.8098.1020True
30800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.8098.1020True
\n", - "
" - ], - "text/plain": [ - " description satellites planes \\\n", - "4 600 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", - "3 600 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", - "23 800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac... 1.0 1.0 \n", - "15 700 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", - "16 700 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", - "13 700 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", - "14 700 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", - "12 700 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", - "35 800 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", - "38 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", - "37 800 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", - "34 800 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", - "36 800 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", - "17 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 1.0 \n", - "20 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", - "18 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 1.0 \n", - "22 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", - "19 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", - "21 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", - "25 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", - "24 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", - "0 600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "1 600 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "5 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "6 700 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "26 800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "27 800 km, 60 deg FOR, Walker 75 deg: 2 x 4 (spac... 8.0 2.0 \n", - "9 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "10 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "11 700 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "31 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "32 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "33 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "2 600 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "7 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "8 700 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "28 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "29 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "30 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "\n", - " sufficient selected sufficient replicates pareto \n", - "4 2.20 2.25 20 False \n", - "3 2.20 2.35 20 False \n", - "23 2.40 2.60 20 False \n", - "15 2.53 2.85 20 True \n", - "16 2.50 2.85 20 True \n", - "13 2.50 2.90 20 True \n", - "14 2.80 2.95 20 True \n", - "12 2.90 3.45 20 True \n", - "35 3.20 3.50 20 True \n", - "38 3.10 3.50 20 True \n", - "37 2.90 3.75 20 True \n", - "34 3.10 3.80 20 True \n", - "36 3.20 3.85 20 True \n", - "17 16.60 16.15 20 True \n", - "20 30.20 28.95 20 True \n", - "18 38.00 36.70 20 True \n", - "22 38.48 35.60 20 False \n", - "19 68.20 66.50 20 True \n", - "21 69.60 66.40 20 True \n", - "25 97.60 97.80 20 True \n", - "24 97.80 97.95 20 True \n", - "0 97.40 97.75 20 True \n", - "1 97.40 97.85 20 True \n", - "5 97.60 97.95 20 True \n", - "6 97.60 97.95 20 True \n", - "26 97.80 98.10 20 True \n", - "27 97.80 98.10 20 True \n", - "9 97.60 97.95 20 True \n", - "10 97.60 97.95 20 True \n", - "11 97.60 97.95 20 True \n", - "31 97.80 98.10 20 True \n", - "32 97.80 98.10 20 True \n", - "33 97.80 98.10 20 True \n", - "2 97.40 97.85 20 True \n", - "7 97.60 97.95 20 True \n", - "8 97.60 97.95 20 True \n", - "28 97.80 98.10 20 True \n", - "29 97.80 98.10 20 True \n", - "30 97.80 98.10 20 True " - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from tatc.tradespace import confirm\n", - "\n", - "# the front of the refined results, with 20 new replicates\n", - "confirmation = confirm(study, CRITERIA, refinement.results, replicates=20)\n", - "confirmed = confirmation.summary\n", - "confirmed[\"description\"] = confirmed.apply(describe, axis=1)\n", - "print(f\"optimism of the selection: {confirmation.optimism()['sufficient']:.2f} percentage points\")\n", - "confirmed.sort_values([\"satellites\", \"planes\", \"sufficient\"])[\n", - " [\"description\", \"satellites\", \"planes\", \"sufficient selected\", \"sufficient\", \"replicates\", \"pareto\"]\n", - "].round(2)" - ] - }, - { - "cell_type": "markdown", - "id": "e1752ee5", - "metadata": {}, - "source": [ - "The selection is optimistic where it chose the best of nearly equal designs. The designs of two to four satellites sample 0.5 to 3.2 percentage points fewer with the new replicates: four satellites in two planes 66.4% rather than 69.6%, and in one plane 66.5% rather than 68.2%. The design of three satellites in three planes that refinement left as good as three in one plane samples 35.6% with the new replicates (rather than 38.5%) and is no longer efficient. The single satellites and the designs of six to nine satellites instead sample slightly more points with the new replicates (by up to 0.9 and 0.5 points), as the new samples of points happen to be sampled more easily at both ends of the front: common random numbers share this difference between samples among the designs, and it is not an effect of the selection. The mean optimism over the designs (-0.02 points) mixes the two, so compare the designs one by one. All but four of the confirmed designs remain efficient within the tolerance (three single satellites that refinement left indifferent, about a tolerance below the front, and the three satellites in three planes): the shape of the front is confirmed, but its middle is up to 3 points less good than it looked." - ] - }, - { - "cell_type": "markdown", - "id": "6ecb8b65", - "metadata": {}, - "source": [ - "## Require Reliable Sampling\n", - "\n", - "A mean share of points sufficiently sampled does not say how reliably a design achieves it: the share differs between samples of points. Statistics over the replicates other than the mean state how a design is judged, and requirements on them are output constraints. Here, the objective is the share that a design exceeds in 80% of the samples (its 0.2 quantile, `Quantile`), and a design is required to sample at least half of the points sufficiently in at least 80% of the samples (the probability of meeting a threshold, `Probability`, with a `Requirement`). `Criteria` collect the objectives, the statistics they name, and the requirements: `aggregate` gives the statistics and the violations of the requirements, and `pareto_probability` the probability that each design is efficient among those that meet them." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "c1a89037", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:18:20.616576Z", - "iopub.status.busy": "2026-11-12T17:18:20.616576Z", - "iopub.status.idle": "2026-11-12T17:18:21.776713Z", - "shell.execute_reply": "2026-11-12T17:18:21.776713Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "209 of 1096 designs meet the requirement\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
descriptionsatellitesplanessufficient p20reliabilityreplicatespareto_probabilityrequirements_probability
962800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.065.01.051.001.0
965800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.068.01.050.941.0
1025800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.81.051.001.0
1026800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.01.050.501.0
\n", - "
" - ], - "text/plain": [ - " description satellites planes \\\n", - "962 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", - "965 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", - "1025 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", - "1026 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", - "\n", - " sufficient p20 reliability replicates pareto_probability \\\n", - "962 65.0 1.0 5 1.00 \n", - "965 68.0 1.0 5 0.94 \n", - "1025 97.8 1.0 5 1.00 \n", - "1026 97.0 1.0 5 0.50 \n", - "\n", - " requirements_probability \n", - "962 1.0 \n", - "965 1.0 \n", - "1025 1.0 \n", - "1026 1.0 " - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from tatc.tradespace import Probability, Quantile, Requirement\n", - "\n", - "RELIABLE = Criteria(\n", - " {\"satellites\": \"min\", \"planes\": \"min\", \"sufficient p20\": \"max\"},\n", - " statistics={\n", - " \"sufficient p20\": Quantile(\"sufficient\", 0.2),\n", - " \"reliability\": Probability(\"sufficient\", \">=\", 50),\n", - " },\n", - " requirements=[Requirement(\"reliability\", \">=\", 0.8)],\n", - ")\n", - "\n", - "reliable = pareto_probability(refinement.results, RELIABLE, n_resamples=1000)\n", - "reliable[\"description\"] = reliable.apply(describe, axis=1)\n", - "print(f\"{reliable.meets_requirements.sum()} of {len(reliable)} designs meet the requirement\")\n", - "reliable[reliable.pareto_probability >= 0.1].sort_values([\"satellites\", \"planes\"])[\n", - " [\"description\", \"satellites\", \"planes\", \"sufficient p20\", \"reliability\", \"replicates\", \"pareto_probability\", \"requirements_probability\"]\n", - "].round(2)" - ] - }, - { - "cell_type": "markdown", - "id": "5bb9e691", - "metadata": {}, - "source": [ - "209 of the 1,096 designs meet the requirement of sampling half of the points sufficiently in at least 80% of the samples, and none of them has fewer than four satellites: the best three satellites sample 38% of the points on average. Among those that meet it, four satellites in one plane (inclined 45 degrees) are efficient for sure, sampling at least 65% of the points in 80% of the samples, and so are six satellites in two planes inclined 75 degrees (at least 98%). Four satellites in two planes sample more (at least 68%) and are efficient in 94% of the resamples, and six satellites in two planes with another relative spacing in 50%: these are the alternatives to weigh with other criteria, such as the cost of launching more planes." - ] - }, - { - "cell_type": "markdown", - "id": "29b30022", - "metadata": {}, - "source": [ - "## Summary\n", - "\n", - "* The front of the means of the replicates is uncertain: `pareto_probability` finds the designs whose efficiency the replicates settle, and those that are equally good candidates.\n", - "* `refine` adds replicates only to the designs whose efficiency is uncertain, with a tolerance of differences that do not matter (part of the `Criteria`), and stops refining designs whose objectives are known to within a share of the tolerance.\n", - "* `confirm` evaluates the selected designs (by default, the front of the results) with new replicates, which removes the optimism of selecting the best of many nearly equal designs.\n", - "* Statistics other than means (such as a `Quantile` or the `Probability` of meeting a threshold) state how reliably a design performs, and `Requirement`s on them are output constraints.\n", - "* Each of these steps takes the study, the criteria, and the results of the step before (or a search's, see `SearchTradeSpace`), and returns its own results and a summary of its designs." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/examples/SearchTradeSpace.ipynb b/docs/examples/SearchTradeSpace.ipynb deleted file mode 100644 index 04253884..00000000 --- a/docs/examples/SearchTradeSpace.ipynb +++ /dev/null @@ -1,1416 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "6a7e7267", - "metadata": {}, - "source": [ - "# Search a Trade Space\n", - "\n", - "This example demonstrates how to search a trade space of constellation designs for Pareto-efficient designs with the `tatc.tradespace` module: declaring a hierarchical design space, evaluating designs in replicates (in parallel, with a cache of the analysis of each satellite), finding the Pareto-efficient designs and what drives them, screening designs with a cheaper analysis, and searching the space with optimizers (Optuna and pymoo, installed with `pip install tatc[tradespace]`).\n", - "\n", - "The trade is a sampling problem of a pre-Phase A study: how many satellites, in how many orbit planes (each of which needs its own launch), sample the Earth sufficiently often? A point is **sufficiently sampled** if an imager observes it at least four times in a day, and the objective is the share of points that are. A second objective measures sufficiency by its purpose: a point is **accurately sampled** if the mean of its samples estimates the daily mean of a field that varies within hours (such as convective precipitation) with an error of at most half the field's standard deviation. The points are a random sample of the Earth (a lattice of points in a random orientation), so the share is a statistical estimate: each replicate of a design draws a different sample of points, which is the uncertainty of the estimate." - ] - }, - { - "cell_type": "markdown", - "id": "30c41ae9", - "metadata": {}, - "source": [ - "The examples that follow take the same trade further: ranking designs with the uncertainty of their replicates (`RankUncertainDesigns`), comparing them across scenarios (`CompareScenarios`), trading their cost and utility (`TradeCostAndUtility`), and planning their deployment and failures (`PlanMissions`). They import the design space and study of this example from `trade_space_example.py`, beside the notebooks." - ] - }, - { - "cell_type": "markdown", - "id": "98da8775", - "metadata": {}, - "source": [ - "## Configure the Analysis\n", - "\n", - "The analysis covers one day, with 100 points in each of five replicates. A design may have at most 10 satellites." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "a30fa691", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:14:49.655581Z", - "iopub.status.busy": "2026-11-12T17:14:49.655581Z", - "iopub.status.idle": "2026-11-12T17:14:50.577261Z", - "shell.execute_reply": "2026-11-12T17:14:50.576251Z" - } - }, - "outputs": [], - "source": [ - "from datetime import datetime, time as time_of_day, timedelta, timezone\n", - "from pathlib import Path\n", - "import tempfile\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import pandas as pd\n", - "\n", - "START = datetime(2026, 7, 1, tzinfo=timezone.utc)\n", - "DURATION = timedelta(days=1) # the period of the analysis\n", - "N_POINTS = 100 # points sampled in each replicate\n", - "N_REPLICATES = 5 # replicates (samples of points) of each design\n", - "SAMPLES_PER_DAY = 4 # a point is sufficiently sampled if it is observed at least this often\n", - "MAX_SATELLITES = 10\n", - "DECORRELATION_TIME = timedelta(hours=3) # of the field whose daily mean is estimated\n", - "MAX_RELATIVE_ERROR = 0.5 # a point is accurately sampled within this share of the field's standard deviation" - ] - }, - { - "cell_type": "markdown", - "id": "2e6e18b3", - "metadata": {}, - "source": [ - "## Define the Design Space\n", - "\n", - "A `DesignSpace` declares the design variables, in the order they are decided. Every design has an altitude and an imager's field of regard, and a layout that is one of two alternatives (a `Choice`), each declared with a building block of the `tatc.tradespace` module:\n", - "\n", - "* a **Walker delta** constellation (`walker_space`), with an inclination, a number of planes, a number of satellites in each plane, and the relative spacing of the satellites between planes (whose upper bound depends on the number of planes), or\n", - "* one or two **sun-synchronous** planes (`sso_planes_space`, a `Repeat` of planes), each with its own equator crossing time and number of satellites. The planes are unordered: two planes in either order are the same design. A constraint of the building block requires the planes to have different crossing times (otherwise, they would be the same plane).\n", - "\n", - "The points sampled in each replicate are an `Uncertain` parameter (the seed of a random orientation of a lattice of points, `Uncertain.seed`), drawn for each replicate rather than designed, as are the failures of satellites and the growth of the cost of developing the satellites (both used in the examples that follow). The replicates use common random numbers: every design samples the same points in the same replicate, so that differences between designs are not differences between their samples. The points of a replicate are a Fibonacci lattice in a random orientation (`generate_points_rotated_lattice`): each point is as likely to fall anywhere as a random point, but the points cover the Earth evenly rather than clustering by chance, so that the shares of points vary less between replicates than with random points (`generate_points_random`; here, with 1.5 to 4 times less variance), and fewer replicates estimate them as precisely. The decorrelation time of the field whose daily mean is estimated is a `Fixed` value of the design space, which the metrics read from each design, rather than a constant of the metrics, so that scenarios can change it (see `CompareScenarios`).\n", - "\n", - "The constraint on the number of satellites returns the number in excess of the limit (a number that is not positive if the design satisfies it), rather than `True` or `False`, so that optimizers can tell how far an infeasible design is from a feasible one." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "5c9a0153", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:14:50.578955Z", - "iopub.status.busy": "2026-11-12T17:14:50.578955Z", - "iopub.status.idle": "2026-11-12T17:14:52.045125Z", - "shell.execute_reply": "2026-11-12T17:14:52.045125Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1096 feasible designs of 12 decisions\n" - ] - } - ], - "source": [ - "from tatc.tradespace import (\n", - " Categorical,\n", - " Choice,\n", - " DesignSpace,\n", - " Fixed,\n", - " Integer,\n", - " Real,\n", - " Uncertain,\n", - " count_satellites,\n", - " sso_planes_space,\n", - " walker_space,\n", - ")\n", - "\n", - "space = DesignSpace(\n", - " altitude=Real(500e3, 800e3, step=100e3),\n", - " field_of_regard=Categorical([30, 60]),\n", - " layout=Choice(\n", - " walker=walker_space(inclination=Real(45, 75, step=15), planes=Integer(1, 4), per_plane=Integer(1, 4)),\n", - " sso=sso_planes_space(crossing=Real(6, 18, step=3), satellites=Integer(1, 2), count=Integer(1, 2)),\n", - " ),\n", - " points_seed=Uncertain.seed(),\n", - " failure_seed=Uncertain.seed(),\n", - " cost_growth=Uncertain(lambda rng: float(rng.triangular(0.9, 1.0, 1.6))), # of development, for cost risk\n", - " decorrelation_time=Fixed(DECORRELATION_TIME), # of the field, which scenarios may change (see CompareScenarios)\n", - " epoch=Fixed(START), # the start of the analysis, which may be drawn for each replicate (see PlanMissions)\n", - " constraints=[lambda d: count_satellites(d.layout) - MAX_SATELLITES],\n", - ")\n", - "designs = space.enumerate()\n", - "print(f\"{len(designs)} feasible designs of {len(space.unit_paths())} decisions\")" - ] - }, - { - "cell_type": "markdown", - "id": "aebe3379", - "metadata": {}, - "source": [ - "## Define the Study\n", - "\n", - "An `ObservationStudy` evaluates each design in each replicate: it builds the design's satellites (`build`, with `build_constellation`, which builds the satellites of either layout with a payload: here, an imager, but also entries of the instrument catalog), collects their observations of the replicate's targets (`Observations`), and computes the metrics of the observations (`sample`). The targets are the points of a randomly oriented lattice, generated in each replicate from its seed (`Targets`, from the design's uncertain `points_seed`). The observations of each satellite are cached on disk: designs share many satellites (the same orbit and imager, if not the same name), whose observations are computed once, by the parallel worker processes of the study (`n_jobs=-1`, one per processor), and kept between sessions. A `ResultStore` keeps the records of the evaluations in a file, so that running the notebook again (or resuming it after an interruption) takes them from the file rather than evaluating them again. Both are keyed by the definition of the study (its fingerprint), which describes the points by the recipe that generates them and the code of TAT-C that the study uses: a changed study evaluates its designs again, and a study whose code changed says why. Variants of the study (of other periods, replicates, or scenarios) share the store, whose fingerprints keep their evaluations apart.\n", - "\n", - "The metrics are the two objectives: the share of points with at least four samples a day, and the share whose sampling error (`tatc.analysis.estimate_sampling_error`, for an exponential correlation in time with a decorrelation time of 3 hours) is at most half the field's standard deviation. The study also records the numbers of satellites and of orbit planes (of the design's `layout`), and plans the deployment of each design and estimates its life-cycle cost (`MissionPlan`, of a `DeploymentSchedule` and a `CostModel`, used in `TradeCostAndUtility` and `PlanMissions`).\n", - "\n", - "`study.replace` makes variants of the study with some of its arguments replaced, such as a cheaper study of a shorter period for screening (below), or studies of the phases of deployment and of failures (`PlanMissions`)." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "dc4e503c", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:14:52.045125Z", - "iopub.status.busy": "2026-11-12T17:14:52.045125Z", - "iopub.status.idle": "2026-11-12T17:14:52.060818Z", - "shell.execute_reply": "2026-11-12T17:14:52.060818Z" - } - }, - "outputs": [], - "source": [ - "from functools import partial\n", - "\n", - "from tatc.analysis import estimate_sampling_error\n", - "from tatc.generation import generate_points_rotated_lattice\n", - "from tatc.schemas import Instrument\n", - "from tatc.tradespace import (\n", - " CostModel,\n", - " DeploymentSchedule,\n", - " LaunchCost,\n", - " MissionPlan,\n", - " ObservationStudy,\n", - " Observations,\n", - " OperationsCost,\n", - " ResultStore,\n", - " SatelliteCost,\n", - " Targets,\n", - " build_constellation,\n", - ")\n", - "\n", - "# the deployment of each design: 3 years of development, a production line of 4 satellites a year, launches of up to 3\n", - "# satellites at most every half year, and 5 years of operations from the first launch\n", - "SCHEDULE = DeploymentSchedule(years=5, development_years=3, production_rate=4, launch_interval=0.5, launch_capacity=3)\n", - "# illustrative costs (millions of dollars), not estimates of any mission: satellites with an imager of each field of\n", - "# regard, small launchers, and operations, discounted at 3% a year\n", - "COST_MODEL = CostModel(\n", - " satellites={\n", - " 30: SatelliteCost(development=40, first_unit=12, learning_rate=0.9, mass=60),\n", - " 60: SatelliteCost(development=60, first_unit=18, learning_rate=0.9, mass=90),\n", - " },\n", - " launch=LaunchCost(per_launch=8),\n", - " operations=OperationsCost(per_year=3, per_satellite_year=0.5),\n", - " discount_rate=0.03,\n", - ")\n", - "\n", - "# the deployment and cost of each design: satellites of the kind of its field of regard, with its growth of\n", - "# development costs\n", - "PLAN = MissionPlan(SCHEDULE, COST_MODEL, kind=\"field_of_regard\", growth={\"development\": \"cost_growth\"})\n", - "# the points of each replicate: a randomly oriented lattice, generated from the replicate's seed\n", - "TARGETS = Targets(generate_points_rotated_lattice, N_POINTS, seed=\"points_seed\")\n", - "CACHE_DIRECTORY = Path(tempfile.gettempdir()) / \"tatc-search-trade-space\"\n", - "\n", - "\n", - "def sample(observations, design, duration=DURATION):\n", - " \"\"\"The shares (%) of points sampled sufficiently and accurately by observations over a duration from the design's\n", - " epoch (of the field of the design's decorrelation time).\"\"\"\n", - " if len(observations) == 0: # no satellites\n", - " return {\"sufficient\": 0.0, \"accurate\": 0.0}\n", - " samples = observations.groupby(\"target_hash\").size()\n", - " error = estimate_sampling_error(observations, design.epoch, design.epoch + duration, design.decorrelation_time)\n", - " threshold = SAMPLES_PER_DAY * duration / timedelta(days=1)\n", - " return {\n", - " \"sufficient\": 100 * (samples >= threshold).sum() / N_POINTS,\n", - " \"accurate\": 100 * (error.relative_error <= MAX_RELATIVE_ERROR).sum() / N_POINTS,\n", - " }\n", - "\n", - "\n", - "def build(d):\n", - " \"\"\"The satellites of a design: an imager of its field of regard in each orbit of its layout.\"\"\"\n", - " imager = Instrument(name=\"imager\", field_of_regard=d.field_of_regard)\n", - " return build_constellation(d.layout, imager, epoch=START, altitude=d.altitude)\n", - "\n", - "\n", - "# the study of the shares (%) of points sampled sufficiently and accurately over the period by the satellites of each\n", - "# design, and of its deployment and cost (by the mission plan), whose evaluations are kept in a store\n", - "study = ObservationStudy(\n", - " space,\n", - " build,\n", - " Observations(TARGETS, \"epoch\", DURATION, directory=CACHE_DIRECTORY),\n", - " sample,\n", - " layout=\"layout\",\n", - " plan=PLAN,\n", - " replicates=N_REPLICATES,\n", - " n_jobs=-1,\n", - " store=ResultStore(CACHE_DIRECTORY / \"results.sqlite\"),\n", - ")\n", - "\n", - "OBJECTIVES = {\"satellites\": \"min\", \"planes\": \"min\", \"sufficient\": \"max\"}\n", - "REFERENCE = {\"satellites\": MAX_SATELLITES + 1, \"planes\": 5, \"sufficient\": 0} # worse than every design, for hypervolumes" - ] - }, - { - "cell_type": "markdown", - "id": "a10276fc", - "metadata": {}, - "source": [ - "## Evaluate Every Design\n", - "\n", - "The design space is small enough to evaluate every design, which gives the true Pareto front against which the screening and the searches below are compared. `summarize` gives a summary of the designs: a row per design, with its values (from which `DesignSpace.designs_of` rebuilds it) and the mean of each objective over the replicates (and its standard deviation and standard error), and `pareto_front` the designs that no other design is as good as in every objective and better than in one." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "7ca0697d", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:14:52.060818Z", - "iopub.status.busy": "2026-11-12T17:14:52.060818Z", - "iopub.status.idle": "2026-11-12T17:16:33.009809Z", - "shell.execute_reply": "2026-11-12T17:16:33.008808Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "5480 evaluations: 1096 designs x 5 replicates\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
descriptionsatellitesplanessufficientsufficient se
1054800 km, 60 deg FOR, SSO: 1 at 18:001.01.03.20.9
960800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...2.01.016.61.2
963800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.030.22.2
961800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...3.01.038.01.2
962800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.068.21.8
965800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.069.60.8
1025800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.80.2
\n", - "
" - ], - "text/plain": [ - " description satellites planes \\\n", - "1054 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", - "960 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 1.0 \n", - "963 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", - "961 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 1.0 \n", - "962 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", - "965 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", - "1025 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", - "\n", - " sufficient sufficient se \n", - "1054 3.2 0.9 \n", - "960 16.6 1.2 \n", - "963 30.2 2.2 \n", - "961 38.0 1.2 \n", - "962 68.2 1.8 \n", - "965 69.6 0.8 \n", - "1025 97.8 0.2 " - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from tatc.tradespace import hypervolume, pareto_front, summarize\n", - "\n", - "results = study.run(designs)\n", - "print(f\"{len(results)} evaluations: {len(designs)} designs x {N_REPLICATES} replicates\")\n", - "\n", - "# a row per design: its values and the means of its objectives over the replicates (with their standard deviations and\n", - "# standard errors), and whether it is efficient\n", - "summary = summarize(results, list(OBJECTIVES))\n", - "summary[\"pareto\"] = pareto_front(summary, OBJECTIVES)\n", - "exact_hypervolume = hypervolume(summary, OBJECTIVES, REFERENCE)\n", - "\n", - "\n", - "def describe(d):\n", - " \"\"\"A short description of a design (a row of its values).\"\"\"\n", - " if d.layout == \"walker\":\n", - " layout = (\n", - " f\"Walker {d['layout.walker.inclination']:.0f} deg: {d['layout.walker.planes']:.0f} x \"\n", - " f\"{d['layout.walker.per_plane']:.0f} (spacing {d['layout.walker.relative_spacing']:.0f})\"\n", - " )\n", - " else:\n", - " planes = [\n", - " f\"{d[f'layout.sso.planes[{k}].satellites']:.0f} at {d[f'layout.sso.planes[{k}].crossing']:02.0f}:00\"\n", - " for k in range(int(d['layout.sso.planes.count']))\n", - " ]\n", - " layout = \"SSO: \" + \", \".join(planes)\n", - " return f\"{d.altitude / 1e3:.0f} km, {d.field_of_regard} deg FOR, {layout}\"\n", - "\n", - "\n", - "summary[\"description\"] = summary.apply(describe, axis=1)\n", - "front = summary[summary.pareto].sort_values([\"satellites\", \"planes\"])\n", - "front[[\"description\", \"satellites\", \"planes\", \"sufficient\", \"sufficient se\"]].round(1)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "2b0ec3e0", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:16:33.011808Z", - "iopub.status.busy": "2026-11-12T17:16:33.011808Z", - "iopub.status.idle": "2026-11-12T17:16:33.227373Z", - "shell.execute_reply": "2026-11-12T17:16:33.226409Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from tatc.tradespace import plot_designs\n", - "\n", - "\n", - "def planes_name(planes):\n", - " \"\"\"The name of a number of planes.\"\"\"\n", - " return f\"{planes:.0f} plane{'s' if planes > 1 else ''}\"\n", - "\n", - "\n", - "ax = plot_designs(\n", - " summary,\n", - " \"satellites\",\n", - " \"sufficient\",\n", - " by=\"planes\",\n", - " front=\"pareto\",\n", - " labels=lambda row: f\"{row.satellites:.0f} sat., {row.planes:.0f} pl.\",\n", - " names=planes_name,\n", - " jitter=0.18, # satellites, for legibility\n", - " legend=\"upper left\",\n", - ")\n", - "ax.set(\n", - " xlabel=\"Satellites\",\n", - " ylabel=\"Points sufficiently sampled (%)\",\n", - " xticks=range(1, MAX_SATELLITES + 1),\n", - " ylim=(0, 105),\n", - ")\n", - "ax.set_title(\"Every design: mean over 5 replicates (satellites jittered for legibility)\", fontsize=10)\n", - "ax.figure.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "a42a293e", - "metadata": {}, - "source": [ - "Of the 1,096 feasible designs, seven are Pareto-efficient (ringed in the figure). All of them fly at the highest altitude (800 km) with the wider field of regard (60 degrees), which observe the most points per satellite, so the trade is in the number of satellites and planes. One satellite samples only 3% of the points sufficiently (at least four times a day), and the share rises steeply with the number of satellites: two satellites in two planes (30%) sample nearly twice as many points as two in one plane (17%), four satellites sample about two thirds of the points in one plane or two (68% and 70%), and six satellites in two inclined planes sample 98%. No design with more than six satellites is efficient, because six already sample nearly every point. Designs with the same number of satellites differ widely: their layout (inclination, planes, and phasing) matters as much as their number." - ] - }, - { - "cell_type": "markdown", - "id": "ac77e2d7", - "metadata": {}, - "source": [ - "## Measure the Sampling Error\n", - "\n", - "Four samples a day count the same whether they come hours apart or minutes apart, but they do not estimate a daily mean equally well: samples closer together than the field's decorrelation time repeat each other. The share of points accurately sampled measures what the samples are for. The table gives the efficient designs by this objective (with the numbers of satellites and planes, as before), and the figure compares the two objectives for every design." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "e1752a9a", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:16:33.229884Z", - "iopub.status.busy": "2026-11-12T17:16:33.229884Z", - "iopub.status.idle": "2026-11-12T17:16:33.304056Z", - "shell.execute_reply": "2026-11-12T17:16:33.303055Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
descriptionsatellitesplanessufficientaccurateaccurate se
1050800 km, 60 deg FOR, SSO: 1 at 12:001.01.03.04.20.6
1047800 km, 60 deg FOR, SSO: 2 at 06:002.01.011.610.40.9
963800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.030.234.21.8
1019800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...3.01.026.217.01.1
1075800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:003.02.028.860.61.3
1001800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac...3.03.034.261.03.8
1020800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac...4.01.049.228.62.1
1081800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:004.02.057.685.40.7
758700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...6.03.089.096.40.5
1045800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.896.60.5
1035800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.80.2
1036800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.80.2
1037800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.80.2
\n", - "
" - ], - "text/plain": [ - " description satellites planes \\\n", - "1050 800 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", - "1047 800 km, 60 deg FOR, SSO: 2 at 06:00 2.0 1.0 \n", - "963 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", - "1019 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... 3.0 1.0 \n", - "1075 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3.0 2.0 \n", - "1001 800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac... 3.0 3.0 \n", - "1020 800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac... 4.0 1.0 \n", - "1081 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4.0 2.0 \n", - "758 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... 6.0 3.0 \n", - "1045 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", - "1035 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "1036 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "1037 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", - "\n", - " sufficient accurate accurate se \n", - "1050 3.0 4.2 0.6 \n", - "1047 11.6 10.4 0.9 \n", - "963 30.2 34.2 1.8 \n", - "1019 26.2 17.0 1.1 \n", - "1075 28.8 60.6 1.3 \n", - "1001 34.2 61.0 3.8 \n", - "1020 49.2 28.6 2.1 \n", - "1081 57.6 85.4 0.7 \n", - "758 89.0 96.4 0.5 \n", - "1045 97.8 96.6 0.5 \n", - "1035 97.8 97.8 0.2 \n", - "1036 97.8 97.8 0.2 \n", - "1037 97.8 97.8 0.2 " - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ACCURACY = {\"satellites\": \"min\", \"planes\": \"min\", \"accurate\": \"max\"}\n", - "accuracy = summarize(results, [\"satellites\", \"planes\", \"sufficient\", \"accurate\"])\n", - "accuracy[\"description\"] = accuracy.apply(describe, axis=1)\n", - "accuracy[\"pareto\"] = pareto_front(accuracy, ACCURACY)\n", - "accuracy[accuracy.pareto].sort_values([\"satellites\", \"planes\"])[\n", - " [\"description\", \"satellites\", \"planes\", \"sufficient\", \"accurate\", \"accurate se\"]\n", - "].round(1)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "0936a1c2", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:16:33.306056Z", - "iopub.status.busy": "2026-11-12T17:16:33.305055Z", - "iopub.status.idle": "2026-11-12T17:16:33.443733Z", - "shell.execute_reply": "2026-11-12T17:16:33.442741Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from tatc.tradespace import style_axes\n", - "from tatc.tradespace.plotting import GRAY\n", - "\n", - "fig, ax = plt.subplots(figsize=(6.5, 5))\n", - "plot_designs(accuracy, \"sufficient\", \"accurate\", by=\"planes\", names=planes_name, legend=\"upper left\", ax=ax)\n", - "ax.plot([0, 100], [0, 100], color=GRAY, lw=1, ls=\"--\")\n", - "ax.annotate(\"equal shares\", (80, 80), xytext=(6, -10), textcoords=\"offset points\", fontsize=8, color=GRAY)\n", - "ax.set(xlabel=\"Points sufficiently sampled (%)\", ylabel=\"Points accurately sampled (%)\", xlim=(0, 102), ylim=(0, 102))\n", - "style_axes(ax, grid=\"both\")\n", - "ax.set_title(\"Sampling counts and sampling errors of every design\", fontsize=10)\n", - "fig.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "a5555a08", - "metadata": {}, - "source": [ - "The revisits of two designs of four satellites, those in one plane that sample the most points sufficiently and those that sample the most points accurately, show why they differ in accuracy: the times between their samples (`tatc.analysis.compute_revisit_statistics`), including the longest gap of the day, and the times of day they sample (`tatc.analysis.compute_local_time_coverage`, in eight 3-hour intervals of local time)." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "481917fb", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:16:33.444732Z", - "iopub.status.busy": "2026-11-12T17:16:33.444732Z", - "iopub.status.idle": "2026-11-12T17:16:33.760244Z", - "shell.execute_reply": "2026-11-12T17:16:33.760244Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
sufficient (%)accurate (%)median revisit (h)median longest gap (h)median 3-h intervals sampled
design
800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spacing 0)68.226.80.413.82.0
800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:0057.685.45.97.64.0
\n", - "
" - ], - "text/plain": [ - " sufficient (%) \\\n", - "design \n", - "800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spaci... 68.2 \n", - "800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 57.6 \n", - "\n", - " accurate (%) \\\n", - "design \n", - "800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spaci... 26.8 \n", - "800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 85.4 \n", - "\n", - " median revisit (h) \\\n", - "design \n", - "800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spaci... 0.4 \n", - "800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 5.9 \n", - "\n", - " median longest gap (h) \\\n", - "design \n", - "800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spaci... 13.8 \n", - "800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 7.6 \n", - "\n", - " median 3-h intervals sampled \n", - "design \n", - "800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spaci... 2.0 \n", - "800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4.0 " - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from tatc.analysis import compute_local_time_coverage, compute_revisit_statistics\n", - "\n", - "four = accuracy[(accuracy.satellites == 4)].sort_values(\"sufficient\", ascending=False)\n", - "# the most sufficiently sampling design of four satellites in one plane, and the most accurately sampling design of four\n", - "first = four[four.planes == 1].iloc[0]\n", - "second = four.sort_values(\"accurate\", ascending=False).iloc[0]\n", - "rows = []\n", - "# the designs of the rows, rebuilt from their values\n", - "for row, design in zip((first, second), space.designs_of(four, [first.design, second.design])):\n", - " # the observations of the design's first replicate, and its points\n", - " observations = study.observations_of(design)\n", - " points = study.targets_of(design)\n", - " revisits = compute_revisit_statistics(observations, START, START + DURATION, targets=points)\n", - " local = compute_local_time_coverage(observations, targets=points)\n", - " observed = revisits[revisits.samples > 0]\n", - " rows.append(\n", - " {\n", - " \"design\": row.description,\n", - " \"sufficient (%)\": row.sufficient,\n", - " \"accurate (%)\": row.accurate,\n", - " \"median revisit (h)\": observed[\"revisit p50\"].dt.total_seconds().median() / 3600,\n", - " \"median longest gap (h)\": revisits.max_gap.dt.total_seconds().median() / 3600,\n", - " \"median 3-h intervals sampled\": local.local_bins_sampled.median(),\n", - " }\n", - " )\n", - "pd.DataFrame(rows).set_index(\"design\").round(1)" - ] - }, - { - "cell_type": "markdown", - "id": "3d77aa41", - "metadata": {}, - "source": [ - "Counting samples and measuring their sampling error rank designs differently. Satellites in one plane (blue in the figure) sample many points four times a day, but in bursts: consecutive passes of satellites that follow each other in a plane, minutes apart, repeat each other for a field that decorrelates in hours. Four satellites in one Walker plane sample 68% of the points at least four times a day, but only 27% accurately: half of their revisits are 0.4 hours apart, and they leave a gap of 13.8 hours. Four satellites in two sun-synchronous planes sample fewer points four times (58%) but 85% accurately: their samples are 5.9 hours apart, in four of the eight 3-hour intervals of the day. Designs in a single plane remain efficient only as those that need the fewest launches, and sample at most 29% of the points accurately; six satellites in three planes sample 96% of the points accurately, nearly as many as nine (98%)." - ] - }, - { - "cell_type": "markdown", - "id": "31c15e60", - "metadata": {}, - "source": [ - "## Find What Drives the Objectives\n", - "\n", - "`sensitivity` gives the share of the variance of each objective (over the designs, by their means over the replicates) that each design variable explains, among the designs in which the variable is active: the variables of the Walker layout apply only to Walker designs, and those of the sun-synchronous layout only to theirs. The shares are adjusted for the variance that the levels of a variable would explain by chance, which matters for samples of designs and for variables of many levels." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "5206fdbc", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:16:33.762237Z", - "iopub.status.busy": "2026-11-12T17:16:33.762237Z", - "iopub.status.idle": "2026-11-12T17:16:33.792018Z", - "shell.execute_reply": "2026-11-12T17:16:33.791025Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
sufficientaccurateactive
variable
field_of_regard0.250.251.00
layout.walker.per_plane0.220.180.64
layout0.190.121.00
layout.walker.planes0.120.290.64
layout.sso.planes.count0.100.190.36
altitude0.030.031.00
layout.walker.relative_spacing0.030.060.64
layout.walker.inclination0.000.000.64
\n", - "
" - ], - "text/plain": [ - " sufficient accurate active\n", - "variable \n", - "field_of_regard 0.25 0.25 1.00\n", - "layout.walker.per_plane 0.22 0.18 0.64\n", - "layout 0.19 0.12 1.00\n", - "layout.walker.planes 0.12 0.29 0.64\n", - "layout.sso.planes.count 0.10 0.19 0.36\n", - "altitude 0.03 0.03 1.00\n", - "layout.walker.relative_spacing 0.03 0.06 0.64\n", - "layout.walker.inclination 0.00 0.00 0.64" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from tatc.tradespace import sensitivity\n", - "\n", - "# the summary keeps the values of each design\n", - "variables = [\n", - " \"altitude\",\n", - " \"field_of_regard\",\n", - " \"layout\",\n", - " \"layout.walker.inclination\",\n", - " \"layout.walker.planes\",\n", - " \"layout.walker.per_plane\",\n", - " \"layout.walker.relative_spacing\",\n", - " \"layout.sso.planes.count\",\n", - "]\n", - "sensitivity(accuracy, variables, [\"sufficient\", \"accurate\"]).round(2)" - ] - }, - { - "cell_type": "markdown", - "id": "879ef8cd", - "metadata": {}, - "source": [ - "The field of regard explains the most of both objectives (25% of their variance), as it sets the swath of every satellite. The layout matters next, but differently for the two objectives: the number of satellites in each Walker plane explains more of the share of points sufficiently sampled (22%) than of those accurately sampled (18%), and the number of Walker planes the reverse (12% and 29%), as more planes spread the samples in time. The altitude explains little of either objective (3%), although a higher orbit widens the swath: its effect is small next to those of the field of regard and the layout. The inclination explains nothing on average over the Walker designs." - ] - }, - { - "cell_type": "markdown", - "id": "8318fcb6", - "metadata": {}, - "source": [ - "## Screen Designs with a Cheaper Analysis\n", - "\n", - "Evaluating every design is affordable here, but not for larger spaces or longer analyses. `screen` evaluates every design with a cheap study, keeps the best (whole fronts, until it keeps at least `keep` of them), and evaluates only those with the full study. A cheap study ranks designs less exactly, so criteria of the cheap study with a tolerance of an objective (`Criteria`) keep designs that are within it of the front of the cheap study.\n", - "\n", - "The cheap study must rank designs as the full study would. Here, the screening study analyzes one replicate, rather than five, over a shorter period, with the threshold of sufficient sampling scaled to the period: 12 hours with two observations, or 6 hours with one. The table compares each screening's front with the true front (how many of its efficient designs it keeps, and its hypervolume), and its cost (the satellites analyzed times the days of their analyses) with that of evaluating every design." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "b50f4cb2", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:16:33.795026Z", - "iopub.status.busy": "2026-11-12T17:16:33.794025Z", - "iopub.status.idle": "2026-11-12T17:17:08.843811Z", - "shell.execute_reply": "2026-11-12T17:17:08.843811Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
screening studykeep (%)tolerance (%)designs keptefficient designs kepthypervolume (% of true front)cost (% of every design)
012 h, 1 replicate5.0NaN744 of 798.816.9
112 h, 1 replicate10.05.02487 of 7100.029.2
26 h, 1 replicate5.0NaN621 of 783.010.6
36 h, 1 replicate20.0NaN2315 of 796.625.1
\n", - "
" - ], - "text/plain": [ - " screening study keep (%) tolerance (%) designs kept \\\n", - "0 12 h, 1 replicate 5.0 NaN 74 \n", - "1 12 h, 1 replicate 10.0 5.0 248 \n", - "2 6 h, 1 replicate 5.0 NaN 62 \n", - "3 6 h, 1 replicate 20.0 NaN 231 \n", - "\n", - " efficient designs kept hypervolume (% of true front) \\\n", - "0 4 of 7 98.8 \n", - "1 7 of 7 100.0 \n", - "2 1 of 7 83.0 \n", - "3 5 of 7 96.6 \n", - "\n", - " cost (% of every design) \n", - "0 16.9 \n", - "1 29.2 \n", - "2 10.6 \n", - "3 25.1 " - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from tatc.tradespace import Criteria, screen\n", - "\n", - "\n", - "def over(duration):\n", - " \"\"\"The study of one replicate over a shorter period, as a cheap analysis.\"\"\"\n", - " return study.replace(\n", - " observations=Observations(TARGETS, \"epoch\", duration, directory=CACHE_DIRECTORY),\n", - " metrics=partial(sample, duration=duration),\n", - " replicates=1,\n", - " )\n", - "\n", - "\n", - "full_cost = results.satellites.sum() * DURATION / timedelta(days=1) # satellite-days of analysis\n", - "true_front = set(summary.design[summary.pareto])\n", - "screenings = []\n", - "for hours, keep, tolerance in [(12, 0.05, None), (12, 0.1, 5.0), (6, 0.05, None), (6, 0.2, None)]:\n", - " # the criteria of the cheap study, with a tolerance of its share, if any, and of the full study\n", - " cheap = OBJECTIVES if tolerance is None else Criteria(OBJECTIVES, tolerance={\"sufficient\": tolerance})\n", - " screening = screen([over(timedelta(hours=hours)), study], [cheap, OBJECTIVES], designs, keep=keep)\n", - " # the satellite-days of the analyses of each stage\n", - " days = screening.results.stage.map({0: hours / 24, 1: DURATION / timedelta(days=1)})\n", - " screenings.append(\n", - " {\n", - " \"screening study\": f\"{hours} h, 1 replicate\",\n", - " \"keep (%)\": 100 * keep,\n", - " \"tolerance (%)\": tolerance,\n", - " \"designs kept\": len(screening.designs),\n", - " \"efficient designs kept\": f\"{len(true_front & {d.key for d in screening.designs})} of {len(true_front)}\",\n", - " \"hypervolume (% of true front)\": 100 * hypervolume(screening.summary, OBJECTIVES, REFERENCE) / exact_hypervolume,\n", - " \"cost (% of every design)\": 100 * (screening.results.satellites * days).sum() / full_cost,\n", - " }\n", - " )\n", - "pd.DataFrame(screenings).round(1)" - ] - }, - { - "cell_type": "markdown", - "id": "4ef50735", - "metadata": {}, - "source": [ - "The 12-hour screening study ranks designs nearly as the full study does. Keeping the best 5% of the designs finds a front with 99% of the hypervolume of the true front at 17% of the cost of evaluating every design, although it misses three of the seven efficient designs, whose places designs with nearly the same objectives take. Keeping 10%, with a tolerance of 5 percentage points, keeps every efficient design at 29% of the cost.\n", - "\n", - "The 6-hour screening study is cheaper, but ranks designs differently: one observation of a point in 6 hours separates designs less than four observations in a day do. Keeping 5% of the designs keeps only one of the seven efficient ones (83% of the hypervolume), and keeping 20% still misses two of them (97% of the hypervolume) at 25% of the cost, nearly as much as the 12-hour study that keeps them all. How many designs to keep depends on how well the cheap study ranks designs, which is worth checking on a sample of designs evaluated with both studies before screening a larger space." - ] - }, - { - "cell_type": "markdown", - "id": "3d127bbc", - "metadata": {}, - "source": [ - "## Search with Optimizers\n", - "\n", - "Larger design spaces cannot be enumerated or even screened, and an optimizer searches them for efficient designs instead. `optimize_optuna` suggests designs with Optuna's trials, which search the hierarchical design space directly (`DesignSpace.suggest`), and records the violation of the constraint of each infeasible design, which Optuna's samplers use to prefer feasible designs. `optimize_pymoo` searches the unit hypercube that encodes the design space (`DesignSpace.decode`) with a pymoo algorithm, which eliminates the proposals of designs proposed or evaluated before: many points of the hypercube decode to the same design (those in the same level of each variable, or that differ only in the variables of a branch not chosen), which pymoo's own elimination of equal points does not see. Both evaluate each design once, however often it is proposed, and evaluate the designs proposed together in parallel. A search chooses its front from one evaluation of each design, which favors designs whose replicates were lucky: its results (a `Search`) are refined and confirmed as for any study (see `RankUncertainDesigns`).\n", - "\n", - "Each search below is given a budget of about 200 proposals, and is compared with a Latin hypercube sample of 200 designs (`DesignSpace.sample`). The designs evaluated (and the analyses of their satellites) are those of the evaluation of every design above, so they are retrieved from the cache." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "1bcffde7", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:17:08.843811Z", - "iopub.status.busy": "2026-11-12T17:17:08.843811Z", - "iopub.status.idle": "2026-11-12T17:17:10.740726Z", - "shell.execute_reply": "2026-11-12T17:17:10.740726Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
designs evaluatedhypervolume (% of true front)
Optuna (NSGA-II)143.092.1
pymoo (NSGA-II)166.0100.0
Latin hypercube sample176.079.3
\n", - "
" - ], - "text/plain": [ - " designs evaluated hypervolume (% of true front)\n", - "Optuna (NSGA-II) 143.0 92.1\n", - "pymoo (NSGA-II) 166.0 100.0\n", - "Latin hypercube sample 176.0 79.3" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import optuna\n", - "from pymoo.algorithms.moo.nsga2 import NSGA2\n", - "\n", - "from tatc.tradespace import hypervolume_progress, optimize_optuna, optimize_pymoo\n", - "\n", - "optuna.logging.set_verbosity(optuna.logging.WARNING)\n", - "BUDGET = 200\n", - "searches = {}\n", - "searches[\"Optuna (NSGA-II)\"] = optimize_optuna(\n", - " study,\n", - " OBJECTIVES,\n", - " n_trials=BUDGET,\n", - " sampler=optuna.samplers.NSGAIISampler(population_size=20, seed=1),\n", - " batch_size=20,\n", - ").results\n", - "searches[\"pymoo (NSGA-II)\"] = optimize_pymoo(\n", - " study, OBJECTIVES, NSGA2(pop_size=20), (\"n_gen\", BUDGET // 20), seed=1\n", - ").results\n", - "searches[\"Latin hypercube sample\"] = study.run(space.sample(BUDGET, method=\"lhs\", seed=1))\n", - "\n", - "# the hypervolume (% of the true front's) of the designs evaluated, as designs are evaluated\n", - "progress = {\n", - " name: 100 * hypervolume_progress(search_results, OBJECTIVES, REFERENCE) / exact_hypervolume\n", - " for name, search_results in searches.items()\n", - "}\n", - "pd.DataFrame(\n", - " {\n", - " name: {\n", - " \"designs evaluated\": search_results.design.nunique(),\n", - " \"hypervolume (% of true front)\": progress[name].iloc[-1],\n", - " }\n", - " for name, search_results in searches.items()\n", - " }\n", - ").T.round(1)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "562e2055", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-12T17:17:10.740726Z", - "iopub.status.busy": "2026-11-12T17:17:10.740726Z", - "iopub.status.idle": "2026-11-12T17:17:10.852067Z", - "shell.execute_reply": "2026-11-12T17:17:10.852067Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from tatc.tradespace import plot_progress\n", - "\n", - "ax = plot_progress(progress)\n", - "ax.axhline(100, color=GRAY, lw=1, ls=\"--\")\n", - "ax.annotate(\"true front\", (0, 100), xytext=(2, 4), textcoords=\"offset points\", fontsize=8, color=GRAY)\n", - "ax.set(ylabel=\"Hypervolume (% of true front)\")\n", - "ax.set_title(\"Progress of the searches\", fontsize=10)\n", - "ax.figure.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "1e082131", - "metadata": {}, - "source": [ - "Both optimizers find more of the hypervolume than a Latin hypercube sample of as many designs. Optuna (NSGA-II, searching the hierarchical space directly) finds 92% of the hypervolume of the true front with 143 designs, 13% of the space. pymoo (NSGA-II, searching the encoded space) finds all of it with 166 designs: it proposes no design twice, and its other 34 proposals violate the constraint on the number of satellites (without eliminating duplicates by design, its 200 proposals encoded only 75 designs, which found 88%). The sample finds 79% with 176 designs. The searches stop at their budget of proposals, not at convergence: a larger budget, or screening, would bring Optuna's closer to the true front. Their results also depend on their seeds (over eight seeds, pymoo's search finds 88 to 100% of the hypervolume, 96.5% on average), so compare several seeds before relying on one." - ] - }, - { - "cell_type": "markdown", - "id": "bcc66e31", - "metadata": {}, - "source": [ - "## Summary\n", - "\n", - "* A `DesignSpace` declares a hierarchical trade space, with choices between alternatives (`Choice`), repeated elements such as orbit planes (`Repeat`), bounds that depend on other variables, constraints that measure their violation, and uncertain parameters (`Uncertain`) drawn for each replicate. Building blocks declare common constellation layouts (`walker_space` and `sso_planes_space`) and build their satellites with instruments or entries of the instrument catalog (`build_constellation`).\n", - "* An `ObservationStudy` (a `Study` of the observations of `Targets`, with a `MissionPlan` of deployment and costs) evaluates designs in replicates (here, of points of a randomly oriented lattice, `generate_points_rotated_lattice`, which vary less between replicates than random points), in parallel, with a cache of `Observations` that analyzes each distinct satellite once and a `ResultStore` that keeps its evaluations (by the fingerprint of the study, which describes its targets and the code of TAT-C it uses, so that a changed study evaluates its designs again). Every design of a space of about a thousand designs can be evaluated in minutes, and `Study.replace` makes variants of a study.\n", - "* A summary of the results (`summarize`, or `aggregate`) has a row per design, with its values, for `pareto_front` and `plot_designs`. Statistical sufficiency is measured by the sampling error of the statistic that observations estimate (`tatc.analysis.estimate_sampling_error`), which counts of samples overstate when samples cluster in time, as they do in a single plane; revisit statistics and local time coverage explain it. `sensitivity` finds the design variables that drive each objective.\n", - "* `screen` evaluates every design with a cheap study and the best with the full one, which finds the front at a fraction of the cost if the cheap study ranks designs as the full one does.\n", - "* `optimize_optuna` and `optimize_pymoo` search spaces too large to enumerate, and find most of the front with a fraction of the designs (`hypervolume_progress`), pymoo's proposing no design twice (by design, not by point of the encoded space). `plot_designs` and `plot_progress` plot the designs, with the efficient ones ringed, and the progress of searches.\n", - "\n", - "The examples that follow take the trade further: ranking designs with the uncertainty of their replicates (`RankUncertainDesigns`), comparing them across scenarios (`CompareScenarios`), trading their cost and utility (`TradeCostAndUtility`), and planning their deployment and failures (`PlanMissions`).\n", - "\n", - "The sampling error here is that of a model of the field (an exponential correlation in time with a decorrelation time of 3 hours); with a simulation of the field (a nature run), `tatc.analysis.sample_field` and `compare_sampled_means` measure it directly. The uncertainty here is that of the sample of points; others (such as the phase of the satellites or the period of the analysis) are further `Uncertain` parameters of the design space." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/examples/TradeCostAndUtility.ipynb b/docs/examples/TradeCostAndUtility.ipynb deleted file mode 100644 index aae6b4bc..00000000 --- a/docs/examples/TradeCostAndUtility.ipynb +++ /dev/null @@ -1,999 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "1a498cec", - "metadata": {}, - "source": [ - "# Trade Cost and Utility\n", - "\n", - "This example demonstrates how to trade the life-cycle cost of designs against what they achieve with the `tatc.tradespace` module: costs estimated from a cost model and each design's deployment, with uncertain growth whose quantiles give the cost at a confidence level, a budget as a requirement, the probability that one design costs more than another when designs share the cost risk of their components, and utilities that weigh several objectives by a stakeholder's preferences.\n", - "\n", - "It continues the example `SearchTradeSpace`, whose design space and study it imports from `trade_space_example.py` (beside the notebooks). The evaluations of every design are taken from the study's store if `SearchTradeSpace` was run before (or are evaluated again, in a few minutes). Its replicates are refined where the efficiency of designs is uncertain, as in `RankUncertainDesigns` (from the store, if that example was run before)." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "38ec6b1f", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-13T02:19:01.506492Z", - "iopub.status.busy": "2026-11-13T02:19:01.506492Z", - "iopub.status.idle": "2026-11-13T02:21:00.638217Z", - "shell.execute_reply": "2026-11-13T02:21:00.638217Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "5695 evaluations\n" - ] - } - ], - "source": [ - "from trade_space_example import OBJECTIVES, describe, designs, planes_name, study\n", - "from tatc.tradespace import Criteria, refine\n", - "\n", - "# the evaluations of every design, with replicates added where their efficiency is uncertain (see RankUncertainDesigns)\n", - "results = study.run(designs)\n", - "TOLERANCE = {\"sufficient\": 1.0} # percentage points of the share that do not matter\n", - "CRITERIA = Criteria(OBJECTIVES, tolerance=TOLERANCE)\n", - "refinement = refine(study, CRITERIA, results, step=5, max_replicates=40, precision=0.5, n_resamples=1000)\n", - "print(f\"{len(refinement.results)} evaluations\")" - ] - }, - { - "cell_type": "markdown", - "id": "16b35cc8", - "metadata": {}, - "source": [ - "## Trade Cost Against Sufficiency\n", - "\n", - "The numbers of satellites and planes are proxies of cost. A `CostModel` estimates the life-cycle cost of each design from the costs of its satellites (the development of each type, and the production of its units on a learning curve), launches (here, a small launcher for every three satellites of a plane), and operations, given by the study (TAT-C does not include cost-estimating relationships). The costs here are illustrative, in millions of dollars. The evaluation adds the cost and its elements to each record (and the years by which the design is `deployed`), for the satellites of each design's imager (`kind`): a wider field of regard costs more to develop and build. The deployment of each design (`DeploymentSchedule.plan`) dates the costs, from rates, so that each design's schedule follows from its satellites and planes: development over three years, then the production of the satellites on one line at four a year, plane by plane, each plane launched when its satellites are ready (in launches of up to three satellites, at most one every half year), and operations from each launch to the end of the mission (five years after the first launch). The dated costs give the present value of the cost (`cost present`, discounted at 3% a year) and the cost of the most expensive year (`cost peak annual`), for annual budgets.\n", - "\n", - "The growth of the cost of development is uncertain (an `Uncertain` parameter, from 0.9 to 1.6 times the estimate, most likely 1), drawn for each replicate, so that statistics over the replicates give the cost at a confidence level: here, the 0.7 quantile (`cost p70`), as budgets are often set. A requirement keeps the designs whose cost at 70% confidence is within a budget, and the front trades this cost against the share of points sufficiently sampled. (Cost depends only on the design, so a constraint of the design space could exclude designs over a budget before they are evaluated, with the cost without growth.)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "30e16c98", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-13T02:21:00.638217Z", - "iopub.status.busy": "2026-11-13T02:21:00.638217Z", - "iopub.status.idle": "2026-11-13T02:21:02.137775Z", - "shell.execute_reply": "2026-11-13T02:21:02.137775Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "520 of 1096 designs cost at most 150 at 70% confidence, of which 46 are efficient in at least half of the resamples\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
descriptionsatellitesplanesdeployedcost p70cost developmentcost productioncost launchcost operationscost presentcost peak annualsufficientpareto_probability
635700 km, 30 deg FOR, SSO: 1 at 06:00113.283.644.412.08.017.575.523.51.01.0
910800 km, 30 deg FOR, SSO: 2 at 06:00213.596.944.422.88.020.087.230.82.60.9
826800 km, 30 deg FOR, Walker 45 deg: 2 x 1 (spac...223.8104.744.422.816.019.894.342.36.20.9
824800 km, 30 deg FOR, Walker 45 deg: 1 x 3 (spac...313.8109.644.433.08.022.598.241.07.81.0
835800 km, 30 deg FOR, Walker 45 deg: 3 x 1 (spac...334.2124.844.433.024.021.8112.252.511.21.0
828800 km, 30 deg FOR, Walker 45 deg: 2 x 2 (spac...424.0129.344.442.716.024.5115.950.722.21.0
963800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...223.8139.266.734.216.019.8126.053.730.21.0
845800 km, 30 deg FOR, Walker 45 deg: 4 x 1 (spac...444.8144.344.442.732.023.5129.262.231.00.7
961800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...313.8149.166.749.48.022.5134.457.438.00.6
\n", - "
" - ], - "text/plain": [ - " description satellites planes \\\n", - "635 700 km, 30 deg FOR, SSO: 1 at 06:00 1 1 \n", - "910 800 km, 30 deg FOR, SSO: 2 at 06:00 2 1 \n", - "826 800 km, 30 deg FOR, Walker 45 deg: 2 x 1 (spac... 2 2 \n", - "824 800 km, 30 deg FOR, Walker 45 deg: 1 x 3 (spac... 3 1 \n", - "835 800 km, 30 deg FOR, Walker 45 deg: 3 x 1 (spac... 3 3 \n", - "828 800 km, 30 deg FOR, Walker 45 deg: 2 x 2 (spac... 4 2 \n", - "963 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2 2 \n", - "845 800 km, 30 deg FOR, Walker 45 deg: 4 x 1 (spac... 4 4 \n", - "961 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3 1 \n", - "\n", - " deployed cost p70 cost development cost production cost launch \\\n", - "635 3.2 83.6 44.4 12.0 8.0 \n", - "910 3.5 96.9 44.4 22.8 8.0 \n", - "826 3.8 104.7 44.4 22.8 16.0 \n", - "824 3.8 109.6 44.4 33.0 8.0 \n", - "835 4.2 124.8 44.4 33.0 24.0 \n", - "828 4.0 129.3 44.4 42.7 16.0 \n", - "963 3.8 139.2 66.7 34.2 16.0 \n", - "845 4.8 144.3 44.4 42.7 32.0 \n", - "961 3.8 149.1 66.7 49.4 8.0 \n", - "\n", - " cost operations cost present cost peak annual sufficient \\\n", - "635 17.5 75.5 23.5 1.0 \n", - "910 20.0 87.2 30.8 2.6 \n", - "826 19.8 94.3 42.3 6.2 \n", - "824 22.5 98.2 41.0 7.8 \n", - "835 21.8 112.2 52.5 11.2 \n", - "828 24.5 115.9 50.7 22.2 \n", - "963 19.8 126.0 53.7 30.2 \n", - "845 23.5 129.2 62.2 31.0 \n", - "961 22.5 134.4 57.4 38.0 \n", - "\n", - " pareto_probability \n", - "635 1.0 \n", - "910 0.9 \n", - "826 0.9 \n", - "824 1.0 \n", - "835 1.0 \n", - "828 1.0 \n", - "963 1.0 \n", - "845 0.7 \n", - "961 0.6 " - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from tatc.tradespace import Quantile, Requirement, aggregate, pareto_probability\n", - "\n", - "BUDGET = 150 # millions of dollars, at 70% confidence\n", - "COST = Criteria(\n", - " {\"cost p70\": \"min\", \"sufficient\": \"max\"},\n", - " statistics={\"cost p70\": Quantile(\"cost\", 0.7)},\n", - " requirements=[Requirement(\"cost p70\", \"<=\", BUDGET)],\n", - " tolerance=TOLERANCE,\n", - ")\n", - "ELEMENTS = [\"cost development\", \"cost production\", \"cost launch\", \"cost operations\"]\n", - "DATED = [\"cost present\", \"cost peak annual\"]\n", - "\n", - "# the probability that each design is efficient, with its values (such as its satellites and planes, and the years by\n", - "# which it is deployed), and the means of the elements of its cost\n", - "costed = pareto_probability(refinement.results, COST, n_resamples=1000)\n", - "means = aggregate(refinement.results, [*ELEMENTS, *DATED], design_columns=[]).set_index(\"design\")\n", - "costed[[*ELEMENTS, *DATED]] = means.loc[costed.design, [*ELEMENTS, *DATED]].to_numpy()\n", - "costed[\"description\"] = costed.apply(describe, axis=1)\n", - "efficient = costed[costed.pareto_probability >= 0.5]\n", - "print(\n", - " f\"{costed.meets_requirements.sum()} of {len(costed)} designs cost at most {BUDGET} at 70% confidence, \"\n", - " + f\"of which {len(efficient)} are efficient in at least half of the resamples\"\n", - ")\n", - "# the most sufficient of these at each cost\n", - "efficient.sort_values([\"cost p70\", \"sufficient\"], ascending=[True, False]).drop_duplicates(\"cost p70\")[\n", - " [\"description\", \"satellites\", \"planes\", \"deployed\", \"cost p70\", *ELEMENTS, *DATED, \"sufficient\", \"pareto_probability\"]\n", - "].round(1)" - ] - }, - { - "cell_type": "markdown", - "id": "164eba41", - "metadata": {}, - "source": [ - "520 of the 1,096 designs cost at most 150 million dollars at 70% confidence. Along the front, money buys sufficiency in steps: one satellite (84 million at 70% confidence, of which 44 million on average develops it) samples 1% of the points sufficiently; a second satellite in its plane, 3%, and in a second plane, 6%; four satellites in two Walker planes (129 million), 22%. The planes now have a price: four satellites in four planes sample more points sufficiently than in two (31% against 22%, as more planes spread the samples in time), at twice the cost of launches (32 million against 16). The wider field of regard joins the front only near the budget, where its development (67 million against 44) is worth its swath: two satellites with the wider imager sample 30% of the points for 139 million, about as many as four with the narrower one in four planes, and three of them 38% for 149 million, the most within the budget. The designs that sample nearly every point (six to nine satellites) cost more than the budget.\n", - "\n", - "Each design's schedule follows from its satellites and planes (`deployed`, years from the start of development to the launch of its last plane): one satellite is launched 3.2 years after development starts; four satellites in two planes take a year to produce, and are deployed after 4.0 years; and four satellites in four planes, after 4.8 years, as each plane takes a launch and launches are half a year apart. Dated, the costs are worth 8 to 9% less at present (at 3% a year), as most are incurred three or more years from now. The most expensive year is the one after development, in which the satellites are produced and the first are launched: four satellites in four planes need 62 million in that year, and one satellite 24 million. A budget of annual funding would limit the satellites produced in a year, which a slower production rate would spread over more years, at the cost of deploying later.\n", - "\n", - "The growth of the cost of development affects every design alike in a replicate (common random numbers), so it shifts the costs at 70% confidence more for designs whose development costs more, here those of the wider imager. With five replicates of most designs, the 0.7 quantile of their costs is a coarse estimate: an evaluation that costs little more than the cost model (unlike the analysis of sampling) could draw more replicates of the cost alone." - ] - }, - { - "cell_type": "markdown", - "id": "8e89a30c", - "metadata": {}, - "source": [ - "## Compare Uncertain Costs\n", - "\n", - "The growth of cost above is one factor of the development of every design, drawn alike in each replicate (common random numbers): designs share all of their cost risk. Cost risk has more structure (M. W. Maier, K. L. Yeakel, and E. B. Wendoloski, \"Cost Variance Analysis in Constellation Architecture Studies,\" *IEEE Systems Journal* 17(2), 2023). The cost of a type of satellite is the sum of those of its components (`Component`, here its bus and imager), each growing by its maturity (a `Triangular` distribution, from formal risk assessments: wider and skewed further up for new components than for existing ones), and the growths of the components are correlated (here by 0.5, `CostModel.correlation`), as costs estimated alike tend to be underestimated together. The growth of each component is drawn from scores, standard normal values of each component and a common score (uncertain parameters of the design space, from `risk_space`), which common random numbers give alike to every design of a replicate (`CostModel.draw`): designs of the same imager share all of its cost risk, and designs of different imagers share the growth of the bus and the common score. Here, the bus exists, the narrower imager modifies an existing one, and the wider imager is new; their expected costs are about those of the cost model above.\n", - "\n", - "A study of the costs alone (whose evaluation estimates the cost of each design's deployment, with the growth of its components drawn from its scores) evaluates the most sufficient efficient design at each cost (as in the table above) in 500 replicates, with common random numbers and without. Its results give the probability that each design costs more than each other (`exceedance`), plotted with `plot_exceedance` in order of the mean cost:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "0e9ef4ae", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-13T02:21:02.139782Z", - "iopub.status.busy": "2026-11-13T02:21:02.139782Z", - "iopub.status.idle": "2026-11-13T02:21:33.519907Z", - "shell.execute_reply": "2026-11-13T02:21:33.519907Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "30 deg: expected development 40.1, first unit 12.1\n", - "60 deg: expected development 59.1, first unit 18.2\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import dataclasses\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import pandas as pd\n", - "\n", - "from trade_space_example import COST_MODEL, SCHEDULE, space\n", - "from tatc.tradespace import Component, SatelliteCost, Study, Triangular, exceedance, plot_exceedance, risk_space\n", - "\n", - "# the growth of the costs of a component by its maturity: lowest, most likely (the estimate), and highest (Maier et\n", - "# al., 2023, Table I)\n", - "MATURITY = {\n", - " \"new\": Triangular(0.827, 2.274),\n", - " \"major modification\": Triangular(0.864, 1.993),\n", - " \"modified\": Triangular(0.904, 1.708),\n", - " \"minor modification\": Triangular(0.943, 1.423),\n", - " \"existing\": Triangular(0.981, 1.140),\n", - "}\n", - "# illustrative costs (millions of dollars) of the components of the satellites of each imager: an existing bus, a\n", - "# modified imager of 30 degrees, and a new imager of 60 degrees, whose growths are correlated by 0.5\n", - "BUS = Component(\"bus\", development=20, first_unit=7, growth=MATURITY[\"existing\"])\n", - "COMPONENT_COSTS = dataclasses.replace(\n", - " COST_MODEL,\n", - " satellites={\n", - " 30: SatelliteCost(\n", - " components=[BUS, Component(\"imager 30\", development=16, first_unit=4, growth=MATURITY[\"modified\"])],\n", - " learning_rate=0.9,\n", - " mass=60,\n", - " ),\n", - " 60: SatelliteCost(\n", - " components=[BUS, Component(\"imager 60\", development=28, first_unit=8, growth=MATURITY[\"new\"])],\n", - " learning_rate=0.9,\n", - " mass=90,\n", - " ),\n", - " },\n", - " correlation=0.5,\n", - ")\n", - "for kind, satellite in COMPONENT_COSTS.satellites.items():\n", - " print(\n", - " f\"{kind} deg: expected development {satellite.total_development:.1f}, first unit {satellite.total_first_unit:.1f}\"\n", - " )\n", - "# the scores of the components and the common score, drawn for each replicate\n", - "costed_space = space.extend(cost_risk=risk_space(COMPONENT_COSTS))\n", - "\n", - "\n", - "def deploy(d):\n", - " \"\"\"The deployment of a design's satellites.\"\"\"\n", - " return SCHEDULE.plan(d.layout, kind=d.field_of_regard)\n", - "\n", - "\n", - "def estimate(deployment, design):\n", - " \"\"\"The cost of a deployment, with the growth of the components drawn from the design's scores.\"\"\"\n", - " return COMPONENT_COSTS.draw(design.cost_risk).estimate(deployment).metrics()\n", - "\n", - "\n", - "# the most sufficient efficient design at each cost (as designs of the space with scores), evaluated with common\n", - "# random numbers and without\n", - "compared = efficient.sort_values([\"cost p70\", \"sufficient\"], ascending=[True, False]).drop_duplicates(\"cost p70\")\n", - "compared_designs = [costed_space.design(d) for d in space.designs_of(compared)]\n", - "labels = {\n", - " d.key: f\"{row.satellites:.0f} x {d.field_of_regard} deg, {planes_name(row.planes)}\"\n", - " for d, row in zip(compared_designs, compared.itertuples())\n", - "}\n", - "costs = Study(costed_space, deploy, estimate, replicates=500)\n", - "shared_results = costs.run(compared_designs)\n", - "independent_results = costs.replace(common_random_numbers=False).run(compared_designs)\n", - "shared = exceedance(shared_results, \"cost\") # in order of the mean cost\n", - "order = list(dict.fromkeys(shared.design))\n", - "independent = exceedance(independent_results, \"cost\", order)\n", - "\n", - "fig, axes = plt.subplots(1, 2, figsize=(12, 5.6))\n", - "for ax, frame, title in zip(axes, [shared, independent], [\"Common random numbers\", \"Independent draws\"]):\n", - " plot_exceedance(frame, labels=labels, colorbar=False, ax=ax)\n", - " ax.set_title(title, fontsize=10)\n", - "axes[1].set(ylabel=\"\")\n", - "axes[1].tick_params(labelleft=False)\n", - "scale = fig.colorbar(axes[0].images[0], ax=axes, fraction=0.025, pad=0.02)\n", - "scale.set_label(\"Probability that the design costs more than the other\", fontsize=9)\n", - "scale.ax.tick_params(labelsize=8, length=0)\n", - "scale.outline.set_visible(False)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "08e81bc1", - "metadata": {}, - "source": [ - "With common random numbers (left), the designs of the narrower imager are ordered in every replicate: they share the growth of all of their components, so that the design with more satellites or planes costs more whatever the growth, although neighbors differ by less than their costs spread (three satellites in one plane cost 5 million dollars more than two in two planes, and each spreads by about 5 million). So are the two designs of the wider imager, 10 million apart while each spreads by 15 to 17 million. Designs of different imagers share the growth of the bus, which spreads little, and the common score, but the spread of the costs of the wider imager is mostly the new imager's own, and their order is open where their costs are near (the pale cells between the designs of each imager): two satellites of the wider imager in two planes cost more than four of the narrower one in two planes in 60% of the replicates, as the growth of the new imager is skewed far up. With independent draws (right), the order of designs of the same imager is open as well: their costs spread as much as before, but no longer together." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "ba40b595", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-13T02:21:33.519907Z", - "iopub.status.busy": "2026-11-13T02:21:33.519907Z", - "iopub.status.idle": "2026-11-13T02:21:33.551943Z", - "shell.execute_reply": "2026-11-13T02:21:33.551943Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "common random numbers: 22 of 22 pairs of the same imager settled, 9 of 14 of different imagers\n", - "independent draws: 16 of 22 pairs of the same imager settled, 8 of 14 of different imagers\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
designothercostcost stdcost differenceexceedance (common)exceedance (independent)
02 x 30 deg, 1 plane1 x 30 deg, 1 plane91.214.7913.411.000.98
12 x 30 deg, 2 planes2 x 30 deg, 1 plane98.964.797.751.000.86
23 x 30 deg, 1 plane2 x 30 deg, 2 planes103.985.515.011.000.75
33 x 30 deg, 3 planes3 x 30 deg, 1 plane119.235.5115.251.000.95
44 x 30 deg, 2 planes3 x 30 deg, 3 planes123.806.194.571.000.70
52 x 60 deg, 2 planes4 x 30 deg, 2 planes129.6014.695.800.600.55
64 x 30 deg, 4 planes2 x 60 deg, 2 planes138.806.199.200.770.76
73 x 60 deg, 1 plane4 x 30 deg, 4 planes139.7917.010.990.480.46
\n", - "
" - ], - "text/plain": [ - " design other cost cost std \\\n", - "0 2 x 30 deg, 1 plane 1 x 30 deg, 1 plane 91.21 4.79 \n", - "1 2 x 30 deg, 2 planes 2 x 30 deg, 1 plane 98.96 4.79 \n", - "2 3 x 30 deg, 1 plane 2 x 30 deg, 2 planes 103.98 5.51 \n", - "3 3 x 30 deg, 3 planes 3 x 30 deg, 1 plane 119.23 5.51 \n", - "4 4 x 30 deg, 2 planes 3 x 30 deg, 3 planes 123.80 6.19 \n", - "5 2 x 60 deg, 2 planes 4 x 30 deg, 2 planes 129.60 14.69 \n", - "6 4 x 30 deg, 4 planes 2 x 60 deg, 2 planes 138.80 6.19 \n", - "7 3 x 60 deg, 1 plane 4 x 30 deg, 4 planes 139.79 17.01 \n", - "\n", - " cost difference exceedance (common) exceedance (independent) \n", - "0 13.41 1.00 0.98 \n", - "1 7.75 1.00 0.86 \n", - "2 5.01 1.00 0.75 \n", - "3 15.25 1.00 0.95 \n", - "4 4.57 1.00 0.70 \n", - "5 5.80 0.60 0.55 \n", - "6 9.20 0.77 0.76 \n", - "7 0.99 0.48 0.46 " - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# the pairs whose order the replicates settle (one design costs more in at least 95% of them), of the same imager\n", - "# and of different imagers\n", - "position = {key: k for k, key in enumerate(order)}\n", - "imager = {d.key: d.field_of_regard for d in compared_designs}\n", - "for name, frame in [(\"common random numbers\", shared), (\"independent draws\", independent)]:\n", - " pairs = frame[frame.design.map(position) > frame.other.map(position)]\n", - " settled = (pairs.exceedance >= 0.95) | (pairs.exceedance <= 0.05)\n", - " same = pairs.design.map(imager) == pairs.other.map(imager)\n", - " print(\n", - " f\"{name}: {settled[same].sum()} of {same.sum()} pairs of the same imager settled, \"\n", - " + f\"{settled[~same].sum()} of {(~same).sum()} of different imagers\"\n", - " )\n", - "\n", - "# each design against the one before it in order of cost: the mean and standard deviation of its cost, the mean\n", - "# difference, and the probability that it costs more, with common random numbers and with independent draws\n", - "spread = shared_results.groupby(\"design\")[\"cost\"].agg([\"mean\", \"std\"])\n", - "neighbors = pd.DataFrame({\"design\": order[1:], \"other\": order[:-1]})\n", - "neighbors = neighbors.merge(shared, on=[\"design\", \"other\"]).merge(\n", - " independent[[\"design\", \"other\", \"exceedance\"]], on=[\"design\", \"other\"], suffixes=(\" (common)\", \" (independent)\")\n", - ")\n", - "neighbors[\"cost\"] = spread.loc[neighbors.design, \"mean\"].to_numpy()\n", - "neighbors[\"cost std\"] = spread.loc[neighbors.design, \"std\"].to_numpy()\n", - "neighbors[\"design\"] = neighbors.design.map(labels)\n", - "neighbors[\"other\"] = neighbors.other.map(labels)\n", - "neighbors[\n", - " [\"design\", \"other\", \"cost\", \"cost std\", \"cost difference\", \"exceedance (common)\", \"exceedance (independent)\"]\n", - "].round(2)" - ] - }, - { - "cell_type": "markdown", - "id": "946e61f2", - "metadata": {}, - "source": [ - "Along the order of cost, each design of the narrower imager costs more than the one before it in every replicate with common random numbers, and in 70 to 98% of them with independent draws: neighbors 5 million dollars apart (three satellites in one plane after two in two planes, and four in two planes after three in three planes) change order in a quarter to a third of the replicates drawn independently, as each spreads by 5 to 6 million. Of the pairs of designs of the same imager, all 22 are settled (one costs more in at least 95% of the replicates) with common random numbers and 16 with independent draws; of the pairs of different imagers, 9 of 14 with common random numbers and 8 with independent draws, as what they share (the bus, and the common score) spreads less than the new imager. Costs that share their risk settle the order of designs that differ by less than their costs spread, as far as they share what spreads, which comparisons of their quantiles, or of costs drawn independently, cannot see. Here, the order of the front's designs by cost is open only where they change imager, where a choice within a budget rests on the growth of the new imager.\n", - "\n", - "The growth of each type of satellite is the simplest structure of this kind (a factor of each kind, such as `growth={\"development\": {30: \"growth_30\", 60: \"growth_60\"}}` in a `MissionPlan`), and a `MissionPlan` draws the growth of components from the scores of each design (`scores=\"cost_risk\"`) in an `ObservationStudy`. The scores are uncertain parameters of the design space, so that the variance of costs, or of their differences, may be attributed to each component (`attribute_variance`, with the paths of the scores, such as `cost_risk.imager 60`) and to the risk that components share (`cost_risk.common`), and a scenario may fix a score (such as at a high quantile of the growth of the new imager)." - ] - }, - { - "cell_type": "markdown", - "id": "b41fbb9e", - "metadata": {}, - "source": [ - "## Trade Utility Against Cost\n", - "\n", - "Sufficiency and accuracy are objectives of `SearchTradeSpace`, each in its own units. A stakeholder who values both weighs them, and a utility makes the weights explicit (`Utility`): a single-attribute utility of each metric, from 0 at its worst acceptable value to 1 at its best (here, linear in the share of points sampled sufficiently, `LinearUtility`, and concave in the share sampled accurately, `ExponentialUtility`, as the first points accurately sampled matter most), combined by weights. Two stakeholders weigh the shares differently: one mostly sufficiency (0.7 against 0.3), as a center that counts samples for forecasts might, and the other mostly accuracy (0.3 against 0.7), as one that estimates daily means might. Each design's utility is that of its means: the shares vary between replicates mostly as noise of the sample of points, which the expected utility (the mean of the utility of each replicate, `Mean(utility)`) would penalize as if it were a risk. The figure plots each stakeholder's utility of every design against its cost at 70% confidence (as above), with the front of each ringed:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "1d83ea69", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-13T02:21:33.551943Z", - "iopub.status.busy": "2026-11-13T02:21:33.551943Z", - "iopub.status.idle": "2026-11-13T02:21:33.788242Z", - "shell.execute_reply": "2026-11-13T02:21:33.788242Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "from tatc.tradespace import ExponentialUtility, LinearUtility, Utility, pareto_front, plot_designs, style_axes\n", - "from tatc.tradespace.plotting import GRAY\n", - "\n", - "# the utility of the shares sampled sufficiently (linear) and accurately (concave: the first points matter most), for\n", - "# two stakeholders who weigh them differently\n", - "CURVES = {\"sufficient\": LinearUtility(0, 100), \"accurate\": ExponentialUtility(0, 100, risk=2)}\n", - "STAKEHOLDERS = {\n", - " \"sufficiency\": Utility(CURVES, weights={\"sufficient\": 0.7, \"accurate\": 0.3}),\n", - " \"accuracy\": Utility(CURVES, weights={\"sufficient\": 0.3, \"accurate\": 0.7}),\n", - "}\n", - "means = aggregate(\n", - " refinement.results,\n", - " statistics={\"sufficient\": \"sufficient\", \"accurate\": \"accurate\", \"cost p70\": Quantile(\"cost\", 0.7)},\n", - ").set_index(\"design\")\n", - "means[\"description\"] = means.apply(describe, axis=1)\n", - "\n", - "fig, axes = plt.subplots(1, 2, figsize=(11, 4.5), sharey=True)\n", - "judged = {}\n", - "for ax, (name, utility) in zip(axes, STAKEHOLDERS.items()):\n", - " judged[name] = means.assign(utility=utility(means))\n", - " judged[name][\"pareto\"] = pareto_front(judged[name], {\"utility\": \"max\", \"cost p70\": \"min\"})\n", - " legend = \"lower right\" if ax is axes[0] else None\n", - " plot_designs(judged[name], \"cost p70\", \"utility\", by=\"planes\", front=\"pareto\", names=planes_name, legend=legend, ax=ax)\n", - " ax.axvline(BUDGET, color=GRAY, lw=1, ls=\"--\")\n", - " ax.set(xlabel=\"Cost at 70% confidence (millions of dollars)\", ylabel=\"Utility\", ylim=(0, 1.02))\n", - " ax.set_title(f\"Weighing {name} most\", fontsize=10)\n", - " style_axes(ax, grid=\"both\")\n", - "fig.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "f055925e", - "metadata": {}, - "source": [ - "The stakeholders' fronts share most of their designs. Those efficient for one stakeholder and not the other:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "182b77eb", - "metadata": { - "execution": { - "iopub.execute_input": "2026-11-13T02:21:33.788242Z", - "iopub.status.busy": "2026-11-13T02:21:33.788242Z", - "iopub.status.idle": "2026-11-13T02:21:33.804174Z", - "shell.execute_reply": "2026-11-13T02:21:33.804174Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "20 designs are efficient for both\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
descriptionsatellitesplanessufficientaccuratecost p70utility (sufficiency)efficient (sufficiency)utility (accuracy)efficient (accuracy)
design
828c0027d01f800 km, 60 deg FOR, SSO: 1 at 12:00, 2 at 18:003229.257.0156.650.44False0.64True
c576e2e2dbd1800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:003228.860.6156.900.45False0.66True
6ba50f2632cd800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4269.665.4173.730.74True0.80False
3690f1194419800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:004257.685.4173.730.69False0.84True
64cf6542c326800 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...6390.295.8213.530.93False0.96True
\n", - "
" - ], - "text/plain": [ - " description satellites \\\n", - "design \n", - "828c0027d01f 800 km, 60 deg FOR, SSO: 1 at 12:00, 2 at 18:00 3 \n", - "c576e2e2dbd1 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3 \n", - "6ba50f2632cd 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4 \n", - "3690f1194419 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4 \n", - "64cf6542c326 800 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... 6 \n", - "\n", - " planes sufficient accurate cost p70 utility (sufficiency) \\\n", - "design \n", - "828c0027d01f 2 29.2 57.0 156.65 0.44 \n", - "c576e2e2dbd1 2 28.8 60.6 156.90 0.45 \n", - "6ba50f2632cd 2 69.6 65.4 173.73 0.74 \n", - "3690f1194419 2 57.6 85.4 173.73 0.69 \n", - "64cf6542c326 3 90.2 95.8 213.53 0.93 \n", - "\n", - " efficient (sufficiency) utility (accuracy) \\\n", - "design \n", - "828c0027d01f False 0.64 \n", - "c576e2e2dbd1 False 0.66 \n", - "6ba50f2632cd True 0.80 \n", - "3690f1194419 False 0.84 \n", - "64cf6542c326 False 0.96 \n", - "\n", - " efficient (accuracy) \n", - "design \n", - "828c0027d01f True \n", - "c576e2e2dbd1 True \n", - "6ba50f2632cd False \n", - "3690f1194419 True \n", - "64cf6542c326 True " - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# the designs efficient for one stakeholder and not the other\n", - "compared = means[[\"description\", \"satellites\", \"planes\", \"sufficient\", \"accurate\", \"cost p70\"]].copy()\n", - "for name in STAKEHOLDERS:\n", - " compared[f\"utility ({name})\"] = judged[name][\"utility\"]\n", - " compared[f\"efficient ({name})\"] = judged[name][\"pareto\"]\n", - "print(f\"{(compared['efficient (sufficiency)'] & compared['efficient (accuracy)']).sum()} designs are efficient for both\")\n", - "compared[compared[\"efficient (sufficiency)\"] != compared[\"efficient (accuracy)\"]].sort_values(\"cost p70\").round(2)" - ] - }, - { - "cell_type": "markdown", - "id": "eca76b2c", - "metadata": {}, - "source": [ - "Within the budget, the stakeholders agree: every design efficient for either of them up to 150 million dollars is efficient for both, as more satellites in more planes buy both shares. Beyond the budget, they part. For 174 million dollars at 70% confidence, the stakeholder of sufficiency prefers four satellites in two Walker planes (70% of the points sufficiently sampled and 65% accurately), and the stakeholder of accuracy four in two sun-synchronous planes crossing at 09:00 and 15:00 (58% and 85%), whose planes spread the samples over the day. The stakeholder of accuracy also finds three satellites in two sun-synchronous planes efficient for 157 million (57 to 61% accurately sampled), and six in three Walker planes for 214 million (96%), which the stakeholder of sufficiency passes over. A utility is a metric of any statistic (such as `Quantile(utility, 0.1)`, the utility that a design exceeds in 90% of the replicates, for risks that the replicates draw) and so an objective of the searches as well; a multiplicative utility (`form=\"multiplicative\"`) makes the shares complements, both of which a design must serve, or substitutes, either of which suffices." - ] - }, - { - "cell_type": "markdown", - "id": "9e616895", - "metadata": {}, - "source": [ - "## Summary\n", - "\n", - "* A `CostModel` estimates the life-cycle cost of each deployment from the costs of its satellites, launches, and operations (given by the study, as TAT-C includes no cost-estimating relationships), dated by the deployment that a `DeploymentSchedule` plans from rates of production and launch, with uncertain growth whose quantiles give the cost at a confidence level, as an objective or a requirement in place of the numbers of satellites and planes.\n", - "* The costs of the components of satellites (`Component`), whose growth by their maturity is drawn from scores that are uncertain parameters of the design space (`risk_space`, `CostModel.draw`), share cost risk between the designs that share components: with common random numbers, the order of designs of the same imager is settled although they differ by less than their costs spread, and the probability that each design costs more than each other (`exceedance`, `plot_exceedance`) shows where the order of the front is open.\n", - "* A `Utility` weighs metrics by a stakeholder's preferences (a single-attribute utility of each, combined by weights) into one objective against cost, and is a metric of any statistic (its mean is the expected utility): here, stakeholders who weigh sufficiency or accuracy most agree within the budget and part beyond it." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/examples/index.rst b/docs/examples/index.rst index 51e313b0..049b17e8 100644 --- a/docs/examples/index.rst +++ b/docs/examples/index.rst @@ -23,19 +23,12 @@ The following provide examples of TAT-C use in a Jupyter notebook environment. AssessSamplingSufficiency.ipynb RunOSSEMonsoon.ipynb RunOSSEHurricane.ipynb - SearchTradeSpace.ipynb - RankUncertainDesigns.ipynb - CompareScenarios.ipynb - TradeCostAndUtility.ipynb - PlanMissions.ipynb + tradespace/index Note that running the above examples in a local Python environment requires additional dependencies which can be installed via:: pip install tatc[examples] -using the pip package manager. The AssessSamplingSufficiency example also requires xarray (``pip install xarray``) for its nature run. The trade space examples also require:: +using the pip package manager. The AssessSamplingSufficiency example also requires xarray (``pip install xarray``) for its nature run. The trade space tutorial also requires:: pip install tatc[tradespace] - -The trade space examples after the first (SearchTradeSpace) import its design space and study from -``trade_space_example.py``, beside the notebooks. diff --git a/docs/examples/tradespace/CompareScenarios.ipynb b/docs/examples/tradespace/CompareScenarios.ipynb new file mode 100644 index 00000000..8df1d81b --- /dev/null +++ b/docs/examples/tradespace/CompareScenarios.ipynb @@ -0,0 +1,527 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "543ce74b", + "metadata": {}, + "source": [ + "# Compare Designs across Scenarios\n", + "\n", + "How accurately samples estimate a daily mean depends on the field: samples hours apart estimate a field that varies slowly better than one that varies within the hour, such as rain rates. Which field a mission will serve may not be known when it is designed. Replicates average over the sample of points, but the field is a condition under which to compare designs: a **scenario**.\n", + "\n", + "It covers:\n", + "\n", + "* evaluating designs in several **scenarios**;\n", + "* the front of each scenario, and how often each design is efficient;\n", + "* **regret**, and designs that are robust to the scenarios;\n", + "* **searching** for designs that do well across the scenarios.\n", + "\n", + "It builds on `ExplainTradeSpace`: the objectives are fewer satellites, fewer planes, and more points accurately sampled." + ] + }, + { + "cell_type": "markdown", + "id": "0385c85b", + "metadata": {}, + "source": [ + "## Define the Scenarios\n", + "\n", + "A scenario gives other values to fixed values or uncertain parameters of the design space. The field's decorrelation time must therefore be a value of the design space, which the metrics read from each design, rather than a constant of the metrics:\n", + "\n", + "* `field_space` adds the decorrelation time to the design space as a `Fixed` value (3 hours, as in `ExplainTradeSpace`);\n", + "* `sample_field` gives each design's decorrelation time to the metrics of `ExplainTradeSpace` (`sample`);\n", + "* `FIELDS` names three fields, which decorrelate within an hour, in 3 hours, and in 12 hours.\n", + "\n", + "With `scenarios`, the study evaluates every design in each field, with the same samples of points, and records the field as the `scenario` of each evaluation." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "3a8573e7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "16440 evaluations in 144 s\n" + ] + } + ], + "source": [ + "import time\n", + "from datetime import timedelta\n", + "\n", + "import pandas as pd\n", + "\n", + "from trade_space_example import ACCURACY, DECORRELATION_TIME, MAX_SATELLITES, accuracy_study, describe, sample, space\n", + "from tatc.tradespace import Fixed\n", + "\n", + "field_space = space.extend(decorrelation_time=Fixed(DECORRELATION_TIME))\n", + "\n", + "\n", + "def sample_field(observations, design):\n", + " \"\"\"The shares (%) of points sampled sufficiently and accurately (of its field).\"\"\"\n", + " return sample(observations, design.decorrelation_time)\n", + "\n", + "\n", + "FIELDS = {\n", + " \"1 hour\": {\"decorrelation_time\": timedelta(hours=1)},\n", + " \"3 hours\": {}, # the fixed value\n", + " \"12 hours\": {\"decorrelation_time\": timedelta(hours=12)},\n", + "}\n", + "field_study = accuracy_study.replace(space=field_space, metrics=sample_field, scenarios=FIELDS)\n", + "began = time.perf_counter()\n", + "fields = field_study.run() # every design of the design space, in each field\n", + "print(f\"{len(fields)} evaluations in {time.perf_counter() - began:.0f} s\")" + ] + }, + { + "cell_type": "markdown", + "id": "abea8201", + "metadata": {}, + "source": [ + "## Compare the Fronts of the Scenarios\n", + "\n", + "Criteria `by` the scenario judge designs in each field: `aggregate` summarizes each design in each field, and `pareto_front` finds the front of each field. `robustness` gives the share of the fields in which each design is efficient (its **Pareto trace**). The table gives the designs efficient in more than half of the fields:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "98c12199", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "efficient designs: {'1 hour': 14, '3 hours': 13, '12 hours': 6}\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanes1 hour3 hours12 hourspareto_trace
design
33b006848799800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.026.234.260.40.67
b85daf65c3a4800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...3.01.08.017.095.60.67
c576e2e2dbd1800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:003.02.040.860.685.80.67
3690f1194419800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:004.02.069.085.493.00.67
cb6bd361b577800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.096.696.697.80.67
5529c21520be800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.897.80.67
de505bc89299800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.897.80.67
679ca275c8fc800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.897.80.67
\n", + "
" + ], + "text/plain": [ + " description satellites \\\n", + "design \n", + "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 \n", + "b85daf65c3a4 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... 3.0 \n", + "c576e2e2dbd1 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3.0 \n", + "3690f1194419 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4.0 \n", + "cb6bd361b577 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 \n", + "5529c21520be 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", + "de505bc89299 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", + "679ca275c8fc 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", + "\n", + " planes 1 hour 3 hours 12 hours pareto_trace \n", + "design \n", + "33b006848799 2.0 26.2 34.2 60.4 0.67 \n", + "b85daf65c3a4 1.0 8.0 17.0 95.6 0.67 \n", + "c576e2e2dbd1 2.0 40.8 60.6 85.8 0.67 \n", + "3690f1194419 2.0 69.0 85.4 93.0 0.67 \n", + "cb6bd361b577 4.0 96.6 96.6 97.8 0.67 \n", + "5529c21520be 3.0 97.8 97.8 97.8 0.67 \n", + "de505bc89299 3.0 97.8 97.8 97.8 0.67 \n", + "679ca275c8fc 3.0 97.8 97.8 97.8 0.67 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import Criteria, aggregate, pareto_front, robustness\n", + "\n", + "BY_FIELD = Criteria(ACCURACY, by=\"scenario\")\n", + "by_field = aggregate(fields, BY_FIELD)\n", + "by_field[\"pareto\"] = pareto_front(by_field, BY_FIELD)\n", + "print(\"efficient designs:\", by_field[by_field.pareto].scenario.value_counts()[list(FIELDS)].to_dict())\n", + "\n", + "# a row per design: its share accurately sampled in each field, and the share of the fields in which it is efficient\n", + "values = by_field.drop_duplicates(\"design\").set_index(\"design\") # the values of each design\n", + "traced = pd.DataFrame(\n", + " {\"description\": values.apply(describe, axis=1), \"satellites\": values.satellites, \"planes\": values.planes}\n", + ")\n", + "traced = traced.join(by_field.pivot(index=\"design\", columns=\"scenario\", values=\"accurate\")[list(FIELDS)])\n", + "traced[\"pareto_trace\"] = robustness(fields, ACCURACY).set_index(\"design\")[\"pareto_trace\"]\n", + "traced[traced.pareto_trace > 0.5].sort_values([\"satellites\", \"planes\"]).round(2)" + ] + }, + { + "cell_type": "markdown", + "id": "d6ecc9d6", + "metadata": {}, + "source": [ + "Which designs are efficient depends on the field: 14 designs in the field of 1 hour, 13 in that of 3 hours, and 6 in that of 12 hours, and no design is efficient in all three. In the field of 12 hours, one plane samples well: three satellites in one plane sample 96% of the points accurately. In the fields that vary within hours, the samples must spread over the day: the same three satellites sample 17% (3 hours) and 8% (1 hour), against 61% and 41% for three satellites in two sun-synchronous planes." + ] + }, + { + "cell_type": "markdown", + "id": "859facfc", + "metadata": {}, + "source": [ + "## Choose a Robust Design\n", + "\n", + "A design need not be efficient in any field to be a good choice when the field is unknown. Its **regret** in a field is how far it falls behind the best design there, and a **robust** design has the least regret in its worst field.\n", + "\n", + "Regret here is in one objective, the share accurately sampled, among the designs of at most a number of satellites (a `Requirement`). With the numbers of satellites and planes as objectives too, a design could match the cheapest efficient design by dropping satellites, and regret would mostly count satellites." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b49af74c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanesmax_regret1 hour regret3 hours regret12 hours regret
at most
2800 km, 60 deg FOR, Walker 75 deg: 2 x 1 (spac...2.02.011.07.66.411.0
3800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:003.02.09.89.80.49.8
4800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:004.02.05.00.00.05.0
6700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...6.03.00.40.40.20.4
\n", + "
" + ], + "text/plain": [ + " description satellites \\\n", + "at most \n", + "2 800 km, 60 deg FOR, Walker 75 deg: 2 x 1 (spac... 2.0 \n", + "3 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3.0 \n", + "4 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4.0 \n", + "6 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... 6.0 \n", + "\n", + " planes max_regret 1 hour regret 3 hours regret 12 hours regret \n", + "at most \n", + "2 2.0 11.0 7.6 6.4 11.0 \n", + "3 2.0 9.8 9.8 0.4 9.8 \n", + "4 2.0 5.0 0.0 0.0 5.0 \n", + "6 3.0 0.4 0.4 0.2 0.4 " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import Requirement\n", + "\n", + "robust = []\n", + "for limit in (2, 3, 4, 6):\n", + " within = Criteria({\"accurate\": \"max\"}, requirements=[Requirement(\"satellites\", \"<=\", limit)])\n", + " regret = robustness(fields, within).set_index(\"design\")\n", + " best = regret[\"max_regret\"].idxmin() # the design of least regret in its worst field\n", + " robust.append(\n", + " {\n", + " \"at most\": limit,\n", + " **traced.loc[best, [\"description\", \"satellites\", \"planes\"]],\n", + " **regret.loc[best].drop(\"pareto_trace\"),\n", + " }\n", + " )\n", + "pd.DataFrame(robust).set_index(\"at most\").round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "5f0a5cfd", + "metadata": {}, + "source": [ + "The robust choice depends on how many satellites the mission can afford. Four satellites in two sun-synchronous planes, crossing the equator at 09:00 and 15:00, are the best in the fields of 1 and 3 hours, and fall 5 points behind the best in the field of 12 hours: a mission that does not know its field loses little by choosing them. Two or three satellites fall 10 or 11 points behind somewhere. Six satellites in three Walker planes (at 700 km) fall at most 0.4 points behind the best in any field, though they are efficient in none: a robust design need not be the best in any scenario. Regrets of a point or two are within the sampling error of the means of five replicates." + ] + }, + { + "cell_type": "markdown", + "id": "57bc8db1", + "metadata": {}, + "source": [ + "## Search for Robust Designs\n", + "\n", + "A search needs one value of each objective for each design, not one for each field. Criteria `across` the fields (`Across`) combine the statistics of each design over the fields: by their mean (`rule=\"mean\"`), or by their worst (`rule=\"worst\"`).\n", + "\n", + "Here, pymoo searches for the designs most accurate on average over the three fields, with as many proposals as in `SearchTradeSpace`. It evaluates each design that it proposes in every field. Every design was evaluated above, so the results come from the store, and the search can be compared with the true front of the mean." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f113c781", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "147 designs evaluated (in 3 fields each): 99.3% of the hypervolume of the true front, and 8 of its 12 designs\n", + "the field in which each design is least accurate: {'1 hour': 1028, '3 hours': 68}\n" + ] + } + ], + "source": [ + "from pymoo.algorithms.moo.nsga2 import NSGA2\n", + "\n", + "from tatc.tradespace import Across, hypervolume, hypervolume_progress, optimize_pymoo\n", + "\n", + "FIELD_MEAN = Criteria(ACCURACY, across=Across(rule=\"mean\"))\n", + "REFERENCE = {\"satellites\": MAX_SATELLITES + 1, \"planes\": 5, \"accurate\": 0} # worse than every design\n", + "mean_summary = aggregate(fields, FIELD_MEAN)\n", + "true_front = set(mean_summary.design[pareto_front(mean_summary, FIELD_MEAN)])\n", + "true_hypervolume = hypervolume(mean_summary, FIELD_MEAN, REFERENCE)\n", + "\n", + "search = optimize_pymoo(field_study, FIELD_MEAN, NSGA2(pop_size=20), (\"n_gen\", 10), seed=1) # 200 proposals\n", + "found = 100 * hypervolume_progress(search.results, FIELD_MEAN, REFERENCE).iloc[-1] / true_hypervolume\n", + "evaluated = set(search.results.design)\n", + "print(\n", + " f\"{len(evaluated)} designs evaluated (in {len(FIELDS)} fields each): {found:.1f}% of the hypervolume of the true \"\n", + " f\"front, and {len(evaluated & true_front)} of its {len(true_front)} designs\"\n", + ")\n", + "print(\"the field in which each design is least accurate:\", traced[list(FIELDS)].idxmin(axis=1).value_counts().to_dict())" + ] + }, + { + "cell_type": "markdown", + "id": "8a515dfc", + "metadata": {}, + "source": [ + "The search finds 99.3% of the hypervolume of the true front of the mean with 147 designs, and 8 of its 12 designs. Each design costs three times as much as in a search of one field, as it is evaluated in each field.\n", + "\n", + "A worst case (`rule=\"worst\"`) suits scenarios that are hardest for different designs. Here, the field that varies within an hour is the hardest for 1,028 of the 1,096 designs, so a search by the worst would mostly search that field alone." + ] + }, + { + "cell_type": "markdown", + "id": "9efa8455", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "* The `scenarios` of a study compare designs under conditions rather than averaging over them. A scenario sets values of the design space (here, a `Fixed` decorrelation time of the field), and the study evaluates each design in each scenario, with the same replicates.\n", + "* Criteria `by` the scenario give the front of each scenario, and `robustness` the share of the scenarios in which each design is efficient (its Pareto trace) and its regret in each. The design of least maximum regret is a robust choice, whether or not it is efficient in any scenario.\n", + "* Criteria `across` the scenarios (`Across`) judge each design once, by its mean or its worst over them, as a search for robust designs needs.\n", + "\n", + "The next notebook, `TradeCostAndUtility`, replaces the numbers of satellites and planes with costs." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/tradespace/EvaluateTradeSpace.ipynb b/docs/examples/tradespace/EvaluateTradeSpace.ipynb new file mode 100644 index 00000000..1ecd6086 --- /dev/null +++ b/docs/examples/tradespace/EvaluateTradeSpace.ipynb @@ -0,0 +1,587 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a1013bb7", + "metadata": {}, + "source": [ + "# Evaluate a Trade Space\n", + "\n", + "This is the first of eight notebooks on trade studies with the `tatc.tradespace` module (installed with `pip install tatc[tradespace]`). Together they follow one trade from start to finish, and each adds one idea to the notebooks before it.\n", + "\n", + "The trade is that of a pre-Phase A study of an imaging constellation: **how many satellites, in how many orbit planes, observe the Earth often enough?** Each orbit plane needs its own launch, so fewer planes cost less. A point on the Earth is **sufficiently sampled** if it is observed at least four times a day.\n", + "\n", + "This notebook takes the four steps of every trade study:\n", + "\n", + "1. declare the **design space**: the decisions and their options;\n", + "2. define the **study**: how each design is built and evaluated;\n", + "3. **evaluate** the designs;\n", + "4. find the **Pareto-efficient** designs, and plot the trade." + ] + }, + { + "cell_type": "markdown", + "id": "b4df384d", + "metadata": {}, + "source": [ + "## Configure the Analysis\n", + "\n", + "Each design is analyzed over one day, at 100 points on the Earth, and may have at most 10 satellites." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "dc3c266d", + "metadata": {}, + "outputs": [], + "source": [ + "from datetime import datetime, timedelta, timezone\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "START = datetime(2026, 7, 1, tzinfo=timezone.utc)\n", + "DURATION = timedelta(days=1) # the period of the analysis\n", + "N_POINTS = 100 # points sampled in each replicate\n", + "N_REPLICATES = 5 # replicates (samples of points) of each design\n", + "SAMPLES_PER_DAY = 4 # observations a day of a sufficiently sampled point\n", + "MAX_SATELLITES = 10" + ] + }, + { + "cell_type": "markdown", + "id": "56bf65c9", + "metadata": {}, + "source": [ + "## Declare the Design Space\n", + "\n", + "A `DesignSpace` names each decision and its options. Every design here has:\n", + "\n", + "* an **altitude**: 500 to 800 km, in steps of 100 km (`Real`);\n", + "* an imager's **field of regard**: 30 or 60 degrees (`Categorical`);\n", + "* a **layout** of its orbits, one of two alternatives (a `Choice`):\n", + " * a **Walker** constellation (`walker_space`): an inclination, a number of planes, a number of satellites in each plane, and the phasing of the satellites between planes; or\n", + " * one or two **sun-synchronous** planes (`sso_planes_space`), each with an equator crossing time and one or two satellites.\n", + "\n", + "Each alternative has its own decisions: only Walker designs have an inclination. A constraint limits a design to 10 satellites. It returns the number of satellites over the limit, and a design is feasible if that number is zero or less.\n", + "\n", + "The last entry, `points_seed`, is not a decision. It is an `Uncertain` parameter, which the next section explains." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b72d42b0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1096 feasible designs\n" + ] + } + ], + "source": [ + "from tatc.tradespace import (\n", + " Categorical,\n", + " Choice,\n", + " DesignSpace,\n", + " Integer,\n", + " Real,\n", + " Uncertain,\n", + " count_satellites,\n", + " sso_planes_space,\n", + " walker_space,\n", + ")\n", + "\n", + "space = DesignSpace(\n", + " altitude=Real(500e3, 800e3, step=100e3),\n", + " field_of_regard=Categorical([30, 60]),\n", + " layout=Choice(\n", + " walker=walker_space(\n", + " inclination=Real(45, 75, step=15),\n", + " planes=Integer(1, 4),\n", + " per_plane=Integer(1, 4),\n", + " ),\n", + " sso=sso_planes_space(\n", + " crossing=Real(6, 18, step=3),\n", + " satellites=Integer(1, 2),\n", + " count=Integer(1, 2),\n", + " ),\n", + " ),\n", + " points_seed=Uncertain.seed(),\n", + " constraints=[lambda d: count_satellites(d.layout) - MAX_SATELLITES],\n", + ")\n", + "designs = space.enumerate()\n", + "print(f\"{len(designs)} feasible designs\")" + ] + }, + { + "cell_type": "markdown", + "id": "f9e79a13", + "metadata": {}, + "source": [ + "## Define the Study\n", + "\n", + "A study evaluates each design in three steps:\n", + "\n", + "1. **build** its satellites: an imager in each orbit of its layout (`build`, with `build_constellation`);\n", + "2. **observe** points on the Earth for a day (`Observations` of `Targets`);\n", + "3. **measure** the observations: the share of points observed at least four times (`count_samples`).\n", + "\n", + "The points are a random sample of the Earth, so a share is an estimate, with sampling error. The study therefore evaluates each design five times, in five **replicates**. Each replicate draws its own sample of points from the uncertain `points_seed`, and every design sees the same five samples, so that differences between designs are not differences between their samples. The points of a sample are a lattice in a random orientation (`generate_points_rotated_lattice`), which covers the Earth evenly.\n", + "\n", + "`ObservationStudy` combines the three steps. Its other arguments:\n", + "\n", + "* `layout` names the decision whose satellites and planes the study counts;\n", + "* `n_jobs=-1` evaluates designs in parallel, on every processor;\n", + "* the `directory` of the `Observations` caches the observations of each satellite on disk, as many designs share satellites;\n", + "* `store` keeps the results in a file: running the notebook again reads them rather than evaluating the designs again (unless the study changes)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8baff2c8", + "metadata": {}, + "outputs": [], + "source": [ + "import tempfile\n", + "from pathlib import Path\n", + "\n", + "from tatc.generation import generate_points_rotated_lattice\n", + "from tatc.schemas import Instrument\n", + "from tatc.tradespace import ObservationStudy, Observations, ResultStore, Targets, build_constellation\n", + "\n", + "\n", + "def build(d):\n", + " \"\"\"The satellites of a design: an imager in each orbit of its layout.\"\"\"\n", + " imager = Instrument(name=\"imager\", field_of_regard=d.field_of_regard)\n", + " return build_constellation(d.layout, imager, epoch=START, altitude=d.altitude)\n", + "\n", + "\n", + "def count_samples(observations, duration=DURATION):\n", + " \"\"\"The share (%) of points observed at least SAMPLES_PER_DAY times a day.\"\"\"\n", + " if len(observations) == 0: # no satellites\n", + " return {\"sufficient\": 0.0}\n", + " samples = observations.groupby(\"target_hash\").size()\n", + " threshold = SAMPLES_PER_DAY * duration / timedelta(days=1)\n", + " return {\"sufficient\": 100 * (samples >= threshold).sum() / N_POINTS}\n", + "\n", + "\n", + "CACHE_DIRECTORY = Path(tempfile.gettempdir()) / \"tatc-trade-space\"\n", + "# the points of each replicate: a lattice in a random orientation, from its seed\n", + "TARGETS = Targets(generate_points_rotated_lattice, N_POINTS, seed=\"points_seed\")\n", + "OBSERVATIONS = Observations(TARGETS, START, DURATION, directory=CACHE_DIRECTORY)\n", + "\n", + "study = ObservationStudy(\n", + " space,\n", + " build,\n", + " OBSERVATIONS,\n", + " count_samples,\n", + " layout=\"layout\",\n", + " replicates=N_REPLICATES,\n", + " n_jobs=-1,\n", + " store=ResultStore(CACHE_DIRECTORY / \"results.sqlite\"),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "9b2c51ab", + "metadata": {}, + "source": [ + "## Evaluate Every Design\n", + "\n", + "The design space is small enough to evaluate every design: 1,096 designs in five replicates each, which takes a few minutes the first time. `study.run` gives a row per evaluation (a design in a replicate), with the design's values and its metrics. The rows of the last design show how its share differs between its five samples of points:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "bfa6842a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5480 evaluations: 1096 designs x 5 replicates\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
designreplicatealtitudefield_of_regardlayoutsatellitesplanessufficient
547529287797ce8d0800000.060sso4256.0
547629287797ce8d1800000.060sso4252.0
547729287797ce8d2800000.060sso4253.0
547829287797ce8d3800000.060sso4250.0
547929287797ce8d4800000.060sso4258.0
\n", + "
" + ], + "text/plain": [ + " design replicate altitude field_of_regard layout satellites \\\n", + "5475 29287797ce8d 0 800000.0 60 sso 4 \n", + "5476 29287797ce8d 1 800000.0 60 sso 4 \n", + "5477 29287797ce8d 2 800000.0 60 sso 4 \n", + "5478 29287797ce8d 3 800000.0 60 sso 4 \n", + "5479 29287797ce8d 4 800000.0 60 sso 4 \n", + "\n", + " planes sufficient \n", + "5475 2 56.0 \n", + "5476 2 52.0 \n", + "5477 2 53.0 \n", + "5478 2 50.0 \n", + "5479 2 58.0 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results = study.run(designs)\n", + "print(f\"{len(results)} evaluations: {len(designs)} designs x {N_REPLICATES} replicates\")\n", + "results[[\"design\", \"replicate\", \"altitude\", \"field_of_regard\", \"layout\", \"satellites\", \"planes\", \"sufficient\"]].tail()" + ] + }, + { + "cell_type": "markdown", + "id": "3006bd09", + "metadata": {}, + "source": [ + "## Find the Efficient Designs\n", + "\n", + "`summarize` averages the replicates of each design: a row per design, with the mean of each metric and its standard error (`se`, the uncertainty of the mean).\n", + "\n", + "The objectives are fewer satellites, fewer planes, and more points sufficiently sampled. A design is **Pareto-efficient** if no other design is as good in every objective and better in one. `pareto_front` finds the efficient designs, given whether each objective is minimized or maximized. (`describe`, from the module `trade_space_example.py` beside the notebooks, describes each design in a few words.)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "51e489ee", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanessufficientsufficient se
1054800 km, 60 deg FOR, SSO: 1 at 18:001.01.03.20.9
960800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...2.01.016.61.2
963800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.030.22.2
961800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...3.01.038.01.2
962800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.068.21.8
965800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.069.60.8
1025800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.80.2
\n", + "
" + ], + "text/plain": [ + " description satellites planes \\\n", + "1054 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", + "960 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 1.0 \n", + "963 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", + "961 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 1.0 \n", + "962 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", + "965 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", + "1025 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "\n", + " sufficient sufficient se \n", + "1054 3.2 0.9 \n", + "960 16.6 1.2 \n", + "963 30.2 2.2 \n", + "961 38.0 1.2 \n", + "962 68.2 1.8 \n", + "965 69.6 0.8 \n", + "1025 97.8 0.2 " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from trade_space_example import describe\n", + "from tatc.tradespace import pareto_front, summarize\n", + "\n", + "OBJECTIVES = {\"satellites\": \"min\", \"planes\": \"min\", \"sufficient\": \"max\"}\n", + "summary = summarize(results, list(OBJECTIVES))\n", + "summary[\"pareto\"] = pareto_front(summary, OBJECTIVES)\n", + "summary[\"description\"] = summary.apply(describe, axis=1)\n", + "front = summary[summary.pareto].sort_values([\"satellites\", \"planes\"])\n", + "front[[\"description\", \"satellites\", \"planes\", \"sufficient\", \"sufficient se\"]].round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "1a98d723", + "metadata": {}, + "source": [ + "## Plot the Trade\n", + "\n", + "`plot_designs` plots every design by two metrics, colored by a third, with the efficient designs ringed:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "67e1b2d6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from trade_space_example import planes_name\n", + "from tatc.tradespace import plot_designs\n", + "\n", + "ax = plot_designs(\n", + " summary,\n", + " \"satellites\",\n", + " \"sufficient\",\n", + " by=\"planes\",\n", + " front=\"pareto\",\n", + " labels=lambda row: f\"{row.satellites:.0f} sat., {row.planes:.0f} pl.\",\n", + " names=planes_name,\n", + " jitter=0.18, # spreads the designs of each number of satellites, for legibility\n", + " legend=\"upper left\",\n", + ")\n", + "ax.set(\n", + " xlabel=\"Satellites\", ylabel=\"Points sufficiently sampled (%)\", xticks=range(1, MAX_SATELLITES + 1), ylim=(0, 105)\n", + ")\n", + "ax.set_title(\"Every design: mean over 5 replicates\", fontsize=10)\n", + "ax.figure.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "31679604", + "metadata": {}, + "source": [ + "Seven of the 1,096 designs are efficient. All of them fly at 800 km with the wider field of regard (60 degrees), which observe the most points per satellite, so the trade is in the numbers of satellites and planes:\n", + "\n", + "* one satellite samples only 3% of the points sufficiently;\n", + "* two satellites in two planes sample 30%, nearly twice as many as two in one plane (17%);\n", + "* four satellites sample about two thirds of the points, in one plane or two (68% and 70%);\n", + "* six satellites in two planes sample 98%, and no design of more satellites is efficient.\n", + "\n", + "Designs with the same number of satellites differ widely (the vertical spread in the figure): their layout matters as much as their number." + ] + }, + { + "cell_type": "markdown", + "id": "a520edc9", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "* A `DesignSpace` declares the decisions of a trade, with choices between alternatives (`Choice`), constraints, and uncertain parameters (`Uncertain`) drawn for each replicate.\n", + "* An `ObservationStudy` builds, observes, and measures each design in replicates, in parallel, with a cache of observations and a store of results.\n", + "* `summarize` averages the replicates of each design, and `pareto_front` and `plot_designs` find and show the efficient designs.\n", + "\n", + "The next notebook, `ExplainTradeSpace`, measures sampling by its purpose and explains why designs differ. The notebooks after it search larger spaces (`SearchTradeSpace`), rank designs with the uncertainty of their replicates (`RankUncertainDesigns`), compare them across scenarios (`CompareScenarios`), trade their cost and utility (`TradeCostAndUtility`), and plan their deployment (`PlanDeployment`) and failures (`PlanForFailures`)." + ] + }, + { + "cell_type": "markdown", + "id": "ad59ce96", + "metadata": {}, + "source": [ + "## Notes\n", + "\n", + "* `trade_space_example.py` repeats the design space and study of this notebook, and the parts of later notebooks that the notebooks after them use, so that each notebook can import them.\n", + "* The building blocks of the layouts declare more than this notebook needs to say: the phasing of a Walker constellation depends on its number of planes, and sun-synchronous planes are unordered and must cross the equator at different times. See `walker_space` and `sso_planes_space`." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/tradespace/ExplainTradeSpace.ipynb b/docs/examples/tradespace/ExplainTradeSpace.ipynb new file mode 100644 index 00000000..9740bc45 --- /dev/null +++ b/docs/examples/tradespace/ExplainTradeSpace.ipynb @@ -0,0 +1,678 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "f9d27900", + "metadata": {}, + "source": [ + "# Explain a Trade Space\n", + "\n", + "`EvaluateTradeSpace` counted samples: a point is sufficiently sampled if it is observed at least four times a day. But four samples minutes apart say less than four spread over the day. This notebook measures sampling by its purpose, then explains why designs differ.\n", + "\n", + "It covers:\n", + "\n", + "* a second objective, from the **sampling error** of each point;\n", + "* **revisit statistics**, which explain the difference between the two objectives;\n", + "* **sensitivity**: which decisions drive each objective.\n", + "\n", + "It imports the design space and study of `EvaluateTradeSpace` from `trade_space_example.py`, beside the notebooks." + ] + }, + { + "cell_type": "markdown", + "id": "0adbc68c", + "metadata": {}, + "source": [ + "## Measure the Sampling Error\n", + "\n", + "Suppose that the observations estimate the daily mean of a field that varies within hours, such as convective precipitation. A point is **accurately sampled** if the mean of its samples estimates the daily mean with an error of at most half the field's standard deviation. Samples closer together than the field's **decorrelation time** (here, 3 hours) repeat each other, so they add little. `estimate_sampling_error` estimates the error at each point from the times of its samples.\n", + "\n", + "The new metrics function (`sample`) gives both shares. `study.replace` copies the study with the new metrics. The copy is a new study, which evaluates every design again, from the cached observations." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "31b6ae51", + "metadata": {}, + "outputs": [], + "source": [ + "from datetime import timedelta\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "\n", + "from trade_space_example import DURATION, N_POINTS, SAMPLES_PER_DAY, START, describe, designs, planes_name, space, study\n", + "from tatc.analysis import estimate_sampling_error\n", + "from tatc.tradespace import summarize\n", + "\n", + "DECORRELATION_TIME = timedelta(hours=3) # of the field whose daily mean is estimated\n", + "MAX_RELATIVE_ERROR = 0.5 # of an accurate sample, in standard deviations of the field\n", + "\n", + "\n", + "def sample(observations, decorrelation_time=DECORRELATION_TIME):\n", + " \"\"\"The shares (%) of points sampled sufficiently and accurately.\"\"\"\n", + " if len(observations) == 0: # no satellites\n", + " return {\"sufficient\": 0.0, \"accurate\": 0.0}\n", + " samples = observations.groupby(\"target_hash\").size()\n", + " end = START + DURATION\n", + " error = estimate_sampling_error(observations, START, end, decorrelation_time)\n", + " return {\n", + " \"sufficient\": 100 * (samples >= SAMPLES_PER_DAY).sum() / N_POINTS,\n", + " \"accurate\": 100 * (error.relative_error <= MAX_RELATIVE_ERROR).sum() / N_POINTS,\n", + " }\n", + "\n", + "\n", + "accuracy_study = study.replace(metrics=sample)\n", + "results = accuracy_study.run(designs)\n", + "summary = summarize(results, [\"satellites\", \"planes\", \"sufficient\", \"accurate\"])\n", + "summary[\"description\"] = summary.apply(describe, axis=1)" + ] + }, + { + "cell_type": "markdown", + "id": "286c62a6", + "metadata": {}, + "source": [ + "The figure compares the two shares of every design. A design on the dashed line samples as many points accurately as sufficiently." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e49e4549", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from tatc.tradespace import plot_designs, style_axes\n", + "from tatc.tradespace.plotting import GRAY\n", + "\n", + "fig, ax = plt.subplots(figsize=(6.5, 5))\n", + "plot_designs(summary, \"sufficient\", \"accurate\", by=\"planes\", names=planes_name, legend=\"upper left\", ax=ax)\n", + "ax.plot([0, 100], [0, 100], color=GRAY, lw=1, ls=\"--\")\n", + "ax.set(xlabel=\"Points sufficiently sampled (%)\", ylabel=\"Points accurately sampled (%)\", xlim=(0, 102), ylim=(0, 102))\n", + "style_axes(ax, grid=\"both\")\n", + "ax.set_title(\"Two measures of sampling, for every design\", fontsize=10)\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f9d2e808", + "metadata": {}, + "source": [ + "Designs in one plane (blue) fall far below the line: they sample many points four times a day, but few of them accurately. Designs in two or more planes lie near the line or above it." + ] + }, + { + "cell_type": "markdown", + "id": "a4331a7b", + "metadata": {}, + "source": [ + "## Find the Efficient Designs by Accuracy\n", + "\n", + "With the share accurately sampled as the third objective, in place of the share sufficiently sampled, the efficient designs change:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "3a483aa6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanessufficientaccurateaccurate se
1050800 km, 60 deg FOR, SSO: 1 at 12:001.01.03.04.20.6
1047800 km, 60 deg FOR, SSO: 2 at 06:002.01.011.610.40.9
963800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.030.234.21.8
1019800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...3.01.026.217.01.1
1075800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:003.02.028.860.61.3
1001800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac...3.03.034.261.03.8
1020800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac...4.01.049.228.62.1
1081800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:004.02.057.685.40.7
758700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...6.03.089.096.40.5
1045800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...8.04.097.896.60.5
1035800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.80.2
1036800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.80.2
1037800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...9.03.097.897.80.2
\n", + "
" + ], + "text/plain": [ + " description satellites planes \\\n", + "1050 800 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", + "1047 800 km, 60 deg FOR, SSO: 2 at 06:00 2.0 1.0 \n", + "963 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", + "1019 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... 3.0 1.0 \n", + "1075 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3.0 2.0 \n", + "1001 800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac... 3.0 3.0 \n", + "1020 800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac... 4.0 1.0 \n", + "1081 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4.0 2.0 \n", + "758 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... 6.0 3.0 \n", + "1045 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", + "1035 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "1036 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "1037 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", + "\n", + " sufficient accurate accurate se \n", + "1050 3.0 4.2 0.6 \n", + "1047 11.6 10.4 0.9 \n", + "963 30.2 34.2 1.8 \n", + "1019 26.2 17.0 1.1 \n", + "1075 28.8 60.6 1.3 \n", + "1001 34.2 61.0 3.8 \n", + "1020 49.2 28.6 2.1 \n", + "1081 57.6 85.4 0.7 \n", + "758 89.0 96.4 0.5 \n", + "1045 97.8 96.6 0.5 \n", + "1035 97.8 97.8 0.2 \n", + "1036 97.8 97.8 0.2 \n", + "1037 97.8 97.8 0.2 " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import pareto_front\n", + "\n", + "ACCURACY = {\"satellites\": \"min\", \"planes\": \"min\", \"accurate\": \"max\"}\n", + "summary[\"pareto\"] = pareto_front(summary, ACCURACY)\n", + "summary[summary.pareto].sort_values([\"satellites\", \"planes\"])[\n", + " [\"description\", \"satellites\", \"planes\", \"sufficient\", \"accurate\", \"accurate se\"]\n", + "].round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "8dac1bcb", + "metadata": {}, + "source": [ + "Thirteen designs are efficient by accuracy, against seven by sufficiency, and the designs that spread their samples over the day join the front:\n", + "\n", + "* two satellites in two Walker planes sample 34% of the points accurately, three times as many as two in one plane (10%);\n", + "* three satellites in two sun-synchronous planes, or in three Walker planes, sample 61%, against 17% for three in one plane;\n", + "* four satellites in two sun-synchronous planes, crossing the equator at 09:00 and 15:00, sample 85%, against 29% for four in one plane;\n", + "* six satellites in three planes sample 96%, nearly as many as nine (98%)." + ] + }, + { + "cell_type": "markdown", + "id": "53f2a714", + "metadata": {}, + "source": [ + "## Explain the Difference\n", + "\n", + "Why do designs in one plane sample so few points accurately? Two designs of four satellites show why: the one in a single plane that samples the most points sufficiently, and the one that samples the most points accurately. For the points of the first replicate (`observations_of` and `targets_of` the study):\n", + "\n", + "* `compute_revisit_statistics` gives the times between the samples of each point, and the longest gap of the day;\n", + "* `compute_local_time_coverage` gives the number of the eight 3-hour intervals of local time in which each point is sampled." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "56b79a0d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sufficient (%)accurate (%)median revisit (h)median longest gap (h)median 3-h intervals sampled
design
800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spacing 0)68.226.80.413.82.0
800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:0057.685.45.97.64.0
\n", + "
" + ], + "text/plain": [ + " sufficient (%) \\\n", + "design \n", + "800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spaci... 68.2 \n", + "800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 57.6 \n", + "\n", + " accurate (%) \\\n", + "design \n", + "800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spaci... 26.8 \n", + "800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 85.4 \n", + "\n", + " median revisit (h) \\\n", + "design \n", + "800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spaci... 0.4 \n", + "800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 5.9 \n", + "\n", + " median longest gap (h) \\\n", + "design \n", + "800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spaci... 13.8 \n", + "800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 7.6 \n", + "\n", + " median 3-h intervals sampled \n", + "design \n", + "800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spaci... 2.0 \n", + "800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4.0 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.analysis import compute_local_time_coverage, compute_revisit_statistics\n", + "\n", + "four = summary[summary.satellites == 4]\n", + "# the design of four satellites in one plane that samples the most points sufficiently, and the design of four that\n", + "# samples the most points accurately\n", + "chosen = pd.concat([four[four.planes == 1].nlargest(1, \"sufficient\"), four.nlargest(1, \"accurate\")])\n", + "rows = []\n", + "for design, row in zip(space.designs_of(chosen), chosen.itertuples()):\n", + " observations = accuracy_study.observations_of(design)\n", + " points = accuracy_study.targets_of(design)\n", + " revisits = compute_revisit_statistics(observations, START, START + DURATION, targets=points)\n", + " local = compute_local_time_coverage(observations, targets=points)\n", + " sampled = revisits[revisits.samples > 0]\n", + " rows.append(\n", + " {\n", + " \"design\": row.description,\n", + " \"sufficient (%)\": row.sufficient,\n", + " \"accurate (%)\": row.accurate,\n", + " \"median revisit (h)\": sampled[\"revisit p50\"].dt.total_seconds().median() / 3600,\n", + " \"median longest gap (h)\": revisits.max_gap.dt.total_seconds().median() / 3600,\n", + " \"median 3-h intervals sampled\": local.local_bins_sampled.median(),\n", + " }\n", + " )\n", + "pd.DataFrame(rows).set_index(\"design\").round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "8340a8fa", + "metadata": {}, + "source": [ + "Satellites that follow each other in one plane pass over a point minutes apart, then leave it for most of the day. The four satellites in one Walker plane sample 68% of the points at least four times a day, but only 27% accurately: half of their revisits are 0.4 hours apart, and they leave a gap of 13.8 hours. The four satellites in two sun-synchronous planes sample fewer points four times (58%), but 85% accurately: their samples are 5.9 hours apart, in four of the eight 3-hour intervals of the day." + ] + }, + { + "cell_type": "markdown", + "id": "7f13afa7", + "metadata": {}, + "source": [ + "## Find What Drives the Objectives\n", + "\n", + "`sensitivity` estimates the share of the variance of each objective, over the designs, that each decision explains. The summary keeps the decisions of each design as columns, named by their paths (such as `layout.walker.planes`). A decision of one alternative is judged among the designs that have it (their share is `active`): the Walker decisions among the Walker designs. The shares are adjusted for what a decision would explain by chance." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "230cc714", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sufficientaccurateactive
variable
field_of_regard0.250.251.00
layout.walker.per_plane0.220.180.64
layout0.190.121.00
layout.walker.planes0.120.290.64
layout.sso.planes.count0.100.190.36
altitude0.030.031.00
layout.walker.relative_spacing0.030.060.64
layout.walker.inclination0.000.000.64
\n", + "
" + ], + "text/plain": [ + " sufficient accurate active\n", + "variable \n", + "field_of_regard 0.25 0.25 1.00\n", + "layout.walker.per_plane 0.22 0.18 0.64\n", + "layout 0.19 0.12 1.00\n", + "layout.walker.planes 0.12 0.29 0.64\n", + "layout.sso.planes.count 0.10 0.19 0.36\n", + "altitude 0.03 0.03 1.00\n", + "layout.walker.relative_spacing 0.03 0.06 0.64\n", + "layout.walker.inclination 0.00 0.00 0.64" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import sensitivity\n", + "\n", + "decisions = [\n", + " \"altitude\",\n", + " \"field_of_regard\",\n", + " \"layout\",\n", + " \"layout.walker.inclination\",\n", + " \"layout.walker.planes\",\n", + " \"layout.walker.per_plane\",\n", + " \"layout.walker.relative_spacing\",\n", + " \"layout.sso.planes.count\",\n", + "]\n", + "sensitivity(summary, decisions, [\"sufficient\", \"accurate\"]).round(2)" + ] + }, + { + "cell_type": "markdown", + "id": "35d73cc6", + "metadata": {}, + "source": [ + "The field of regard explains the most of both objectives (25%), as it sets the swath of every satellite. The layout matters next, but differently for the two objectives. The number of satellites in each Walker plane explains more of sufficiency (22%) than of accuracy (18%), and the number of Walker planes the reverse (12% and 29%), as more planes spread the samples in time. The altitude explains little of either (3%), and the inclination nothing." + ] + }, + { + "cell_type": "markdown", + "id": "43278438", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "* What a design achieves depends on how it is measured: counts of samples favor satellites that follow each other in one plane, and the sampling error of a daily mean favors samples spread over the day (`estimate_sampling_error`).\n", + "* `study.replace` copies a study with other parts, such as other metrics.\n", + "* Revisit statistics and local time coverage (`compute_revisit_statistics`, `compute_local_time_coverage`) explain why designs differ, and `sensitivity` finds the decisions that drive each objective.\n", + "\n", + "The next notebook, `SearchTradeSpace`, finds the efficient designs without evaluating every design." + ] + }, + { + "cell_type": "markdown", + "id": "e5721f39", + "metadata": {}, + "source": [ + "## Notes\n", + "\n", + "* The sampling error here is that of a model of the field: an exponential correlation in time with a decorrelation time of 3 hours. With a simulation of the field (a nature run), `tatc.analysis.sample_field` and `compare_sampled_means` measure it directly (see `AssessSamplingSufficiency`)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/tradespace/PlanDeployment.ipynb b/docs/examples/tradespace/PlanDeployment.ipynb new file mode 100644 index 00000000..0970404c --- /dev/null +++ b/docs/examples/tradespace/PlanDeployment.ipynb @@ -0,0 +1,470 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6667e34b", + "metadata": {}, + "source": [ + "# Plan the Deployment\n", + "\n", + "The shares of points sampled so far are those of each design's full constellation, as if all of its satellites flew for the whole mission. In fact, they are launched over months or years, and fewer satellites sample the points meanwhile. This notebook accounts for the deployment of each design, then asks whether to commit to its whole constellation at once.\n", + "\n", + "It covers:\n", + "\n", + "* the **phases** of a deployment, and what a design achieves over its mission;\n", + "* **staged** deployments, whose later stages are deployed only if a rule decides to.\n", + "\n", + "It builds on `TradeCostAndUtility`, whose mission plan dates the launches of each design, and on `CompareScenarios`, whose fields the rules of the staged deployments respond to." + ] + }, + { + "cell_type": "markdown", + "id": "696b3146", + "metadata": {}, + "source": [ + "## Account for Deployment\n", + "\n", + "The launches of a design divide its mission into phases, in each of which some of its satellites fly. With `phases`, the study evaluates each phase with the observations of its satellites (over the same day, from the cache) and combines the phases over the mission:\n", + "\n", + "* `sufficient mission`: the share of points sufficiently sampled, on average over the five years from the first launch;\n", + "* `sufficient time`: the years from the start of development until a requirement is met, here that half of the points are sampled sufficiently.\n", + "\n", + "The phased study evaluates the efficient designs of `EvaluateTradeSpace`: the most sufficient design of each number of satellites and planes." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "bd998b9b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanesdeployedsufficientsufficient missionsufficient timelost
design
163120bf9590800 km, 60 deg FOR, SSO: 1 at 18:001.01.03.23.23.2inf0.0
f7413b1f8466800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...2.01.03.516.616.6inf0.0
33b006848799800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.03.830.227.3inf2.9
d5d3fa915ca7800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...3.01.03.838.038.0inf0.0
1af5f2707be3800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.04.568.263.54.54.7
6ba50f2632cd800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.04.069.664.34.05.3
6bef11e40977800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.04.597.887.14.510.7
\n", + "
" + ], + "text/plain": [ + " description satellites \\\n", + "design \n", + "163120bf9590 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 \n", + "f7413b1f8466 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 \n", + "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 \n", + "d5d3fa915ca7 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 \n", + "1af5f2707be3 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 \n", + "6ba50f2632cd 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 \n", + "6bef11e40977 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 \n", + "\n", + " planes deployed sufficient sufficient mission \\\n", + "design \n", + "163120bf9590 1.0 3.2 3.2 3.2 \n", + "f7413b1f8466 1.0 3.5 16.6 16.6 \n", + "33b006848799 2.0 3.8 30.2 27.3 \n", + "d5d3fa915ca7 1.0 3.8 38.0 38.0 \n", + "1af5f2707be3 1.0 4.5 68.2 63.5 \n", + "6ba50f2632cd 2.0 4.0 69.6 64.3 \n", + "6bef11e40977 2.0 4.5 97.8 87.1 \n", + "\n", + " sufficient time lost \n", + "design \n", + "163120bf9590 inf 0.0 \n", + "f7413b1f8466 inf 0.0 \n", + "33b006848799 inf 2.9 \n", + "d5d3fa915ca7 inf 0.0 \n", + "1af5f2707be3 4.5 4.7 \n", + "6ba50f2632cd 4.0 5.3 \n", + "6bef11e40977 4.5 10.7 " + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from trade_space_example import OBJECTIVES, cost_study, describe\n", + "from tatc.tradespace import Requirement, aggregate, pareto_front, summarize\n", + "\n", + "summary = summarize(cost_study.run(), [\"satellites\", \"planes\", \"sufficient\", \"accurate\"])\n", + "summary[\"description\"] = summary.apply(describe, axis=1)\n", + "front = summary[pareto_front(summary, OBJECTIVES)]\n", + "leaders = front.sort_values(\"sufficient\", ascending=False).drop_duplicates([\"satellites\", \"planes\"])\n", + "\n", + "phased_study = cost_study.replace(phases=[Requirement(\"sufficient\", \">=\", 50)])\n", + "phased = phased_study.run(leaders)\n", + "PHASED = [\"deployed\", \"sufficient\", \"sufficient mission\", \"sufficient time\"]\n", + "deployed = aggregate(phased, PHASED, design_columns=[]).set_index(\"design\")[PHASED]\n", + "leaders = leaders.set_index(\"design\")[[\"description\", \"satellites\", \"planes\"]].join(deployed)\n", + "leaders[\"lost\"] = leaders[\"sufficient\"] - leaders[\"sufficient mission\"]\n", + "leaders.sort_values([\"satellites\", \"planes\"]).round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "c3846667", + "metadata": {}, + "source": [ + "Deployment costs the designs of several planes or launches. Six satellites in two planes sample 98% of the points once deployed, but 87% on average over the mission: the first plane flies alone for three quarters of a year while the second is produced, and half of the points are sampled sufficiently only 4.5 years after development starts. Four satellites lose about 5 points of their 68 or 70%, in one plane (which takes two launches of up to three satellites) or in two, and two satellites in two planes lose 3 points of their 30%. The designs launched at once lose nothing, and the designs of fewer than four satellites never sample half of the points (an infinite `sufficient time`). A shorter mission, slower production, or rarer launches would weigh deployment more, and could reorder the front." + ] + }, + { + "cell_type": "markdown", + "id": "108c1543", + "metadata": {}, + "source": [ + "## Stage the Deployment\n", + "\n", + "A deployment need not commit to every plane at once. A `Stage` is a set of planes that is produced and launched only if a rule decides to, at given times of the mission. The rule decides from what is known then (a `Decision`) and from the values of the design. A stage that is not deployed is not produced, launched, or paid for. Staging saves the cost of a stage where the mission does not need it, and loses what the stage would have achieved while it waits, where the mission does.\n", + "\n", + "Here, the robust design of four satellites of `CompareScenarios` (two sun-synchronous planes of two) stages its second plane in one of five ways, a new decision of the design (`staging`):\n", + "\n", + "| staging | the second plane is deployed |\n", + "|---|---|\n", + "| at once | with the first |\n", + "| first plane | never |\n", + "| decided at launch | if the field decorrelates within 6 hours, decided at the first launch |\n", + "| decided a year later | if the field decorrelates within 6 hours, decided a year after the first launch |\n", + "| measured at launch | if the first plane samples fewer than half of the points accurately, measured at its launch (`Decision.capability`) |\n", + "\n", + "The rules that read the field read the scenario, which a mission would not know; the last rule reads only what the first plane achieves. The `stages` of the plan are a function of the design. Each staging is evaluated in each field of `CompareScenarios`, for the share of points accurately sampled on average over the mission, and the present value of the cost (`cost present`, discounted at 3% a year):" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2135879f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
accurate missioncost present
scenario1 hour3 hours12 hours1 hour3 hours12 hours
staging
at once62.677.991.0156.4156.4156.4
first plane4.810.073.0118.8118.8118.8
decided at launch62.677.973.0156.4156.4118.8
decided a year later49.762.873.0154.5154.5118.8
measured at launch62.677.973.0156.4156.4118.8
\n", + "
" + ], + "text/plain": [ + " accurate mission cost present \\\n", + "scenario 1 hour 3 hours 12 hours 1 hour 3 hours \n", + "staging \n", + "at once 62.6 77.9 91.0 156.4 156.4 \n", + "first plane 4.8 10.0 73.0 118.8 118.8 \n", + "decided at launch 62.6 77.9 73.0 156.4 156.4 \n", + "decided a year later 49.7 62.8 73.0 154.5 154.5 \n", + "measured at launch 62.6 77.9 73.0 156.4 156.4 \n", + "\n", + " \n", + "scenario 12 hours \n", + "staging \n", + "at once 156.4 \n", + "first plane 118.8 \n", + "decided at launch 118.8 \n", + "decided a year later 118.8 \n", + "measured at launch 118.8 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import dataclasses\n", + "from datetime import timedelta\n", + "\n", + "from trade_space_example import DECORRELATION_TIME, FIELDS, PLAN, cost_space, sample_field\n", + "from tatc.tradespace import Categorical, Fixed, Stage\n", + "\n", + "STAGING = [\"at once\", \"first plane\", \"decided at launch\", \"decided a year later\", \"measured at launch\"]\n", + "staging_space = cost_space.extend(decorrelation_time=Fixed(DECORRELATION_TIME), staging=Categorical(STAGING))\n", + "\n", + "\n", + "def stages(d):\n", + " \"\"\"The stages of a design's deployment: its second plane, by its staging.\"\"\"\n", + " if d.staging == \"at once\":\n", + " return []\n", + " if d.staging == \"first plane\":\n", + " return [Stage(1, 0.0, lambda decision: False)]\n", + " if d.staging == \"measured at launch\":\n", + " return [Stage(1, 0.0, lambda decision: decision.capability[\"accurate\"] < 50)]\n", + " when = 0.0 if d.staging == \"decided at launch\" else 1.0 # years after the first launch\n", + " return [Stage(1, when, lambda decision: d.decorrelation_time < timedelta(hours=6))]\n", + "\n", + "\n", + "staged_study = phased_study.replace(\n", + " space=staging_space, metrics=sample_field, plan=dataclasses.replace(PLAN, stages=stages), scenarios=FIELDS\n", + ")\n", + "(four,) = cost_space.designs_of(summary[summary.description == \"800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00\"])\n", + "staged = staged_study.run([staging_space.design(four, staging=option) for option in STAGING])\n", + "staged.groupby([\"staging\", \"scenario\"], sort=False)[[\"accurate mission\", \"cost present\"]].mean().unstack(\n", + " \"scenario\"\n", + ").round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "0949e986", + "metadata": {}, + "source": [ + "Deciding at the first launch is worth the most. Where the field varies within hours, the second plane is produced and launched as if it were deployed at once: 63% and 78% of the points are accurately sampled on average over the mission, for 156 million dollars. Where the field varies slowly, the second plane is not deployed, which saves 38 million dollars (24%) for 18 points of the mean (73% against 91%): a trade that the rule makes, and that a mission might not.\n", + "\n", + "Deciding a year later costs the fields that need the second plane 13 to 15 points of the mean (50% and 63%), as the first plane flies alone a year longer, and saves only 2 million dollars, by discounting the later production. The earlier the need is known, the more staging saves, at less loss.\n", + "\n", + "The rule that measures makes the same choices as the rule that reads the field, in every field. The first plane alone samples 5% and 10% of the points accurately where the field varies within hours, so the second plane is deployed, and 73% where it varies over 12 hours, so it is not. A mission knows what its satellites achieve, not the field, so this is a rule it could follow." + ] + }, + { + "cell_type": "markdown", + "id": "ccf111a8", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "* A `DeploymentSchedule` divides each design's mission into phases of the satellites that fly, which the study evaluates (with `phases`) for what the design achieves on average over its mission, and the time until it meets a requirement.\n", + "* A `Stage` of a deployment is produced and launched only if a rule decides to, from what is known then (a `Decision`, such as what the satellites in orbit achieve, `Decision.capability`) and the values of the design. A study measures what the option is worth.\n", + "\n", + "The next notebook, `PlanForFailures`, simulates the failures of satellites and launches over each mission." + ] + }, + { + "cell_type": "markdown", + "id": "aa666288", + "metadata": {}, + "source": [ + "## Notes\n", + "\n", + "* Each phase is evaluated over the same day of July, as if the geometry of the satellites and the season were those of that day throughout the mission (quasi-static phases, see `evaluate_phases`). This misses the drift between planes of different inclinations or altitudes, and seasons. The planes of these designs share an altitude and an inclination, and the shares do not depend on the sun, so the day should represent the mission. An `Uncertain` start of the observations, drawn for each replicate over a year, would average over the drift and the seasons, at the cost of analyzing the satellites again for each day.\n", + "* The rule that measures the first plane reads its capability at once, as the study computes it. A real measurement takes time, and a rule that waits a year to measure loses what deciding a year later loses.\n", + "* A rule may also read the satellites still operating (see `Decision`), for a reserve plane launched only if satellites fail." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/tradespace/PlanForFailures.ipynb b/docs/examples/tradespace/PlanForFailures.ipynb new file mode 100644 index 00000000..60ba204f --- /dev/null +++ b/docs/examples/tradespace/PlanForFailures.ipynb @@ -0,0 +1,1006 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "88d8cd26", + "metadata": {}, + "source": [ + "# Plan for Failures\n", + "\n", + "Satellites and launches fail, and what failures cost depends on how the mission responds to them. This notebook simulates failures over each design's mission, and compares ways to restore failed satellites as decisions of each design.\n", + "\n", + "It covers:\n", + "\n", + "* a **failure model** of satellites and launches;\n", + "* **restoration policies**, as decisions of the design;\n", + "* choosing a design and its policy together;\n", + "* **attributing** the spread of the replicates to their uncertain parameters.\n", + "\n", + "It builds on `PlanDeployment`: the study evaluates each history of failures by the phases in which its satellites operate." + ] + }, + { + "cell_type": "markdown", + "id": "42057516", + "metadata": {}, + "source": [ + "## Model Failures\n", + "\n", + "A `FailureModel` gives the life of a satellite from its launch, and the probability that a launch fails. The life here is a bathtub curve (`Bathtub`) of infant mortality, random failures, and wear-out (illustrative), and 5% of launches fail:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "2c839235", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "37% of the satellites fail within 5 years\n" + ] + } + ], + "source": [ + "from tatc.tradespace import Bathtub, Exponential, FailureModel, Weibull\n", + "\n", + "FAILURE_MODEL = FailureModel(\n", + " life=Bathtub(infant=Weibull(shape=0.5, scale=100), random=Exponential(0.03), wear_out=Weibull(shape=4, scale=9)),\n", + " launch=0.05,\n", + ")\n", + "print(f\"{1 - FAILURE_MODEL.life.survival(5):.0%} of the satellites fail within 5 years\")" + ] + }, + { + "cell_type": "markdown", + "id": "27b9cb14", + "metadata": {}, + "source": [ + "## Respond to Failures\n", + "\n", + "A `RestorationPolicy` responds to failures. Here, five policies:\n", + "\n", + "* **degrade**: fly the satellites that remain;\n", + "* **produce**: replace each failed satellite by producing a new one, after half a year of procurement, and launching it;\n", + "* **spare in orbit**: launch a spare with each plane, which takes a failed satellite's place within months;\n", + "* **spare on ground**: store a spare, which is launched at the next opportunity;\n", + "* **spares in orbit and on ground**: both.\n", + "\n", + "A spare that is used is produced again. The policy is a decision of each design: `policy_space` declares whether to restore failed satellites, and the numbers of spares in each plane and on the ground (none or one of each). `space.extend` adds the policy to the design space, with the seed of the failures (`failure_seed`, drawn for each replicate).\n", + "\n", + "`Failures` simulate 20 histories of the failures of each replicate, restored by the design's policy. The study evaluates each history by the phases in which its satellites operate, and gives the means over the histories and their quantiles: here, the share accurately sampled in the worst 10% of the histories (`accurate mission histories p10`), and the cost at 70% confidence (`cost histories p70`). The designs are the efficient designs by accuracy of `ExplainTradeSpace`, each with each policy." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "64a55b8d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "65 designs and policies x 5 replicates x 20 histories\n" + ] + } + ], + "source": [ + "from trade_space_example import ACCURACY, cost_space, cost_study, describe\n", + "from tatc.tradespace import (\n", + " Failures,\n", + " Integer,\n", + " RestorationPolicy,\n", + " Uncertain,\n", + " aggregate,\n", + " pareto_front,\n", + " policy_space,\n", + " summarize,\n", + ")\n", + "\n", + "summary = summarize(cost_study.run(), [\"satellites\", \"planes\", \"accurate\"])\n", + "efficient = summary[pareto_front(summary, ACCURACY)]\n", + "\n", + "POLICY = policy_space(orbit_spares=Integer(0, 1), ground_spares=Integer(0, 1), replenish=True)\n", + "failure_space = cost_space.extend(failure_seed=Uncertain.seed(), policy=POLICY)\n", + "FAILURES = Failures(\n", + " FAILURE_MODEL,\n", + " RestorationPolicy(procurement_years=0.5, replenish=True), # the policy of each design starts from this one\n", + " histories=20,\n", + " seed=\"failure_seed\",\n", + " quantiles={\"accurate mission\": 0.1, \"cost\": 0.7},\n", + ")\n", + "failure_study = cost_study.replace(space=failure_space, failures=FAILURES)\n", + "\n", + "# the efficient designs, each with each policy\n", + "with_policies, base_of = [], {}\n", + "for base in cost_space.designs_of(efficient):\n", + " for policy in POLICY.enumerate():\n", + " design = failure_space.design(base, policy=policy)\n", + " with_policies.append(design)\n", + " base_of[design.key] = base.key\n", + "trades = failure_study.run(with_policies)\n", + "print(f\"{len(with_policies)} designs and policies x 5 replicates x 20 histories\")" + ] + }, + { + "cell_type": "markdown", + "id": "d15b5c76", + "metadata": {}, + "source": [ + "The table gives four of the designs, each with each policy: two satellites in two planes, four in two, six in three, and nine in three. Its columns are the means over the replicates of the share accurately sampled over the mission (`accurate`, on average over the histories, and `accurate p10`, in their worst 10%) and of the cost at 70% confidence (`cost p70`). The first column is the share of the full constellation, without deployment or failures, from `ExplainTradeSpace`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d3789588", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
accurateaccurate p10cost p70
descriptionfull constellationpolicy
800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spacing 0)34.2degrade17.70.6136.5
produce26.119.5159.4
spare in orbit28.225.1192.7
spare on ground28.925.6175.2
spares in orbit and on ground28.525.6206.4
800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:0085.4degrade50.710.8170.4
produce68.556.2218.3
spare in orbit68.861.3246.8
spare on ground72.562.2235.4
spares in orbit and on ground69.363.1260.7
700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spacing 0)96.4degrade64.238.9209.5
produce78.070.1278.8
spare in orbit74.267.3316.7
spare on ground79.671.5294.4
spares in orbit and on ground74.366.9329.0
800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spacing 0)97.8degrade79.366.4253.5
produce82.878.1340.0
spare in orbit76.871.6394.6
spare on ground82.878.2355.7
spares in orbit and on ground76.971.6405.7
\n", + "
" + ], + "text/plain": [ + " accurate \\\n", + "description full constellation policy \n", + "800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spaci... 34.2 degrade 17.7 \n", + " produce 26.1 \n", + " spare in orbit 28.2 \n", + " spare on ground 28.9 \n", + " spares in orbit and on ground 28.5 \n", + "800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 85.4 degrade 50.7 \n", + " produce 68.5 \n", + " spare in orbit 68.8 \n", + " spare on ground 72.5 \n", + " spares in orbit and on ground 69.3 \n", + "700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spaci... 96.4 degrade 64.2 \n", + " produce 78.0 \n", + " spare in orbit 74.2 \n", + " spare on ground 79.6 \n", + " spares in orbit and on ground 74.3 \n", + "800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spaci... 97.8 degrade 79.3 \n", + " produce 82.8 \n", + " spare in orbit 76.8 \n", + " spare on ground 82.8 \n", + " spares in orbit and on ground 76.9 \n", + "\n", + " accurate p10 \\\n", + "description full constellation policy \n", + "800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spaci... 34.2 degrade 0.6 \n", + " produce 19.5 \n", + " spare in orbit 25.1 \n", + " spare on ground 25.6 \n", + " spares in orbit and on ground 25.6 \n", + "800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 85.4 degrade 10.8 \n", + " produce 56.2 \n", + " spare in orbit 61.3 \n", + " spare on ground 62.2 \n", + " spares in orbit and on ground 63.1 \n", + "700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spaci... 96.4 degrade 38.9 \n", + " produce 70.1 \n", + " spare in orbit 67.3 \n", + " spare on ground 71.5 \n", + " spares in orbit and on ground 66.9 \n", + "800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spaci... 97.8 degrade 66.4 \n", + " produce 78.1 \n", + " spare in orbit 71.6 \n", + " spare on ground 78.2 \n", + " spares in orbit and on ground 71.6 \n", + "\n", + " cost p70 \n", + "description full constellation policy \n", + "800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spaci... 34.2 degrade 136.5 \n", + " produce 159.4 \n", + " spare in orbit 192.7 \n", + " spare on ground 175.2 \n", + " spares in orbit and on ground 206.4 \n", + "800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 85.4 degrade 170.4 \n", + " produce 218.3 \n", + " spare in orbit 246.8 \n", + " spare on ground 235.4 \n", + " spares in orbit and on ground 260.7 \n", + "700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spaci... 96.4 degrade 209.5 \n", + " produce 278.8 \n", + " spare in orbit 316.7 \n", + " spare on ground 294.4 \n", + " spares in orbit and on ground 329.0 \n", + "800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spaci... 97.8 degrade 253.5 \n", + " produce 340.0 \n", + " spare in orbit 394.6 \n", + " spare on ground 355.7 \n", + " spares in orbit and on ground 405.7 " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "\n", + "def describe_policy(row):\n", + " \"\"\"The name of a design's policy.\"\"\"\n", + " if not row[\"policy.restore\"]:\n", + " return \"degrade\"\n", + " orbit, ground = row[\"policy.orbit_spares\"] > 0, row[\"policy.ground_spares\"] > 0\n", + " return {\n", + " (False, False): \"produce\",\n", + " (True, False): \"spare in orbit\",\n", + " (False, True): \"spare on ground\",\n", + " (True, True): \"spares in orbit and on ground\",\n", + " }[orbit, ground]\n", + "\n", + "\n", + "POLICIES = [\"degrade\", \"produce\", \"spare in orbit\", \"spare on ground\", \"spares in orbit and on ground\"]\n", + "# the means over the replicates of the mean share over the histories, the share in their worst 10%, and the cost at\n", + "# 70% confidence over the histories\n", + "ROBUST = {\n", + " \"accurate\": \"accurate mission\",\n", + " \"accurate p10\": \"accurate mission histories p10\",\n", + " \"cost p70\": \"cost histories p70\",\n", + "}\n", + "traded = aggregate(trades, statistics=ROBUST).set_index(\"design\")\n", + "traded[\"policy\"] = pd.Categorical(traded.apply(describe_policy, axis=1), POLICIES)\n", + "traded[\"base\"] = [base_of[key] for key in traded.index]\n", + "bases = efficient.set_index(\"design\")\n", + "traded[\"description\"] = bases.loc[traded.base].apply(describe, axis=1).to_numpy()\n", + "traded[\"full constellation\"] = bases.loc[traded.base, \"accurate\"].to_numpy()\n", + "\n", + "# four of the designs, with each policy: two satellites in two planes, four in two, six in three, and nine in three\n", + "shown = efficient.drop_duplicates([\"satellites\", \"planes\"]).set_index([\"satellites\", \"planes\"])\n", + "shown = shown.loc[[(2, 2), (4, 2), (6, 3), (9, 3)], \"design\"]\n", + "table = traded[traded.base.isin(shown)].sort_values([\"satellites\", \"policy\"])\n", + "table.round(1).set_index([\"description\", \"full constellation\", \"policy\"])[list(ROBUST)]" + ] + }, + { + "cell_type": "markdown", + "id": "cf2393ff", + "metadata": {}, + "source": [ + "The shares over the mission fall short of those of the full constellation under every policy, by the phases of deployment and the failures of launches as well as of satellites:\n", + "\n", + "* **Degrading** is cheapest, but loses the most, above all in the worst histories: two satellites in two planes keep 18% on average, and 1% in their worst 10% of histories, as both can fail. Nine satellites keep the most of what they would sample (79% of 98%), as a failure leaves eight.\n", + "* **Producing replacements** restores most of what degrading loses, at 17 to 34% more cost.\n", + "* **A spare on the ground** restores as well or better, for about 16 million dollars more than producing replacements, and pays off in the worst histories of the small designs: two satellites in two planes keep 26% in their worst histories with it, against 20%.\n", + "* **A spare in orbit can hurt.** Each plane waits for its spare to be produced, and a spare in a plane of three satellites takes a second launch, which delays the deployment. Six satellites in three planes then sample less on average than by producing replacements (74% against 78%), and nine satellites less than by degrading (77% against 79%), at a higher cost. Spares both in orbit and on the ground cost the most, and sample about as much as a spare in orbit alone." + ] + }, + { + "cell_type": "markdown", + "id": "d05b0c12", + "metadata": {}, + "source": [ + "## Choose a Design and its Policy\n", + "\n", + "The front of cost at 70% confidence against the share accurately sampled in the worst 10% of the histories chooses designs and policies together:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "810e99b5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionpolicyaccurateaccurate p10cost p70
design
2a310c00151b800 km, 60 deg FOR, SSO: 1 at 12:00degrade3.20.4110.2
bc2076a0d3d8800 km, 60 deg FOR, SSO: 2 at 06:00degrade7.02.1128.9
bb6574900ac3800 km, 60 deg FOR, SSO: 1 at 12:00produce3.93.5130.6
638697713902800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac...degrade10.94.6146.2
43f50c8bc38a800 km, 60 deg FOR, SSO: 2 at 06:00produce9.27.3153.4
ad99c42082ab800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...produce26.119.5159.4
cc2e14e787ff800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...spare on ground28.925.6175.2
eeb7c70a720b800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00produce47.338.5198.1
3a902b976460700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...degrade64.238.9209.5
6d54bdbf4648800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00spare on ground51.744.9212.4
1afde0569e34800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00produce68.556.2218.3
e7721a705c31800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00spare on ground72.562.2235.4
46932f795a5a800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...degrade79.569.0253.5
6e4564d2ae2c700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...produce78.070.1278.8
570a452fdb8f700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...spare on ground79.671.5294.4
2b499d154a98800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac...produce81.273.8326.4
a37619256b26800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac...produce83.078.7340.0
\n", + "
" + ], + "text/plain": [ + " description \\\n", + "design \n", + "2a310c00151b 800 km, 60 deg FOR, SSO: 1 at 12:00 \n", + "bc2076a0d3d8 800 km, 60 deg FOR, SSO: 2 at 06:00 \n", + "bb6574900ac3 800 km, 60 deg FOR, SSO: 1 at 12:00 \n", + "638697713902 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... \n", + "43f50c8bc38a 800 km, 60 deg FOR, SSO: 2 at 06:00 \n", + "ad99c42082ab 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", + "cc2e14e787ff 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", + "eeb7c70a720b 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 \n", + "3a902b976460 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", + "6d54bdbf4648 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 \n", + "1afde0569e34 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 \n", + "e7721a705c31 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 \n", + "46932f795a5a 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", + "6e4564d2ae2c 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", + "570a452fdb8f 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", + "2b499d154a98 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... \n", + "a37619256b26 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", + "\n", + " policy accurate accurate p10 cost p70 \n", + "design \n", + "2a310c00151b degrade 3.2 0.4 110.2 \n", + "bc2076a0d3d8 degrade 7.0 2.1 128.9 \n", + "bb6574900ac3 produce 3.9 3.5 130.6 \n", + "638697713902 degrade 10.9 4.6 146.2 \n", + "43f50c8bc38a produce 9.2 7.3 153.4 \n", + "ad99c42082ab produce 26.1 19.5 159.4 \n", + "cc2e14e787ff spare on ground 28.9 25.6 175.2 \n", + "eeb7c70a720b produce 47.3 38.5 198.1 \n", + "3a902b976460 degrade 64.2 38.9 209.5 \n", + "6d54bdbf4648 spare on ground 51.7 44.9 212.4 \n", + "1afde0569e34 produce 68.5 56.2 218.3 \n", + "e7721a705c31 spare on ground 72.5 62.2 235.4 \n", + "46932f795a5a degrade 79.5 69.0 253.5 \n", + "6e4564d2ae2c produce 78.0 70.1 278.8 \n", + "570a452fdb8f spare on ground 79.6 71.5 294.4 \n", + "2b499d154a98 produce 81.2 73.8 326.4 \n", + "a37619256b26 produce 83.0 78.7 340.0 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "chosen = traded[pareto_front(traded, {\"cost p70\": \"min\", \"accurate p10\": \"max\"})]\n", + "chosen.sort_values(\"cost p70\")[[\"description\", \"policy\", \"accurate\", \"accurate p10\", \"cost p70\"]].round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "87b797d1", + "metadata": {}, + "source": [ + "Along the front, degrading is the cheapest policy of a design, and restoring buys robustness. Two satellites in two Walker planes keep 20% of the points accurately sampled in their worst histories if they produce replacements (159 million dollars), and 26% with a spare on the ground (175 million). Six satellites in three Walker planes keep 39%, 70%, and 72% if they degrade, produce replacements, or keep a spare on the ground, for 210, 279, and 294 million. Nine satellites in three planes degrade gracefully (69% in their worst histories, for 254 million), and producing replacements raises them to 79%, for 340 million. A spare on the ground is efficient for designs of two to six satellites, but a spare in orbit is not efficient for any design. The policy that a design deserves depends on the design, which is why it is a decision of the design." + ] + }, + { + "cell_type": "markdown", + "id": "ddddde74", + "metadata": {}, + "source": [ + "## Find What Spreads the Results\n", + "\n", + "The replicates of a design differ by its uncertain parameters: the sample of points (`points_seed`), the histories of failures (`failure_seed`), and the growth of the cost of development (`cost_growth`). Which of them spreads an objective says what would sharpen it. The sample of points and the histories are noise of the estimates, which more points or more histories reduce; the growth of costs is a risk of the mission.\n", + "\n", + "`attribute_variance` evaluates each design again with one parameter drawn as in other replicates and the others held. The **total share** of a parameter is the share of the variance between replicates that it causes, alone or with others (near 0 if it does not matter), with its standard error (`se`). Here, for the designs and policies of the front, from 20 replicates, 20 more, and 20 with each parameter drawn as in the second 20:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "40b705f4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1700 evaluations in 0 s\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
accurate missionaccurate mission histories p10cost histories p70accurate mission seaccurate mission histories p10 secost histories p70 se
parameter
points_seed92.430.40.06.43.30.0
cost_growth0.00.081.80.00.019.0
failure_seed3.667.035.80.76.57.1
\n", + "
" + ], + "text/plain": [ + " accurate mission accurate mission histories p10 \\\n", + "parameter \n", + "points_seed 92.4 30.4 \n", + "cost_growth 0.0 0.0 \n", + "failure_seed 3.6 67.0 \n", + "\n", + " cost histories p70 accurate mission se \\\n", + "parameter \n", + "points_seed 0.0 6.4 \n", + "cost_growth 81.8 0.0 \n", + "failure_seed 35.8 0.7 \n", + "\n", + " accurate mission histories p10 se cost histories p70 se \n", + "parameter \n", + "points_seed 3.3 0.0 \n", + "cost_growth 0.0 19.0 \n", + "failure_seed 6.5 7.1 " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import time\n", + "\n", + "from tatc.tradespace import attribute_variance\n", + "\n", + "began = time.perf_counter()\n", + "attribution = attribute_variance(\n", + " failure_study, list(ROBUST.values()), failure_space.designs_of(trades, chosen.index), replicates=20\n", + ")\n", + "print(f\"{len(attribution.results)} evaluations in {time.perf_counter() - began:.0f} s\")\n", + "attribution.summary().mul(100).round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "e6726209", + "metadata": {}, + "source": [ + "The sample of points spreads the mean shares accurately sampled (92% of their variance between replicates), and the failures hardly do (4%), as each replicate averages 20 histories. The share in the worst 10% of the histories is spread mostly by the failures (67%, and 30% by the points), as a quantile of 20 histories is a noisy estimate. Both are noise of the estimates, with different remedies: more points would sharpen the means, and more histories the worst 10%, which is cheap.\n", + "\n", + "The cost at 70% confidence is spread by the growth of the cost of development (82%), a risk of the mission, and by the failures (36%), which cost replacements and spares. These shares are the least certain, with standard errors of 19 and 7 points. The total shares of each objective sum to about 100% within their errors, so the parameters hardly interact." + ] + }, + { + "cell_type": "markdown", + "id": "81c4343e", + "metadata": {}, + "source": [ + "The order of designs on the front depends on their differences, in which the parameters that act alike on two designs cancel. `differences` attributes the variance of the differences between pairs of designs from the same evaluations: here, between the designs and policies adjacent along the front, by cost:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "fc3c9a2c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
accurate missionaccurate mission histories p10cost histories p70accurate mission seaccurate mission histories p10 secost histories p70 se
parameter
points_seed92.130.40.06.44.50.0
cost_growth0.00.00.00.00.00.0
failure_seed2.973.0105.80.56.54.7
\n", + "
" + ], + "text/plain": [ + " accurate mission accurate mission histories p10 \\\n", + "parameter \n", + "points_seed 92.1 30.4 \n", + "cost_growth 0.0 0.0 \n", + "failure_seed 2.9 73.0 \n", + "\n", + " cost histories p70 accurate mission se \\\n", + "parameter \n", + "points_seed 0.0 6.4 \n", + "cost_growth 0.0 0.0 \n", + "failure_seed 105.8 0.5 \n", + "\n", + " accurate mission histories p10 se cost histories p70 se \n", + "parameter \n", + "points_seed 4.5 0.0 \n", + "cost_growth 0.0 0.0 \n", + "failure_seed 6.5 4.7 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ordered = chosen.sort_values(\"cost p70\").index\n", + "attribution.differences(list(zip(ordered, ordered[1:]))).summary().mul(100).round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "ba021360", + "metadata": {}, + "source": [ + "The growth of the cost of development cancels in every difference. All of these designs fly the same imager, whose development grows alike for each, so the growth is a risk of each mission but not a reason to prefer one design to another; the failures alone spread the differences of their costs. The shares differ by what spreads them: the sample of points for the means (92%), and mostly the histories for the worst 10% (73%). More points would settle the order of neighbors by their means, and more histories their order by the worst 10% and by cost." + ] + }, + { + "cell_type": "markdown", + "id": "d8a77e6b", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "* A `FailureModel` draws the failures of satellites and launches, and a `RestorationPolicy` restores them (by producing new satellites, or by spares in orbit or on the ground) or not. `Failures` simulate histories of each replicate's mission, for both the cost and the capability of each policy.\n", + "* The policy is a decision of each design (`policy_space`), which the front chooses with the design.\n", + "* `attribute_variance` finds the uncertain parameters that spread the replicates of each design, which says what would sharpen each objective, and `Attribution.differences` those that spread the differences between designs.\n", + "\n", + "This is the last notebook of the tutorial." + ] + }, + { + "cell_type": "markdown", + "id": "c30a0294", + "metadata": {}, + "source": [ + "## Notes\n", + "\n", + "* Simulating failures is cheap, but evaluating each phase's satellites is not, and most phases repeat the same sets of satellites. The histories of a replicate are therefore evaluated together, with a cache that evaluates each set of satellites once (`evaluate_missions`, `PhaseCache`).\n", + "* The histories are stratified: each satellite's life and each launch is drawn from its own stratum of its distribution, which estimates means several times more precisely than independent histories (`Deployment.simulate_many`).\n", + "* Without restoration (degrading), satellites fail independently, so the mean share over the failures is computed exactly, from the probability that each set of satellites operates (`expected_missions`); its worst 10% and its cost still come from the histories.\n", + "* A design life does not retire a satellite, and a replacement whose launch fails is not flown again (see `DeploymentSchedule`)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/tradespace/RankUncertainDesigns.ipynb b/docs/examples/tradespace/RankUncertainDesigns.ipynb new file mode 100644 index 00000000..a90be1dc --- /dev/null +++ b/docs/examples/tradespace/RankUncertainDesigns.ipynb @@ -0,0 +1,1284 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "890b27f9", + "metadata": {}, + "source": [ + "# Rank Uncertain Designs\n", + "\n", + "Each design's share of points sampled is a mean over five replicates, each of its own sample of points. The means are uncertain, and so is the front of the means: a design just behind another might be ahead with other samples. This notebook ranks designs with that uncertainty.\n", + "\n", + "It covers:\n", + "\n", + "* the **probability** that each design is efficient;\n", + "* **refining**: adding replicates only where they change the ranking;\n", + "* **confirming** the chosen designs with new replicates;\n", + "* judging designs by **statistics other than the mean**, with **requirements**.\n", + "\n", + "It imports the design space and study of `EvaluateTradeSpace` from `trade_space_example.py`, beside the notebooks (with the study's results from its store, if that notebook was run). The objectives are the same: fewer satellites, fewer planes, and more points sufficiently sampled." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "a87ae62a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5480 evaluations: 1096 designs x 5 replicates\n" + ] + } + ], + "source": [ + "from trade_space_example import OBJECTIVES, describe, designs, study\n", + "\n", + "results = study.run(designs)\n", + "print(f\"{len(results)} evaluations: {len(designs)} designs x {study.replicates} replicates\")" + ] + }, + { + "cell_type": "markdown", + "id": "0b18dfc4", + "metadata": {}, + "source": [ + "## Estimate the Probability of Efficiency\n", + "\n", + "`pareto_probability` estimates the probability that each design is efficient by a bootstrap: it resamples the five replicates many times, and counts how often each design is on the front of the resampled means. It resamples the same replicates for every design, as the designs share their samples of points." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "337bf66d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanessufficientparetopareto_probability
1017800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac...1.01.02.8False0.38
776700 km, 60 deg FOR, SSO: 1 at 12:001.01.03.0False0.20
1048800 km, 60 deg FOR, SSO: 1 at 09:001.01.03.0False0.12
1050800 km, 60 deg FOR, SSO: 1 at 12:001.01.03.0False0.10
1052800 km, 60 deg FOR, SSO: 1 at 15:001.01.03.0False0.12
1054800 km, 60 deg FOR, SSO: 1 at 18:001.01.03.2True0.54
960800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...2.01.016.6True0.98
963800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.030.2True1.00
961800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...3.01.038.0True1.00
972800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...3.03.037.6False0.32
971800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...3.03.037.8False0.29
962800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.068.2True1.00
965800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.069.6True0.92
1026800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.6False0.32
1025800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.8True1.00
\n", + "
" + ], + "text/plain": [ + " description satellites planes \\\n", + "1017 800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac... 1.0 1.0 \n", + "776 700 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", + "1048 800 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", + "1050 800 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", + "1052 800 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", + "1054 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", + "960 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 1.0 \n", + "963 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", + "961 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 1.0 \n", + "972 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", + "971 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", + "962 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", + "965 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", + "1026 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "1025 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "\n", + " sufficient pareto pareto_probability \n", + "1017 2.8 False 0.38 \n", + "776 3.0 False 0.20 \n", + "1048 3.0 False 0.12 \n", + "1050 3.0 False 0.10 \n", + "1052 3.0 False 0.12 \n", + "1054 3.2 True 0.54 \n", + "960 16.6 True 0.98 \n", + "963 30.2 True 1.00 \n", + "961 38.0 True 1.00 \n", + "972 37.6 False 0.32 \n", + "971 37.8 False 0.29 \n", + "962 68.2 True 1.00 \n", + "965 69.6 True 0.92 \n", + "1026 97.6 False 0.32 \n", + "1025 97.8 True 1.00 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import pareto_probability\n", + "\n", + "probability = pareto_probability(results, OBJECTIVES, n_resamples=1000)\n", + "probability[\"description\"] = probability.apply(describe, axis=1)\n", + "candidates = probability[probability.pareto_probability >= 0.1].sort_values([\"satellites\", \"planes\", \"sufficient\"])\n", + "candidates[[\"description\", \"satellites\", \"planes\", \"sufficient\", \"pareto\", \"pareto_probability\"]].round(2)" + ] + }, + { + "cell_type": "markdown", + "id": "12c3797c", + "metadata": {}, + "source": [ + "Four of the seven efficient designs are efficient in every resample, and two more nearly so: two satellites in one plane (98%) and four in two planes (92%). The single satellite is not settled. One crossing the equator at 18:00 is efficient in 54% of the resamples, one in a Walker orbit inclined 75 degrees in 38%, and others in 10 to 20%. Likewise, three satellites in three planes (29% and 32%) sample about as many points as three in one plane, and six satellites in two planes with another phasing (32%) as many as the efficient design. Given five replicates, these designs are equally good candidates." + ] + }, + { + "cell_type": "markdown", + "id": "a05fc602", + "metadata": {}, + "source": [ + "## Refine Uncertain Designs\n", + "\n", + "More replicates of every design would settle the front, at the cost of evaluating every design again for each. `refine` adds replicates only to the designs whose efficiency is uncertain (efficient in more than 5% and fewer than 95% of the resamples), five at a time, until none is uncertain or a design has 40 replicates.\n", + "\n", + "Some differences are too small to matter, and too small to settle: a tenth of a percentage point between designs that sample nearly every point. A **tolerance** treats the designs within it of the front as efficient. Here, differences of less than 1 percentage point do not matter. The tolerance is part of the `Criteria` by which designs are judged. `refine` also stops refining a design once its share is known to within half the tolerance (a standard error of 0.5 points): the design is then **indifferent**." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "83764413", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "215 evaluations added, 0.6% of those of 40 replicates of every design\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
rounduncertainindifferentrefinedevaluations
0031229145
111611525
221411315
331412210
44141315
55141315
661412210
77131200
\n", + "
" + ], + "text/plain": [ + " round uncertain indifferent refined evaluations\n", + "0 0 31 2 29 145\n", + "1 1 16 11 5 25\n", + "2 2 14 11 3 15\n", + "3 3 14 12 2 10\n", + "4 4 14 13 1 5\n", + "5 5 14 13 1 5\n", + "6 6 14 12 2 10\n", + "7 7 13 12 0 0" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import Criteria, refine\n", + "\n", + "CRITERIA = Criteria(OBJECTIVES, tolerance={\"sufficient\": 1.0}) # percentage points that do not matter\n", + "refinement = refine(study, CRITERIA, results, step=5, max_replicates=40, n_resamples=1000)\n", + "added = len(refinement.results) - len(results)\n", + "print(f\"{added} evaluations added, {added / (len(designs) * 35):.1%} of those of 40 replicates of every design\")\n", + "refinement.history" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "785eff86", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "39 designs are efficient within the tolerance; the designs refined:\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanessufficientreplicatesparetopareto_probabilityindifferent
224500 km, 60 deg FOR, SSO: 1 at 06:001.01.01.4010False0.01False
226500 km, 60 deg FOR, SSO: 1 at 09:001.01.01.4010False0.01False
228500 km, 60 deg FOR, SSO: 1 at 12:001.01.01.6010False0.02False
743700 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac...1.01.01.6010False0.04False
232500 km, 60 deg FOR, SSO: 1 at 18:001.01.01.7010False0.03False
500600 km, 60 deg FOR, SSO: 1 at 09:001.01.01.8010False0.12True
230500 km, 60 deg FOR, SSO: 1 at 15:001.01.01.9010False0.14True
498600 km, 60 deg FOR, SSO: 1 at 06:001.01.01.9010False0.19True
504600 km, 60 deg FOR, SSO: 1 at 15:001.01.02.1010False0.18True
502600 km, 60 deg FOR, SSO: 1 at 12:001.01.02.2010True0.40True
506600 km, 60 deg FOR, SSO: 1 at 18:001.01.02.2010True0.32True
1017800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac...1.01.02.4010True0.57True
774700 km, 60 deg FOR, SSO: 1 at 09:001.01.02.5010True0.76True
780700 km, 60 deg FOR, SSO: 1 at 18:001.01.02.5010True0.79True
778700 km, 60 deg FOR, SSO: 1 at 15:001.01.02.5315True0.70True
776700 km, 60 deg FOR, SSO: 1 at 12:001.01.02.8010True0.95False
772700 km, 60 deg FOR, SSO: 1 at 06:001.01.02.9010True0.98False
1052800 km, 60 deg FOR, SSO: 1 at 15:001.01.02.9010True0.98False
1046800 km, 60 deg FOR, SSO: 1 at 06:001.01.03.1010True0.98False
1054800 km, 60 deg FOR, SSO: 1 at 18:001.01.03.1010True0.99False
1048800 km, 60 deg FOR, SSO: 1 at 09:001.01.03.2010True0.99False
1050800 km, 60 deg FOR, SSO: 1 at 12:001.01.03.2010True0.99False
686700 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...2.01.013.3010False0.01False
1030800 km, 60 deg FOR, Walker 75 deg: 3 x 1 (spac...3.03.034.7010False0.03False
698700 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...3.03.034.9010False0.01False
1001800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac...3.03.035.2715False0.02False
972800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...3.03.037.0240False0.19False
971800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...3.03.038.4825True0.89True
966800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.067.6010False0.02False
981800 km, 60 deg FOR, Walker 45 deg: 4 x 1 (spac...4.04.065.9010False0.00False
980800 km, 60 deg FOR, Walker 45 deg: 4 x 1 (spac...4.04.067.0715False0.02False
\n", + "
" + ], + "text/plain": [ + " description satellites planes \\\n", + "224 500 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", + "226 500 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", + "228 500 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", + "743 700 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac... 1.0 1.0 \n", + "232 500 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", + "500 600 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", + "230 500 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", + "498 600 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", + "504 600 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", + "502 600 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", + "506 600 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", + "1017 800 km, 60 deg FOR, Walker 75 deg: 1 x 1 (spac... 1.0 1.0 \n", + "774 700 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", + "780 700 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", + "778 700 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", + "776 700 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", + "772 700 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", + "1052 800 km, 60 deg FOR, SSO: 1 at 15:00 1.0 1.0 \n", + "1046 800 km, 60 deg FOR, SSO: 1 at 06:00 1.0 1.0 \n", + "1054 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 1.0 \n", + "1048 800 km, 60 deg FOR, SSO: 1 at 09:00 1.0 1.0 \n", + "1050 800 km, 60 deg FOR, SSO: 1 at 12:00 1.0 1.0 \n", + "686 700 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 1.0 \n", + "1030 800 km, 60 deg FOR, Walker 75 deg: 3 x 1 (spac... 3.0 3.0 \n", + "698 700 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", + "1001 800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac... 3.0 3.0 \n", + "972 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", + "971 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", + "966 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", + "981 800 km, 60 deg FOR, Walker 45 deg: 4 x 1 (spac... 4.0 4.0 \n", + "980 800 km, 60 deg FOR, Walker 45 deg: 4 x 1 (spac... 4.0 4.0 \n", + "\n", + " sufficient replicates pareto pareto_probability indifferent \n", + "224 1.40 10 False 0.01 False \n", + "226 1.40 10 False 0.01 False \n", + "228 1.60 10 False 0.02 False \n", + "743 1.60 10 False 0.04 False \n", + "232 1.70 10 False 0.03 False \n", + "500 1.80 10 False 0.12 True \n", + "230 1.90 10 False 0.14 True \n", + "498 1.90 10 False 0.19 True \n", + "504 2.10 10 False 0.18 True \n", + "502 2.20 10 True 0.40 True \n", + "506 2.20 10 True 0.32 True \n", + "1017 2.40 10 True 0.57 True \n", + "774 2.50 10 True 0.76 True \n", + "780 2.50 10 True 0.79 True \n", + "778 2.53 15 True 0.70 True \n", + "776 2.80 10 True 0.95 False \n", + "772 2.90 10 True 0.98 False \n", + "1052 2.90 10 True 0.98 False \n", + "1046 3.10 10 True 0.98 False \n", + "1054 3.10 10 True 0.99 False \n", + "1048 3.20 10 True 0.99 False \n", + "1050 3.20 10 True 0.99 False \n", + "686 13.30 10 False 0.01 False \n", + "1030 34.70 10 False 0.03 False \n", + "698 34.90 10 False 0.01 False \n", + "1001 35.27 15 False 0.02 False \n", + "972 37.02 40 False 0.19 False \n", + "971 38.48 25 True 0.89 True \n", + "966 67.60 10 False 0.02 False \n", + "981 65.90 10 False 0.00 False \n", + "980 67.07 15 False 0.02 False " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "refined = refinement.summary\n", + "refined[\"description\"] = refined.apply(describe, axis=1)\n", + "print(f\"{refined.pareto.sum()} designs are efficient within the tolerance; the designs refined:\")\n", + "refined[refined.replicates > 5].sort_values([\"satellites\", \"planes\", \"sufficient\"])[\n", + " [\"description\", \"satellites\", \"planes\", \"sufficient\", \"replicates\", \"pareto\", \"pareto_probability\", \"indifferent\"]\n", + "].round(2)" + ] + }, + { + "cell_type": "markdown", + "id": "3a29636c", + "metadata": {}, + "source": [ + "Refinement adds 215 evaluations, 0.6% of those that 40 replicates of every design would take, to 31 designs. One round of five replicates settles most of them, as efficient or not, and a few take more. With the tolerance, 39 designs are efficient candidates, among them every design of six to nine satellites that samples about 98% of the points: they differ by less than matters.\n", + "\n", + "The single satellites that refinement leaves indifferent sample 1.8 to 2.5% of the points, about one tolerance below the best (3.2%). More replicates would settle only whether they fall within the tolerance, which does not change the trade, so refinement stops once their shares are known to within half the tolerance. Three satellites in three planes vary more between replicates: one design is indifferent after 25 replicates, and another remains uncertain at 40." + ] + }, + { + "cell_type": "markdown", + "id": "953d4052", + "metadata": {}, + "source": [ + "## Confirm the Front\n", + "\n", + "The efficient designs were chosen for their means, and so in part for luck: among a thousand designs, those that look best are likely to have drawn favorable samples of points. `confirm` evaluates the chosen designs (by default, the front of the results it is given) with new replicates, which played no part in choosing them. The difference between the means of the replicates that chose a design and those of the new ones is the **optimism** of the choice." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "aff06deb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "39 designs confirmed, of which 35 are efficient by the new replicates\n", + "mean optimism: -0.02 percentage points\n", + "mean optimism by number of satellites: {1.0: -0.39, 2.0: 0.85, 3.0: 2.09, 4.0: 2.45, 6.0: -0.18, 8.0: -0.34, 9.0: -0.34}\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanessufficient selectedsufficientoptimismpareto
17800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac...2.01.016.6016.150.45True
20800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...2.02.030.2028.951.25True
18800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...3.01.038.0036.701.30True
22800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac...3.03.038.4835.602.88False
19800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.068.2066.501.70True
21800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.069.6066.403.20True
\n", + "
" + ], + "text/plain": [ + " description satellites planes \\\n", + "17 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 1.0 \n", + "20 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", + "18 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 1.0 \n", + "22 800 km, 60 deg FOR, Walker 45 deg: 3 x 1 (spac... 3.0 3.0 \n", + "19 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", + "21 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", + "\n", + " sufficient selected sufficient optimism pareto \n", + "17 16.60 16.15 0.45 True \n", + "20 30.20 28.95 1.25 True \n", + "18 38.00 36.70 1.30 True \n", + "22 38.48 35.60 2.88 False \n", + "19 68.20 66.50 1.70 True \n", + "21 69.60 66.40 3.20 True " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import confirm\n", + "\n", + "confirmation = confirm(study, CRITERIA, refinement.results, replicates=20) # 20 new replicates of the front\n", + "confirmed = confirmation.summary\n", + "confirmed[\"description\"] = confirmed.apply(describe, axis=1)\n", + "confirmed[\"optimism\"] = confirmed[\"sufficient selected\"] - confirmed[\"sufficient\"]\n", + "print(f\"{len(confirmed)} designs confirmed, of which {confirmed.pareto.sum()} are efficient by the new replicates\")\n", + "print(f\"mean optimism: {confirmation.optimism()['sufficient']:.2f} percentage points\")\n", + "print(\"mean optimism by number of satellites:\", confirmed.groupby(\"satellites\").optimism.mean().round(2).to_dict())\n", + "# the middle of the front: two to four satellites\n", + "confirmed[confirmed.satellites.between(2, 4)].sort_values([\"satellites\", \"planes\"])[\n", + " [\"description\", \"satellites\", \"planes\", \"sufficient selected\", \"sufficient\", \"optimism\", \"pareto\"]\n", + "].round(2)" + ] + }, + { + "cell_type": "markdown", + "id": "c7fcb49f", + "metadata": {}, + "source": [ + "The designs of two to four satellites sample up to 3.2 points fewer with the new replicates (2.5 points on average for four satellites): four satellites in two planes sample 66.4% rather than 69.6%. The three satellites in three planes, which refinement left as good as three in one plane, sample 35.6% and are no longer efficient.\n", + "\n", + "The single satellites and the designs of six to nine satellites sample slightly more with the new replicates instead (by 0.2 to 0.4 points on average): the new samples of points happen to be easier to sample. The designs share their samples, so this difference applies to every design alike, and is not optimism. The mean optimism over all the designs (-0.02 points) mixes the two, so compare designs one by one. 35 of the 39 designs remain efficient: the shape of the front holds, but its middle is up to 3 points less good than it looked." + ] + }, + { + "cell_type": "markdown", + "id": "903c75df", + "metadata": {}, + "source": [ + "## Require Reliable Sampling\n", + "\n", + "A mean does not say how reliably a design performs, as its share differs between samples of points. Other statistics over the replicates judge designs by their reliability:\n", + "\n", + "* `Quantile(\"sufficient\", 0.2)`: the share that a design exceeds in 80% of the samples;\n", + "* `Probability(\"sufficient\", \">=\", 50)`: the share of the samples in which a design samples at least half of the points sufficiently.\n", + "\n", + "A `Requirement` on a statistic rules out the designs that do not meet it. Here, the objective is the 0.2 quantile, and a design must sample half of the points sufficiently in at least 80% of the samples. The `Criteria` hold the objectives, the statistics that they name, and the requirements." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "b12f2169", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "209 of 1096 designs meet the requirement\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanessufficient p20reliabilityreplicatespareto_probability
962800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac...4.01.065.01.051.00
965800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4.02.068.01.050.94
1025800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.81.051.00
1026800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac...6.02.097.01.050.50
\n", + "
" + ], + "text/plain": [ + " description satellites planes \\\n", + "962 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", + "965 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", + "1025 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "1026 800 km, 60 deg FOR, Walker 75 deg: 2 x 3 (spac... 6.0 2.0 \n", + "\n", + " sufficient p20 reliability replicates pareto_probability \n", + "962 65.0 1.0 5 1.00 \n", + "965 68.0 1.0 5 0.94 \n", + "1025 97.8 1.0 5 1.00 \n", + "1026 97.0 1.0 5 0.50 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tatc.tradespace import Probability, Quantile, Requirement\n", + "\n", + "RELIABLE = Criteria(\n", + " {\"satellites\": \"min\", \"planes\": \"min\", \"sufficient p20\": \"max\"},\n", + " statistics={\n", + " \"sufficient p20\": Quantile(\"sufficient\", 0.2),\n", + " \"reliability\": Probability(\"sufficient\", \">=\", 50),\n", + " },\n", + " requirements=[Requirement(\"reliability\", \">=\", 0.8)],\n", + ")\n", + "reliable = pareto_probability(refinement.results, RELIABLE, n_resamples=1000)\n", + "reliable[\"description\"] = reliable.apply(describe, axis=1)\n", + "print(f\"{reliable.meets_requirements.sum()} of {len(reliable)} designs meet the requirement\")\n", + "reliable[reliable.pareto_probability >= 0.1].sort_values([\"satellites\", \"planes\"])[\n", + " [\"description\", \"satellites\", \"planes\", \"sufficient p20\", \"reliability\", \"replicates\", \"pareto_probability\"]\n", + "].round(2)" + ] + }, + { + "cell_type": "markdown", + "id": "9f219519", + "metadata": {}, + "source": [ + "209 of the 1,096 designs meet the requirement, none of them with fewer than four satellites. Among them, four satellites in one plane and six in two planes are efficient for sure, sampling at least 65% and 98% of the points in 80% of the samples. Four satellites in two planes sample more than four in one (at least 68%), and are efficient in 94% of the resamples: these are the alternatives to weigh against the cost of a second plane." + ] + }, + { + "cell_type": "markdown", + "id": "7ec42115", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "* The front of the means of the replicates is uncertain: `pareto_probability` finds the designs whose efficiency the replicates settle, and those that are equally good candidates.\n", + "* `refine` adds replicates only to the designs whose efficiency is uncertain, ignoring differences within a tolerance (part of the `Criteria`).\n", + "* `confirm` evaluates the chosen designs with new replicates, which measures the optimism of choosing the best of many nearly equal designs.\n", + "* Statistics other than means (such as a `Quantile`, or the `Probability` of meeting a threshold) judge how reliably a design performs, and `Requirement`s on them rule out designs.\n", + "* Each of these steps takes the study, the criteria, and the results of the step before (or of a search, see `SearchTradeSpace`), and gives its own results and a summary of its designs.\n", + "\n", + "The next notebook, `CompareScenarios`, compares designs under conditions that are not known in advance." + ] + }, + { + "cell_type": "markdown", + "id": "e687906b", + "metadata": {}, + "source": [ + "## Notes\n", + "\n", + "* A `budget` of `refine` limits its evaluations, refining the least settled designs first.\n", + "* An absolute tolerance suits a share near 100% better than a share near 0%; a tolerance proportional to the objective would treat both alike." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/tradespace/SearchTradeSpace.ipynb b/docs/examples/tradespace/SearchTradeSpace.ipynb new file mode 100644 index 00000000..2666823b --- /dev/null +++ b/docs/examples/tradespace/SearchTradeSpace.ipynb @@ -0,0 +1,412 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b744951b", + "metadata": {}, + "source": [ + "# Search a Large Trade Space\n", + "\n", + "`EvaluateTradeSpace` evaluated all 1,096 designs. A larger design space, or a longer analysis, cannot afford that. This notebook finds the efficient designs while evaluating only some of them, and compares each method with the true front of `EvaluateTradeSpace`.\n", + "\n", + "It covers:\n", + "\n", + "* the **hypervolume**: one number for how close a set of designs comes to the true front;\n", + "* **screening** every design with a cheaper study;\n", + "* **searching** with optimizers (Optuna and pymoo).\n", + "\n", + "It imports the design space and study of `EvaluateTradeSpace` from `trade_space_example.py`, beside the notebooks. If that notebook was run, the study's results come from its store." + ] + }, + { + "cell_type": "markdown", + "id": "61cf8391", + "metadata": {}, + "source": [ + "## Measure a Front by its Hypervolume\n", + "\n", + "The hypervolume of a set of designs is the volume of the objective space that its efficient designs dominate, bounded by a reference point worse than every design. A set that finds the whole true front has the hypervolume of the true front; a set that misses efficient designs has less. Below, each method's designs are compared by their hypervolume, as a percentage of that of the true front." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "1d94fb88", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "the true front: 7 designs\n" + ] + } + ], + "source": [ + "from trade_space_example import MAX_SATELLITES, OBJECTIVES, designs, space, study\n", + "from tatc.tradespace import hypervolume, pareto_front, summarize\n", + "\n", + "results = study.run(designs)\n", + "summary = summarize(results, list(OBJECTIVES))\n", + "summary[\"pareto\"] = pareto_front(summary, OBJECTIVES)\n", + "true_front = set(summary.design[summary.pareto])\n", + "REFERENCE = {\"satellites\": MAX_SATELLITES + 1, \"planes\": 5, \"sufficient\": 0} # worse than every design\n", + "true_hypervolume = hypervolume(summary, OBJECTIVES, REFERENCE)\n", + "print(f\"the true front: {len(true_front)} designs\")" + ] + }, + { + "cell_type": "markdown", + "id": "b44435b5", + "metadata": {}, + "source": [ + "## Screen Designs with a Cheaper Study\n", + "\n", + "`screen` evaluates every design with a cheap study, keeps the best of them (whole fronts, until it has kept a share `keep` of the designs), and evaluates only those with the full study. It works if the cheap study ranks designs as the full study would.\n", + "\n", + "Here, a cheap study analyzes one replicate rather than five, over a shorter period, with the threshold of sufficient sampling scaled to the period (`count_samples` with a `duration`): two observations in 12 hours, or one in 6 hours. The table compares each screening with the true front, and its cost (the satellites analyzed, times the days of their analyses) with that of evaluating every design." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "1a92e627", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
cheap studykeep (%)designs keptefficient designs kepthypervolume (%)cost (%)
012 h, 1 replicate5.0744 of 798.816.9
112 h, 1 replicate10.01406 of 799.222.0
26 h, 1 replicate5.0621 of 783.010.6
36 h, 1 replicate20.02315 of 796.625.1
\n", + "
" + ], + "text/plain": [ + " cheap study keep (%) designs kept efficient designs kept \\\n", + "0 12 h, 1 replicate 5.0 74 4 of 7 \n", + "1 12 h, 1 replicate 10.0 140 6 of 7 \n", + "2 6 h, 1 replicate 5.0 62 1 of 7 \n", + "3 6 h, 1 replicate 20.0 231 5 of 7 \n", + "\n", + " hypervolume (%) cost (%) \n", + "0 98.8 16.9 \n", + "1 99.2 22.0 \n", + "2 83.0 10.6 \n", + "3 96.6 25.1 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from datetime import timedelta\n", + "from functools import partial\n", + "\n", + "import pandas as pd\n", + "\n", + "from trade_space_example import CACHE_DIRECTORY, START, TARGETS, count_samples\n", + "from tatc.tradespace import Observations, screen\n", + "\n", + "\n", + "def cheap_study(hours):\n", + " \"\"\"A cheaper study: one replicate over a shorter period.\"\"\"\n", + " duration = timedelta(hours=hours)\n", + " return study.replace(\n", + " observations=Observations(TARGETS, START, duration, directory=CACHE_DIRECTORY),\n", + " metrics=partial(count_samples, duration=duration),\n", + " replicates=1,\n", + " )\n", + "\n", + "\n", + "full_cost = results.satellites.sum() # satellite-days of evaluating every design (one day each)\n", + "rows = []\n", + "for hours, keep in [(12, 0.05), (12, 0.1), (6, 0.05), (6, 0.2)]:\n", + " screening = screen([cheap_study(hours), study], OBJECTIVES, designs, keep=keep)\n", + " days = screening.results.stage.map({0: hours / 24, 1: 1.0}) # of each analysis, by the cheap or the full study\n", + " kept = {d.key for d in screening.designs}\n", + " rows.append(\n", + " {\n", + " \"cheap study\": f\"{hours} h, 1 replicate\",\n", + " \"keep (%)\": 100 * keep,\n", + " \"designs kept\": len(kept),\n", + " \"efficient designs kept\": f\"{len(true_front & kept)} of {len(true_front)}\",\n", + " \"hypervolume (%)\": 100 * hypervolume(screening.summary, OBJECTIVES, REFERENCE) / true_hypervolume,\n", + " \"cost (%)\": 100 * (screening.results.satellites * days).sum() / full_cost,\n", + " }\n", + " )\n", + "pd.DataFrame(rows).round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "bb2a2b65", + "metadata": {}, + "source": [ + "The 12-hour study ranks designs nearly as the full study does. Keeping the best 5% of the designs finds 99% of the hypervolume of the true front at 17% of the cost of evaluating every design, although it misses three of the seven efficient designs, whose places designs with nearly the same objectives take. Keeping 10% finds six of the seven, at 22% of the cost.\n", + "\n", + "The 6-hour study is cheaper, but ranks designs differently: one observation in 6 hours separates designs less than four in a day do. Keeping 5% of the designs keeps only one of the seven efficient designs (83% of the hypervolume), and keeping 20% still misses two of them, at more cost than the 12-hour study that keeps 10%." + ] + }, + { + "cell_type": "markdown", + "id": "958118bd", + "metadata": {}, + "source": [ + "## Search with Optimizers\n", + "\n", + "Larger spaces cannot even be screened. An optimizer searches them instead: it proposes designs, learns from their results, and proposes better ones.\n", + "\n", + "* `optimize_optuna` uses an Optuna sampler, which proposes designs of the design space directly.\n", + "* `optimize_pymoo` uses a pymoo algorithm, which proposes numbers between 0 and 1 that encode designs.\n", + "\n", + "Both evaluate each design once, however often it is proposed, and evaluate the designs proposed together in parallel. Each search here may propose 200 designs, about a fifth of the space, and a Latin hypercube sample of 200 designs (`DesignSpace.sample`) is the baseline. `hypervolume_progress` gives the hypervolume of the designs evaluated so far, after each evaluation. The designs were all evaluated above, so their results come from the store." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ae594f52", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
designs evaluatedhypervolume (%)
Optuna (NSGA-II)143.092.1
pymoo (NSGA-II)166.0100.0
Latin hypercube sample176.079.3
\n", + "
" + ], + "text/plain": [ + " designs evaluated hypervolume (%)\n", + "Optuna (NSGA-II) 143.0 92.1\n", + "pymoo (NSGA-II) 166.0 100.0\n", + "Latin hypercube sample 176.0 79.3" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import optuna\n", + "from pymoo.algorithms.moo.nsga2 import NSGA2\n", + "\n", + "from tatc.tradespace import hypervolume_progress, optimize_optuna, optimize_pymoo\n", + "\n", + "optuna.logging.set_verbosity(optuna.logging.WARNING)\n", + "BUDGET = 200 # proposals of each search\n", + "searches = {\n", + " \"Optuna (NSGA-II)\": optimize_optuna(\n", + " study,\n", + " OBJECTIVES,\n", + " n_trials=BUDGET,\n", + " sampler=optuna.samplers.NSGAIISampler(population_size=20, seed=1),\n", + " batch_size=20,\n", + " ).results,\n", + " \"pymoo (NSGA-II)\": optimize_pymoo(study, OBJECTIVES, NSGA2(pop_size=20), (\"n_gen\", BUDGET // 20), seed=1).results,\n", + " \"Latin hypercube sample\": study.run(space.sample(BUDGET, method=\"lhs\", seed=1)),\n", + "}\n", + "# the hypervolume (% of the true front's) of the designs evaluated so far, after each evaluation\n", + "progress = {\n", + " name: 100 * hypervolume_progress(search, OBJECTIVES, REFERENCE) / true_hypervolume\n", + " for name, search in searches.items()\n", + "}\n", + "pd.DataFrame(\n", + " {\n", + " name: {\"designs evaluated\": search.design.nunique(), \"hypervolume (%)\": progress[name].iloc[-1]}\n", + " for name, search in searches.items()\n", + " }\n", + ").T.round(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b5b86fdf", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "from tatc.tradespace import plot_progress\n", + "from tatc.tradespace.plotting import GRAY\n", + "\n", + "ax = plot_progress(progress)\n", + "ax.axhline(100, color=GRAY, lw=1, ls=\"--\")\n", + "ax.annotate(\"true front\", (0, 100), xytext=(2, 4), textcoords=\"offset points\", fontsize=8, color=GRAY)\n", + "ax.set(ylabel=\"Hypervolume (% of true front)\")\n", + "ax.set_title(\"Progress of the searches\", fontsize=10)\n", + "ax.figure.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "fda7e896", + "metadata": {}, + "source": [ + "Both optimizers find more of the front than a sample of as many designs. pymoo finds the whole front with 166 designs, 15% of the space (its other 34 proposals violate the constraint on the number of satellites). Optuna finds 92% of the hypervolume with 143 designs, and the sample 79% with 176. The searches stop at their budget, not when they converge: a larger budget, or screening first, would bring Optuna's closer to the true front." + ] + }, + { + "cell_type": "markdown", + "id": "71dc70b3", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "* The hypervolume measures how close a set of designs comes to the true front (`hypervolume`, and `hypervolume_progress` as a search proceeds).\n", + "* `screen` evaluates every design with a cheap study and only the best with the full one, which finds the front at a fraction of the cost if the cheap study ranks designs as the full one does.\n", + "* `optimize_optuna` and `optimize_pymoo` search spaces too large to enumerate, and find most of the front with a fraction of the designs.\n", + "\n", + "A search chooses its front from the mean of each design's replicates, which favors designs whose replicates were lucky. The next notebook, `RankUncertainDesigns`, ranks designs with the uncertainty of their replicates, for the results of a search as for those of every design." + ] + }, + { + "cell_type": "markdown", + "id": "56b025ff", + "metadata": {}, + "source": [ + "## Notes\n", + "\n", + "* How many designs to keep depends on how well the cheap study ranks designs. Check it on a sample of designs evaluated with both studies before screening a large space.\n", + "* The results of a search depend on its seed: over eight seeds, pymoo's search here finds 88 to 100% of the hypervolume (96.5% on average). Compare several seeds before relying on one.\n", + "* Many encoded points decode to the same design (those in the same level of each variable, or that differ only in the variables of an alternative not chosen). `optimize_pymoo` eliminates proposals of designs proposed or evaluated before, which pymoo's own elimination of equal points does not see." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/tradespace/TradeCostAndUtility.ipynb b/docs/examples/tradespace/TradeCostAndUtility.ipynb new file mode 100644 index 00000000..83ed8902 --- /dev/null +++ b/docs/examples/tradespace/TradeCostAndUtility.ipynb @@ -0,0 +1,788 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "350c6e2c", + "metadata": {}, + "source": [ + "# Trade Cost and Utility\n", + "\n", + "So far, the numbers of satellites and planes have stood in for cost. This notebook estimates the life-cycle cost of each design, and trades it against what the design achieves.\n", + "\n", + "It covers:\n", + "\n", + "* **costs**, from a cost model and the schedule of each design's deployment;\n", + "* **uncertain cost growth**, and the cost at a confidence level as an objective, within a **budget**;\n", + "* **utility**, which weighs several objectives by a stakeholder's preferences.\n", + "\n", + "It builds on `ExplainTradeSpace`, whose study measures both shares of points sampled." + ] + }, + { + "cell_type": "markdown", + "id": "d975d3a1", + "metadata": {}, + "source": [ + "## Estimate Costs\n", + "\n", + "Three parts describe the mission of each design (with illustrative costs, in millions of dollars):\n", + "\n", + "* A `DeploymentSchedule`: three years of development; production on one line, at four satellites a year; launches of up to three satellites, at most one every half year; and five years of operations from the first launch.\n", + "* A `CostModel`: the costs of developing a satellite of each imager and of producing its first unit (later units cost less, on a learning curve), a cost per launch, and the costs of operations. TAT-C has no cost-estimating relationships: the study gives these costs.\n", + "* A `MissionPlan` combines them. It plans each design's deployment by the schedule, and estimates its cost for the satellites of its imager (`kind=\"field_of_regard\"`).\n", + "\n", + "The growth of the cost of development is uncertain: an `Uncertain` parameter (`cost_growth`) from 0.9 to 1.6 times the estimate, most likely 1, drawn for each replicate. `space.extend` adds it to the design space, and the plan multiplies the costs of development by it (`growth`)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ada3ffd3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
satellitesplanesfield_of_regardcost_growthdeployedcostcost developmentcost productioncost launchcost operations
011301.053.2579.6542.1512.08.017.5
111301.083.2580.8243.3212.08.017.5
211301.243.2586.9349.4312.08.017.5
311301.013.2577.9740.4712.08.017.5
411301.173.2584.3546.8512.08.017.5
\n", + "
" + ], + "text/plain": [ + " satellites planes field_of_regard cost_growth deployed cost \\\n", + "0 1 1 30 1.05 3.25 79.65 \n", + "1 1 1 30 1.08 3.25 80.82 \n", + "2 1 1 30 1.24 3.25 86.93 \n", + "3 1 1 30 1.01 3.25 77.97 \n", + "4 1 1 30 1.17 3.25 84.35 \n", + "\n", + " cost development cost production cost launch cost operations \n", + "0 42.15 12.0 8.0 17.5 \n", + "1 43.32 12.0 8.0 17.5 \n", + "2 49.43 12.0 8.0 17.5 \n", + "3 40.47 12.0 8.0 17.5 \n", + "4 46.85 12.0 8.0 17.5 " + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from trade_space_example import accuracy_study, describe, planes_name, space\n", + "from tatc.tradespace import (\n", + " CostModel,\n", + " DeploymentSchedule,\n", + " LaunchCost,\n", + " MissionPlan,\n", + " OperationsCost,\n", + " SatelliteCost,\n", + " Uncertain,\n", + ")\n", + "\n", + "SCHEDULE = DeploymentSchedule(years=5, development_years=3, production_rate=4, launch_interval=0.5, launch_capacity=3)\n", + "COST_MODEL = CostModel(\n", + " satellites={ # by field of regard\n", + " 30: SatelliteCost(development=40, first_unit=12, learning_rate=0.9, mass=60),\n", + " 60: SatelliteCost(development=60, first_unit=18, learning_rate=0.9, mass=90),\n", + " },\n", + " launch=LaunchCost(per_launch=8),\n", + " operations=OperationsCost(per_year=3, per_satellite_year=0.5),\n", + " discount_rate=0.03,\n", + ")\n", + "PLAN = MissionPlan(SCHEDULE, COST_MODEL, kind=\"field_of_regard\", growth={\"development\": \"cost_growth\"})\n", + "cost_space = space.extend(cost_growth=Uncertain(lambda rng: float(rng.triangular(0.9, 1.0, 1.6))))\n", + "cost_study = accuracy_study.replace(space=cost_space, plan=PLAN)\n", + "results = cost_study.run() # every design of the design space\n", + "COSTS = [\"cost\", \"cost development\", \"cost production\", \"cost launch\", \"cost operations\"]\n", + "results[[\"satellites\", \"planes\", \"field_of_regard\", \"cost_growth\", \"deployed\", *COSTS]].head().round(2)" + ] + }, + { + "cell_type": "markdown", + "id": "fe184464", + "metadata": {}, + "source": [ + "Each evaluation now has the cost of the design and its parts, and the years from the start of development to the design's last launch (`deployed`).\n", + "\n", + "## Trade Cost against Sufficiency\n", + "\n", + "Budgets are often set at a confidence level: a cost within which a design stays with a probability of 70%, the 0.7 `Quantile` of its cost over the replicates (`cost p70`). The criteria:\n", + "\n", + "* minimize the cost at 70% confidence, and maximize the share of points sufficiently sampled;\n", + "* require the cost at 70% confidence to be within a budget of 150 million dollars (a `Requirement`).\n", + "\n", + "`aggregate` gives the statistics of the criteria for each design, and `pareto_front` finds the efficient designs among those that meet the requirement." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "71c5b6f8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "520 of 1096 designs cost at most 150 at 70% confidence\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "from tatc.tradespace import Criteria, Quantile, Requirement, aggregate, pareto_front, plot_designs\n", + "from tatc.tradespace.plotting import GRAY\n", + "\n", + "BUDGET = 150 # millions of dollars, at 70% confidence\n", + "COST = Criteria(\n", + " {\"cost p70\": \"min\", \"sufficient\": \"max\"},\n", + " statistics={\"cost p70\": Quantile(\"cost\", 0.7)},\n", + " requirements=[Requirement(\"cost p70\", \"<=\", BUDGET)],\n", + ")\n", + "costed = aggregate(results, COST)\n", + "costed[\"pareto\"] = pareto_front(costed, COST)\n", + "print(f\"{costed.meets_requirements.sum()} of {len(costed)} designs cost at most {BUDGET} at 70% confidence\")\n", + "\n", + "ax = plot_designs(costed, \"cost p70\", \"sufficient\", by=\"planes\", front=\"pareto\", names=planes_name, legend=\"upper left\")\n", + "ax.axvline(BUDGET, color=GRAY, lw=1, ls=\"--\")\n", + "ax.set(xlabel=\"Cost at 70% confidence (millions of dollars)\", ylabel=\"Points sufficiently sampled (%)\", ylim=(0, 105))\n", + "ax.set_title(\"Every design, with the efficient designs within the budget ringed\", fontsize=10)\n", + "ax.figure.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "18f5ac2a", + "metadata": {}, + "source": [ + "The efficient designs, with the years until they are deployed and some parts of their costs. A summary keeps the values that are the same in every replicate of a design, such as the cost of launches; the cost of development grows by a different factor in each replicate, so its mean is added:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "2f42311e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanesdeployedcost developmentcost launchcost p70sufficient
0700 km, 30 deg FOR, SSO: 1 at 06:00113.244.48.083.61.0
7800 km, 30 deg FOR, SSO: 2 at 06:00213.544.48.096.92.6
2800 km, 30 deg FOR, Walker 45 deg: 2 x 1 (spac...223.844.416.0104.76.2
1800 km, 30 deg FOR, Walker 45 deg: 1 x 3 (spac...313.844.48.0109.67.8
4800 km, 30 deg FOR, Walker 45 deg: 3 x 1 (spac...334.244.424.0124.811.2
3800 km, 30 deg FOR, Walker 45 deg: 2 x 2 (spac...424.044.416.0129.322.2
12800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...223.866.716.0139.230.2
5800 km, 30 deg FOR, Walker 45 deg: 4 x 1 (spac...444.844.432.0144.331.0
11800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...313.866.78.0149.138.0
\n", + "
" + ], + "text/plain": [ + " description satellites planes \\\n", + "0 700 km, 30 deg FOR, SSO: 1 at 06:00 1 1 \n", + "7 800 km, 30 deg FOR, SSO: 2 at 06:00 2 1 \n", + "2 800 km, 30 deg FOR, Walker 45 deg: 2 x 1 (spac... 2 2 \n", + "1 800 km, 30 deg FOR, Walker 45 deg: 1 x 3 (spac... 3 1 \n", + "4 800 km, 30 deg FOR, Walker 45 deg: 3 x 1 (spac... 3 3 \n", + "3 800 km, 30 deg FOR, Walker 45 deg: 2 x 2 (spac... 4 2 \n", + "12 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2 2 \n", + "5 800 km, 30 deg FOR, Walker 45 deg: 4 x 1 (spac... 4 4 \n", + "11 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3 1 \n", + "\n", + " deployed cost development cost launch cost p70 sufficient \n", + "0 3.2 44.4 8.0 83.6 1.0 \n", + "7 3.5 44.4 8.0 96.9 2.6 \n", + "2 3.8 44.4 16.0 104.7 6.2 \n", + "1 3.8 44.4 8.0 109.6 7.8 \n", + "4 4.2 44.4 24.0 124.8 11.2 \n", + "3 4.0 44.4 16.0 129.3 22.2 \n", + "12 3.8 66.7 16.0 139.2 30.2 \n", + "5 4.8 44.4 32.0 144.3 31.0 \n", + "11 3.8 66.7 8.0 149.1 38.0 " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "development = aggregate(results, [\"cost development\"], design_columns=[]).drop(columns=\"replicates\")\n", + "front = costed[costed.pareto].merge(development, on=\"design\").sort_values(\"cost p70\")\n", + "front = front.drop_duplicates([\"cost p70\", \"sufficient\"]) # one of the designs that tie\n", + "front[\"description\"] = front.apply(describe, axis=1)\n", + "front[\n", + " [\"description\", \"satellites\", \"planes\", \"deployed\", \"cost development\", \"cost launch\", \"cost p70\", \"sufficient\"]\n", + "].round(1)" + ] + }, + { + "cell_type": "markdown", + "id": "51cf4f0a", + "metadata": {}, + "source": [ + "520 of the 1,096 designs cost at most 150 million dollars at 70% confidence. Along the front, money buys sufficiency in steps:\n", + "\n", + "* one satellite with the narrower imager costs 84 million dollars, of which 44 million develop it, and samples 1% of the points sufficiently;\n", + "* a second satellite costs 97 million in the same plane (3%), and 105 million in a second plane (6%), as each plane needs its own launch;\n", + "* four satellites cost 129 million in two planes (22%), and 144 million in four planes (31%): two more launches buy 9 points, as more planes spread the samples in time;\n", + "* the wider imager joins the front only near the budget, where its development (67 million against 44) is worth its swath: two satellites with it sample 30% of the points for 139 million, and three of them 38% for 149 million, the most within the budget.\n", + "\n", + "The designs that sample nearly every point (six to nine satellites) cost more than the budget. The deployment of each design follows from its satellites and planes: one satellite is launched 3.2 years after development starts, and four satellites in four planes 4.8 years after, as launches are at least half a year apart. The mean cost of development is the same for every design of an imager, as the growth of each replicate is drawn alike for every design." + ] + }, + { + "cell_type": "markdown", + "id": "3dd1f946", + "metadata": {}, + "source": [ + "## Trade Utility against Cost\n", + "\n", + "Sufficiency and accuracy are separate objectives, each in its own units. A stakeholder who values both must weigh them, and a `Utility` makes the weights explicit:\n", + "\n", + "* a utility of each share, from 0 at its worst value to 1 at its best: linear in the share sufficiently sampled (`LinearUtility`), and concave in the share accurately sampled (`ExponentialUtility`), as the first points accurately sampled matter most;\n", + "* weights, which combine the utilities of the shares.\n", + "\n", + "Two stakeholders weigh the shares differently: one mostly sufficiency (0.7 against 0.3), as a center that counts samples for forecasts might, and the other mostly accuracy (0.3 against 0.7), as one that estimates daily means might. A design's utility is that of its mean shares. The figure plots each stakeholder's utility of every design against its cost at 70% confidence, with the front of each stakeholder ringed:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "1890e620", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from tatc.tradespace import ExponentialUtility, LinearUtility, Utility, style_axes\n", + "\n", + "CURVES = {\"sufficient\": LinearUtility(0, 100), \"accurate\": ExponentialUtility(0, 100, risk=2)}\n", + "STAKEHOLDERS = {\n", + " \"sufficiency\": Utility(CURVES, weights={\"sufficient\": 0.7, \"accurate\": 0.3}),\n", + " \"accuracy\": Utility(CURVES, weights={\"sufficient\": 0.3, \"accurate\": 0.7}),\n", + "}\n", + "means = aggregate(\n", + " results, statistics={\"sufficient\": \"sufficient\", \"accurate\": \"accurate\", \"cost p70\": Quantile(\"cost\", 0.7)}\n", + ").set_index(\"design\")\n", + "means[\"description\"] = means.apply(describe, axis=1)\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(11, 4.5), sharey=True)\n", + "judged = {}\n", + "for ax, (name, utility) in zip(axes, STAKEHOLDERS.items()):\n", + " judged[name] = means.assign(utility=utility(means))\n", + " judged[name][\"pareto\"] = pareto_front(judged[name], {\"utility\": \"max\", \"cost p70\": \"min\"})\n", + " legend = \"lower right\" if ax is axes[0] else None\n", + " plot_designs(\n", + " judged[name], \"cost p70\", \"utility\", by=\"planes\", front=\"pareto\", names=planes_name, legend=legend, ax=ax\n", + " )\n", + " ax.axvline(BUDGET, color=GRAY, lw=1, ls=\"--\")\n", + " ax.set(xlabel=\"Cost at 70% confidence (millions of dollars)\", ylabel=\"Utility\", ylim=(0, 1.02))\n", + " ax.set_title(f\"Weighing {name} most\", fontsize=10)\n", + " style_axes(ax, grid=\"both\")\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "a20dfa0b", + "metadata": {}, + "source": [ + "The stakeholders' fronts share most of their designs. Those efficient for one stakeholder and not the other:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "73063496", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "18 designs are efficient for both\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
descriptionsatellitesplanessufficientaccuratecost p70utility (sufficiency)efficient (sufficiency)utility (accuracy)efficient (accuracy)
design
828c0027d01f800 km, 60 deg FOR, SSO: 1 at 12:00, 2 at 18:003229.257.0156.650.44False0.64True
c576e2e2dbd1800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:003228.860.6156.900.45False0.66True
6ba50f2632cd800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac...4269.665.4173.730.74True0.80False
3690f1194419800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:004257.685.4173.730.69False0.84True
7d5b745cf8f6800 km, 60 deg FOR, Walker 45 deg: 4 x 1 (spac...4468.671.2188.730.74True0.82False
64cf6542c326800 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac...6390.295.8213.530.93False0.96True
\n", + "
" + ], + "text/plain": [ + " description satellites \\\n", + "design \n", + "828c0027d01f 800 km, 60 deg FOR, SSO: 1 at 12:00, 2 at 18:00 3 \n", + "c576e2e2dbd1 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3 \n", + "6ba50f2632cd 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4 \n", + "3690f1194419 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4 \n", + "7d5b745cf8f6 800 km, 60 deg FOR, Walker 45 deg: 4 x 1 (spac... 4 \n", + "64cf6542c326 800 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... 6 \n", + "\n", + " planes sufficient accurate cost p70 utility (sufficiency) \\\n", + "design \n", + "828c0027d01f 2 29.2 57.0 156.65 0.44 \n", + "c576e2e2dbd1 2 28.8 60.6 156.90 0.45 \n", + "6ba50f2632cd 2 69.6 65.4 173.73 0.74 \n", + "3690f1194419 2 57.6 85.4 173.73 0.69 \n", + "7d5b745cf8f6 4 68.6 71.2 188.73 0.74 \n", + "64cf6542c326 3 90.2 95.8 213.53 0.93 \n", + "\n", + " efficient (sufficiency) utility (accuracy) \\\n", + "design \n", + "828c0027d01f False 0.64 \n", + "c576e2e2dbd1 False 0.66 \n", + "6ba50f2632cd True 0.80 \n", + "3690f1194419 False 0.84 \n", + "7d5b745cf8f6 True 0.82 \n", + "64cf6542c326 False 0.96 \n", + "\n", + " efficient (accuracy) \n", + "design \n", + "828c0027d01f True \n", + "c576e2e2dbd1 True \n", + "6ba50f2632cd False \n", + "3690f1194419 True \n", + "7d5b745cf8f6 False \n", + "64cf6542c326 True " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "compared = means[[\"description\", \"satellites\", \"planes\", \"sufficient\", \"accurate\", \"cost p70\"]].copy()\n", + "for name in STAKEHOLDERS:\n", + " compared[f\"utility ({name})\"] = judged[name][\"utility\"]\n", + " compared[f\"efficient ({name})\"] = judged[name][\"pareto\"]\n", + "print(\n", + " f\"{(compared['efficient (sufficiency)'] & compared['efficient (accuracy)']).sum()} designs are efficient for both\"\n", + ")\n", + "compared[compared[\"efficient (sufficiency)\"] != compared[\"efficient (accuracy)\"]].sort_values(\"cost p70\").round(2)" + ] + }, + { + "cell_type": "markdown", + "id": "6172984f", + "metadata": {}, + "source": [ + "Within the budget, the stakeholders agree: every design efficient for either of them up to 150 million dollars is efficient for both, as more satellites in more planes buy both shares. Beyond the budget, they part. For 174 million dollars at 70% confidence, the stakeholder of sufficiency prefers four satellites in two Walker planes (70% of the points sufficiently sampled, and 65% accurately), and the stakeholder of accuracy four satellites in two sun-synchronous planes crossing at 09:00 and 15:00 (58% and 85%), whose planes spread the samples over the day. The stakeholder of accuracy also finds three satellites in two sun-synchronous planes efficient for 157 million, and six satellites in three Walker planes for 214 million, which the stakeholder of sufficiency passes over." + ] + }, + { + "cell_type": "markdown", + "id": "19ed320e", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "* A `CostModel` estimates the life-cycle cost of each design from the costs of its satellites, launches, and operations, and a `DeploymentSchedule` dates them by the deployment that it plans from rates of production and launch. A `MissionPlan` combines them in a study.\n", + "* Uncertain growth of costs makes the cost at a confidence level (a `Quantile` over the replicates) an objective, and a budget a `Requirement`, in place of the numbers of satellites and planes.\n", + "* A `Utility` weighs metrics by a stakeholder's preferences into one objective, to trade against cost.\n", + "\n", + "The next notebook, `PlanDeployment`, accounts for the years over which each design is deployed." + ] + }, + { + "cell_type": "markdown", + "id": "71f52cd4", + "metadata": {}, + "source": [ + "## Notes\n", + "\n", + "* Cost risk has more structure than one factor of growth: the components of satellites grow by their maturity, their growths are correlated, and designs that share components share their growth. `ValidateCostVarianceNSOSA` (in the validation notebooks) models these with `Component`, `Triangular`, and `risk_space`, and compares designs by the probability that one costs more than another (`exceedance`).\n", + "* Five replicates make the 0.7 quantile of each design's cost a coarse estimate. An evaluation of the cost alone, which costs little more than the cost model, could draw many more replicates.\n", + "* The results also give the present value of each design's cost (`cost present`, discounted at 3% a year) and the cost of its most expensive year (`cost peak annual`), for annual budgets.\n", + "* A utility is a metric of any statistic, such as `Quantile(utility, 0.1)`: the utility that a design exceeds in 90% of the replicates. A multiplicative utility (`form=\"multiplicative\"`) makes the shares complements, both of which a design must serve, or substitutes." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/tradespace/index.rst b/docs/examples/tradespace/index.rst new file mode 100644 index 00000000..25bac193 --- /dev/null +++ b/docs/examples/tradespace/index.rst @@ -0,0 +1,46 @@ +==================== +Trade Space Tutorial +==================== + +These notebooks follow one trade study with the ``tatc.tradespace`` module +from start to finish: how many satellites, in how many orbit planes, an +imager needs to observe the Earth often enough. Each notebook adds one idea +to those before it, so read them in order: + +#. :doc:`EvaluateTradeSpace`: declare a design space and a study, evaluate + every design, and find the Pareto-efficient designs. +#. :doc:`ExplainTradeSpace`: measure sampling by its error, explain why + designs differ, and find the decisions that drive the objectives. +#. :doc:`SearchTradeSpace`: find the efficient designs of larger spaces by + screening with a cheaper study and by searching with optimizers. +#. :doc:`RankUncertainDesigns`: rank designs with the uncertainty of their + replicates, refine and confirm the front, and require reliable + performance. +#. :doc:`CompareScenarios`: compare designs under conditions that are not + known in advance, and find designs robust to them. +#. :doc:`TradeCostAndUtility`: estimate life-cycle costs with uncertain + growth, trade them within a budget, and weigh objectives by utility. +#. :doc:`PlanDeployment`: account for the phases of each design's + deployment, and stage it. +#. :doc:`PlanForFailures`: simulate failures, choose restoration policies + with the designs, and find what spreads the results. + +The notebooks import the design space and the study of the first notebook, +and the parts of later notebooks that the notebooks after them use, from +``trade_space_example.py`` beside them. Each study keeps its results in a +store, from which a notebook takes the evaluations of the notebooks before it +where their studies are the same. The notebooks require:: + + pip install tatc[tradespace] + +.. toctree:: + :hidden: + + EvaluateTradeSpace.ipynb + ExplainTradeSpace.ipynb + SearchTradeSpace.ipynb + RankUncertainDesigns.ipynb + CompareScenarios.ipynb + TradeCostAndUtility.ipynb + PlanDeployment.ipynb + PlanForFailures.ipynb diff --git a/docs/examples/trade_space_example.py b/docs/examples/tradespace/trade_space_example.py similarity index 55% rename from docs/examples/trade_space_example.py rename to docs/examples/tradespace/trade_space_example.py index 5f67b7ca..4a025dab 100644 --- a/docs/examples/trade_space_example.py +++ b/docs/examples/tradespace/trade_space_example.py @@ -1,8 +1,7 @@ """ -The design space and study of the example `SearchTradeSpace`, which the -examples that follow it (`RankUncertainDesigns`, `CompareScenarios`, -`TradeCostAndUtility`, and `PlanMissions`) import. See `SearchTradeSpace` -for what each part means. +The trade space of the trade space tutorial, which its notebooks import: the +parts that a notebook defines and later notebooks use, under the name of the +notebook that defines and explains them. @author: Paul T. Grogan """ @@ -20,7 +19,6 @@ CostModel, DeploymentSchedule, DesignSpace, - Fixed, Integer, LaunchCost, MissionPlan, @@ -38,16 +36,14 @@ walker_space, ) +# EvaluateTradeSpace: the design space, and the study of sufficient sampling + START = datetime(2026, 7, 1, tzinfo=timezone.utc) DURATION = timedelta(days=1) # the period of the analysis N_POINTS = 100 # points sampled in each replicate N_REPLICATES = 5 # replicates (samples of points) of each design -SAMPLES_PER_DAY = ( - 4 # a point is sufficiently sampled if it is observed at least this often -) +SAMPLES_PER_DAY = 4 # observations a day of a sufficiently sampled point MAX_SATELLITES = 10 -DECORRELATION_TIME = timedelta(hours=3) # of the field whose daily mean is estimated -MAX_RELATIVE_ERROR = 0.5 # a point is accurately sampled within this share of the field's standard deviation space = DesignSpace( altitude=Real(500e3, 800e3, step=100e3), @@ -59,110 +55,62 @@ per_plane=Integer(1, 4), ), sso=sso_planes_space( - crossing=Real(6, 18, step=3), satellites=Integer(1, 2), count=Integer(1, 2) + crossing=Real(6, 18, step=3), + satellites=Integer(1, 2), + count=Integer(1, 2), ), ), points_seed=Uncertain.seed(), - failure_seed=Uncertain.seed(), - cost_growth=Uncertain( - lambda rng: float(rng.triangular(0.9, 1.0, 1.6)) - ), # of development, for cost risk - decorrelation_time=Fixed( - DECORRELATION_TIME - ), # of the field, which scenarios may change - epoch=Fixed( - START - ), # the start of the analysis, which may be drawn for each replicate constraints=[lambda d: count_satellites(d.layout) - MAX_SATELLITES], ) designs = space.enumerate() -# the deployment of each design: 3 years of development, a production line of 4 satellites a year, launches of up to 3 -# satellites at most every half year, and 5 years of operations from the first launch -SCHEDULE = DeploymentSchedule( - years=5, - development_years=3, - production_rate=4, - launch_interval=0.5, - launch_capacity=3, -) -# illustrative costs (millions of dollars), not estimates of any mission: satellites with an imager of each field of -# regard, small launchers, and operations, discounted at 3% a year -COST_MODEL = CostModel( - satellites={ - 30: SatelliteCost(development=40, first_unit=12, learning_rate=0.9, mass=60), - 60: SatelliteCost(development=60, first_unit=18, learning_rate=0.9, mass=90), - }, - launch=LaunchCost(per_launch=8), - operations=OperationsCost(per_year=3, per_satellite_year=0.5), - discount_rate=0.03, -) -# the deployment and cost of each design: satellites of the kind of its field of regard, with its growth of -# development costs -PLAN = MissionPlan( - SCHEDULE, COST_MODEL, kind="field_of_regard", growth={"development": "cost_growth"} -) -# the points of each replicate: a randomly oriented lattice, generated from the replicate's seed -TARGETS = Targets(generate_points_rotated_lattice, N_POINTS, seed="points_seed") -CACHE_DIRECTORY = Path(tempfile.gettempdir()) / "tatc-search-trade-space" +def build(d): + """The satellites of a design: an imager in each orbit of its layout.""" + imager = Instrument(name="imager", field_of_regard=d.field_of_regard) + return build_constellation(d.layout, imager, epoch=START, altitude=d.altitude) -def sample(observations, design, duration=DURATION): - """The shares (%) of points sampled sufficiently and accurately by observations over a duration from the design's - epoch (of the field of the design's decorrelation time).""" +def count_samples(observations, duration=DURATION): + """The share (%) of points observed at least SAMPLES_PER_DAY times a day.""" if len(observations) == 0: # no satellites - return {"sufficient": 0.0, "accurate": 0.0} + return {"sufficient": 0.0} samples = observations.groupby("target_hash").size() - error = estimate_sampling_error( - observations, design.epoch, design.epoch + duration, design.decorrelation_time - ) threshold = SAMPLES_PER_DAY * duration / timedelta(days=1) - return { - "sufficient": 100 * (samples >= threshold).sum() / N_POINTS, - "accurate": 100 * (error.relative_error <= MAX_RELATIVE_ERROR).sum() / N_POINTS, - } + return {"sufficient": 100 * (samples >= threshold).sum() / N_POINTS} -def build(d): - """The satellites of a design: an imager of its field of regard in each orbit of its layout.""" - imager = Instrument(name="imager", field_of_regard=d.field_of_regard) - return build_constellation(d.layout, imager, epoch=START, altitude=d.altitude) - +CACHE_DIRECTORY = Path(tempfile.gettempdir()) / "tatc-trade-space" +# the points of each replicate: a lattice in a random orientation, from its seed +TARGETS = Targets(generate_points_rotated_lattice, N_POINTS, seed="points_seed") +OBSERVATIONS = Observations(TARGETS, START, DURATION, directory=CACHE_DIRECTORY) -# the study of the shares (%) of points sampled sufficiently and accurately over the period by the satellites of each -# design, and of its deployment and cost (by the mission plan), whose evaluations are kept in a store study = ObservationStudy( space, build, - Observations(TARGETS, "epoch", DURATION, directory=CACHE_DIRECTORY), - sample, + OBSERVATIONS, + count_samples, layout="layout", - plan=PLAN, replicates=N_REPLICATES, n_jobs=-1, store=ResultStore(CACHE_DIRECTORY / "results.sqlite"), ) - OBJECTIVES = {"satellites": "min", "planes": "min", "sufficient": "max"} -ACCURACY = {"satellites": "min", "planes": "min", "accurate": "max"} -REFERENCE = { - "satellites": MAX_SATELLITES + 1, - "planes": 5, - "sufficient": 0, -} # worse than every design, for hypervolumes def describe(d): """A short description of a design (a row of its values).""" if d.layout == "walker": layout = ( - f"Walker {d['layout.walker.inclination']:.0f} deg: {d['layout.walker.planes']:.0f} x " - f"{d['layout.walker.per_plane']:.0f} (spacing {d['layout.walker.relative_spacing']:.0f})" + f"Walker {d['layout.walker.inclination']:.0f} deg: " + f"{d['layout.walker.planes']:.0f} x {d['layout.walker.per_plane']:.0f} " + f"(spacing {d['layout.walker.relative_spacing']:.0f})" ) else: planes = [ - f"{d[f'layout.sso.planes[{k}].satellites']:.0f} at {d[f'layout.sso.planes[{k}].crossing']:02.0f}:00" + f"{d[f'layout.sso.planes[{k}].satellites']:.0f} at " + f"{d[f'layout.sso.planes[{k}].crossing']:02.0f}:00" for k in range(int(d["layout.sso.planes.count"])) ] layout = "SSO: " + ", ".join(planes) @@ -172,3 +120,66 @@ def describe(d): def planes_name(planes): """The name of a number of planes.""" return f"{planes:.0f} plane{'s' if planes > 1 else ''}" + + +# ExplainTradeSpace: the study of accurate sampling as well + +DECORRELATION_TIME = timedelta(hours=3) # of the field whose daily mean is estimated +MAX_RELATIVE_ERROR = 0.5 # of an accurate sample, in standard deviations of the field + + +def sample(observations, decorrelation_time=DECORRELATION_TIME): + """The shares (%) of points sampled sufficiently and accurately.""" + if len(observations) == 0: # no satellites + return {"sufficient": 0.0, "accurate": 0.0} + samples = observations.groupby("target_hash").size() + end = START + DURATION + error = estimate_sampling_error(observations, START, end, decorrelation_time) + return { + "sufficient": 100 * (samples >= SAMPLES_PER_DAY).sum() / N_POINTS, + "accurate": 100 * (error.relative_error <= MAX_RELATIVE_ERROR).sum() / N_POINTS, + } + + +accuracy_study = study.replace(metrics=sample) +ACCURACY = {"satellites": "min", "planes": "min", "accurate": "max"} + +# CompareScenarios: fields of other decorrelation times + +FIELDS = { + "1 hour": {"decorrelation_time": timedelta(hours=1)}, + "3 hours": {}, + "12 hours": {"decorrelation_time": timedelta(hours=12)}, +} + + +def sample_field(observations, design): + """The shares (%) of points sampled sufficiently and accurately (of its field).""" + return sample(observations, design.decorrelation_time) + + +# TradeCostAndUtility: the deployment and cost of each design + +SCHEDULE = DeploymentSchedule( + years=5, + development_years=3, + production_rate=4, + launch_interval=0.5, + launch_capacity=3, +) +COST_MODEL = CostModel( + satellites={ + 30: SatelliteCost(development=40, first_unit=12, learning_rate=0.9, mass=60), + 60: SatelliteCost(development=60, first_unit=18, learning_rate=0.9, mass=90), + }, + launch=LaunchCost(per_launch=8), + operations=OperationsCost(per_year=3, per_satellite_year=0.5), + discount_rate=0.03, +) +PLAN = MissionPlan( + SCHEDULE, COST_MODEL, kind="field_of_regard", growth={"development": "cost_growth"} +) +cost_space = space.extend( + cost_growth=Uncertain(lambda rng: float(rng.triangular(0.9, 1.0, 1.6))) +) +cost_study = accuracy_study.replace(space=cost_space, plan=PLAN) From 11882ff981fac4c98d9f3fddd0166b5ec592a66c Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Fri, 13 Nov 2026 17:14:20 -0700 Subject: [PATCH 42/52] move the OSSE examples to docs/examples/osse, which keeps their downloaded nature run in its data directory --- .gitignore | 2 +- CHANGELOG.md | 1 + docs/examples/index.rst | 3 +-- .../{ => osse}/RunOSSEHurricane.ipynb | 6 ++--- docs/examples/{ => osse}/RunOSSEMonsoon.ipynb | 6 ++--- docs/examples/osse/index.rst | 27 +++++++++++++++++++ .../validation/ValidateFeaturesTCPRIMED.ipynb | 2 +- docs/validation/ValidateImagerATMS.ipynb | 2 +- docs/validation/ValidateImagerCrIS.ipynb | 4 +-- 9 files changed, 40 insertions(+), 13 deletions(-) rename docs/examples/{ => osse}/RunOSSEHurricane.ipynb (99%) rename docs/examples/{ => osse}/RunOSSEMonsoon.ipynb (99%) create mode 100644 docs/examples/osse/index.rst diff --git a/.gitignore b/.gitignore index a82df84f..d60a7cc0 100644 --- a/.gitignore +++ b/.gitignore @@ -73,7 +73,7 @@ docs/_build/ # Reference data downloaded by example and validation notebooks docs/validation/data/ -docs/examples/data/ +docs/examples/osse/data/ # PyBuilder .pybuilder/ diff --git a/CHANGELOG.md b/CHANGELOG.md index f5c7102b..9d467d6d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -41,6 +41,7 @@ Added: - The `RunOSSEMonsoon` example declares its constellation trade as a design space, caches the looks of each satellite, evaluates its replicates in parallel, and finds its Pareto-efficient designs. Changed: + - The OSSE examples (`RunOSSEMonsoon`, `RunOSSEHurricane`) are in `docs/examples/osse`, and download the Nature Run to a `data` directory beside them. - Instruments reject unknown fields, rather than ignoring them: a misspelled field in the data of a `PointedInstrument` previously gave an `Instrument` with a field of regard of 180 degrees. - Dumping a `Satellite` or other system with a `PointedInstrument` or `ConicalInstrument` keeps the fields of its class, and loading the data restores it. Previously, these instruments were written and restored as a base `Instrument`, without a warning. Data written by earlier versions lacks these fields, so it still loads as an `Instrument`. - Dumping a space system with an `attitude` omits the `velocity_frame` of its instruments, which the attitude sets, so the data can be loaded. diff --git a/docs/examples/index.rst b/docs/examples/index.rst index 049b17e8..0ad624ba 100644 --- a/docs/examples/index.rst +++ b/docs/examples/index.rst @@ -21,8 +21,7 @@ The following provide examples of TAT-C use in a Jupyter notebook environment. CollectLimb.ipynb CollectSpace.ipynb AssessSamplingSufficiency.ipynb - RunOSSEMonsoon.ipynb - RunOSSEHurricane.ipynb + osse/index tradespace/index Note that running the above examples in a local Python environment requires additional dependencies which can be installed via:: diff --git a/docs/examples/RunOSSEHurricane.ipynb b/docs/examples/osse/RunOSSEHurricane.ipynb similarity index 99% rename from docs/examples/RunOSSEHurricane.ipynb rename to docs/examples/osse/RunOSSEHurricane.ipynb index 5b9c1b4f..3c6df58e 100644 --- a/docs/examples/RunOSSEHurricane.ipynb +++ b/docs/examples/osse/RunOSSEHurricane.ipynb @@ -9,7 +9,7 @@ "\n", "An observing system simulation experiment (OSSE) evaluates how well an observing system, real or planned, would observe a phenomenon, by sampling a high-resolution model simulation (the *nature run*) as the system would. This example is an OSSE of a **hurricane** in the 7-km [GEOS-5 Nature Run (G5NR)](https://gmao.gsfc.nasa.gov/global_mesoscale/7km-G5NR/). In late August of the Nature Run's second year, a simulated hurricane crosses the North Atlantic from near the Cape Verde Islands (about 15 N, 27 W on 20 August) to Nova Scotia (30 August). This example covers two days, 25 and 26 August, when the storm passes north of Puerto Rico and Hispaniola and begins to recurve to the north.\n", "\n", - "The observing systems are the same as in the [monsoon OSSE](RunOSSEMonsoon.ipynb): the atmospheric sounders on the current NOAA/NASA polar-orbiting satellites ([ATMS](../validation/ValidateImagerATMS.ipynb) and [CrIS](../validation/ValidateImagerCrIS.ipynb)) and two notional future sounders with finer resolution. Unlike the monsoon, whose features are scattered convective cells over land with a strong diurnal cycle, the features here are organized around one large storm over the ocean. Two kinds of features are defined:\n", + "The observing systems are the same as in the [monsoon OSSE](RunOSSEMonsoon.ipynb): the atmospheric sounders on the current NOAA/NASA polar-orbiting satellites ([ATMS](../../validation/ValidateImagerATMS.ipynb) and [CrIS](../../validation/ValidateImagerCrIS.ipynb)) and two notional future sounders with finer resolution. Unlike the monsoon, whose features are scattered convective cells over land with a strong diurnal cycle, the features here are organized around one large storm over the ocean. Two kinds of features are defined:\n", "\n", "* **cold cloud tops**, as in the monsoon OSSE, which outline the storm's central dense overcast and the convective cells of its rainbands; and\n", "* **heavy precipitation**, which outlines its eyewall and rainbands, where microwave sounders sense the rain and ice beneath the cloud tops.\n", @@ -69,7 +69,7 @@ "import shapely\n", "from shapely.geometry import box\n", "\n", - "DATA_DIR = Path(\"data\") / \"osse\"\n", + "DATA_DIR = Path(\"data\")\n", "DATA_DIR.mkdir(parents=True, exist_ok=True)\n", "\n", "# study region: a box around the storm's track over the two days\n", @@ -1334,7 +1334,7 @@ "source": [ "## Define the Sensors\n", "\n", - "The platforms, swaths, and sensors are those of the monsoon OSSE (see there for their basis): ATMS and CrIS on Suomi NPP, NOAA-20, and NOAA-21, with the swaths of TAT-C's [instrument catalog](../validation/catalog.rst), tested against NOAA-20 data, and the notional future microwave (MW) and infrared (IR) sounders with finer resolution, sharing the ATMS and CrIS swaths. Here the element sets are those of 25 August 2026." + "The platforms, swaths, and sensors are those of the monsoon OSSE (see there for their basis): ATMS and CrIS on Suomi NPP, NOAA-20, and NOAA-21, with the swaths of TAT-C's [instrument catalog](../../validation/catalog.rst), tested against NOAA-20 data, and the notional future microwave (MW) and infrared (IR) sounders with finer resolution, sharing the ATMS and CrIS swaths. Here the element sets are those of 25 August 2026." ] }, { diff --git a/docs/examples/RunOSSEMonsoon.ipynb b/docs/examples/osse/RunOSSEMonsoon.ipynb similarity index 99% rename from docs/examples/RunOSSEMonsoon.ipynb rename to docs/examples/osse/RunOSSEMonsoon.ipynb index 17fe493a..e6e80e40 100644 --- a/docs/examples/RunOSSEMonsoon.ipynb +++ b/docs/examples/osse/RunOSSEMonsoon.ipynb @@ -7,7 +7,7 @@ "source": [ "# OSSE: North American Monsoon Convection\n", "\n", - "An observing system simulation experiment (OSSE) evaluates how well an observing system, real or planned, would observe a phenomenon, by sampling a high-resolution model simulation (the *nature run*) as the system would. This example is an OSSE of **convection during the North American Monsoon**. The nature run is the 7-km [GEOS-5 Nature Run (G5NR)](https://gmao.gsfc.nasa.gov/global_mesoscale/7km-G5NR/). The *features* of interest are patches of very cold cloud tops over the American Southwest. The observing systems are the atmospheric sounders on the current NOAA/NASA polar-orbiting satellites ([ATMS](../validation/ValidateImagerATMS.ipynb) and [CrIS](../validation/ValidateImagerCrIS.ipynb)) and two notional future sounders with finer resolution.\n", + "An observing system simulation experiment (OSSE) evaluates how well an observing system, real or planned, would observe a phenomenon, by sampling a high-resolution model simulation (the *nature run*) as the system would. This example is an OSSE of **convection during the North American Monsoon**. The nature run is the 7-km [GEOS-5 Nature Run (G5NR)](https://gmao.gsfc.nasa.gov/global_mesoscale/7km-G5NR/). The *features* of interest are patches of very cold cloud tops over the American Southwest. The observing systems are the atmospheric sounders on the current NOAA/NASA polar-orbiting satellites ([ATMS](../../validation/ValidateImagerATMS.ipynb) and [CrIS](../../validation/ValidateImagerCrIS.ipynb)) and two notional future sounders with finer resolution.\n", "\n", "The experiment asks two questions about each feature:\n", "\n", @@ -63,7 +63,7 @@ "import shapely\n", "from shapely.geometry import box\n", "\n", - "DATA_DIR = Path(\"data\") / \"osse\"\n", + "DATA_DIR = Path(\"data\")\n", "DATA_DIR.mkdir(parents=True, exist_ok=True)\n", "\n", "# study region: the American Southwest, the core of the North American Monsoon\n", @@ -1179,7 +1179,7 @@ "\n", "**Platforms.** The current constellation of sounders is Suomi NPP, NOAA-20, and NOAA-21, three satellites in a sun-synchronous orbit with an ascending node of about 13:30 local time. Each carries both the Advanced Technology Microwave Sounder (ATMS) and the Cross-track Infrared Sounder (CrIS).\n", "\n", - "**Swaths.** The swaths of ATMS and CrIS come from TAT-C's [instrument catalog](../validation/catalog.rst) (`tatc.catalog`), whose swath configurations of NOAA-20 (`swath_noaa_20` of ATMS and `swath` of CrIS) were tested against its data: each is a rectangular `PointedInstrument` spanning the scan positions measured in the validation notebooks ([ATMS](../validation/ValidateImagerATMS.ipynb) and [CrIS](../validation/ValidateImagerCrIS.ipynb)), with CrIS's scan plane tilted forward as measured, on a satellite whose attitude scans perpendicular to the inertial velocity (`VelocityFrame.INERTIAL`) rather than to the ground track. The catalog tailors the along-track field of view to the 30 s time step, so that consecutive footprints tile the swath. The configurations of NOAA-20 are used for all three satellites, so NOAA-21 and Suomi NPP are assumed identical to it.\n", + "**Swaths.** The swaths of ATMS and CrIS come from TAT-C's [instrument catalog](../../validation/catalog.rst) (`tatc.catalog`), whose swath configurations of NOAA-20 (`swath_noaa_20` of ATMS and `swath` of CrIS) were tested against its data: each is a rectangular `PointedInstrument` spanning the scan positions measured in the validation notebooks ([ATMS](../../validation/ValidateImagerATMS.ipynb) and [CrIS](../../validation/ValidateImagerCrIS.ipynb)), with CrIS's scan plane tilted forward as measured, on a satellite whose attitude scans perpendicular to the inertial velocity (`VelocityFrame.INERTIAL`) rather than to the ground track. The catalog tailors the along-track field of view to the 30 s time step, so that consecutive footprints tile the swath. The configurations of NOAA-20 are used for all three satellites, so NOAA-21 and Suomi NPP are assumed identical to it.\n", "\n", "**Resolution.** Each sensor has a horizontal resolution (the diameter of its footprint at nadir) and a sample spacing (the distance between the centers of neighboring footprints at nadir). A sensor cannot resolve detail finer than either its footprint or its sample spacing, so its *resolution element* is the larger of the two. ATMS oversamples (its 2.2 degree beams overlap at a 1.11 degree spacing), so its footprint limits it. CrIS undersamples slightly (its 0.963 degree views leave gaps at a 1.09 degree pitch), so its sample spacing limits it. The future sensors are assumed to sample in proportion to their footprints, in the same ratio as their heritage counterparts, so a future infrared sounder has as many more views per scan as its finer footprint requires.\n", "\n", diff --git a/docs/examples/osse/index.rst b/docs/examples/osse/index.rst new file mode 100644 index 00000000..d01ed00a --- /dev/null +++ b/docs/examples/osse/index.rst @@ -0,0 +1,27 @@ +======================================= +Observing System Simulation Experiments +======================================= + +These notebooks run observing system simulation experiments (OSSEs): they +sample features of the simulated weather of the 7-km GEOS-5 Nature Run with +the swaths of the atmospheric sounders of current polar-orbiting satellites +(ATMS and CrIS) and of notional future ones. The hurricane OSSE uses the +observing systems of the monsoon OSSE, so read that one first: + +#. :doc:`RunOSSEMonsoon`: the cold cloud tops of North American Monsoon + convection over the American Southwest, the horizontal resolution of the + sounders, and a trade of the satellites and orbit planes of a + constellation. +#. :doc:`RunOSSEHurricane`: the cold cloud tops and heavy precipitation of a + simulated North Atlantic hurricane, with the same sensors. + +Each notebook downloads the part of the Nature Run that it needs once, to a +``data`` directory beside it. The notebooks require:: + + pip install tatc[osse] + +.. toctree:: + :hidden: + + RunOSSEMonsoon.ipynb + RunOSSEHurricane.ipynb diff --git a/docs/validation/ValidateFeaturesTCPRIMED.ipynb b/docs/validation/ValidateFeaturesTCPRIMED.ipynb index 86e55639..b3cf7c34 100644 --- a/docs/validation/ValidateFeaturesTCPRIMED.ipynb +++ b/docs/validation/ValidateFeaturesTCPRIMED.ipynb @@ -11,7 +11,7 @@ "\n", "For every tropical cyclone, TC PRIMED collects the overpasses that cover enough of the storm from the passive microwave imagers and sounders of the Global Precipitation Measurement (GPM) constellation. Whether an overpass is kept is a geometric decision: it depends on how much of a circle around the storm's center the swath covers.\n", "\n", - "In TAT-C, `collect_feature_observations` collects observations of *features*: regions that exist for a period of time, such as the storms of a nature run in an observing system simulation experiment (OSSE; see the [hurricane OSSE example](../examples/RunOSSEHurricane.ipynb)). Each observation is one satellite's view of the part of a feature inside its swath, together with the fraction of the feature's area viewed.\n", + "In TAT-C, `collect_feature_observations` collects observations of *features*: regions that exist for a period of time, such as the storms of a nature run in an observing system simulation experiment (OSSE; see the [hurricane OSSE example](../examples/osse/RunOSSEHurricane.ipynb)). Each observation is one satellite's view of the part of a feature inside its swath, together with the fraction of the feature's area viewed.\n", "\n", "Here, the features are TC PRIMED's circles around each storm, at its best-track position. TAT-C reproduces TC PRIMED's selection of overpasses for the 13 Atlantic tropical cyclones of 2025, by 10 satellites carrying five sensors:\n", "* **Cross-track sounders:** ATMS on Suomi NPP, NOAA-20, and NOAA-21, and MHS on Metop-B and Metop-C.\n", diff --git a/docs/validation/ValidateImagerATMS.ipynb b/docs/validation/ValidateImagerATMS.ipynb index bf4cceb4..00dfd81c 100644 --- a/docs/validation/ValidateImagerATMS.ipynb +++ b/docs/validation/ValidateImagerATMS.ipynb @@ -2338,7 +2338,7 @@ "\n", "**Changes to TAT-C.** This validation led to the `velocity_frame` option and exposed two problems with the rectangular `PointedInstrument`, which have been fixed: rectangular footprint polygons for wide, elongated views were inaccurate (misplaced corners and too few points along the long sides), and `collect_observations` checked a pointed instrument's view only at the midpoint of each access period, missing up to 77% of observations for a view tailored to a scan period. It now checks the view at the time the view sweeps over the point and reports that time as the epoch.\n", "\n", - "**Footprint size.** TAT-C's viewing geometry gives the zenith angle and slant range of every pixel, from which the footprint of a beam of known width follows. ATMS's 2.2 deg beam has a 32 km footprint at nadir (confirming the nominal value), which grows to about 93 km (equivalent diameter) at the swath edge. Resolution therefore depends on where in the swath a feature is observed, which the [monsoon OSSE example](../examples/RunOSSEMonsoon.ipynb) accounts for.\n" + "**Footprint size.** TAT-C's viewing geometry gives the zenith angle and slant range of every pixel, from which the footprint of a beam of known width follows. ATMS's 2.2 deg beam has a 32 km footprint at nadir (confirming the nominal value), which grows to about 93 km (equivalent diameter) at the swath edge. Resolution therefore depends on where in the swath a feature is observed, which the [monsoon OSSE example](../examples/osse/RunOSSEMonsoon.ipynb) accounts for.\n" ] } ], diff --git a/docs/validation/ValidateImagerCrIS.ipynb b/docs/validation/ValidateImagerCrIS.ipynb index 63544621..bbe8287a 100644 --- a/docs/validation/ValidateImagerCrIS.ipynb +++ b/docs/validation/ValidateImagerCrIS.ipynb @@ -15,7 +15,7 @@ "2. **Scan geometry.** Which scan angles, array layout, and scan plane orientation reproduce the actual scan?\n", "3. **Geolocation.** How closely do TAT-C's pixel positions (`collect_ground_pixels`) match the reported FOV positions, and how much of the difference comes from scan timing and the rotation of the FOV array, which TAT-C does not model?\n", "4. **Swath.** Does TAT-C's swath (`compute_ground_track`) match the area CrIS samples, for time steps from one scan to two minutes?\n", - "5. **Footprint size.** Does the satellite viewing geometry reproduce the reported zenith angles and ranges on which the footprint size depends, and how large are CrIS footprints and how do they grow toward the swath edge? Footprint size (horizontal resolution) is the figure of merit of the [monsoon OSSE example](../examples/RunOSSEMonsoon.ipynb), which uses the parameters fit here." + "5. **Footprint size.** Does the satellite viewing geometry reproduce the reported zenith angles and ranges on which the footprint size depends, and how large are CrIS footprints and how do they grow toward the swath edge? Footprint size (horizontal resolution) is the figure of merit of the [monsoon OSSE example](../examples/osse/RunOSSEMonsoon.ipynb), which uses the parameters fit here." ] }, { @@ -2470,7 +2470,7 @@ "source": [ "## Summary\n", "\n", - "The parameters fitted to the NOAA-20 CrIS data, used by the [monsoon OSSE example](../examples/RunOSSEMonsoon.ipynb):" + "The parameters fitted to the NOAA-20 CrIS data, used by the [monsoon OSSE example](../examples/osse/RunOSSEMonsoon.ipynb):" ] }, { From 1c4091847e6425e055f01629fdf7bffa85fc8a4f Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Fri, 13 Nov 2026 21:29:55 -0700 Subject: [PATCH 43/52] add figures to the trade space tutorial notebooks that had few, and color plots of designs by at most three groups of planes --- .../tradespace/CompareScenarios.ipynb | 144 +++++++++++-- .../tradespace/EvaluateTradeSpace.ipynb | 100 +++++++-- .../tradespace/ExplainTradeSpace.ipynb | 154 ++++++++++--- docs/examples/tradespace/PlanDeployment.ipynb | 141 +++++++++++- .../examples/tradespace/PlanForFailures.ipynb | 204 +++++++++++++++--- .../tradespace/RankUncertainDesigns.ipynb | 194 ++++++++++++++--- .../tradespace/SearchTradeSpace.ipynb | 85 ++++++-- .../tradespace/TradeCostAndUtility.ipynb | 44 ++-- .../tradespace/trade_space_example.py | 6 + 9 files changed, 907 insertions(+), 165 deletions(-) diff --git a/docs/examples/tradespace/CompareScenarios.ipynb b/docs/examples/tradespace/CompareScenarios.ipynb index 8df1d81b..ad389acb 100644 --- a/docs/examples/tradespace/CompareScenarios.ipynb +++ b/docs/examples/tradespace/CompareScenarios.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "543ce74b", + "id": "4679e176", "metadata": {}, "source": [ "# Compare Designs across Scenarios\n", @@ -21,7 +21,7 @@ }, { "cell_type": "markdown", - "id": "0385c85b", + "id": "5922e667", "metadata": {}, "source": [ "## Define the Scenarios\n", @@ -38,14 +38,14 @@ { "cell_type": "code", "execution_count": 1, - "id": "3a8573e7", + "id": "4c97b966", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "16440 evaluations in 144 s\n" + "16440 evaluations in 1 s\n" ] } ], @@ -79,7 +79,7 @@ }, { "cell_type": "markdown", - "id": "abea8201", + "id": "7ec2c26b", "metadata": {}, "source": [ "## Compare the Fronts of the Scenarios\n", @@ -90,7 +90,7 @@ { "cell_type": "code", "execution_count": 2, - "id": "98c12199", + "id": "8e021fe5", "metadata": {}, "outputs": [ { @@ -274,7 +274,58 @@ }, { "cell_type": "markdown", - "id": "d6ecc9d6", + "id": "130532b7", + "metadata": {}, + "source": [ + "Every design in each field, by its layout, with the front of each field ringed:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8b9e713f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "from tatc.tradespace import plot_designs\n", + "\n", + "LAYOUTS = {\"walker\": \"Walker\", \"sso\": \"Sun-synchronous\"}\n", + "fig, axes = plt.subplots(1, 3, figsize=(14, 4.2), sharey=True)\n", + "for ax, field in zip(axes, FIELDS):\n", + " plot_designs(\n", + " by_field[by_field.scenario == field],\n", + " \"satellites\",\n", + " \"accurate\",\n", + " by=\"layout\",\n", + " front=\"pareto\",\n", + " names=LAYOUTS,\n", + " jitter=0.18, # spreads the designs of each number of satellites, for legibility\n", + " legend=\"lower right\" if ax is axes[0] else None,\n", + " ax=ax,\n", + " )\n", + " ax.set(xlabel=\"Satellites\", ylabel=\"\", xticks=range(1, MAX_SATELLITES + 1), ylim=(0, 105))\n", + " ax.set_title(f\"A field that decorrelates in {field}\", fontsize=10)\n", + "axes[0].set_ylabel(\"Points accurately sampled (%)\")\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "0685f3c7", "metadata": {}, "source": [ "Which designs are efficient depends on the field: 14 designs in the field of 1 hour, 13 in that of 3 hours, and 6 in that of 12 hours, and no design is efficient in all three. In the field of 12 hours, one plane samples well: three satellites in one plane sample 96% of the points accurately. In the fields that vary within hours, the samples must spread over the day: the same three satellites sample 17% (3 hours) and 8% (1 hour), against 61% and 41% for three satellites in two sun-synchronous planes." @@ -282,7 +333,7 @@ }, { "cell_type": "markdown", - "id": "859facfc", + "id": "41e6700a", "metadata": {}, "source": [ "## Choose a Robust Design\n", @@ -294,8 +345,8 @@ }, { "cell_type": "code", - "execution_count": 3, - "id": "b49af74c", + "execution_count": 4, + "id": "acf5055d", "metadata": {}, "outputs": [ { @@ -399,7 +450,7 @@ "6 3.0 0.4 0.4 0.2 0.4 " ] }, - "execution_count": 3, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -407,11 +458,11 @@ "source": [ "from tatc.tradespace import Requirement\n", "\n", - "robust = []\n", + "robust, robust_design = [], {}\n", "for limit in (2, 3, 4, 6):\n", " within = Criteria({\"accurate\": \"max\"}, requirements=[Requirement(\"satellites\", \"<=\", limit)])\n", " regret = robustness(fields, within).set_index(\"design\")\n", - " best = regret[\"max_regret\"].idxmin() # the design of least regret in its worst field\n", + " best = robust_design[limit] = regret[\"max_regret\"].idxmin() # the design of least regret in its worst field\n", " robust.append(\n", " {\n", " \"at most\": limit,\n", @@ -424,7 +475,62 @@ }, { "cell_type": "markdown", - "id": "5f0a5cfd", + "id": "8d72e778", + "metadata": {}, + "source": [ + "In each field, the robust design of each number of satellites (blue) against the best design of at most as many satellites in that field (gray): the gap between them is the robust design's regret in the field." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ae6ac96b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from tatc.tradespace import style_axes\n", + "from tatc.tradespace.plotting import COLORS, GRAY\n", + "\n", + "fig, axes = plt.subplots(1, len(robust_design), figsize=(14, 3.6), sharey=True)\n", + "for ax, (limit, best) in zip(axes, robust_design.items()):\n", + " within = by_field[by_field.satellites <= limit]\n", + " ceiling = within.groupby(\"scenario\")[\"accurate\"].max()[list(FIELDS)]\n", + " ax.plot(range(len(FIELDS)), ceiling, color=GRAY, lw=2, ls=\"--\", marker=\"o\", ms=5, label=\"best of the field\")\n", + " ax.plot(\n", + " range(len(FIELDS)),\n", + " traced.loc[best, list(FIELDS)],\n", + " color=COLORS[0],\n", + " lw=2,\n", + " marker=\"o\",\n", + " ms=6,\n", + " label=\"robust design\",\n", + " )\n", + " ax.set_xticks(range(len(FIELDS)), list(FIELDS))\n", + " ax.set(xlabel=\"Decorrelation time of the field\", ylim=(0, 105), xlim=(-0.3, len(FIELDS) - 0.7))\n", + " ax.set_title(\n", + " f\"At most {limit} satellites\\n{traced.loc[best, 'description'].replace(', 60 deg FOR', '')}\", fontsize=8\n", + " )\n", + " style_axes(ax)\n", + "axes[0].set_ylabel(\"Points accurately sampled (%)\")\n", + "axes[0].legend(loc=\"lower right\", fontsize=8, frameon=False)\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "4b370add", "metadata": {}, "source": [ "The robust choice depends on how many satellites the mission can afford. Four satellites in two sun-synchronous planes, crossing the equator at 09:00 and 15:00, are the best in the fields of 1 and 3 hours, and fall 5 points behind the best in the field of 12 hours: a mission that does not know its field loses little by choosing them. Two or three satellites fall 10 or 11 points behind somewhere. Six satellites in three Walker planes (at 700 km) fall at most 0.4 points behind the best in any field, though they are efficient in none: a robust design need not be the best in any scenario. Regrets of a point or two are within the sampling error of the means of five replicates." @@ -432,7 +538,7 @@ }, { "cell_type": "markdown", - "id": "57bc8db1", + "id": "a4abb242", "metadata": {}, "source": [ "## Search for Robust Designs\n", @@ -444,8 +550,8 @@ }, { "cell_type": "code", - "execution_count": 4, - "id": "f113c781", + "execution_count": 6, + "id": "2050e0b0", "metadata": {}, "outputs": [ { @@ -480,7 +586,7 @@ }, { "cell_type": "markdown", - "id": "8a515dfc", + "id": "13af5d5e", "metadata": {}, "source": [ "The search finds 99.3% of the hypervolume of the true front of the mean with 147 designs, and 8 of its 12 designs. Each design costs three times as much as in a search of one field, as it is evaluated in each field.\n", @@ -490,7 +596,7 @@ }, { "cell_type": "markdown", - "id": "9efa8455", + "id": "2d4c4ff6", "metadata": {}, "source": [ "## Summary\n", diff --git a/docs/examples/tradespace/EvaluateTradeSpace.ipynb b/docs/examples/tradespace/EvaluateTradeSpace.ipynb index 1ecd6086..7a812f8b 100644 --- a/docs/examples/tradespace/EvaluateTradeSpace.ipynb +++ b/docs/examples/tradespace/EvaluateTradeSpace.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "a1013bb7", + "id": "affa1f88", "metadata": {}, "source": [ "# Evaluate a Trade Space\n", @@ -21,7 +21,7 @@ }, { "cell_type": "markdown", - "id": "b4df384d", + "id": "17309571", "metadata": {}, "source": [ "## Configure the Analysis\n", @@ -32,7 +32,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "dc3c266d", + "id": "bc7b296c", "metadata": {}, "outputs": [], "source": [ @@ -50,7 +50,7 @@ }, { "cell_type": "markdown", - "id": "56bf65c9", + "id": "493b062b", "metadata": {}, "source": [ "## Declare the Design Space\n", @@ -71,7 +71,7 @@ { "cell_type": "code", "execution_count": 2, - "id": "b72d42b0", + "id": "c05d366a", "metadata": {}, "outputs": [ { @@ -119,7 +119,7 @@ }, { "cell_type": "markdown", - "id": "f9e79a13", + "id": "84b51cbc", "metadata": {}, "source": [ "## Define the Study\n", @@ -143,7 +143,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "8baff2c8", + "id": "374124d4", "metadata": {}, "outputs": [], "source": [ @@ -189,7 +189,7 @@ }, { "cell_type": "markdown", - "id": "9b2c51ab", + "id": "90858c7f", "metadata": {}, "source": [ "## Evaluate Every Design\n", @@ -200,7 +200,7 @@ { "cell_type": "code", "execution_count": 4, - "id": "bfa6842a", + "id": "8967e528", "metadata": {}, "outputs": [ { @@ -330,7 +330,7 @@ }, { "cell_type": "markdown", - "id": "3006bd09", + "id": "a1a7b153", "metadata": {}, "source": [ "## Find the Efficient Designs\n", @@ -343,7 +343,7 @@ { "cell_type": "code", "execution_count": 5, - "id": "51e489ee", + "id": "9e23a64a", "metadata": {}, "outputs": [ { @@ -474,23 +474,77 @@ }, { "cell_type": "markdown", - "id": "1a98d723", + "id": "e1fd9d7d", + "metadata": {}, + "source": [ + "Each mean averages five replicates, which differ by their samples of points. The figure shows the share of each replicate of the efficient designs (dots) and their mean (bar):" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "6f877e2d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "\n", + "from tatc.tradespace import style_axes\n", + "from tatc.tradespace.plotting import COLORS, INK\n", + "\n", + "fig, ax = plt.subplots(figsize=(8, 3.8))\n", + "for k, row in enumerate(front.itertuples()):\n", + " shares = results.loc[results.design == row.design, \"sufficient\"].to_numpy()\n", + " spread = np.linspace(-0.12, 0.12, len(shares)) # separates equal shares, for legibility\n", + " ax.scatter(k + spread, shares, s=24, color=COLORS[0], alpha=0.7, lw=0, label=\"replicate\" if k == 0 else None)\n", + " ax.hlines(row.sufficient, k - 0.28, k + 0.28, color=INK, lw=2, label=\"mean\" if k == 0 else None)\n", + "ax.set_xticks(range(len(front)), [f\"{row.satellites:.0f} sat., {row.planes:.0f} pl.\" for row in front.itertuples()])\n", + "ax.set(ylabel=\"Points sufficiently sampled (%)\", ylim=(0, 105))\n", + "ax.set_title(\"The replicates of the efficient designs\", fontsize=10)\n", + "ax.legend(loc=\"upper left\", fontsize=8, frameon=False)\n", + "style_axes(ax)\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "2f039119", + "metadata": {}, + "source": [ + "The replicates of the designs in the middle of the trade spread by up to 12 points (two satellites in two planes sample 24 to 36% of the points), and those of six satellites by 1 point, as they sample nearly every point of every sample. The standard error of each mean (`se`) measures this uncertainty, with which `RankUncertainDesigns` ranks designs." + ] + }, + { + "cell_type": "markdown", + "id": "517a6fd4", "metadata": {}, "source": [ "## Plot the Trade\n", "\n", - "`plot_designs` plots every design by two metrics, colored by a third, with the efficient designs ringed:" + "`plot_designs` plots every design by two metrics, colored by a third, with the efficient designs ringed. The color is the number of planes, with three and four planes together: a scatter of more than three colors is hard to read for readers with color vision deficiencies." ] }, { "cell_type": "code", - "execution_count": 6, - "id": "67e1b2d6", + "execution_count": 7, + "id": "523cddaa", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -500,17 +554,17 @@ } ], "source": [ - "from trade_space_example import planes_name\n", + "from trade_space_example import PLANE_GROUPS\n", "from tatc.tradespace import plot_designs\n", "\n", "ax = plot_designs(\n", - " summary,\n", + " summary.assign(plane_group=summary.planes.clip(upper=3)), # 3 or 4 planes share a color\n", " \"satellites\",\n", " \"sufficient\",\n", - " by=\"planes\",\n", + " by=\"plane_group\",\n", " front=\"pareto\",\n", " labels=lambda row: f\"{row.satellites:.0f} sat., {row.planes:.0f} pl.\",\n", - " names=planes_name,\n", + " names=PLANE_GROUPS,\n", " jitter=0.18, # spreads the designs of each number of satellites, for legibility\n", " legend=\"upper left\",\n", ")\n", @@ -524,7 +578,7 @@ }, { "cell_type": "markdown", - "id": "31679604", + "id": "cb408eb2", "metadata": {}, "source": [ "Seven of the 1,096 designs are efficient. All of them fly at 800 km with the wider field of regard (60 degrees), which observe the most points per satellite, so the trade is in the numbers of satellites and planes:\n", @@ -539,7 +593,7 @@ }, { "cell_type": "markdown", - "id": "a520edc9", + "id": "9cac71e8", "metadata": {}, "source": [ "## Summary\n", @@ -553,7 +607,7 @@ }, { "cell_type": "markdown", - "id": "ad59ce96", + "id": "8b8ce5a7", "metadata": {}, "source": [ "## Notes\n", diff --git a/docs/examples/tradespace/ExplainTradeSpace.ipynb b/docs/examples/tradespace/ExplainTradeSpace.ipynb index 9740bc45..925abddc 100644 --- a/docs/examples/tradespace/ExplainTradeSpace.ipynb +++ b/docs/examples/tradespace/ExplainTradeSpace.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "f9d27900", + "id": "3d867713", "metadata": {}, "source": [ "# Explain a Trade Space\n", @@ -20,7 +20,7 @@ }, { "cell_type": "markdown", - "id": "0adbc68c", + "id": "da1dfaee", "metadata": {}, "source": [ "## Measure the Sampling Error\n", @@ -33,7 +33,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "31b6ae51", + "id": "99a62858", "metadata": {}, "outputs": [], "source": [ @@ -42,7 +42,17 @@ "import matplotlib.pyplot as plt\n", "import pandas as pd\n", "\n", - "from trade_space_example import DURATION, N_POINTS, SAMPLES_PER_DAY, START, describe, designs, planes_name, space, study\n", + "from trade_space_example import (\n", + " DURATION,\n", + " N_POINTS,\n", + " PLANE_GROUPS,\n", + " SAMPLES_PER_DAY,\n", + " START,\n", + " describe,\n", + " designs,\n", + " space,\n", + " study,\n", + ")\n", "from tatc.analysis import estimate_sampling_error\n", "from tatc.tradespace import summarize\n", "\n", @@ -71,7 +81,7 @@ }, { "cell_type": "markdown", - "id": "286c62a6", + "id": "bce8a673", "metadata": {}, "source": [ "The figure compares the two shares of every design. A design on the dashed line samples as many points accurately as sufficiently." @@ -80,12 +90,12 @@ { "cell_type": "code", "execution_count": 2, - "id": "e49e4549", + "id": "7326121b", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -99,7 +109,8 @@ "from tatc.tradespace.plotting import GRAY\n", "\n", "fig, ax = plt.subplots(figsize=(6.5, 5))\n", - "plot_designs(summary, \"sufficient\", \"accurate\", by=\"planes\", names=planes_name, legend=\"upper left\", ax=ax)\n", + "grouped = summary.assign(plane_group=summary.planes.clip(upper=3)) # 3 or 4 planes share a color\n", + "plot_designs(grouped, \"sufficient\", \"accurate\", by=\"plane_group\", names=PLANE_GROUPS, legend=\"upper left\", ax=ax)\n", "ax.plot([0, 100], [0, 100], color=GRAY, lw=1, ls=\"--\")\n", "ax.set(xlabel=\"Points sufficiently sampled (%)\", ylabel=\"Points accurately sampled (%)\", xlim=(0, 102), ylim=(0, 102))\n", "style_axes(ax, grid=\"both\")\n", @@ -110,7 +121,7 @@ }, { "cell_type": "markdown", - "id": "f9d2e808", + "id": "6a8c3ad5", "metadata": {}, "source": [ "Designs in one plane (blue) fall far below the line: they sample many points four times a day, but few of them accurately. Designs in two or more planes lie near the line or above it." @@ -118,7 +129,7 @@ }, { "cell_type": "markdown", - "id": "a4331a7b", + "id": "6f075262", "metadata": {}, "source": [ "## Find the Efficient Designs by Accuracy\n", @@ -129,7 +140,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "3a483aa6", + "id": "715976e0", "metadata": {}, "outputs": [ { @@ -332,7 +343,7 @@ }, { "cell_type": "markdown", - "id": "8dac1bcb", + "id": "5ae36ead", "metadata": {}, "source": [ "Thirteen designs are efficient by accuracy, against seven by sufficiency, and the designs that spread their samples over the day join the front:\n", @@ -345,7 +356,7 @@ }, { "cell_type": "markdown", - "id": "53f2a714", + "id": "099aefac", "metadata": {}, "source": [ "## Explain the Difference\n", @@ -359,7 +370,7 @@ { "cell_type": "code", "execution_count": 4, - "id": "56b79a0d", + "id": "92827f66", "metadata": {}, "outputs": [ { @@ -458,9 +469,9 @@ "# the design of four satellites in one plane that samples the most points sufficiently, and the design of four that\n", "# samples the most points accurately\n", "chosen = pd.concat([four[four.planes == 1].nlargest(1, \"sufficient\"), four.nlargest(1, \"accurate\")])\n", - "rows = []\n", + "rows, observed = [], {}\n", "for design, row in zip(space.designs_of(chosen), chosen.itertuples()):\n", - " observations = accuracy_study.observations_of(design)\n", + " observations = observed[row.description] = accuracy_study.observations_of(design)\n", " points = accuracy_study.targets_of(design)\n", " revisits = compute_revisit_statistics(observations, START, START + DURATION, targets=points)\n", " local = compute_local_time_coverage(observations, targets=points)\n", @@ -480,15 +491,66 @@ }, { "cell_type": "markdown", - "id": "8340a8fa", + "id": "8450fac9", "metadata": {}, "source": [ - "Satellites that follow each other in one plane pass over a point minutes apart, then leave it for most of the day. The four satellites in one Walker plane sample 68% of the points at least four times a day, but only 27% accurately: half of their revisits are 0.4 hours apart, and they leave a gap of 13.8 hours. The four satellites in two sun-synchronous planes sample fewer points four times (58%), but 85% accurately: their samples are 5.9 hours apart, in four of the eight 3-hour intervals of the day." + "The local times at which each design samples a dozen of the points (spread from south to north) show the difference:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "5555b886", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "\n", + "from tatc.tradespace.plotting import COLORS\n", + "\n", + "sampled = pd.concat(observed.values()).drop_duplicates(\"target_hash\")\n", + "sampled = sampled.assign(latitude=[point.y for point in sampled.geometry]).sort_values(\"latitude\")\n", + "shown = sampled.iloc[np.linspace(0, len(sampled) - 1, 12).round().astype(int)]\n", + "fig, axes = plt.subplots(1, 2, figsize=(11, 4), sharey=True)\n", + "for ax, (name, observations) in zip(axes, observed.items()):\n", + " times = []\n", + " for point in shown.itertuples():\n", + " samples = observations[observations.target_hash == point.target_hash]\n", + " longitude = np.array([p.x for p in samples.geometry])\n", + " hours = (samples.epoch - START).dt.total_seconds().to_numpy() / 3600 + longitude / 15 # local solar time\n", + " times.append(np.sort(hours % 24))\n", + " ax.eventplot(times, colors=COLORS[0], lineoffsets=range(len(times)), linelengths=0.6, linewidths=1.5)\n", + " ax.set(xlim=(0, 24), xticks=range(0, 25, 3), xlabel=\"Local time of each sample (h)\")\n", + " ax.set_title(name, fontsize=9)\n", + " style_axes(ax, grid=\"x\")\n", + "axes[0].set_yticks(range(len(shown)), [f\"{latitude:.0f} deg\" for latitude in shown.latitude])\n", + "axes[0].set_ylabel(\"Latitude of the point\")\n", + "fig.tight_layout()\n", + "plt.show()" ] }, { "cell_type": "markdown", - "id": "7f13afa7", + "id": "575ddea4", + "metadata": {}, + "source": [ + "Satellites that follow each other in one plane pass over a point minutes apart, on one or a few consecutive orbits, then leave it for the rest of the day; the Walker plane, inclined 45 degrees, also never samples points beyond about 50 degrees of latitude. The two sun-synchronous planes sample most points two to four times, spread over the day. The four satellites in one Walker plane sample 68% of the points at least four times a day, but only 27% accurately: half of their revisits are 0.4 hours apart, and they leave a gap of 13.8 hours. The four satellites in two sun-synchronous planes sample fewer points four times (58%), but 85% accurately: their samples are 5.9 hours apart, in four of the eight 3-hour intervals of the day." + ] + }, + { + "cell_type": "markdown", + "id": "1305deb2", "metadata": {}, "source": [ "## Find What Drives the Objectives\n", @@ -498,8 +560,8 @@ }, { "cell_type": "code", - "execution_count": 5, - "id": "230cc714", + "execution_count": 6, + "id": "40126ee8", "metadata": {}, "outputs": [ { @@ -600,7 +662,7 @@ "layout.walker.inclination 0.00 0.00 0.64" ] }, - "execution_count": 5, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -618,12 +680,52 @@ " \"layout.walker.relative_spacing\",\n", " \"layout.sso.planes.count\",\n", "]\n", - "sensitivity(summary, decisions, [\"sufficient\", \"accurate\"]).round(2)" + "shares = sensitivity(summary, decisions, [\"sufficient\", \"accurate\"])\n", + "shares.round(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b1adf213", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(7.5, 4))\n", + "rows = np.arange(len(shares))\n", + "for k, (metric, name) in enumerate([(\"sufficient\", \"sufficiently\"), (\"accurate\", \"accurately\")]):\n", + " ax.barh(\n", + " rows + (k - 0.5) * 0.38,\n", + " shares[metric],\n", + " height=0.38,\n", + " color=COLORS[k],\n", + " edgecolor=\"white\",\n", + " lw=1,\n", + " label=f\"Points {name} sampled\",\n", + " )\n", + "ax.set_yticks(rows, shares.index)\n", + "ax.invert_yaxis()\n", + "ax.set(xlabel=\"Share of the variance of the designs' means explained\")\n", + "ax.legend(loc=\"lower right\", fontsize=8, frameon=False)\n", + "style_axes(ax, grid=\"x\")\n", + "fig.tight_layout()\n", + "plt.show()" ] }, { "cell_type": "markdown", - "id": "35d73cc6", + "id": "7d66f14c", "metadata": {}, "source": [ "The field of regard explains the most of both objectives (25%), as it sets the swath of every satellite. The layout matters next, but differently for the two objectives. The number of satellites in each Walker plane explains more of sufficiency (22%) than of accuracy (18%), and the number of Walker planes the reverse (12% and 29%), as more planes spread the samples in time. The altitude explains little of either (3%), and the inclination nothing." @@ -631,7 +733,7 @@ }, { "cell_type": "markdown", - "id": "43278438", + "id": "b1a15cd6", "metadata": {}, "source": [ "## Summary\n", @@ -645,7 +747,7 @@ }, { "cell_type": "markdown", - "id": "e5721f39", + "id": "55fc0d34", "metadata": {}, "source": [ "## Notes\n", diff --git a/docs/examples/tradespace/PlanDeployment.ipynb b/docs/examples/tradespace/PlanDeployment.ipynb index 0970404c..6cc4fab0 100644 --- a/docs/examples/tradespace/PlanDeployment.ipynb +++ b/docs/examples/tradespace/PlanDeployment.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "6667e34b", + "id": "c31c602b", "metadata": {}, "source": [ "# Plan the Deployment\n", @@ -19,7 +19,7 @@ }, { "cell_type": "markdown", - "id": "696b3146", + "id": "1aa0f625", "metadata": {}, "source": [ "## Account for Deployment\n", @@ -35,7 +35,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "bd998b9b", + "id": "6bc87f54", "metadata": {}, "outputs": [ { @@ -219,7 +219,80 @@ }, { "cell_type": "markdown", - "id": "c3846667", + "id": "14ec3893", + "metadata": {}, + "source": [ + "The phases of three of these designs over their missions, from the start of development, for the points of the first replicate (with the schedule of the mission plan, `SCHEDULE.plan`, and `evaluate_phases`):" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c7af361b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "from trade_space_example import SCHEDULE, cost_space, planes_name, sample\n", + "from tatc.tradespace import style_axes\n", + "from tatc.tradespace.mission import evaluate_phases\n", + "from tatc.tradespace.plotting import COLORS, GRAY\n", + "\n", + "fig, ax = plt.subplots(figsize=(8, 4))\n", + "for color, (satellites, planes) in zip(COLORS, [(4, 1), (4, 2), (6, 2)]):\n", + " key = leaders[(leaders.satellites == satellites) & (leaders.planes == planes)].index[0]\n", + " (design,) = cost_space.designs_of(summary[summary.design == key])\n", + " realized = design.realize(0)\n", + " deployment = SCHEDULE.plan(realized.layout, kind=realized.field_of_regard)\n", + " phases = evaluate_phases(\n", + " deployment.phases(cost_study.satellites_of(design)), cost_study.observations_of(design), sample\n", + " )\n", + " edges = [*phases.start, phases.end.iloc[-1]]\n", + " ax.stairs(\n", + " phases.sufficient,\n", + " edges,\n", + " color=color,\n", + " lw=2,\n", + " baseline=None,\n", + " label=f\"{satellites} satellites, {planes_name(planes)}\",\n", + " )\n", + "ax.axvline(SCHEDULE.development_years, color=GRAY, lw=1, ls=\"--\")\n", + "ax.annotate(\n", + " \"end of development\",\n", + " (SCHEDULE.development_years, 2),\n", + " xytext=(-4, 0),\n", + " textcoords=\"offset points\",\n", + " ha=\"right\",\n", + " fontsize=8,\n", + " color=GRAY,\n", + ")\n", + "ax.set(\n", + " xlabel=\"Years from the start of development\",\n", + " ylabel=\"Points sufficiently sampled (%)\",\n", + " xlim=(0, None),\n", + " ylim=(0, 105),\n", + ")\n", + "ax.legend(loc=\"center right\", fontsize=8, frameon=False)\n", + "style_axes(ax)\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "2e115925", "metadata": {}, "source": [ "Deployment costs the designs of several planes or launches. Six satellites in two planes sample 98% of the points once deployed, but 87% on average over the mission: the first plane flies alone for three quarters of a year while the second is produced, and half of the points are sampled sufficiently only 4.5 years after development starts. Four satellites lose about 5 points of their 68 or 70%, in one plane (which takes two launches of up to three satellites) or in two, and two satellites in two planes lose 3 points of their 30%. The designs launched at once lose nothing, and the designs of fewer than four satellites never sample half of the points (an infinite `sufficient time`). A shorter mission, slower production, or rarer launches would weigh deployment more, and could reorder the front." @@ -227,7 +300,7 @@ }, { "cell_type": "markdown", - "id": "108c1543", + "id": "55853e86", "metadata": {}, "source": [ "## Stage the Deployment\n", @@ -249,8 +322,8 @@ }, { "cell_type": "code", - "execution_count": 2, - "id": "2135879f", + "execution_count": 3, + "id": "eec3e4ab", "metadata": {}, "outputs": [ { @@ -370,7 +443,7 @@ "measured at launch 118.8 " ] }, - "execution_count": 2, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -410,7 +483,53 @@ }, { "cell_type": "markdown", - "id": "0949e986", + "id": "36fe7a03", + "metadata": {}, + "source": [ + "Each staging in each field, by what it samples over the mission and what it costs:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "37d6f8ba", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "\n", + "means = staged.groupby([\"staging\", \"scenario\"], sort=False)[[\"accurate mission\", \"cost present\"]].mean()\n", + "fig, axes = plt.subplots(1, 2, figsize=(11, 3.4), sharey=True)\n", + "for k, (color, field) in enumerate(zip(COLORS, FIELDS)):\n", + " part = means.xs(field, level=\"scenario\").reindex(STAGING)\n", + " rows = np.arange(len(STAGING)) + (k - 1) * 0.2 # offsets the fields, whose values may be equal\n", + " for ax, column in zip(axes, [\"accurate mission\", \"cost present\"]):\n", + " ax.scatter(part[column], rows, s=46, color=color, edgecolor=\"white\", lw=1, zorder=3, label=f\"field of {field}\")\n", + "axes[0].set_yticks(range(len(STAGING)), STAGING)\n", + "axes[0].invert_yaxis()\n", + "axes[0].set(xlabel=\"Points accurately sampled over the mission (%)\", xlim=(0, 100))\n", + "axes[1].set(xlabel=\"Present cost (millions of dollars)\")\n", + "axes[0].legend(loc=\"lower left\", fontsize=8, frameon=False)\n", + "for ax in axes:\n", + " style_axes(ax, grid=\"x\")\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "9d9352fa", "metadata": {}, "source": [ "Deciding at the first launch is worth the most. Where the field varies within hours, the second plane is produced and launched as if it were deployed at once: 63% and 78% of the points are accurately sampled on average over the mission, for 156 million dollars. Where the field varies slowly, the second plane is not deployed, which saves 38 million dollars (24%) for 18 points of the mean (73% against 91%): a trade that the rule makes, and that a mission might not.\n", @@ -422,7 +541,7 @@ }, { "cell_type": "markdown", - "id": "ccf111a8", + "id": "03b23bc6", "metadata": {}, "source": [ "## Summary\n", @@ -435,7 +554,7 @@ }, { "cell_type": "markdown", - "id": "aa666288", + "id": "39198653", "metadata": {}, "source": [ "## Notes\n", diff --git a/docs/examples/tradespace/PlanForFailures.ipynb b/docs/examples/tradespace/PlanForFailures.ipynb index 60ba204f..df25c28e 100644 --- a/docs/examples/tradespace/PlanForFailures.ipynb +++ b/docs/examples/tradespace/PlanForFailures.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "88d8cd26", + "id": "3e52904d", "metadata": {}, "source": [ "# Plan for Failures\n", @@ -21,7 +21,7 @@ }, { "cell_type": "markdown", - "id": "42057516", + "id": "466f7b9b", "metadata": {}, "source": [ "## Model Failures\n", @@ -32,7 +32,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "2c839235", + "id": "e20ee309", "metadata": {}, "outputs": [ { @@ -55,7 +55,55 @@ }, { "cell_type": "markdown", - "id": "27b9cb14", + "id": "c498cbd0", + "metadata": {}, + "source": [ + "The share of satellites still operating at each age, and the rate at which those that operate fail, whose bathtub shape gives the curve its name: failures are frequent just after launch (infant mortality), least frequent after about two years, and more frequent again as satellites wear out." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7c437e44", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "from tatc.tradespace import style_axes\n", + "from tatc.tradespace.plotting import COLORS, GRAY, INK\n", + "\n", + "age = np.linspace(0.02, 10, 500) # years since launch\n", + "fig, axes = plt.subplots(1, 2, figsize=(11, 3.6))\n", + "axes[0].plot(age, 100 * FAILURE_MODEL.life.survival(age), color=COLORS[0], lw=2)\n", + "axes[0].set(ylabel=\"Satellites operating (%)\", ylim=(0, 102))\n", + "axes[1].plot(age, FAILURE_MODEL.life.hazard(age), color=COLORS[0], lw=2)\n", + "axes[1].set(ylabel=\"Failures a year, of those operating\", ylim=(0, 1))\n", + "for ax in axes:\n", + " ax.axvline(5, color=GRAY, lw=1, ls=\"--\")\n", + " ax.set(xlabel=\"Years since launch\", xlim=(0, 10))\n", + " style_axes(ax, grid=\"both\")\n", + "axes[1].annotate(\"infant mortality\", (0.3, 0.2), xytext=(8, 14), textcoords=\"offset points\", fontsize=8, color=INK)\n", + "axes[1].annotate(\"wear-out\", (8.5, 0.5), xytext=(-60, 10), textcoords=\"offset points\", fontsize=8, color=INK)\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "ec2f68a0", "metadata": {}, "source": [ "## Respond to Failures\n", @@ -75,8 +123,8 @@ }, { "cell_type": "code", - "execution_count": 2, - "id": "64a55b8d", + "execution_count": 3, + "id": "35efa3e2", "metadata": {}, "outputs": [ { @@ -127,7 +175,7 @@ }, { "cell_type": "markdown", - "id": "d15b5c76", + "id": "8905ad94", "metadata": {}, "source": [ "The table gives four of the designs, each with each policy: two satellites in two planes, four in two, six in three, and nine in three. Its columns are the means over the replicates of the share accurately sampled over the mission (`accurate`, on average over the histories, and `accurate p10`, in their worst 10%) and of the cost at 70% confidence (`cost p70`). The first column is the share of the full constellation, without deployment or failures, from `ExplainTradeSpace`." @@ -135,8 +183,8 @@ }, { "cell_type": "code", - "execution_count": 3, - "id": "d3789588", + "execution_count": 4, + "id": "4c9a47e8", "metadata": {}, "outputs": [ { @@ -379,7 +427,7 @@ " spares in orbit and on ground 405.7 " ] }, - "execution_count": 3, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -425,7 +473,7 @@ }, { "cell_type": "markdown", - "id": "cf2393ff", + "id": "00f2c896", "metadata": {}, "source": [ "The shares over the mission fall short of those of the full constellation under every policy, by the phases of deployment and the failures of launches as well as of satellites:\n", @@ -438,7 +486,7 @@ }, { "cell_type": "markdown", - "id": "d05b0c12", + "id": "884f27fc", "metadata": {}, "source": [ "## Choose a Design and its Policy\n", @@ -448,8 +496,8 @@ }, { "cell_type": "code", - "execution_count": 4, - "id": "810e99b5", + "execution_count": 5, + "id": "a41c39e2", "metadata": {}, "outputs": [ { @@ -671,7 +719,7 @@ "a37619256b26 produce 83.0 78.7 340.0 " ] }, - "execution_count": 4, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -683,7 +731,48 @@ }, { "cell_type": "markdown", - "id": "87b797d1", + "id": "eb715b9d", + "metadata": {}, + "source": [ + "Each policy's designs (blue) among every design and policy (gray), with those on the front ringed:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "58d5e989", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(1, len(POLICIES), figsize=(16, 3.6), sharex=True, sharey=True)\n", + "for ax, policy in zip(axes, POLICIES):\n", + " mine = traded[traded.policy == policy]\n", + " ax.scatter(traded[\"cost p70\"], traded[\"accurate p10\"], s=12, color=GRAY, alpha=0.3, lw=0)\n", + " ax.scatter(mine[\"cost p70\"], mine[\"accurate p10\"], s=22, color=COLORS[0], lw=0)\n", + " on_front = mine[mine.index.isin(chosen.index)]\n", + " ax.scatter(on_front[\"cost p70\"], on_front[\"accurate p10\"], s=70, facecolor=\"none\", edgecolor=INK, lw=1.5)\n", + " ax.set_title(f\"{policy}\\n{len(on_front)} on the front\", fontsize=9)\n", + " ax.set(xlabel=\"Cost at 70% confidence\")\n", + " style_axes(ax, grid=\"both\")\n", + "axes[0].set_ylabel(\"Accurately sampled (%), worst 10%\")\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "07a354e0", "metadata": {}, "source": [ "Along the front, degrading is the cheapest policy of a design, and restoring buys robustness. Two satellites in two Walker planes keep 20% of the points accurately sampled in their worst histories if they produce replacements (159 million dollars), and 26% with a spare on the ground (175 million). Six satellites in three Walker planes keep 39%, 70%, and 72% if they degrade, produce replacements, or keep a spare on the ground, for 210, 279, and 294 million. Nine satellites in three planes degrade gracefully (69% in their worst histories, for 254 million), and producing replacements raises them to 79%, for 340 million. A spare on the ground is efficient for designs of two to six satellites, but a spare in orbit is not efficient for any design. The policy that a design deserves depends on the design, which is why it is a decision of the design." @@ -691,7 +780,7 @@ }, { "cell_type": "markdown", - "id": "ddddde74", + "id": "cc00b8b1", "metadata": {}, "source": [ "## Find What Spreads the Results\n", @@ -703,8 +792,8 @@ }, { "cell_type": "code", - "execution_count": 5, - "id": "40b705f4", + "execution_count": 7, + "id": "c687c0ed", "metadata": {}, "outputs": [ { @@ -804,7 +893,7 @@ "failure_seed 6.5 7.1 " ] }, - "execution_count": 5, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -824,7 +913,66 @@ }, { "cell_type": "markdown", - "id": "e6726209", + "id": "30400392", + "metadata": {}, + "source": [ + "The total shares of each objective, with one standard error:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "608307dd", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxYAAAFyCAYAAABoREzCAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAU7JJREFUeJzt3Qm8jOX///HPOce+72vKml1E2Yos8Y1CKipKG6UioqQsSVEqRJa+ilahPZUkSrImCZEUIevJvi/nzP/xvr7/md9ZOcfMnGXm9Xw85pyZ+77nvq+5Z677vj/3tUV4PB6PAQAAAIAfIv15MwAAAAAIgQUAAAAAvxFYAAAAAPAbgQUAAAAAvxFYAAAAAPAbgQUAAAAAvxFYAAAAAPAbgQUAAAAAvxFYmJnGCDx8+LD7DwAAACD1CCzM7MiRI5Y/f373HwAAAEDqEVgAAAAA8BuBBQAAAAC/EVgAAAAA8BuBBQAAAAC/EVgAAAAA8BuBBQAAAAC/EVgAAAAA8BuBBQAAAAC/EVgAAAAA8BuBBQCks5hYT6Zab6A8/fTT1qdPn4Cuc+jQoValShWrX79+wNZZu3ZtO3LkyHmXe/PNN+33338P2HYBILPJkt4JAIBwFxUZYY/P3GGb954O2DrLF8tmozqXtnAzatQo27x5s5UsWTJg61y9enWKllNgUaBAARfYAEA4osQCADIABRUbdp4M2COlQcqJEyesc+fOVq1aNbvsssusVatWbvru3butWbNmVrduXatevbo9/PDDFhsb67uAbtmypd12223ufY0aNbL169fbjTfeaFWrVnXrOHr0qK9U4qabbrLmzZu7C+4bbrjB9u3bl2RaXnrpJbvyyivt8ssvt//85z+2devWJJebO3euW6ZWrVrWtGlTt21ROk6ePOm237t370Tvu+aaa6xXr152xRVXWMWKFa1fv37m8fyvVOfPP/90n0nrVAnFp59+6ntfRESEHTx40D0vW7asDRkyxBo2bGjlypWzZ5991k1//fXXbeXKlda3b1/3/q+++sqWLVvm9p9e16hRwyZNmpSi7wQAMqt0DSx++OEHd5IpVaqUO3DHPZCLDvg6gOvOU86cOd1Bf9OmTfGW2b9/v3Xp0sXy5cvn7hTde++9vhMaAODcvv76a3fRrIvzX3/91WbMmOGm63g6e/Zs+/nnn23NmjX2999/26xZs3zv++mnn+yFF15w76tQoYI7lk+ePNk2bNhg2bJls7feesu37KJFi2z69OmumlCZMmVs4MCBidKh+Rs3brSlS5faqlWr3HH9wQcfTLTc3r177fbbb3frV7p69OhhN998sztfLFmyxLe9cePGJfl5lV4tp/cuXLjQ3n//fTdd27vlllvc9A8++MCdS5ILbLS/lE7tgxdffNF27Nhh9913n9WrV8/GjBnjSjjatGljI0eOtP79+7vX69ats1tvvTXV3w8AZCbpGlgcO3bM3SGbMGFCskXaOjnoZLV8+XLLnTu3tW7d2t2R8tLJ4LfffrN58+bZF1984YIVnWgAAOenY7CCAV3Ez5w507Jmzeqmq3RiwIABbn6dOnXc3fi4VYJ0x/7iiy92z3VBrVKA4sWLu9d6HvcmUNu2ba1EiRLuuY7P3377baJ06MaSpnvv8Ov4v23btkTL6VxQs2ZN9/CeA3bu3Oku7lPizjvvdJ8xV65c1rVrV7dNtZ9QMKNgQipVqmRXXXWVC1CSosBGihQpYuXLl7ctW7YkuZxKfIYPH27PPPOM/fjjj1awYMEUpREAMqt0DSyuu+46V4ys4vOEdPdp7NixNmjQIGvfvr0rnn777bfdCcRbsqGToe62qQhaDfV0Ihg/fry746blAADnpgtj3cVX1aPFixe7KjsHDhyw0aNHu9IBXcjrLr4upuPe1MmRI4fveVRUVKLXZ8+eTXabKqFO6pivkgwFL3qsXbvWPYItqbSca7qk9LOqYfqXX37pSt2ffPLJJEtgAGR80dHRNmHCq+4/Mmnjbd0BUh1fVX/yyp8/vwsgVAStImX9V3G97pZ5afnIyEh3MkwqYJFTp065h9fhw4d9d+i8dYgBIK3omBUs5zum/fPPP+5O+vXXX+/aJujGjaoAqZqpSiBUrUk3alQ9qGPHjr7jpAIB77r1PLnX+q/2Brt27XLrmzJlirVo0cI3z7tcu3btXDUibaNQoUJ25swZV31IpSVxqQ2GAg4FOwqCdCOpdOnS7uLdu/1zHcvfeecdd/5QMKDqV4888ogrDVebjTfeeMO6d+/u2luohEE3t5JaZ8L1e1/nzZvXBWXeearaVblyZVcSojTqRhnnGCDz2bNnj02aNNGaNr3GChcubOEoMoXnqQwbWCioEG/Rupdee+fpf7FixeLNz5IlizspeZdJiuq9Dhs2LNH0vXt32YkTtM8AkHayZMlqRYsWd704BZJ3ffv2RdvZs2eSXW7RooU2YsTzCgfs7NkYu/HG9la8eBG77bbO1qPH/a4xto67jRo1tOPHj9mePTvt8OGDdurUSfdcDh8+ZCdPHve9Pnr0sG/Zo0eP2BVX1LNOnW6xXbt2uwbPY8eO9s3zLteyZTP7++8t1rRpE7cOpeXWWztZqVLxzwEyfvxYVwUqJuasu+E0ceJ4d/z20vNTp44net/p06esQoXy1qBBfddOonXrVtasWRO3/TFjXrIBA560ceNeUXmFjRr1vGXPnsX3mbzrjImJcfvUO/3MmdN24MA+9/qWW26yYcOGu0boAwcOsAULvrPFi5e4qldRUZE2ePAg3/sAZB7790f7/odrHi5Z8qIULRfh8XaJkc5U7PzJJ59Yhw4d3Gs1rmvcuLG7Uxa328BOnTq5ZVUXeMSIEa4Bn+4KxaVgQ4FDz549U1xioQaFutOkRuAAkJY8FuG6nA3GOBYRlr6HeB2LdRGv0oj0pp6p1FuU9zwDACmh6qK60TFjxizXE144iszsJRbehn4qfoobWOi1GvZ5l1Ed4LhUvK0ifO/7k5I9e3b3SGqnBbNKAgCkpf8FK4EPWFJDN4L0yCjHVo7zAFLLe8zg+JGJAwsVlys4mD9/vi+QUMmC2k54SyLUK4nuhKk7RPUkIgsWLHB1WAM56ioA4MJoHIuM4vvvv0/vJABASEvXwELjTaiRXNwG2+oNRG0k1I2hetRQr1Hq+k+BxuDBg92YF95ibNX9VU8mamynLmnV2E+DOKlhnpbD+amHg1mzZlqnTp2taNGi6Z0cAAAAZFLpGlioX3T18+316KOPuv/dunVzI7s+/vjjbqwL9Xuukgl1J6vuZeN29ffee++5YEK9jKh4SiO8JjcwEpIOLNTTQbNmzQksAAAAkDkDi2uuucZ1NZgc1cvVwEJ6JEelG+oyEAAAAED6oQUKAAAAAL8RWAAAAADwG4EFAKQzT2xMuq5X1U7Vji0pbdq0STRWUFI9P508efKC29p17tzZ0sLQoUOtSpUqSfYa+Ndff7nRtzXS97Rp0865nrj7RFV6NVo5ACADdzcLAOEiIjLKjkwdbGd3bwnYOrOUKGd57xnu93q++uqrFA2Cp1784naskRIad6hevXpuwNO0MGrUKNu8eXO8sZG8PvzwQ7viiivstddeC8g+ORd1iS70hw8g1HBUA4AMQEFFzPaNAXukNkiZOHGiXXnlla5r77h37MuWLeu6ARd1/61uvjW2kB5bt261Bx54wM27+uqr3TQNWqpHx44drWbNmlajRo14F+ta34ABA9y21AOgxpbwjlUkc+fOdT0AamwiLfPdd9+56Zs2bbLGjRvbZZdd5tY7aNCgJD+H3q+Sh1q1alnTpk3diLnSqFEjV6rSqlUrN/p2XG+//bYbGfzjjz92adF7Ro8e7QINvdb/pUuXJrlP4rrrrrts7Nixvtf9+/f3jeOh/+q1sHXr1m6f7Nq1y+/PCgAZDSUWAADLnj27rVixwn7//Xd3IX3HHXdYliz/d4o4cOCAvfTSS+6COGfOnHb8+HF3x11jCClwWLRokRUoUMAtq6pNlStXdhfqCjJ04ayL5AYNGrj5+/btc4OdqgpW3EHrVJqgC3BdcOfLl8+Nc6SA5e+//7ZXX33Vrr/+ehs4cKBbdv/+/Yk+g7Z1++23u3Xqglzdkd98883222+/2ZIlS9z24qbT684773TbVnUwb2Cg7re9XaAvW7bMBQ3aN/5QcPLLL79Y8eLF/f6sAJAREVgAAKxLly7uv9ogKKDYvXu3XXTRRb75uvjVYKVdu3Z1d/3btm0bb35c3377rf3888/uebFixVzphaZ5AwtdpOsiPyGNU6QL7CZNmvimKXjZtm2bm/bYY4+5gVVVEtGyZctE71ewooBCD+9neuihh2zHjh3JpjU5CgCee+45FwRpf6hNxYkTJ1xQdaHUNkNBRSA+KwBkRAQWAIB47SOioqJc+4e4NE137nXnXyUCChLef/99d5f9fBIGEXny5ElyOY1rdO211yY5NpGCGlVnmjdvnrujr5IFf9s6JOf06dMuGFLVJJXeHD582PLnz2+nTp06Z2ChACQm5v8azKvqVdzPGvd5RvmsABBItLEAAJzXkSNHbM+ePS6QGDx4sGsboLv6kjdvXjt06JBvWd1hnzJlinseHR3tqkTpIvp81P5AJRtr1qzxTVP1LG+7A93tV7UlNcJWkJOQgp21a9faunXr3OsZM2ZY6dKl3SM1FBAouLj44ovd6/Hjx6fofRUrVvSlVyUd5woG/P2sAJARUWIBABmAenHKyOtT4KD2CseOHXMlELqrrsbX0q9fPxc45MqVy7755hsbN26c9ezZ01VJ0p35p556KskuXpO6MNcd/Pvvv9+14dDFvbp/1TT12vTuu+9atmzZXK9KatuRkNpFqF2FLshV4lKwYEH74IMPkqx2dS6q9qWG6mpQXaRIEbv11ltT9L4ePXq4faQG7uXLl/dV/QrGZwWAjCjCo6N+mPMWc+vEqRNKOFHvJ5063WyzZn1o1apVS+/kAGFJ402oy9nMsl4ACCdcK6UcVaEAIJ0F6+KfoAIAkJYILAAAAAD4jcACAAAAgN8ILAAAAAD4jcAig4iJDd829OH82QEAAEIF3c1mEFGREfb4zB22ee/pNN3uyegd7v/jM3ZYjqIXPqLshSpfLJuN6py6PuYBAACQ8RBYZCAKKjbsPJm2Gz142tTD+5bo02Zn0njbAJwYT6xFRURmmvX649NPP7USJUr4xnjQKN59+vSx1atX+7VeDSLXvXt3N/r1888/7wagC4Y333zTpb1KlSpBWT8AZGYEFgCQznTx32vlLNt0JDpg66yUt6iNr9fJAkmDzunC3d/Aonbt2uccPO5CvPXWW3b77bfbwIEDLZgUWBQoUIDAAgCSkLFuZQFAmFJQse7QzoA9UhOkfPbZZ2606Msuu8wGDBjgRpv++++/3byyZcu6aRqFWiNtHz161O655x6rUaOGewwbNswt98cff9ill17qnmvc1eLFi9uTTz7pXv/www/WvHlz++qrr+zzzz+3F1980QUXr7/+ui9gefDBB932q1evbitXrkwynXv37rWOHTu6Eb217ddee81NVwnFzJkz7dVXX3XrPXjwYKL3vvDCC+592oaCGo12LUqLtql5Xbp0cQOlyuzZs61WrVpufdqW9pHSq7T17dvXTdfnUUlJ3bp1fctNmjQpVd87AIQSSiwAIIzpYl2BwuLFi91d+GnTptm+ffviLaPXy5cvt4iICBdknDp1ytasWWMnTpywq666yr2vc+fObvq2bdvswIEDVr58eZs/f757/7x586xly5bWpk0ba9eunbsIV/Unb1Wo33//3d544w2bOHGiTZ482Z566imbO3duorT26tXLKleubB9//LFLty7oFSg88cQTbh1x15uwNOOjjz6yH3/80fLnz+/Slz17dpszZ45NnTrVli5d6kohevTo4dal4GDQoEEucGnYsKHFxsba4cOH3TLvvvuu20aHDh3cutu3b2/9+/e32267zb3WugEgXFFiAQBhTHfcdWfeW7VHpRLZsmWLt8xdd93lggr59ttvXVuGyMhIy507t915550ucJAWLVq4+XrccccdLtBQ6YFea15yKlasaPXr13fPdSH/119/Jbmc1nP//fe758WKFXOlF5p2Pl988YU98MADLqiQggULWlRUlHuvAiIFDNKzZ894n+WRRx6xUaNGuSDKu0xCzZo1s+HDh9szzzzjAhetGwDCFYEFAOCc8uTJk+w8b8AhKpXwBhZ6rovuTz75xDZt2mT16tVLdh05cuTwPdcFv6pGpUTcbQdC3PWNHj3ald7kypXLBVsKMJKi0osvv/zSSpYs6ap+qUoXAIQrAgsACGNqb6A78hs3bnSvVdXn9Onku71WwKBqS2pHcezYMXvnnXesVatWvrv8qv6k9hlqb6Fl1QZD1aUUMEi+fPl87RhSS+ubMmWKex4dHe2qRF177bXnfZ+qX6mKlXe7KkWJiYlx65s1a5ar5iSq+uT9LKpapbYXDz/8sCvJUMlOUunXfitXrpwrxVFg4V0OAMIRbSwAIANQL07psT5VKVKjZLUZULsDXairhCK5qj+DBw+23r17u8bOcsstt1inTv/rfUoNtvXwlk40bdrUdu7caf369fO9X1WkVLVKvUM99NBDrhpUSo0bN85d5GvbCmzUFsNbhepctE2lo1GjRq5XK1XhUqnKddddZ+vWrXPVr1S1S1XC1M5DFCQoaFC1MJVaeBtlqx2GPs+YMWNsxIgRrp3GggUL3HIKnl5++eUUfx4ACDURHh2dw5zuVqnure5C6W5Uerl5/JZ0GMdis0Usesw8V79oVqB82m7bzKqWymEf9iqX5tsFMpL0HsfiyJEjljdvXvdcF/zqsnXDhg0BTw8AZEbr16+3Tp1utlmzPrRq1aqld3JCt8RCDfN0hwsAcOGCNYhdStc7fvx4112rqgfp5sp7770XlPQAAEJbqgILFfnOmDHDFi1aZNu3b3dd8KlIuU6dOq5e6t13322lSpUKXmoBAAGnaj/eMScAALhQKbqdpV491BBPfZ2rfqr6MVejOfUzrrq5qker+qrqt1xd+qlRHQAAAIDwkaISC3Wzp4ZqauimBm4JeRvu7dixwxWpq1cRjUwKAAAAIDykKLDQqKQpUbp0aXv++ef9TRMAAACATMbvFoPqx9zbBzgAAACA8BTpT9db6qtcXRQWLFjQ9Su+cuXKwKYOAAAAQGgHFvfff78bkfTo0aO2b98+69ixo3Xr1i2wqQMAAAAQWoFF+/btXeNsL/X81K5dOzciqUZobdOmje3ZsydY6USw5Chonks7uf8AAABA0Mex6Nq1qzVv3tweeugh69WrlyutqF69uutq9syZM7ZgwQLr16/fBScE6UQBReXO6Z0KAAAAhEuJxS233GIrVqxwbSsaNGhgjRs3tm+++cb9v/rqq93zQYMGBTe1AAAAADL/yNv58+e3yZMn248//ujaU1x77bU2fPhwVx0KAAAAQPhKVePt/fv3288//+x6gNL/fPnyWZ06deyrr74KXgoBAAAAhE5gMX36dLvooousbdu2dskll9icOXNs6NCh9tlnn7mRuTX6No23AQAAgPCU4sBi4MCBNnXqVNu9e7fNnz/fBg8e7KZXqVLFvv/+e1ctqmHDhsFMKwAAAIDMHlhovIrKlSu75xUqVLDjx4/Hm9+9e3dbtmxZ4FMIAAAAIHQab6uxtqpBXXPNNW6E7TvuuCPRMsWKFQt0+gAAAACEUmAxevRoa9asmf3+++921113WatWrYKbMgAAAACh2d3sDTfc4B4AAAAAkOo2FjNmzLCU2r59uy1evDjFywMAAAAIk8Bi0qRJVrVqVdet7IYNGxLNP3TokBvL4vbbb7fLL7/c9u3bF4y0AgAAIEzFeGItXMVkks+eoqpQCxcutM8//9zGjx/vup3NnTu3FS9e3HLkyGEHDhxwXdAWKVLEtb1Yt26dmxcIMTEx9vTTT9u7777rtlGqVCm3jUGDBllERIRbxuPxuPE0pkyZYgcPHrTGjRu7QKhSpUoBSQMAAADSX1REpPVaOcs2HYlO0+2e3v6/7T28cpZl21PU0lqlvEVtfL1OFlJtLNq1a+ce//77r/3444+2detWO3HihAsoNPq2HpGRqRrI+7xeeOEFFyS89dZbVr16ddcb1d1332358+e33r17u2VUijJu3Di3TLly5dz4Gq1bt7b169e7wAcAAAChQUHFukM703SbUUcPWl4z++totMUcOpOm2w7pxtuiQKJDhw6WFpYsWWLt27d33dxK2bJl7f3337cVK1b4SivGjh3rSjC0nLz99tuuxOTTTz+1W2+9NU3SCQAAAIS7wBYxBFijRo3cKN9//PGHe/3rr7+60pLrrrvOvd6yZYurItWyZUvfe1SaUb9+fVu6dGm6pRsAAAAIN6kusUhLTzzxhB0+fNiqVKliUVFRrs3Fc889Z126dHHzFVRIwjYdeu2dl5RTp065h5e2IbGxse6RHgJdjSyzSa/9DgAAMgeulWIz/L7P0IHFrFmz7L333rPp06e7NharV6+2Pn36uEbcGgn8Qo0cOdKGDRuWaPrevbvsxImjltayZMlqRYsGpsF7ZrVvX7SdPUu9RQAAkBjXSpau10olS16U+QOLxx57zJVaeNtK1KxZ0zUaV2CgwKJEiRJu+p49e6xkyZK+9+l17dq1k12verZ69NFH45VYlClTxooVK2n58uUL6mdC0goXTvteFgAAADKLwpngWumCA4vTp0+7Ng4VKlSwLFmCE58cP348UdGLqkR5i4LUC5SCC7XD8AYSChKWL19uPXv2THa92bNnd4+EtK1wL2ZLL+x3AACAzH2tFHkhF/v33nuv5cqVy1VP2rZtm5veq1cve/755wOauBtuuMG1qfjyyy/t77//tk8++cRGjx5tN954o5uvsSxUNerZZ59142ysXbvW7rzzTldVKq16rgIAAABwAYGFqhGpd6bvv/8+3jgR6plp5syZAU2cBuS7+eab7cEHH3Qjf/fv39/uv/9+Gz58uG+Zxx9/3AU1PXr0sCuuuMKOHj1qX3/9NWNYAAAAAGko1XWYND6EAogGDRr4Rr8WlV789ddfAU1c3rx53TgVeiRHaXjmmWfcAwAAAEAmKbGIjo62YsWKJZp+7NixeIEGAAAAgPCR6sCiXr16rs2DlzeYeP31161hw4aBTR0AAACA0KwKNWLECDfy9fr16+3s2bP2yiuvuOdLliyxhQsXBieVAAAAAEKrxOKqq65yA9UpqNC4Et98842rGrV06VKrW7ducFIJAAAAIEO7oAEoNHbFlClTAp8aAAAAAOFRYvHVV1/Z3LlzE03XtDlz5gQqXQAAAABCObB44oknLCYmJtF0j8fj5gEAAAAIP6kOLDZt2mTVqlVLNL1KlSr2559/BipdAAAAAEI5sMifP79t3rw50XQFFblz5w5UugAAAACEcmDRvn1769OnT7xRthVU9OvXz9q1axfo9AEAAAAIxcBi1KhRrmRCVZ/KlSvnHlWrVrXChQvbSy+9FJxUAgAAAAit7mZVFUqD4c2bN89+/fVXy5kzp9WqVcuaNGkSnBQCAAAACM1xLCIiIqxVq1buAQAAAAAXFFjMnz/fPfbu3WuxsbHx5k2dOjVQaQMAhKHo6GibNWumderU2YoWLZreyQEABKuNxbBhw1xJhQKLf//91w4cOBDvAQCAv4HFpEkT3X8AQAiXWEyePNnefPNNu+OOO4KTIgAAAAChX2Jx+vRpa9SoUXBSAwAAACA8Aov77rvPpk+fHpzUAAAAAAiPqlAnT560//73v/btt9+6bmazZs0ab/7o0aMDmT4AAAAAoRhYrFmzxmrXru2er1u3LlE3tAAAAADCT6oDi++++y44KQEAAAAQPm0sAAAAACAgA+StXLnSZs2aZdu2bXO9RMX18ccfByptAAAAAEK1xGLGjBmuu9kNGzbYJ598YmfOnLHffvvNFixYYPnz5w9OKgEAAACEVmAxYsQIGzNmjM2ePduyZctmr7zyiv3+++/WqVMnu/jii4OTSgAAAAChFVj89ddf1rZtW/dcgcWxY8dcb1B9+/Z13dACAAAACD+pDiwKFixoR44ccc9Lly7t63L24MGDdvz48cCnEAAAAEDoNd5u0qSJzZs3z2rWrGm33HKLPfLII659haa1aNEiOKkEAAAAEFqBxauvvupG35annnrKjby9ZMkSu+mmm2zQoEHBSCMAAACAUAssChUq5HseGRlpTzzxRKDTBAAAACAUA4vDhw9bvnz5fM/PxbscAAAAgPCRJaUNtnft2mXFihWzAgUKuF6gEvJ4PG56TExMMNIJAAAAILMHFmqc7a0C9d133wU7TQCADMATG2MRkVEWbsL1cwNAmgQWTZs2df/Pnj1rCxcutHvuuccuuugivzcOAMi4dHF9ZOpgO7t7S5pu9/D+/3VdfnjqIDtQKFeabjtLiXKW957habpNAAjLxttZsmSxF1980e68887gpQgAkGEoqIjZvjFNtxl79H9VamP3/G0xxyg5AICQHSCvefPmrtQCAAAAAC64u9nrrrvOdTG7du1aq1u3ruXOnTve/Hbt2qV2lQAAAADCLbB48MEH3f/Ro0cnmkevUAAAAEB4SnVgERsbG5yUAAAAAAifNhYAAAAA4HeJhRw7dsw14N62bZudPn063rzevXtfyCoBAAAAhFNg8csvv1ibNm3s+PHjLsDQwHn//vuv5cqVy43MTWABAAAAhJ9UV4Xq27ev3XDDDXbgwAHLmTOnLVu2zLZu3ep6iHrppZeCk0oAAAAAoRVYrF692vr162eRkZEWFRVlp06dsjJlytioUaPsySefDE4qAQAAAIRWYJE1a1YXVIiqPqmdheTPn9+2b98e+BQCAAAA6SQ2bw472ayK+48At7GoU6eO/fTTT1apUiVr2rSpDRkyxLWxeOedd6xGjRqpXR0AAACQYXkUWLSomt7JCM0SixEjRljJkiXd8+eee84KFixoPXv2tOjoaPvvf/8bjDQCAAAACLUSi3r16vmeqyrU119/Heg0AQAAAAj1Eotnn33WtmzZYmllx44d1rVrVytcuLDrhapmzZq2cuVK33yPx+OqY6kURfNbtmxpmzZtSrP0AQAAALiAwOKDDz6wihUrWqNGjWzixImufUWwqEvbxo0buwbjc+bMsfXr19vLL7/sql95qTeqcePG2eTJk2358uWWO3dua926tZ08eTJo6QIAAADgZ2Dx66+/2po1a+yaa65x41aUKlXK2rZta9OnT3eD5gXSCy+84LqynTZtml155ZVWrlw5a9WqlVWoUMFXWjF27FgbNGiQtW/f3mrVqmVvv/227dy50z799NOApgUAAABAANtYSPXq1V0jbj0WL17sgoo+ffrYAw88YIcPH7ZA+fzzz13pwy233GILFy600qVL24MPPmjdu3d381Ula/fu3a76k5e6va1fv74tXbrUbr311iTXq7E39PDypjk2NtY90oO3C99wlV77HUDGOy4VzhZh3S7O6v6nF45JQMbDtVJsht/3FxRYxKWqR2rbkC1bNjty5IgF0ubNm23SpEn26KOPusH31M1t79693ba6devmggopXrx4vPfptXdeUkaOHGnDhg1LNH3v3l124sRRS2tZsmS1okXjf4Zws29ftJ09eya9kwEgAxyXCmeLtLsvyWbpiWMSkLFwrWTpelwqWfKi4AUWKilQKYUeGzdudONZ6EL95ptvtkBSZKZeqFQy4h1DY926da49hQKLCzVw4EAXrMQtsVCVq2LFSlq+fPkCknakTuHCRdM7CQDgwzEJQEZTOBMcl1IdWDRo0MCVHKg9w91332233Xabq6IUDOrpqVq1avGmVa1a1T766CP3vESJEu7/nj17fGNreF/Xrl072fVmz57dPZIq5gn3Yrb0wn4HkJFwTAKQ0URmguNSqgOLFi1a2NSpUxNd8AeDeoRSiUhcf/zxh11yySXuuRpzK7iYP3++L5BQ6YN6h9KgfQAAAAAyaGCh0bbTSt++fV23tqoK1alTJ1uxYoUb3ds7wndERIRrNK6xNSpVquQCjcGDB7ueqjp06JBm6QQAAADCnd+Nt4PpiiuusE8++cS1iXjmmWdc4KDuZbt06eJb5vHHH7djx45Zjx497ODBg3bVVVe50cBz5MiRrmkHAAAAwkmGDizk+uuvd4/kqNRCQYceAAAAANJHxm8FAgAAACDDI7AAAAAAkD6BxaJFi6xr167WsGFD27Fjh5v2zjvv2I8//uh/igAAAACEfmChMSRat27tRtv+5Zdf7NSpU276oUOHfAPZAQAAAAgvqQ4s1LWrRr6eMmWKZc2aNd6YE6tWrQp0+gAAAACEYmChAeuaNGmSaHr+/Pldd68AAAAAwk+qAwuNdP3nn38mmq72FeXLlw9UugAAAACEcmDRvXt3e+SRR2z58uVuDImdO3fae++9Z/3797eePXsGJ5UAAAAAQmuAvCeeeMJiY2OtRYsWdvz4cVctKnv27C6w6NWrV3BSCQAAACC0AguVUjz11FP22GOPuSpRR48etWrVqlmePHmCk0IAAAAAoRdYeGXLls0FFAAAAACQ6sDi2LFj9vzzz9v8+fNt7969rlpUXJs3bw5k+gAAAACEYmBx33332cKFC+2OO+6wkiVLuqpRAAAAAMJbqgOLOXPm2JdffukGxAMAAACAC+putmDBglaoUCH2HgAAAIALDyyGDx9uQ4YMcV3NAgAAAECKq0LVqVMnXlsKdTNbvHhxK1u2rGXNmjXesqtWrWLPAgAAAGEmRYFFhw4dgp8SAAAAAKEdWAwdOjT4KQEAAAAQPm0sypcvb/v27Us0/eDBg24eAAAAgPCT6sDi77//tpiYmETTT506Zf/880+g0gUAAAAgFMex+Pzzz33P586da/nz5/e9VqChkbjLlSsX+BQCAAAACJ3AwtuAW71DdevWLd489QylHqJefvnlwKcQAAAAQOgEFrGxse6/SiV++uknK1KkSDDTBQAAACAUAwuvLVu2BCclAAAAAMKn8TYAAAAAJERgAQAAAMBvBBYAAAAA0iawePTRR+3YsWPu+Q8//GBnz571f8sAAAAAwiuwGD9+vB09etQ9b9asme3fvz/Y6QIAAAAQar1CaYyKcePGWatWrczj8djSpUutYMGCSS7bpEmTQKcRAAAAQCgEFi+++KI98MADNnLkSDdA3o033pjkcpqnUbgBAAAAhJcsKR11Ww9Vh8qXL59t3LjRihUrFvzUAQAAAAi9AfLy5Mlj3333nRt9O0uWVI+tBwAAACBEpTo6aNq0qavu9NFHH9mGDRvctGrVqln79u0tKioqGGkEAAAAEGqBxZ9//mlt27a1f/75xypXruymqe1FmTJl7Msvv7QKFSoEI50AAAAAQmmAvN69e1v58uVt+/bttmrVKvfYtm2bqx6leQAAAADCT6pLLBYuXGjLli2zQoUK+aYVLlzYnn/+eWvcuHGg0wcAAAAgFEsssmfPbkeOHEk0XT1GZcuWLVDpAgAAABDKgcX1119vPXr0sOXLl7vB8vRQCYbGuWjXrl1wUgkAAAAgtAILjcCtBtoNGza0HDlyuIeqQFWsWNFeeeWV4KQSAAAAQGi1sShQoIB99tlnrncob3ezVatWdYEFAAAAgPB0waPcKZAgmAAAAABwQVWhAAAAEH6io6NtwoRX3X8gKQQWAAAAOC8FFJMmTSSwQLIILAAAAAD4jcACAAAAQPoEFosWLbKuXbu6Lmd37Njhpr3zzjv2448/WjBpdO+IiAjr06ePb9rJkyftoYcecqN/58mTx2666Sbbs2dPUNMBAAAAwM/A4qOPPrLWrVtbzpw57ZdffrFTp0656YcOHbIRI0ZYsPz000/22muvWa1ateJN79u3r82ePds++OADW7hwoe3cudM6duwYtHQAAAAACEBg8eyzz9rkyZNtypQpljVrVt90DZK3atUqC4ajR49aly5d3DYLFizom65g5o033rDRo0db8+bNrW7dujZt2jRbsmSJGw0cAAAAQAYNLDZu3GhNmjRJND1//vx28OBBCwZVdWrbtq21bNky3vSff/7Zzpw5E296lSpV7OKLL7alS5cGJS0AAAAAAjBAXokSJdyo22XLlo03Xe0rypcvb4E2Y8YMVxKiqlAJ7d6927Jly+ZGA4+rePHibl5yVH3LW4VLDh8+7P7Hxsa6R3qIjAzvdvTptd8BJC+cj0sck4Dk80V6XS+F8zEpvY9LKd33qQ4sunfvbo888ohNnTrVNaRWmwaVDvTv398GDx5sgbR9+3a3rXnz5lmOHDkCtt6RI0fasGHDEk3fu3eXnThx1NJalixZrWjR4hbO9u2LtrNnz6R3MgD8f+F+XOKYBCS2f3+07/+ePTvTdNvhfkxK7+NSyZIXBSeweOKJJ1zE1KJFCzt+/LirFpU9e3YXWPTq1csCSVWd9u7da5dffrlvWkxMjP3www/26quv2ty5c+306dOuClbcUgv1CqWSleQMHDjQHn300XglFmXKlLFixUpavnz5AvoZkDKFCxdN7yQAgA/HJCCxffv+V+W9UKGiVrx4qfROTtgpnAmOS6kKLHRRv3jxYtfm4bHHHnNVotSwulq1aq6r10BT8LJ27dp40+6++27XjmLAgAEuGFAD8vnz57tuZr1tQLZt2+a6wk2OAiE9kirmCfditvTCfgeQkXBMApLPF1wvpY/ITLDPUxVYREVFWatWrWzDhg2uhEABRTDlzZvXatSoEW9a7ty53ZgV3un33nuvK30oVKiQK21QqYmCigYNGgQ1bQAAAAD8qAqlC/rNmzdbuXLlLCMYM2aMi+BUYqEG2RpjY+LEiemdLAAAACCsZLmQcSzUnmL48OFu3AiVIMQV7DYK33//fbzXatQ9YcIE9wAAAACQSQKLNm3auP/t2rVzvUJ5eTwe91rtMAAAAACEl1QHFt99911wUgIAAAAgfAKLpk2bBiclAAAAAMInsPDSGBbq1lXjSMRVq1atQKQLAAAAQCgHFtHR0W4siTlz5iQ5nzYWAAAAQPhJ9Ugbffr0cSNdL1++3HLmzGlff/21vfXWW1apUiX7/PPPg5NKAAAAAKFVYrFgwQL77LPPrF69em78iEsuucSuvfZa183syJEjrW3btsFJKQAAAMwTG2MRkVHpnQzA/8Di2LFjVqxYMfe8YMGCrmrUpZdeajVr1rRVq1aldnUAAABIBQUVR6YOtrO7t6Tpdg/vP/6//1MH2YFCudJ029mqN7Lc7R9M020iDQKLypUr28aNG61s2bJ22WWX2WuvveaeT5482UqWLHkBSQAAAEBqKKiI2b4xTbcZe/R/7Whj9/xtMcfStsQkpnjZNN0e0iiweOSRR2zXrl3u+dChQ+0///mPvffee5YtWzZ78803LzAZAAAAAMIqsOjatavved26dW3r1q32+++/28UXX2xFihQJdPoAAAAAhPI4Fl65cuWyyy+/PDCpAQAAABAegYXGqVCVp/nz59vevXstNjY2Ua9RAAD/qGOMWbNmWqdOna1o0aLpnRwAAILTxkKBhbqVrVGjhkVERKR2FQCAFAQWkyZNtGbNmhNYAABCM7CYMWOGzZo1y9q0aROcFAEAAAAI/ZG31ftTxYoVg5MaAAAAAOERWPTr189eeeUV83g8wUkRAAAAgNCsCtWxY8dEDbTnzJlj1atXt6xZs8ab9/HHHwc2hQAAAABCI7DInz9/vNc33nhjsNIDAAAAIBNKUWAxbdq04KcEAAAAQPi0sThx4oQdP37c91ojb48dO9a++eabQKcNAAAAQKgGFu3bt7e3337bPT948KBdeeWV9vLLL7vpkyZNCkYaAQAAAIRaYLFq1Sq7+uqr3fMPP/zQSpQo4UotFGyMGzcuGGkEgHQTE0sPeAAABGWAPFWDyps3r3uu6k/qMSoyMtIaNGjgAgwACCVRkRH2+Mwdtnnv6TTd7snoHe7/4zN2WI6iOS2tXV05tz3SqliabxcAEEaBhQbH+/TTT13PUHPnzrW+ffu66Xv37rV8+fIFI40AkK4UVGzYeTJtN3rwtEWY2Zbo02Zn0njbZlauaLY03yYAIMyqQg0ZMsT69+9vZcuWtfr161vDhg19pRd16tQJRhoBAAAAhFqJxc0332xXXXWV7dq1yy677DLf9BYtWjC+BQAAABCmUh1YiBps6xGXeocCAABAaCqcLcK6XZzV/QcCFlgAAAAgvBTOFml3X0L7KwSwjQUAAAAAJERgAQAAAMBvBBYAAAAA0qaNxeeff57iFbZr186f9AAAJEdB81zayf0HACBkAosOHTqkaGUREREWExPjb5oAAAooKndO71QAABDYwCI2NjblawQAAAAQdmhjAQAAACB9xrE4duyYLVy40LZt22anT5+ON693797+pwoAAABAaAcWv/zyi7Vp08aOHz/uAoxChQrZv//+a7ly5bJixYoRWAAAAABhKNVVofr27Ws33HCDHThwwHLmzGnLli2zrVu3Wt26de2ll14KTioBAAAAhFZgsXr1auvXr59FRkZaVFSUnTp1ysqUKWOjRo2yJ598MjipBAAAABBagUXWrFldUCGq+qR2FpI/f37bvn174FMIAAAAIPTaWNSpU8d++uknq1SpkjVt2tSGDBni2li88847VqNGjeCkEgAAAEBolViMGDHCSpYs6Z4/99xzVrBgQevZs6dFR0fba6+9Fow0AgAAAAi1Eot69er5nqsq1Ndffx3oNAEAAAAI9RKL5s2b28GDBxNNP3z4sJsHAAAAIPykOrD4/vvvEw2KJydPnrRFixYFKl0AAAAAQrEq1Jo1a3zP169fb7t37/a9jomJcVWiSpcuHfgUAgAAAAidwKJ27doWERHhHklVedJgeePHjw90+gAAAACEUlWoLVu22F9//WUej8dWrFjhXnsfO3bscG0s7rnnnoAmbuTIkXbFFVdY3rx5XUPxDh062MaNGxNVwXrooYescOHClidPHrvppptsz549AU0HAAAAgACVWFxyySXuf2xsrKWVhQsXuqBBwcXZs2fdyN6tWrVyVbFy587tlunbt699+eWX9sEHH7hB+h5++GHr2LGjLV68OM3SCQAAAIS7VHc3Kyq5GDt2rG3YsMG9rlatmj3yyCNWoUKFgCYuYVe2b775piu5+Pnnn61JkyZ26NAhe+ONN2z69Om+6lnTpk2zqlWr2rJly6xBgwYBTQ8AAACAAAUWc+fOtXbt2rk2F40bN3bTVDpQvXp1mz17tl177bUWLAokpFChQu6/AowzZ85Yy5YtfctUqVLFLr74Ylu6dGmygcWpU6fcw0vVuLylMWlZIhNXZGSqO+gKKem134HzCfe8Ga44JiEj47gUnmLT8biU0t9cqgOLJ554wlU/ev755xNNHzBgQNACC+3MPn36uGCmRo0abpp6psqWLZsVKFAg3rLFixeP12tVUm03hg0blmj63r277MSJo5bWsmTJakWLFrdwtm9ftJ09eya9kwHEQ94MXxyTkFFxXApf+9LxuFSy5EXBCSxU/WnWrFmJpqvhtqpHBYvaWqxbt85+/PFHv9c1cOBAe/TRR+OVWJQpU8aKFStp+fLl83v9SL3ChYumdxIAwIdjEoCMpnAmOC6lOrAoWrSorV692ipVqhRvuqap/UMwqEH2F198YT/88INddNH/RUwlSpRwg/VpJPC4pRbqFUrzkpM9e3b3SKqYh+LF9MF+B5CRcEwCkNFEZoLjUopT+Mwzz9jx48ete/fu1qNHD3vhhRfcSNt6qFrU/fff7+YFkrq2VVDxySef2IIFC6xcuXLx5tetW9eyZs1q8+fP901Td7Tbtm2zhg0bBjQtAAAAAAJQYqE2CQ888IANHjzYjSvx8ssvuypFUqpUKXv66aetd+/eFujqT+rx6bPPPnPb9LabULeyGpBP/++9915XrUkNulWNqVevXi6ooEcoAAAAIAMGFio9EI28rcbbehw5csRN00V/MEyaNMn9v+aaa+JNV5eyd911l3s+ZswYVzSkgfHU01Pr1q1t4sSJQUkPAAAAgAC0sVBQEVewAoqEwcy55MiRwyZMmOAeAAAAADJBYHHppZcmCi4S2r9/v79pAgAAABDKgYXaWahdAwAAAABccGBx6623Bq1LWQAAAACZV4q7mz1fFSgAAAAA4SsykA2pAQAAAISnFFeFio2NDW5KAAAAAGRaGX9scAAAAAAZHoEFAAAAAL8RWAAAAADwG4EFAAAAAL8RWAAAAADwG4EFAAAAAL8RWAAAAADwG4EFAAAAAL8RWAAAAADwG4EFAAAAAL8RWAAAAADwG4EFAAAAAL8RWAAAAADwG4EFAAAAAL8RWAAAAADwG4EFAAAAAL8RWAAAAADwG4EFAAAAAL8RWAAAAADwG4EFAAAAAL8RWAAAAADwG4EFAAAAAL8RWAAAAADwG4EFAAAAAL8RWAAAAADwG4EFAAAAAL8RWAAAAADwG4EFAAAAAL8RWAAAAADwG4EFAAAAAL8RWAAAAADwG4EFAAAAAL8RWAAAAADwG4EFwlZ0dLRNmPCq+w8AAAD/EFggbCmgmDRpIoEFAABAABBYIF0VyRNlntgYC0fh+rkBAEBoypLeCUB4y5szyiIio+zI1MF2dveWNN324f3H//d/6iA7UChXmm47S4lylvee4Wm6TQAAgGAisECGoKAiZvvGNN1mwdOx1u3irFbwwFaLOUbhHQAAgD8ILBC2CmeLtLsvyZbeyQAAAAgJ3KYFAAAA4DcCCwAAAAB+I7AAAAAA4LeQCSwmTJhgZcuWtRw5clj9+vVtxYoV6Z0kAAAAIGyERGAxc+ZMe/TRR23o0KG2atUqu+yyy6x169a2d+/e9E4aAAAAEBZCIrAYPXq0de/e3e6++26rVq2aTZ482XLlymVTp05N76QBAAAAYSHTdzd7+vRp+/nnn23gwIG+aZGRkdayZUtbunRpku85deqUe3gdOnTI/T948KDFxsZaelCaS+c5ZWcKnrFwUiT7STt8+LAdz1/Kzp4Mn8+eJX8pizp8ON1+b0g58iZ5E8iIx6Vwy5tnchU0O3zYLonIbWezFLRwcklEbnc8Ts/jkn5zefPmtYiIiHMuF+HxeDyWie3cudNKly5tS5YssYYNG/qmP/7447Zw4UJbvnx5ovc8/fTTNmzYsDROKQAAAJA56UZ8vnz5QrvE4kKodENtMrwUAe7fv98KFy583kgMoUPRf5kyZWz79u3nzSgA0g55E8iYyJvhLW/evOddJtMHFkWKFLGoqCjbs2dPvOl6XaJEiSTfkz17dveIq0CBAkFNJzIuHRw5QAIZD3kTyJjImwjZxtvZsmWzunXr2vz58+OVQOh13KpRAAAAAIIn05dYiKo1devWzerVq2dXXnmljR071o4dO+Z6iQIAAAAQfCERWHTu3Nmio6NtyJAhtnv3bqtdu7Z9/fXXVrx48fROGjIwVYfT2CcJq8UBSF/kTSBjIm/ifDJ9r1AAAAAA0l+mb2MBAAAAIP0RWAAAAADwG4EFAAAAAL8RWCBk/f33327Aw9WrV1uo0ejx6qTAH6G8f5CxhfJvj7wJIJwRWISZpUuXugEF27Zta5kFJ1mEA/ImgEBRD5m9evWy8uXLux6cNFr2DTfcEG/ML3+8+eabARtYuGzZsm6YAIQGAosw88Ybb7iDzQ8//GA7d+5M17ScPn06XbcPZCTkTQCBCvg1cPCCBQvsxRdftLVr17ou+Js1a2YPPfRQeicPIY7AIowcPXrUZs6caT179nR3RXXHIaHZs2fbFVdcYTly5LAiRYrYjTfe6Jt36tQpGzBggLvzoTsgFStWdBdDyd29+PTTT93dzIRVBF5//XUrV66c24bogHfVVVe59xcuXNiuv/56++uvv3zv07JSp04dt75rrrnGN0/rqlq1qltXlSpVbOLEiUl+dvWqrPS+9NJL8abrTqvW+eeffyb5vu+//94Nupg7d26XvsaNG9vWrVvdPKWxffv2bryUPHnyuP327bffJroT8+yzz9qdd97plrnkkkvs888/d+Ou6L2aVqtWLVu5cqXvPd59qf1XqVIl99lat25t27dvTzKNKd0XK1ascPtQ8zWY5C+//HLO9SHtkDfJm+RNBMqDDz7o8o5+VzfddJNdeumlVr16dTeY8LJly3zLbdu2zfdbz5cvn3Xq1Mn27Nnjm//rr7+6YCRv3rxuvoIV5QflPQ1AfOjQIbcdPXQMScr58qKOGcq3ffv29a0LmZzGsUB4eOONNzz16tVzz2fPnu2pUKGCJzY21jf/iy++8ERFRXmGDBniWb9+vWf16tWeESNG+OZ36tTJU6ZMGc/HH3/s+euvvzzffvutZ8aMGW7etGnTPPnz54+3vU8++URjpPheDx061JM7d27Pf/7zH8+qVas8v/76q5v+4Ycfej766CPPpk2bPL/88ovnhhtu8NSsWdMTExPj5q9YscKtR9vbtWuXZ9++fW76u+++6ylZsqR77+bNm93/QoUKed588003f8uWLe59Wqc899xznmrVqsVLY+/evT1NmjRJcn+dOXPGfab+/ft7/vzzT7dPtO6tW7e6+do/kydP9qxdu9bzxx9/eAYNGuTJkSOHb75ccsklLk1aTsv07NnTky9fPrcPZs2a5dm4caOnQ4cOnqpVq/q+C+3LrFmzuu9qyZIlnpUrV3quvPJKT6NGjeLty8suu8z3+nz74siRI56iRYt6br/9ds+6devc91++fPl4+wfph7xJ3iRvIhCUByMiIuIdH5KiPFy7dm3PVVdd5X7Hy5Yt89StW9fTtGlT3zLVq1f3dO3a1bNhwwaXR5QvlLdOnTrlGTt2rMsvyvd66HeclPPlRaX3oosu8jzzzDO+dSFzI7AIIzr56WDgPTEXKVLE89133/nmN2zY0NOlS5ck36uTrE508+bNS3J+Si9edFLeu3fvOdMZHR3t3qcDUVIXIV66+Jo+fXq8acOHD3efI6n37dixw12cLV++3L0+ffq02wfeE3xCOuDp/d9//70npXQgHj9+fLyLFx2YvXTQ1DoHDx7sm7Z06VI3zXtA1b7Uax3ovXRg1zRv2hNevJxvX7z22muewoULe06cOOGbP2nSJC5eMgjyJnmTvIlA0O9Qvx3dZDiXb775xuW5bdu2+ab99ttv7r26YSB58+ZNNg8mdVzxJy+OGTPmgtaFjIeqUGFi48aNrlj0tttuc6+zZMlinTt39lWX8FY9aNGiRZLv1zw1LG3atKlf6VB1g6JFi8abtmnTJpcuNTJTcauqKHiLaZNz7NgxV8R67733uuJV70NVG+JW1YirVKlSrprJ1KlTfVVLVIXklltuSXL5QoUK2V133eWqOqjR2yuvvGK7du2KV32lf//+roqDqkdo+xs2bEiUblWn8FJxsNSsWTPRtL179/qm6ftRkbGXqk9oG1r/hewLvU/p8FZxkYYNGya7f5F2yJvkTfImAkU3jFNCvztVndTDq1q1avF+y6o6dd9991nLli3t+eefTzb/nktK8yJCR5b0TgDShi5Szp49607gcQ9Aqo/96quvWv78+S1nzpzJvv9c8yQyMjLRAe3MmTOJllN96IR0YaCLmilTprj0xcbGWo0aNc7ZgFQHK9F76tevH2+eLrKSo4PkHXfcYWPGjLFp06a5C7hcuXIlu7yW6d27t6trrjrwgwYNsnnz5lmDBg3cwVLPVTdcdcS1j26++eZE6c6aNavvubf+aFLT9LkvxIXuC2QM5M3/IW8C/lPbH/1uf//9d7/XpXYTt99+u3355Zc2Z84cGzp0qM2YMSNe+67zSWleROigxCIM6KLl7bfftpdfftnd3fQ+1DBLFwvvv/++W053zZLrik538XRyXbhwYZLzdafzyJEj7g6dV0q6oNy3b5+7Y6uLAt2R1V2NAwcOxFsmW7Zs7n9MTEy8O4lK++bNm93BKu7D26A0KW3atHEXUJMmTXIXJPfcc89506hGlQMHDrQlS5a4i6rp06e76YsXL3Z3TXWQ1f4pUaKE640jUN9Z3Eaj2kcHDx50+yehlOwLvW/NmjV28uRJ3/viNuJD+iBv/h/yJnkT/lNpnkryJkyYEC/Pe+m36v3dqdOBuB0PrF+/3s1XyYWXGn6rYfU333xjHTt2dAG9N+/HzffJSUleTOm6kDkQWISBL774wl0QqDheJ9+4D/UY4a1yobsRupDRfxVVqou6F154wc1TFYhu3bq5k716RNmyZYvrGWLWrFluvu7G6e7ik08+6YpLdYJPqmebhAoWLOh6m/nvf//ren9R93gqfo2rWLFi7i6HLjbUY4V6opBhw4bZyJEjbdy4cfbHH3+49OqgN3r06GS3p7uEOsjpYkR3ds5V5UCfUctpfAH1WqEDq6qGeC8g9P6PP/7YdyGoOzsXemczId01Vdejy5cvt59//tmlWXdi1QtOUs63L5Q23cXq3r27O3l89dVXiXrhQdojb/4f8iZ5E4GhoEIX6vpNfvTRRy5v6Lih36A3X6l6ky70u3TpYqtWrXLVMdVDmqpUqmeyEydO2MMPP+yOJcpjChB++uknXx7TcUclcrrh8e+//9rx48eTTEtK8qLWpW62d+zY4daFTC69G3kg+K6//npPmzZtztnQy9sLjHosUU8R2bJlc40nO3bs6FtWjQv79u3rejjR/IoVK3qmTp0ar0GopuXMmdNt87///W+iBqJxGzV6qdGpel7Jnj27p1atWq5Bpt6n9XlNmTLF9XoTGRkZr9eK9957z5feggULul5kvI3WkmtYql5zNH3UqFHn3G+7d+92vcJ4P68amKlXHm+POFp/s2bN3OdV2l599VWXtkceeeScjdISfraE6fQ2itN3od5htF9atmwZr0ebpPblufaFtyGq3qP5Wk7rT7h/lF6tG2mDvEneFPImAm3nzp2ehx56yP1u9LsqXbq0p127dvE6hdDvVtPUI5waat9yyy0ub4l6frr11ltd/tH7S5Uq5Xn44YfjdTLwwAMPuI4H9FtN7reZkryo37+OL8pPXJZmfhH6k97BDZCWFi1a5Kp2qAjY2zgzI9Hd5D59+viKrNOK7jjpDrXq0sYdjwBIK+TNpJE3AWQWNN5G2FAvMxr8Sg3S1NtMRrxwSU/fffedNW/enAsXpDny5rmRNwFkFrSxQNhQHXX1cKO7jaNGjUrv5GQ46u5TvX8AaY28eW7kTQCZBVWhAAAAAPiNEgsAAAAAfiOwQKairi81UqgG/Ro7dmyK36cuITt06BDw9KibSHXxmRx11adl0rqxp6i+eu3atdN8u8CFIn+nHPkbGYk6GFAX2fny5fPlCXUje758fL48hsyHwAKZxuHDh12/2gMGDHD9Xffo0SPRMhp4RweqlAwAlhYaNWpku3btcqMnn0+gL1I04mlyg6ohc0vpyfi5555zv0GNY1GgQIEkl9m2bZurw69lNC7FY4895gaB8/rll1/cQHR58uRxI3Hv37/fN0/L1a1b1/WB7y/yd+qQvzM2XVTr+074eOihh3zLaFBEvVaPX8pfujDXeDBeymvKc5qnPKi8GJfeq8E1M4K33nrL9eqmwSq9eULjXiSVjxHaCCyQaegC6MyZM+4iqGTJku5CKKPTiKIaaVQnlLSiZlO64NPJSCcsZC6nT58O6LrUy1LPnj2TnK9BtJSftJwuCHRxoC5VhwwZ4lvmvvvucz0SaRAtDYA3YsQI3zxd1DRu3DjZweFSg/ydMuTvzEEX1brA9j7mzZvnpis/emlE69mzZ9sHH3xgCxcutJ07d7rRrePeGDhy5IjLe+oRTIMoxh2dXYM0qvvjjECDb2rwPA3u6c0TRYsWzRT5GAGW3gNpIHg0CI0GtNFANAUKFPAUK1bMDYx19OhRz1133eXJkyePp0KFCp6vvvoq3vvWrl3r+c9//uMGzdF7unbt6omOjvbNnzNnjqdx48ZuoKhChQp52rZt6/nzzz8TDSqlQZ6uueYaNzCOBr9ZsmTJOdN7rsF6NDCV1hn3oe0klHAZ74Bd3bp187Rv397z4osvekqUKOHS/eCDD3pOnz7te+/Jkyc9/fr1cwMB5cqVy3PllVfGG0woKdqGBgjTYF36nBqE7LPPPvPN1/u1zIEDB9zrv//+2w1Qpu9D26hWrZrnyy+/9O2zuA+l2ZuuXr16eYoWLeoGENK+X7FiRaJt6Hu8/PLLPVmzZnXTkhqoS2mtUqWKW0/lypU9EyZM8M3TgEgaUEn7R/Mvvvhiz4gRI875+cPN7Nmz3e/+7Nmz7rUGMNO+HzBggG+Ze++919OlSxff6w8//NB9z96B3F566aV469S0Z555xnPHHXe4372+93N9F1o+7u9Er8/HO7BbQvrNaGA7bz6TSZMmefLly+fSIPpdb9iwwT2fOHGib0A/DWZXqVIlz+HDh1O078jf5O9wpvOwzrexsbHu9cGDB913+cEHH/iWUT7Td60B4+S6665z+VHWr1/vflOi37W++59++ilF29bAkS+88ILbvo5DGqju2Wef9c1fs2aNG8QuR44cLu90797dc+TIEd/88+Uv5cOk8mXCQSj/+OMPz9VXX+1+fxp485tvvkk0KOW2bdvcsUHHKw0mqWNG3GNBSvP6448/7rnooovc59Xnfv3111N8jQP/EFiEMGVuncCHDx/uMrT+R0VFuYOVAgxN69mzpxs589ixY+49OkHqBDdw4EB3kFu1apXn2muvdQeduBdKCho2bdrkLqxuuOEGT82aNeONequDhU5wX3zxhWfjxo2em2++2R1kzpw5k2Ra9V6NOHvVVVd5Vq5c6Vm2bJmnbt26vgPU8ePHPd9++61br066u3bt8l3cxaV5WkbLapl9+/b5Dka6WNJIofpcukDUQVr7weu+++7zNGrUyPPDDz+4QEkHLh0AtZ+So23p4DV9+nS3P3r37u0CNu92E154KAjT/tSBXBdmSsfChQvdZ/GOtqv9pbTrxCNapy6GdGHx22+/uc+iA27CbSh404Faade8hBce7777rhupWNvZvHmz+6+D8ptvvunm6/PqhKPPrwukRYsWuc+F/6PvRBfi3hP62LFj3SjY9evX9y2ji09d4Il+y1pegYO+V11A6wJV/72UL/TbVMCh787720vuu9i7d6/7vrUO/U70+kIDi8GDBye6ONVvQ+tX3pcGDRp4xo0b5/LuTTfd5HniiSfcdP2O414QnAv5m/wdzhTU6Tz73HPP+abNnz8/3m/HSwHf6NGj3XPlNV1kK+/pAl15URQUxB25+nx0ka3flH4L+v3ou/ceo3SjUb+bjh07ugtupatcuXK+wDcl+Uu/RwUjDRs2jJcv4wYWOgbUqFHD06JFC8/q1atdvqhTp068wELBgQKOe+65x+UhBVO33367C5K9NzpSktc7derkfusa3V75UMeLGTNmpPgaB/4hsAhhOmnrRO6lk5sidN0Z9dJBIO4dEgUfrVq1iree7du3+06ISVGkr/k6KMUNLOLeIdAJU9O8dz4T0glTQY/uViR8j/funffucFJ3Mr2829aycelgpINc3IsVHbA7d+7su5uq7e/YsSPe+3QQ1AEoOdrWoEGDfK91kNY0leokdeGhAOzpp59Ocl0Jl/WuT3e13nvvPd80HXx1ITJq1Kh47/v000/jrS/hhYfu2iS8kND3rZOB6K5p8+bNfXfUkDTdNdZFmuhOti4WdFdMd/j++ecf9114L1Z1UtRJK67HHnvM3cn20u9S64nrfN9Fwrt8FxpY6GIgYX7XTQbvHXJZt26dp0mTJu6C57bbbvMcOnTI8/bbb7u7hvq8er9+W0899VSy2yd/k7/D2cyZMxP9/vSd67iR0BVXXOECAVHwqTynvKc8qDyjY4tKCv/991/P/fff74IA/da9gWpCKlFUAO0NJBLSBbmCDv0WvVTKFrck83z5SxToeG8UeMUNLObOnevJkiVLvH2gfBT3WPbOO++4ICLub1QBhW7G6P0pSYuuU7TOefPmJfl5L+QaB6lDG4sQV6tWLd/zqKgoVye3Zs2avmneEW737t3r/v/6669ulFfV3/U+qlSp4qtDKZs2bbLbbrvNypcv73qAUCM1bx3p5LatOtNxt5PQhg0bXG8wenhVq1bNNTjVvECoXr262wdx0+RNz9q1a11980svvTTeZ1e9V+/nTk7cz5k7d263T5L7nL1797Znn33W1UsfOnSorVmz5pzr1rZV71zLe2XNmtXVaU+4X+rVq5fseo4dO+bWde+998b7fEqL9/OpZx01iq1cubJL5zfffHPOtIWrpk2buoa4uu5UY0XViVbd4h9//NH9XkqVKmWVKlVyy+o7ivvdiV4rD+n3ltx3l5G+C+Ubfa6tW7fa9OnT3e9Rv91XX33VevXq5Row67jx8ccfu/riSSF/J438HR7eeOMNu+6669yxITXUAFp5TnlPv1Xlmfvvv99efPFFe++992zz5s22ceNG147hmWeeSXId+h1pZPsWLVokO/+yyy5zv20v/R5jY2PdulOSv1LCewyIuw8aNmwYbxkdR/7880/Lmzev7zdcqFAh18g9bj49V1r0G9c8HaeTkpJrHPgni5/vRwank1RcalAVd5q30aEOInL06FHXC8ULL7yQaF3e4EDzNUrulClT3EFC71WDrYSNTs+1nYyyL+J+bh2Mfv7553gHLNGB50LXm5AawrZu3dqNoqsT+8iRI10DWF2g+SvuiSEhfT7Rd1a/fv1487yf9/LLL7ctW7bYnDlz7Ntvv7VOnTpZy5Yt7cMPP/Q7baFEjSinTp3qTlD67nVS0jQFGwcOHEj2hJaa7y6tvgs1skzYo5O3VxrNS8qjjz7qGoxedNFF7jPr4lXpV6NrvdbxIT2Qv8nfGZGCAu1vBd5xKX/pnKlewuL22Kb8l1zemzZtmlu2ffv27oaGuljW71MNwuN2uBBXzpw5A/I5UpMPLpR+x+plTkFTQmoInpK0nO/zpuQaB/6hxALx6OTz22+/uVKIihUrxnvoxLZv3z53F2PQoEHuDoju1Opiyl9az/bt293Da/369e6gq7s0qemlReLeDU4JdeWn9+iuR8LPndxB/kLprs0DDzzgTjT9+vVzFwPJpb1ChQpu+uLFi33TdIdTPY6kZr+oZEpBoO5wJfx85cqV8y2nu7GdO3d2aZo5c6Z99NFH8boXhdnVV1/temoZM2aML4jwBhZ66Hnc33Xc7070WnfOE17gJnSu70In1tT+xpOiO4a6mx/3zqN6r9G2k/p9qXtT3XlUt7CiNOj3KPqfXJrI3+TvcKVgQN04K/COSxfQysdxuwzWuVUl/wnv5Et0dLQrlRg/fnyq8p5KT3WxnVzXxMqbukmiUi8v/R41loxKtwLFewxQD1lxe7ZKeP2h0lztr4S/45R06SyqkaEgQyU8F3KNA/8RWCBRv9g60aiqk05uKhqcO3eu3X333e7AVbBgQVedSgNZqchywYIF7g6mv3TnTAeELl26uK71dBf1zjvvdBdu56oCkJAOSDqIfv311+7Oj7rHTAld6Gnb2qYuCHRnT2nQHUfdfQwU3enV/tT69TlVJKsDrqgUSHdevvjiC3cS0Z0VHejUVajGFtBn0sWYuhzUYESq9pAaw4YNc59n3Lhx9scff7gLSp30Ro8e7ebr//vvv2+///67m68uEHXRldz4B+FKeUDVY3RXzRtENGnSxH2f2m9xSyx0YakT+vDhw908deeqKkQag+Bczvdd6KSo9e7evfucgb0uUlQ1QP+Vf/VcD+8d7latWrkL2DvuuMNdXOi3qZsGOg5kz5493rpUHUEBhfK+Ljq8VSYmTJjg3quL1ITVvrzI3+TvcKQLXH0H3bp1syxZ4lcQ0YWyvmOdP/U7UWmazrMKKho0aJDkb0vHk9KlS7vXymvvvPOOC/SVJ5PLezly5HBjwzz++OP29ttvu3O6LuhVPUuUL7SM0rhu3TqXFpWw6ZjgrSodCDoGKB9qOzpeqBrpU089FW8ZpaVIkSKuREbzlY90s0ZV9/75558UbUfHRm3jnnvucWP9eNcxa9asFF3jIABS2SYDmYgaUiXsOSJh929JNQRV47Abb7zRdZmoRlPq3alPnz6+BlVqFKWeG9QgTD2VfP/99/HWkVQDSzVY1LRzde94ru4oU9q4U9RITT1CqPFZwu4o40rY2EyNJocMGeIpW7asa1CpnjK0H9Q7RXKSakSrRrLeXn8SNthU979qZKl9p54p1JBejfC81HuQutCLiIjw9cpx4sQJ1/BSvQ+dqzvKhL2LJNUdpRoMqnceNRpUgz01CFTPGd5GfJqn/a9eN9Sw1dszEDyJfjsJOyPQvtZ3l5C3u1n9ptQI09vw+1x58nzfxeeff+56n1JjyHN1N6vfUMJuThPmQ/UQpJ7ilNf1G1OXrEn13qYeajQvLvWUpMamSqN6mPP2DJcU8jf5O9yowfG5GgXru1dXqfqu1LORfo/qUCWhr7/+2nWPHDd/qZMF5SHlJX2Xe/bsSTYdep96ktKxwnscitvVcEq7mz1X/jpf423RflCHMvp9Xnrppe5zJcxj+vx33nmnLz+UL1/epUedRqQ0Ldqvffv2dXlc29KxcurUqSm+xoF/IvQnEAEKAAAAgPBFVSgAAAAAfiOwAAAAAOA3AgsAAAAAfiOwAAAAAOA3AgsAAAAAfiOwAAAAAOA3AgsAAAAAfiOwAAAAAOA3AgsAAAAAfiOwAAAAAOA3AgsAAAAAfiOwAAAAAGD++n8LT74AdTwNVAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "PARAMETERS = {\n", + " \"points_seed\": \"sample of points\",\n", + " \"failure_seed\": \"histories of failures\",\n", + " \"cost_growth\": \"growth of costs\",\n", + "}\n", + "LABELS = {\n", + " \"accurate mission\": \"Accurately sampled,\\nmean of the histories\",\n", + " \"accurate mission histories p10\": \"Accurately sampled,\\nworst 10% of the histories\",\n", + " \"cost histories p70\": \"Cost at\\n70% confidence\",\n", + "}\n", + "shares = attribution.summary().mul(100)\n", + "fig, ax = plt.subplots(figsize=(8, 3.8))\n", + "x = np.arange(len(LABELS))\n", + "for k, (parameter, name) in enumerate(PARAMETERS.items()):\n", + " ax.bar(\n", + " x + (k - 1) * 0.27,\n", + " shares.loc[parameter, list(LABELS)],\n", + " width=0.27,\n", + " yerr=shares.loc[parameter, [f\"{column} se\" for column in LABELS]],\n", + " color=COLORS[k],\n", + " edgecolor=\"white\",\n", + " lw=1,\n", + " error_kw={\"ecolor\": INK, \"lw\": 1},\n", + " label=name,\n", + " )\n", + "ax.set_xticks(x, list(LABELS.values()))\n", + "ax.set(ylabel=\"Total share of the variance (%)\", ylim=(0, None))\n", + "ax.legend(loc=\"upper center\", fontsize=8, frameon=False)\n", + "style_axes(ax)\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "da3c8d4e", "metadata": {}, "source": [ "The sample of points spreads the mean shares accurately sampled (92% of their variance between replicates), and the failures hardly do (4%), as each replicate averages 20 histories. The share in the worst 10% of the histories is spread mostly by the failures (67%, and 30% by the points), as a quantile of 20 histories is a noisy estimate. Both are noise of the estimates, with different remedies: more points would sharpen the means, and more histories the worst 10%, which is cheap.\n", @@ -834,7 +982,7 @@ }, { "cell_type": "markdown", - "id": "81c4343e", + "id": "5bc51596", "metadata": {}, "source": [ "The order of designs on the front depends on their differences, in which the parameters that act alike on two designs cancel. `differences` attributes the variance of the differences between pairs of designs from the same evaluations: here, between the designs and policies adjacent along the front, by cost:" @@ -842,8 +990,8 @@ }, { "cell_type": "code", - "execution_count": 6, - "id": "fc3c9a2c", + "execution_count": 9, + "id": "d53fe0cc", "metadata": {}, "outputs": [ { @@ -936,7 +1084,7 @@ "failure_seed 6.5 4.7 " ] }, - "execution_count": 6, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -948,7 +1096,7 @@ }, { "cell_type": "markdown", - "id": "ba021360", + "id": "a7a0fb65", "metadata": {}, "source": [ "The growth of the cost of development cancels in every difference. All of these designs fly the same imager, whose development grows alike for each, so the growth is a risk of each mission but not a reason to prefer one design to another; the failures alone spread the differences of their costs. The shares differ by what spreads them: the sample of points for the means (92%), and mostly the histories for the worst 10% (73%). More points would settle the order of neighbors by their means, and more histories their order by the worst 10% and by cost." @@ -956,7 +1104,7 @@ }, { "cell_type": "markdown", - "id": "d8a77e6b", + "id": "f78af606", "metadata": {}, "source": [ "## Summary\n", @@ -970,7 +1118,7 @@ }, { "cell_type": "markdown", - "id": "c30a0294", + "id": "ae99eb83", "metadata": {}, "source": [ "## Notes\n", diff --git a/docs/examples/tradespace/RankUncertainDesigns.ipynb b/docs/examples/tradespace/RankUncertainDesigns.ipynb index a90be1dc..994a0d08 100644 --- a/docs/examples/tradespace/RankUncertainDesigns.ipynb +++ b/docs/examples/tradespace/RankUncertainDesigns.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "890b27f9", + "id": "51020379", "metadata": {}, "source": [ "# Rank Uncertain Designs\n", @@ -22,7 +22,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "a87ae62a", + "id": "cc653395", "metadata": {}, "outputs": [ { @@ -42,7 +42,7 @@ }, { "cell_type": "markdown", - "id": "0b18dfc4", + "id": "a83bcd9c", "metadata": {}, "source": [ "## Estimate the Probability of Efficiency\n", @@ -53,7 +53,7 @@ { "cell_type": "code", "execution_count": 2, - "id": "337bf66d", + "id": "4aef9718", "metadata": {}, "outputs": [ { @@ -277,7 +277,59 @@ }, { "cell_type": "markdown", - "id": "12c3797c", + "id": "03afabef", + "metadata": {}, + "source": [ + "The single satellites show why: the means of their five replicates are within a few tenths of a percentage point of each other, and their 95% confidence intervals (two standard errors either side) overlap." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "19cf5721", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "from tatc.tradespace import style_axes\n", + "from tatc.tradespace.plotting import COLORS, GRAY, INK\n", + "\n", + "single = candidates[candidates.satellites == 1].sort_values(\"sufficient\")\n", + "fig, ax = plt.subplots(figsize=(8, 3))\n", + "rows = range(len(single))\n", + "ax.errorbar(single.sufficient, rows, xerr=2 * single[\"sufficient se\"], fmt=\"o\", color=COLORS[0], ms=6, lw=2, capsize=0)\n", + "for k, row in enumerate(single.itertuples()):\n", + " ax.annotate(\n", + " f\"efficient in {row.pareto_probability:.0%}\",\n", + " (row.sufficient, k),\n", + " xytext=(0, 8),\n", + " textcoords=\"offset points\",\n", + " ha=\"center\",\n", + " fontsize=8,\n", + " color=INK,\n", + " )\n", + "ax.set_yticks(rows, single.description.str.replace(\", 60 deg FOR\", \"\"))\n", + "ax.set(xlabel=\"Points sufficiently sampled (%): mean and 95% interval\", ylim=(-0.6, len(single) - 0.3))\n", + "style_axes(ax, grid=\"x\")\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "cfd847c6", "metadata": {}, "source": [ "Four of the seven efficient designs are efficient in every resample, and two more nearly so: two satellites in one plane (98%) and four in two planes (92%). The single satellite is not settled. One crossing the equator at 18:00 is efficient in 54% of the resamples, one in a Walker orbit inclined 75 degrees in 38%, and others in 10 to 20%. Likewise, three satellites in three planes (29% and 32%) sample about as many points as three in one plane, and six satellites in two planes with another phasing (32%) as many as the efficient design. Given five replicates, these designs are equally good candidates." @@ -285,7 +337,7 @@ }, { "cell_type": "markdown", - "id": "a05fc602", + "id": "c0c4e63c", "metadata": {}, "source": [ "## Refine Uncertain Designs\n", @@ -297,8 +349,8 @@ }, { "cell_type": "code", - "execution_count": 3, - "id": "83764413", + "execution_count": 4, + "id": "104737eb", "metadata": {}, "outputs": [ { @@ -417,7 +469,7 @@ "7 7 13 12 0 0" ] }, - "execution_count": 3, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -434,8 +486,8 @@ }, { "cell_type": "code", - "execution_count": 4, - "id": "785eff86", + "execution_count": 5, + "id": "355e4987", "metadata": {}, "outputs": [ { @@ -890,7 +942,7 @@ "980 67.07 15 False 0.02 False " ] }, - "execution_count": 4, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -906,7 +958,7 @@ }, { "cell_type": "markdown", - "id": "3a29636c", + "id": "5801af83", "metadata": {}, "source": [ "Refinement adds 215 evaluations, 0.6% of those that 40 replicates of every design would take, to 31 designs. One round of five replicates settles most of them, as efficient or not, and a few take more. With the tolerance, 39 designs are efficient candidates, among them every design of six to nine satellites that samples about 98% of the points: they differ by less than matters.\n", @@ -916,7 +968,7 @@ }, { "cell_type": "markdown", - "id": "953d4052", + "id": "853c9fb7", "metadata": {}, "source": [ "## Confirm the Front\n", @@ -926,8 +978,8 @@ }, { "cell_type": "code", - "execution_count": 5, - "id": "aff06deb", + "execution_count": 6, + "id": "807da56f", "metadata": {}, "outputs": [ { @@ -1052,7 +1104,7 @@ "21 69.60 66.40 3.20 True " ] }, - "execution_count": 5, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -1075,7 +1127,53 @@ }, { "cell_type": "markdown", - "id": "c7fcb49f", + "id": "a37460f8", + "metadata": {}, + "source": [ + "The optimism of every confirmed design, by its number of satellites (designs that are no longer efficient by the new replicates are hollow):" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "99289e48", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "\n", + "positions = {n: k for k, n in enumerate(sorted(confirmed.satellites.unique()))}\n", + "x = confirmed.satellites.map(positions).to_numpy() + np.random.default_rng(0).uniform(-0.15, 0.15, len(confirmed))\n", + "still = confirmed.pareto.to_numpy(dtype=bool)\n", + "optimism = confirmed.optimism.to_numpy()\n", + "fig, ax = plt.subplots(figsize=(7.5, 3.6))\n", + "ax.axhline(0, color=GRAY, lw=1, ls=\"--\")\n", + "ax.scatter(x[still], optimism[still], s=32, color=COLORS[0], lw=0, label=\"efficient by the new replicates\")\n", + "ax.scatter(\n", + " x[~still], optimism[~still], s=32, facecolor=\"none\", edgecolor=COLORS[0], lw=1.5, label=\"no longer efficient\"\n", + ")\n", + "ax.set_xticks(list(positions.values()), [f\"{n:.0f}\" for n in positions])\n", + "ax.set(xlabel=\"Satellites\", ylabel=\"Optimism (percentage points)\")\n", + "ax.legend(loc=\"upper right\", fontsize=8, frameon=False)\n", + "style_axes(ax)\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f37149ff", "metadata": {}, "source": [ "The designs of two to four satellites sample up to 3.2 points fewer with the new replicates (2.5 points on average for four satellites): four satellites in two planes sample 66.4% rather than 69.6%. The three satellites in three planes, which refinement left as good as three in one plane, sample 35.6% and are no longer efficient.\n", @@ -1085,7 +1183,7 @@ }, { "cell_type": "markdown", - "id": "903c75df", + "id": "6e83a018", "metadata": {}, "source": [ "## Require Reliable Sampling\n", @@ -1100,8 +1198,8 @@ }, { "cell_type": "code", - "execution_count": 6, - "id": "b12f2169", + "execution_count": 8, + "id": "419f7f85", "metadata": {}, "outputs": [ { @@ -1200,7 +1298,7 @@ "1026 97.0 1.0 5 0.50 " ] }, - "execution_count": 6, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -1226,7 +1324,53 @@ }, { "cell_type": "markdown", - "id": "9f219519", + "id": "da1a6745", + "metadata": {}, + "source": [ + "The replicates of these designs, and of the most reliable design of three satellites, against the threshold of half of the points (dashed): a design meets the requirement if at least 80% of its replicates lie right of the threshold, and its objective is the share that 80% of them exceed (its 0.2 quantile, the tick)." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "da41d282", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "three = reliable[reliable.satellites == 3].nlargest(1, \"sufficient p20\")\n", + "shown = pd.concat([three, reliable[reliable.pareto_probability >= 0.1]]).sort_values([\"satellites\", \"planes\"])\n", + "fig, ax = plt.subplots(figsize=(8, 3.2))\n", + "ax.axvline(50, color=GRAY, lw=1, ls=\"--\")\n", + "for k, (_, row) in enumerate(shown.iterrows()):\n", + " shares = refinement.results.loc[refinement.results.design == row.design, \"sufficient\"].to_numpy()\n", + " ax.scatter(\n", + " shares, np.full(len(shares), k), s=24, color=COLORS[0], alpha=0.6, lw=0, label=\"replicate\" if k == 0 else None\n", + " )\n", + " ax.scatter(row[\"sufficient p20\"], k, marker=\"|\", s=200, color=INK, lw=2, label=\"0.2 quantile\" if k == 0 else None)\n", + "ax.set_yticks(range(len(shown)), shown.description.str.replace(\", 60 deg FOR\", \"\"))\n", + "ax.set(xlabel=\"Points sufficiently sampled (%)\", xlim=(0, 102), ylim=(-0.6, len(shown) - 0.4))\n", + "ax.legend(loc=\"upper left\", fontsize=8, frameon=False)\n", + "style_axes(ax, grid=\"x\")\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "530b6fa1", "metadata": {}, "source": [ "209 of the 1,096 designs meet the requirement, none of them with fewer than four satellites. Among them, four satellites in one plane and six in two planes are efficient for sure, sampling at least 65% and 98% of the points in 80% of the samples. Four satellites in two planes sample more than four in one (at least 68%), and are efficient in 94% of the resamples: these are the alternatives to weigh against the cost of a second plane." @@ -1234,7 +1378,7 @@ }, { "cell_type": "markdown", - "id": "7ec42115", + "id": "74d48a91", "metadata": {}, "source": [ "## Summary\n", @@ -1250,7 +1394,7 @@ }, { "cell_type": "markdown", - "id": "e687906b", + "id": "8e4c7da5", "metadata": {}, "source": [ "## Notes\n", diff --git a/docs/examples/tradespace/SearchTradeSpace.ipynb b/docs/examples/tradespace/SearchTradeSpace.ipynb index 2666823b..92c72fa5 100644 --- a/docs/examples/tradespace/SearchTradeSpace.ipynb +++ b/docs/examples/tradespace/SearchTradeSpace.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "b744951b", + "id": "5124dfb0", "metadata": {}, "source": [ "# Search a Large Trade Space\n", @@ -20,7 +20,7 @@ }, { "cell_type": "markdown", - "id": "61cf8391", + "id": "b51ff879", "metadata": {}, "source": [ "## Measure a Front by its Hypervolume\n", @@ -31,7 +31,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "1d94fb88", + "id": "01692fbc", "metadata": {}, "outputs": [ { @@ -57,7 +57,7 @@ }, { "cell_type": "markdown", - "id": "b44435b5", + "id": "e736bd35", "metadata": {}, "source": [ "## Screen Designs with a Cheaper Study\n", @@ -70,7 +70,7 @@ { "cell_type": "code", "execution_count": 2, - "id": "1a92e627", + "id": "35495471", "metadata": {}, "outputs": [ { @@ -203,7 +203,7 @@ }, { "cell_type": "markdown", - "id": "bb2a2b65", + "id": "0f837469", "metadata": {}, "source": [ "The 12-hour study ranks designs nearly as the full study does. Keeping the best 5% of the designs finds 99% of the hypervolume of the true front at 17% of the cost of evaluating every design, although it misses three of the seven efficient designs, whose places designs with nearly the same objectives take. Keeping 10% finds six of the seven, at 22% of the cost.\n", @@ -213,7 +213,7 @@ }, { "cell_type": "markdown", - "id": "958118bd", + "id": "d236f23e", "metadata": {}, "source": [ "## Search with Optimizers\n", @@ -229,7 +229,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "ae594f52", + "id": "01e8217c", "metadata": {}, "outputs": [ { @@ -324,7 +324,7 @@ { "cell_type": "code", "execution_count": 4, - "id": "b5b86fdf", + "id": "ce572cad", "metadata": {}, "outputs": [ { @@ -355,15 +355,74 @@ }, { "cell_type": "markdown", - "id": "fda7e896", + "id": "04a68fe0", "metadata": {}, "source": [ - "Both optimizers find more of the front than a sample of as many designs. pymoo finds the whole front with 166 designs, 15% of the space (its other 34 proposals violate the constraint on the number of satellites). Optuna finds 92% of the hypervolume with 143 designs, and the sample 79% with 176. The searches stop at their budget, not when they converge: a larger budget, or screening first, would bring Optuna's closer to the true front." + "Where each search looked: the designs that it evaluated (blue) among every design of the space (gray), with the true front ringed." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d8c9d612", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "\n", + "from tatc.tradespace import style_axes\n", + "from tatc.tradespace.plotting import COLORS, INK\n", + "\n", + "satellites = summary.satellites + np.random.default_rng(0).uniform(-0.18, 0.18, len(summary)) # for legibility\n", + "fig, axes = plt.subplots(1, 3, figsize=(14, 4), sharey=True)\n", + "for ax, (name, search) in zip(axes, searches.items()):\n", + " evaluated = summary.design.isin(search.design).to_numpy()\n", + " ax.scatter(\n", + " satellites[~evaluated], summary.sufficient[~evaluated], s=10, color=GRAY, alpha=0.3, lw=0, label=\"not evaluated\"\n", + " )\n", + " ax.scatter(\n", + " satellites[evaluated], summary.sufficient[evaluated], s=14, color=COLORS[0], alpha=0.8, lw=0, label=\"evaluated\"\n", + " )\n", + " ax.scatter(\n", + " satellites[summary.pareto],\n", + " summary.sufficient[summary.pareto],\n", + " s=70,\n", + " facecolor=\"none\",\n", + " edgecolor=INK,\n", + " lw=1.5,\n", + " label=\"true front\",\n", + " )\n", + " ax.set(xlabel=\"Satellites\", xticks=range(1, MAX_SATELLITES + 1), ylim=(0, 105))\n", + " ax.set_title(f\"{name}: {evaluated.sum()} designs\", fontsize=10)\n", + " style_axes(ax)\n", + "axes[0].set_ylabel(\"Points sufficiently sampled (%)\")\n", + "axes[0].legend(loc=\"upper left\", fontsize=8, frameon=False, markerscale=1.4)\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "d796b1b2", + "metadata": {}, + "source": [ + "Both optimizers find more of the front than a sample of as many designs. pymoo's proposals gather at the top of each column of designs, near the front, while the sample's spread over the space. pymoo finds the whole front with 166 designs, 15% of the space (its other 34 proposals violate the constraint on the number of satellites). Optuna finds 92% of the hypervolume with 143 designs, and the sample 79% with 176. The searches stop at their budget, not when they converge: a larger budget, or screening first, would bring Optuna's closer to the true front." ] }, { "cell_type": "markdown", - "id": "71dc70b3", + "id": "c8c5a7fe", "metadata": {}, "source": [ "## Summary\n", @@ -377,7 +436,7 @@ }, { "cell_type": "markdown", - "id": "56b025ff", + "id": "2174a6c1", "metadata": {}, "source": [ "## Notes\n", diff --git a/docs/examples/tradespace/TradeCostAndUtility.ipynb b/docs/examples/tradespace/TradeCostAndUtility.ipynb index 83ed8902..a916a223 100644 --- a/docs/examples/tradespace/TradeCostAndUtility.ipynb +++ b/docs/examples/tradespace/TradeCostAndUtility.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "350c6e2c", + "id": "4e611495", "metadata": {}, "source": [ "# Trade Cost and Utility\n", @@ -20,7 +20,7 @@ }, { "cell_type": "markdown", - "id": "d975d3a1", + "id": "f679f58b", "metadata": {}, "source": [ "## Estimate Costs\n", @@ -37,7 +37,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "ada3ffd3", + "id": "216ec565", "metadata": {}, "outputs": [ { @@ -165,7 +165,7 @@ } ], "source": [ - "from trade_space_example import accuracy_study, describe, planes_name, space\n", + "from trade_space_example import PLANE_GROUPS, accuracy_study, describe, space\n", "from tatc.tradespace import (\n", " CostModel,\n", " DeploymentSchedule,\n", @@ -196,7 +196,7 @@ }, { "cell_type": "markdown", - "id": "fe184464", + "id": "23876394", "metadata": {}, "source": [ "Each evaluation now has the cost of the design and its parts, and the years from the start of development to the design's last launch (`deployed`).\n", @@ -214,7 +214,7 @@ { "cell_type": "code", "execution_count": 2, - "id": "71c5b6f8", + "id": "80fc3006", "metadata": {}, "outputs": [ { @@ -226,7 +226,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -249,9 +249,12 @@ ")\n", "costed = aggregate(results, COST)\n", "costed[\"pareto\"] = pareto_front(costed, COST)\n", + "costed[\"plane_group\"] = costed.planes.clip(upper=3) # 3 or 4 planes share a color\n", "print(f\"{costed.meets_requirements.sum()} of {len(costed)} designs cost at most {BUDGET} at 70% confidence\")\n", "\n", - "ax = plot_designs(costed, \"cost p70\", \"sufficient\", by=\"planes\", front=\"pareto\", names=planes_name, legend=\"upper left\")\n", + "ax = plot_designs(\n", + " costed, \"cost p70\", \"sufficient\", by=\"plane_group\", front=\"pareto\", names=PLANE_GROUPS, legend=\"upper left\"\n", + ")\n", "ax.axvline(BUDGET, color=GRAY, lw=1, ls=\"--\")\n", "ax.set(xlabel=\"Cost at 70% confidence (millions of dollars)\", ylabel=\"Points sufficiently sampled (%)\", ylim=(0, 105))\n", "ax.set_title(\"Every design, with the efficient designs within the budget ringed\", fontsize=10)\n", @@ -261,7 +264,7 @@ }, { "cell_type": "markdown", - "id": "18f5ac2a", + "id": "32e5e476", "metadata": {}, "source": [ "The efficient designs, with the years until they are deployed and some parts of their costs. A summary keeps the values that are the same in every replicate of a design, such as the cost of launches; the cost of development grows by a different factor in each replicate, so its mean is added:" @@ -270,7 +273,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "2f42311e", + "id": "c732c5b8", "metadata": {}, "outputs": [ { @@ -449,7 +452,7 @@ }, { "cell_type": "markdown", - "id": "51cf4f0a", + "id": "2c1834ed", "metadata": {}, "source": [ "520 of the 1,096 designs cost at most 150 million dollars at 70% confidence. Along the front, money buys sufficiency in steps:\n", @@ -464,7 +467,7 @@ }, { "cell_type": "markdown", - "id": "3dd1f946", + "id": "31bb12ff", "metadata": {}, "source": [ "## Trade Utility against Cost\n", @@ -480,12 +483,12 @@ { "cell_type": "code", "execution_count": 4, - "id": "1890e620", + "id": "ae075375", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -506,6 +509,7 @@ " results, statistics={\"sufficient\": \"sufficient\", \"accurate\": \"accurate\", \"cost p70\": Quantile(\"cost\", 0.7)}\n", ").set_index(\"design\")\n", "means[\"description\"] = means.apply(describe, axis=1)\n", + "means[\"plane_group\"] = means.planes.clip(upper=3) # 3 or 4 planes share a color\n", "\n", "fig, axes = plt.subplots(1, 2, figsize=(11, 4.5), sharey=True)\n", "judged = {}\n", @@ -514,7 +518,7 @@ " judged[name][\"pareto\"] = pareto_front(judged[name], {\"utility\": \"max\", \"cost p70\": \"min\"})\n", " legend = \"lower right\" if ax is axes[0] else None\n", " plot_designs(\n", - " judged[name], \"cost p70\", \"utility\", by=\"planes\", front=\"pareto\", names=planes_name, legend=legend, ax=ax\n", + " judged[name], \"cost p70\", \"utility\", by=\"plane_group\", front=\"pareto\", names=PLANE_GROUPS, legend=legend, ax=ax\n", " )\n", " ax.axvline(BUDGET, color=GRAY, lw=1, ls=\"--\")\n", " ax.set(xlabel=\"Cost at 70% confidence (millions of dollars)\", ylabel=\"Utility\", ylim=(0, 1.02))\n", @@ -526,7 +530,7 @@ }, { "cell_type": "markdown", - "id": "a20dfa0b", + "id": "9c9af0ac", "metadata": {}, "source": [ "The stakeholders' fronts share most of their designs. Those efficient for one stakeholder and not the other:" @@ -535,7 +539,7 @@ { "cell_type": "code", "execution_count": 5, - "id": "73063496", + "id": "ab147572", "metadata": {}, "outputs": [ { @@ -730,7 +734,7 @@ }, { "cell_type": "markdown", - "id": "6172984f", + "id": "ed863e18", "metadata": {}, "source": [ "Within the budget, the stakeholders agree: every design efficient for either of them up to 150 million dollars is efficient for both, as more satellites in more planes buy both shares. Beyond the budget, they part. For 174 million dollars at 70% confidence, the stakeholder of sufficiency prefers four satellites in two Walker planes (70% of the points sufficiently sampled, and 65% accurately), and the stakeholder of accuracy four satellites in two sun-synchronous planes crossing at 09:00 and 15:00 (58% and 85%), whose planes spread the samples over the day. The stakeholder of accuracy also finds three satellites in two sun-synchronous planes efficient for 157 million, and six satellites in three Walker planes for 214 million, which the stakeholder of sufficiency passes over." @@ -738,7 +742,7 @@ }, { "cell_type": "markdown", - "id": "19ed320e", + "id": "181031eb", "metadata": {}, "source": [ "## Summary\n", @@ -752,7 +756,7 @@ }, { "cell_type": "markdown", - "id": "71f52cd4", + "id": "0323bd05", "metadata": {}, "source": [ "## Notes\n", diff --git a/docs/examples/tradespace/trade_space_example.py b/docs/examples/tradespace/trade_space_example.py index 4a025dab..1b48e152 100644 --- a/docs/examples/tradespace/trade_space_example.py +++ b/docs/examples/tradespace/trade_space_example.py @@ -122,6 +122,12 @@ def planes_name(planes): return f"{planes:.0f} plane{'s' if planes > 1 else ''}" +# the groups of numbers of planes that color the designs of plots (by +# `planes.clip(upper=3)`): at most three colors, which readers with color vision +# deficiencies tell apart in a scatter of designs +PLANE_GROUPS = {1: "1 plane", 2: "2 planes", 3: "3 or 4 planes"} + + # ExplainTradeSpace: the study of accurate sampling as well DECORRELATION_TIME = timedelta(hours=3) # of the field whose daily mean is estimated From dbe007bf651cce4aa9452613004bbf032a085eda Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Fri, 13 Nov 2026 21:53:59 -0700 Subject: [PATCH 44/52] name the number of planes and satellites in each plane alike in the constellation fragments (planes and per_plane), and add fragments of streets-of-coverage constellations and mutual orbiting groups --- CHANGELOG.md | 2 +- .../tradespace/EvaluateTradeSpace.ipynb | 24 +- .../tradespace/trade_space_example.py | 6 +- src/tatc/tradespace/__init__.py | 4 + src/tatc/tradespace/constellations.py | 394 +++++++++++++++--- tests/tradespace/test_constellations.py | 184 +++++++- tests/tradespace/test_cost.py | 10 +- tests/tradespace/test_deployment.py | 2 +- 8 files changed, 530 insertions(+), 96 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 9d467d6d..8bbc54e8 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -19,7 +19,7 @@ Added: - Criteria by which designs are judged (`tradespace.Criteria`): objectives to minimize or maximize, requirements (`Requirement`, output constraints that designs meet or violate once evaluated, by an amount relative to the required value or a `scale`), the statistics over replicates that they name (`Mean`, `StandardDeviation`, `StandardError`, `Minimum`, `Maximum`, `Quantile`, and `Probability`, the share of replicates that meet a threshold; other names are means of metrics), tolerances of objectives, and the columns that group the records of an evaluation (`by`, such as a sensor), whose designs are judged separately. `aggregate` gives statistics of each design (and, with criteria, the violations of their requirements), and `summarize` means with their standard deviations and standard errors. `pareto_front`, `pareto_ranks` (which ranks designs that miss requirements after those that meet them), `hypervolume`, `pareto_probability` (which also gives the probability of meeting the requirements), `refine`, `confirm`, `screen`, `optimize_optuna` (a constraint of each trial for each requirement), and `optimize_pymoo` (a constraint for each requirement) take criteria, or a mapping of objectives to their directions. Results with several records of an evaluation that `by` does not separate raise an error rather than being averaged. - Function `tradespace.refine` (and class `Refinement`), which adds replicates only to the designs whose Pareto efficiency is uncertain, until it is settled, optionally with a tolerance of differences that do not matter (also of `pareto_probability`), and within a `budget` of evaluations (refining the least settled designs first). Designs about a tolerance from the front, which more replicates settle only slowly, are `indifferent` and not refined once their objectives are known to within a share of their tolerances (`precision`, from the standard errors of the objectives that `pareto_probability` gives). `Study.run` evaluates given replicates (`replicates`). - Class `tradespace.ResultStore`, a persistent store (SQLite) of the evaluations of a study (argument `store` of `Study`), from which a study that is interrupted or extended takes the evaluations stored before (except evaluations that failed and designs that failed validation, which are evaluated again). Workers add each evaluation as it completes, so that an interrupted run loses only the evaluations in progress, and records are kept as JSON (with values such as dates and infinite numbers tagged, so that they are read exactly). Function `tradespace.sensitivity` (and `main_effects`), the share of the variance of metrics explained by each design variable where it is active. Tolerances of objectives may be percentages of their values (such as `"5%"`). `Uncertain.seed` draws a seed of random numbers for each replicate, and `remove_failures` removes the satellites that fail, the same in every design. - - Building blocks of constellations: fragments of design spaces of Walker constellations (`tradespace.walker_space`) and planes of sun-synchronous orbits (`sso_planes_space`, whose planes have different crossing times), `build_constellation`, which builds the satellites of either with instruments or entries of the instrument catalog (with their validated attitudes, and several entries on one satellite), and `count_satellites` and `count_planes`. The phase and node of the lead satellite of a Walker constellation (`phase_fraction` and `node_fraction`, design variables or uncertain parameters) are fractions of the intervals over which they give distinct constellations (`360 / per_plane` degrees of phase, and `360 / planes` degrees of node for a delta configuration or 360 for a star), so that a search does not evaluate the same constellation at several phases or nodes. Planes of inclined orbits (`planes_space`), each with its own inclination and node (uncertain by default, as of satellites launched as secondary payloads). The satellites of the planes of `sso_planes_space` and `planes_space` are evenly spaced, or follow each other in a train at an `interval` (minutes), on the same ground track or in the same plane (`repeat_ground_track`). The phase of each plane (`phase_fraction`, which replaces `phase` of `sso_planes_space`) is a fraction of the interval over which it gives distinct planes (`360 / satellites` degrees for evenly spaced satellites, 360 for a train), from which each fragment derives the plane's `true_anomaly`, as for the lead satellite of a Walker constellation. `build_constellation`, `count_satellites`, and `count_planes` take several layouts (a list, or a `Repeat` of a `Choice` of layouts), such as the shells of a mixed constellation. The values of each fragment in a design are those of a `Layout` (`layout_of`, with `WalkerLayout`, `SSOPlanesLayout`, `PlanesLayout`, and `Layouts` of several), which gives its `Plane`s and the orbits of their satellites in order; other layouts subclass it and are built, counted (`plane_sizes`), deployed, and costed as the others. + - Building blocks of constellations: fragments of design spaces of Walker constellations (`tradespace.walker_space`) and planes of sun-synchronous orbits (`sso_planes_space`, whose planes have different crossing times), `build_constellation`, which builds the satellites of either with instruments or entries of the instrument catalog (with their validated attitudes, and several entries on one satellite), and `count_satellites` and `count_planes`. The phase and node of the lead satellite of a Walker constellation (`phase_fraction` and `node_fraction`, design variables or uncertain parameters) are fractions of the intervals over which they give distinct constellations (`360 / per_plane` degrees of phase, and `360 / planes` degrees of node for a delta configuration or 360 for a star), so that a search does not evaluate the same constellation at several phases or nodes. Planes of inclined orbits (`planes_space`), each with its own inclination and node (uncertain by default, as of satellites launched as secondary payloads). Streets-of-coverage constellations (`soc_space`), whose planes and satellites in each plane the fragment derives from a swath width, inclination, and altitude, and mutual orbiting groups (`mog_space`), launched together as one plane. The fragments name the number of planes `planes` and the satellites in each plane `per_plane` (`sso_planes_space` and `planes_space` previously took `count` and `satellites`). The satellites of the planes of `sso_planes_space` and `planes_space` are evenly spaced, or follow each other in a train at an `interval` (minutes), on the same ground track or in the same plane (`repeat_ground_track`). The phase of each plane (`phase_fraction`, which replaces `phase` of `sso_planes_space`) is a fraction of the interval over which it gives distinct planes (`360 / per_plane` degrees for evenly spaced satellites, 360 for a train), from which each fragment derives the plane's `true_anomaly`, as for the lead satellite of a Walker constellation. `build_constellation`, `count_satellites`, and `count_planes` take several layouts (a list, or a `Repeat` of a `Choice` of layouts), such as the shells of a mixed constellation. The values of each fragment in a design are those of a `Layout` (`layout_of`, with `WalkerLayout`, `SSOPlanesLayout`, `PlanesLayout`, `SOCLayout`, `MOGLayout`, and `Layouts` of several), which gives its `Plane`s and the orbits of their satellites in order; other layouts subclass it and are built, counted (`plane_sizes`), deployed, and costed as the others. - Function `tradespace.screen` (and class `Screening`), which screens designs with studies of increasing fidelity, keeping whole fronts of the best designs of each stage for the next. - Searches of design spaces with optional optimizers: `tradespace.optimize_optuna` suggests designs with Optuna trials (`DesignSpace.suggest`, define-by-run over the hierarchical space), and `optimize_pymoo` and `make_pymoo_problem` search the unit hypercube that encodes a design space (`DesignSpace.unit_paths`, `encode`, and `decode`) with pymoo, whose algorithms eliminate the proposals of designs proposed or evaluated before (`distinct`, by design rather than by point of the hypercube, `make_pymoo_problem`'s `duplicates`). Each design is evaluated once, and the designs proposed together are evaluated together, in parallel if the study is. A search returns its results and designs (`Search`), which `refine` and `confirm` refine and confirm as for any study. Constraints of a design space may return the amount of their violation (`Infeasible.violation`), which Optuna's trials record (`set_constraint`) for its constraint-aware samplers, and which is the constraint value of pymoo problems. Optional dependencies `tradespace` (joblib, Optuna, and pymoo). - Deployment of constellations (`tradespace.DeploymentSchedule`): from the rates and durations of a study (the mission, the design life, development, and production rate of each type of satellite, its production on a line, and launches at a cadence and capacity, in number or mass, optionally in an order of planes), each design's deployment (`DeploymentSchedule.plan`, a `Deployment` of its `Production`, `Launch`es, and replacements), so that a design of more satellites and planes takes longer to deploy. A sustained constellation (`DeploymentSchedule.sustained`, such as of an operational program over the period of a study) is replaced after the end of the mission as before it, and its costs are those incurred by the end, which count the units in production then by the share produced and later blocks by the share of their development done. A deployment's launches divide the mission into phases of constant sets of operating satellites (`Deployment.phases`), evaluated over the study's representative period from the observations of the full constellation (`evaluate_phases`) and combined over the mission (`summarize_phases`: the time-weighted mean of each metric and the time until it first meets a requirement). diff --git a/docs/examples/tradespace/EvaluateTradeSpace.ipynb b/docs/examples/tradespace/EvaluateTradeSpace.ipynb index 7a812f8b..2739eecd 100644 --- a/docs/examples/tradespace/EvaluateTradeSpace.ipynb +++ b/docs/examples/tradespace/EvaluateTradeSpace.ipynb @@ -106,8 +106,8 @@ " ),\n", " sso=sso_planes_space(\n", " crossing=Real(6, 18, step=3),\n", - " satellites=Integer(1, 2),\n", - " count=Integer(1, 2),\n", + " planes=Integer(1, 2),\n", + " per_plane=Integer(1, 2),\n", " ),\n", " ),\n", " points_seed=Uncertain.seed(),\n", @@ -244,7 +244,7 @@ " \n", " \n", " 5475\n", - " 29287797ce8d\n", + " e571197c9cb9\n", " 0\n", " 800000.0\n", " 60\n", @@ -255,7 +255,7 @@ " \n", " \n", " 5476\n", - " 29287797ce8d\n", + " e571197c9cb9\n", " 1\n", " 800000.0\n", " 60\n", @@ -266,7 +266,7 @@ " \n", " \n", " 5477\n", - " 29287797ce8d\n", + " e571197c9cb9\n", " 2\n", " 800000.0\n", " 60\n", @@ -277,7 +277,7 @@ " \n", " \n", " 5478\n", - " 29287797ce8d\n", + " e571197c9cb9\n", " 3\n", " 800000.0\n", " 60\n", @@ -288,7 +288,7 @@ " \n", " \n", " 5479\n", - " 29287797ce8d\n", + " e571197c9cb9\n", " 4\n", " 800000.0\n", " 60\n", @@ -303,11 +303,11 @@ ], "text/plain": [ " design replicate altitude field_of_regard layout satellites \\\n", - "5475 29287797ce8d 0 800000.0 60 sso 4 \n", - "5476 29287797ce8d 1 800000.0 60 sso 4 \n", - "5477 29287797ce8d 2 800000.0 60 sso 4 \n", - "5478 29287797ce8d 3 800000.0 60 sso 4 \n", - "5479 29287797ce8d 4 800000.0 60 sso 4 \n", + "5475 e571197c9cb9 0 800000.0 60 sso 4 \n", + "5476 e571197c9cb9 1 800000.0 60 sso 4 \n", + "5477 e571197c9cb9 2 800000.0 60 sso 4 \n", + "5478 e571197c9cb9 3 800000.0 60 sso 4 \n", + "5479 e571197c9cb9 4 800000.0 60 sso 4 \n", "\n", " planes sufficient \n", "5475 2 56.0 \n", diff --git a/docs/examples/tradespace/trade_space_example.py b/docs/examples/tradespace/trade_space_example.py index 1b48e152..36f9df01 100644 --- a/docs/examples/tradespace/trade_space_example.py +++ b/docs/examples/tradespace/trade_space_example.py @@ -56,8 +56,8 @@ ), sso=sso_planes_space( crossing=Real(6, 18, step=3), - satellites=Integer(1, 2), - count=Integer(1, 2), + planes=Integer(1, 2), + per_plane=Integer(1, 2), ), ), points_seed=Uncertain.seed(), @@ -109,7 +109,7 @@ def describe(d): ) else: planes = [ - f"{d[f'layout.sso.planes[{k}].satellites']:.0f} at " + f"{d[f'layout.sso.planes[{k}].per_plane']:.0f} at " f"{d[f'layout.sso.planes[{k}].crossing']:02.0f}:00" for k in range(int(d["layout.sso.planes.count"])) ] diff --git a/src/tatc/tradespace/__init__.py b/src/tatc/tradespace/__init__.py index 415d72ac..3b583664 100644 --- a/src/tatc/tradespace/__init__.py +++ b/src/tatc/tradespace/__init__.py @@ -26,7 +26,9 @@ build_constellation, count_planes, count_satellites, + mog_space, planes_space, + soc_space, sso_planes_space, walker_space, ) @@ -115,8 +117,10 @@ "build_constellation", "count_planes", "count_satellites", + "mog_space", "planes_space", "policy_space", + "soc_space", "sso_planes_space", "walker_space", # studies diff --git a/src/tatc/tradespace/constellations.py b/src/tatc/tradespace/constellations.py index 8b877429..1c2553e2 100644 --- a/src/tatc/tradespace/constellations.py +++ b/src/tatc/tradespace/constellations.py @@ -2,11 +2,19 @@ Building blocks of trade studies of constellations: fragments of design spaces for common constellation layouts (Walker constellations, planes of sun-synchronous orbits, and planes of inclined orbits, whose satellites are -evenly spaced or follow each other in trains), a builder of the satellites of +evenly spaced or follow each other in trains, streets-of-coverage +constellations, and mutual orbiting groups), a builder of the satellites of a layout (or of several, such as the shells of a mixed constellation) with a payload (instruments, or entries of the instrument catalog), and counts of satellites and planes for objectives and constraints. +The fragments share the names of their values: `planes` is the number of +planes, `per_plane` the number of satellites in each plane, and +`satellites` the number of satellites of a layout without planes (a mutual +orbiting group); `inclination` and `node` are in degrees, and +`phase_fraction` and `node_fraction` are fractions of the intervals over +which the phase and node give distinct layouts. + A fragment is a `DesignSpace` to place in a larger design space, for example as a branch of a `Choice` between layouts:: @@ -49,7 +57,9 @@ def build(d): from ..schemas import ( CircularOrbit, Instrument, + MOGConstellation, Satellite, + SOCConstellation, SunSynchronousOrbit, TrainConstellation, WalkerConstellation, @@ -64,6 +74,10 @@ def build(d): """The kind of the layouts of `sso_planes_space`.""" PLANES = "planes" """The kind of the layouts of `planes_space`.""" +SOC = "soc" +"""The kind of the layouts of `soc_space`.""" +MOG = "mog" +"""The kind of the layouts of `mog_space`.""" def _node(value: Any, default: Any) -> Any: @@ -159,7 +173,7 @@ def _lead_right_ascension(d: Scope) -> float: def _plane_true_anomaly(d: Scope) -> float: """The true anomaly (degrees) of the first satellite of a plane.""" - period = 360 if d.interval is not None else 360 / d.satellites + period = 360 if d.interval is not None else 360 / d.per_plane return float(d.phase_fraction) * period % 360 @@ -172,8 +186,8 @@ def _distinct_crossings(d: Scope) -> bool: def sso_planes_space( *, crossing: Any = None, - satellites: Any = None, - count: Any = None, + planes: Any = None, + per_plane: Any = None, phase_fraction: Any = 0.0, interval: Any = None, altitude: Any = None, @@ -188,10 +202,14 @@ def sso_planes_space( (see `tatc.schemas.SunSynchronousOrbit`), each with its own equator crossing time (local solar time, in hours), number of satellites, spacing of its satellites, and phase (see below), and (optionally, if not - given to - `build_constellation`) their altitude (meters). Each is a node of a - design space (such as a design variable, a value derived from the index - of the plane, or an uncertain parameter) or a value. + given to `build_constellation`) their altitude (meters). Each is a node + of a design space (such as a design variable, a value derived from the + index of the plane, or an uncertain parameter) or a value. + + The planes are a `Repeat` named `planes`: the number of planes is its + `count` (in a design, `planes.count`), and the values of each plane + (`crossing`, `per_plane`, `interval`, `phase_fraction`, and the derived + `true_anomaly`) are its items (`planes[0].crossing`). The satellites of a plane are evenly spaced around its orbit if its `interval` is `None`, or follow each other in a train (see @@ -207,7 +225,7 @@ def sso_planes_space( The phase of each plane is a fraction of the interval over which it gives distinct planes (as that of a Walker constellation, see - `walker_space`): `360 / satellites` degrees of true anomaly if its + `walker_space`): `360 / per_plane` degrees of true anomaly if its satellites are evenly spaced (a shift by which moves each onto the next), or 360 degrees if they are a train. Fractions in [0, 1) therefore give every distinct plane once, may be design variables or uncertain @@ -224,11 +242,11 @@ def sso_planes_space( Args: crossing (Any): The crossing time of each plane, by default a variable from 6 to 18 hours in steps of 1.5. - satellites (Any): The number of satellites of each plane, by default a - variable from 1 to 4. - count (Any): The number of planes, by default a variable from 1 to 3. + planes (Any): The number of planes, by default a variable from 1 to 3. + per_plane (Any): The number of satellites in each plane, by default + a variable from 1 to 4. phase_fraction (Any): The phase of each plane, as a fraction of - `360 / satellites` degrees (evenly spaced) or 360 degrees (a + `360 / per_plane` degrees (evenly spaced) or 360 degrees (a train): an uncertain parameter, such as `Uncertain.uniform(0, 1)`, if it is not designed. interval (Any): The interval (minutes) between the satellites of a @@ -247,7 +265,7 @@ def sso_planes_space( """ plane = DesignSpace( crossing=_node(crossing, Real(6, 18, step=1.5)), - satellites=_node(satellites, Integer(1, 4)), + per_plane=_node(per_plane, Integer(1, 4)), interval=Fixed(None) if interval is None else interval, phase_fraction=phase_fraction, true_anomaly=Derived(_plane_true_anomaly), @@ -256,7 +274,7 @@ def sso_planes_space( "kind": Fixed(SSO_PLANES), "ascending": ascending, "repeat_ground_track": repeat_ground_track, - "planes": Repeat(plane, count=_node(count, Integer(1, 3)), ordered=ordered), + "planes": Repeat(plane, count=_node(planes, Integer(1, 3)), ordered=ordered), } if altitude is not None: children["altitude"] = altitude @@ -268,8 +286,8 @@ def planes_space( *, inclination: Any = None, node: Any = None, - satellites: Any = None, - count: Any = None, + planes: Any = None, + per_plane: Any = None, phase_fraction: Any = 0.0, interval: Any = None, altitude: Any = None, @@ -283,10 +301,11 @@ def planes_space( node (right ascension of the ascending node at the epoch, degrees), number of satellites, spacing of its satellites (evenly spaced, or a train at an `interval`), and phase (a fraction, see `sso_planes_space`), - and (optionally, if not given to - `build_constellation`) their altitude (meters). Each is a node of a - design space (such as a design variable, a value derived from the index - of the plane, or an uncertain parameter) or a value. + and (optionally, if not given to `build_constellation`) their altitude + (meters). Each is a node of a design space (such as a design variable, a + value derived from the index of the plane, or an uncertain parameter) or + a value. The planes are a `Repeat` named `planes`, as those of + `sso_planes_space`. Unlike a Walker constellation, whose planes are evenly spaced in node, the planes may have any nodes and inclinations, as those of satellites @@ -300,11 +319,11 @@ def planes_space( variable from 30 to 90 degrees in steps of 15. node (Any): The node of each plane, by default uncertain (uniform from 0 to 360 degrees). - satellites (Any): The number of satellites of each plane, by default a - variable from 1 to 4. - count (Any): The number of planes, by default a variable from 1 to 3. + planes (Any): The number of planes, by default a variable from 1 to 3. + per_plane (Any): The number of satellites in each plane, by default + a variable from 1 to 4. phase_fraction (Any): The phase of each plane, as a fraction of - `360 / satellites` degrees (evenly spaced) or 360 degrees (a + `360 / per_plane` degrees (evenly spaced) or 360 degrees (a train). interval (Any): The interval (minutes) between the satellites of a train in each plane, or `None` for evenly spaced satellites. @@ -320,7 +339,7 @@ def planes_space( plane = DesignSpace( inclination=_node(inclination, Real(30, 90, step=15)), node=_node(node, Uncertain.uniform(0, 360)), - satellites=_node(satellites, Integer(1, 4)), + per_plane=_node(per_plane, Integer(1, 4)), interval=Fixed(None) if interval is None else interval, phase_fraction=phase_fraction, true_anomaly=Derived(_plane_true_anomaly), @@ -328,10 +347,188 @@ def planes_space( children = { "kind": Fixed(PLANES), "repeat_ground_track": repeat_ground_track, - "planes": Repeat(plane, count=_node(count, Integer(1, 3)), ordered=ordered), + "planes": Repeat(plane, count=_node(planes, Integer(1, 3)), ordered=ordered), + } + if altitude is not None: + children["altitude"] = altitude + return DesignSpace(constraints=constraints, **children) + + +def _soc_of(values: Any, altitude: float, epoch: datetime | None = None): + """The streets-of-coverage constellation of the values of a layout (or of + a scope), at an altitude and (if given) an epoch.""" + orbit = { + "altitude": altitude, + "inclination": values.inclination, + "true_anomaly": getattr(values, "true_anomaly", 0.0), + "right_ascension_ascending_node": getattr(values, "right_ascension", 0.0), + } + return SOCConstellation( + name="soc", + orbit=CircularOrbit(**orbit, **({} if epoch is None else {"epoch": epoch})), + swath_width=values.swath_width, + packing_distance=values.packing_distance, + polar=values.polar, + ) + + +def _soc_planes(d: Scope) -> int: + """The number of planes of a streets-of-coverage layout.""" + return _soc_of(d, d.altitude).get_number_planes() + + +def _soc_per_plane(d: Scope) -> int: + """The number of satellites in each plane of a streets-of-coverage + layout.""" + return _soc_of(d, d.altitude).get_satellites_per_plane() + + +def _soc_right_ascension(d: Scope) -> float: + """The right ascension of the ascending node (degrees) of the lead + satellite of a streets-of-coverage layout.""" + period = 360 if _soc_of(d, d.altitude).is_polar() else 360 / d.planes + return float(d.node_fraction) * period % 360 + + +def soc_space( + *, + swath_width: Any, + inclination: Any = None, + packing_distance: Any = 1.0, + polar: Any = None, + altitude: Any = None, + phase_fraction: Any = 0.0, + node_fraction: Any = 0.0, + constraints: Sequence[Callable[[Scope], Any]] = (), +) -> DesignSpace: + """ + Gets a fragment of a design space of streets-of-coverage constellations + (see `tatc.schemas.SOCConstellation`): the fewest satellites whose + footprints (of a swath width, in meters) cover the Earth continuously at + an inclination (degrees), in a Walker delta pattern for inclined orbits + or the polar pattern for near-polar ones (`polar`, by default chosen by + the inclination), with a margin of overlap (`packing_distance`, 1 for + none). Each is a node of a design space (such as a design variable, or a + value derived from the instrument, as the swath width of the sensor of a + design) or a value. + + The fragment derives its number of planes (`planes`) and of satellites + in each plane (`per_plane`) from them and the altitude (meters), which + therefore must be decided before them: a value of the fragment + (`altitude`), or of the design space outside it (declared before it), + the same as given to `build_constellation`. + + The phase and node of the lead satellite are fractions, as those of a + Walker constellation (see `walker_space`): of `360 / per_plane` degrees + of phase, and of `360 / planes` degrees of node (inclined orbits) or 360 + degrees (polar orbits, whose planes span 180 degrees). The fragment + derives the lead satellite's `true_anomaly` and `right_ascension` + (degrees) from them. + + Args: + swath_width (Any): The swath width (meters) of the footprints. + inclination (Any): The inclination, by default a variable from 30 to + 90 degrees in steps of 15. + packing_distance (Any): The relative distance between footprints + (inclined orbits) or the relative radius of the footprints (polar + orbits), in (0, 1]: less than 1 for a margin of overlap. + polar (Any): `True` for the polar pattern, `False` for the Walker + delta pattern, or `None` for the polar pattern of near-polar + orbits. + altitude (Any): The altitude, if part of the layout. + phase_fraction (Any): The phase of the lead satellite, as a fraction + of `360 / per_plane` degrees. + node_fraction (Any): The node of the lead satellite, as a fraction of + `360 / planes` degrees (inclined orbits) or 360 degrees (polar + orbits). + constraints (Sequence[Callable]): Constraints of the fragment (such + as a maximum of `planes * per_plane` satellites). + + Returns: + DesignSpace: the fragment + """ + children = { + "kind": Fixed(SOC), + "inclination": _node(inclination, Real(30, 90, step=15)), + "swath_width": swath_width, + "packing_distance": packing_distance, + "polar": Fixed(None) if polar is None else polar, + "phase_fraction": phase_fraction, + "node_fraction": node_fraction, } if altitude is not None: children["altitude"] = altitude + children["planes"] = Derived(_soc_planes) + children["per_plane"] = Derived(_soc_per_plane) + children["true_anomaly"] = Derived(_lead_true_anomaly) + children["right_ascension"] = Derived(_soc_right_ascension) + return DesignSpace(constraints=constraints, **children) + + +def _group_true_anomaly(d: Scope) -> float: + """The true anomaly (degrees) of the reference orbit of a mutual orbiting + group.""" + return float(d.phase_fraction) * 360 % 360 + + +def mog_space( + *, + parallel_axis: Any, + transverse_axis: Any, + inclination: Any = None, + node: Any = 0.0, + satellites: Any = None, + clockwise: Any = True, + altitude: Any = None, + phase_fraction: Any = 0.0, + constraints: Sequence[Callable[[Scope], Any]] = (), +) -> DesignSpace: + """ + Gets a fragment of a design space of mutual orbiting groups (see + `tatc.schemas.MOGConstellation`): satellites that orbit each other (on + an ellipse with axes, in meters, parallel and transverse to the + velocity, clockwise or not) about a reference circular orbit of an + inclination and node (degrees), and (optionally, if not given to + `build_constellation`) altitude (meters). Each is a node of a design + space (such as a design variable) or a value. + + The satellites of a group are launched together, as a single plane (of + `count_planes`), although the orbit of each has its own inclination and + node. The phase of the reference orbit is a fraction of 360 degrees, + from which the fragment derives its `true_anomaly` (degrees). + + Args: + parallel_axis (Any): The axis (meters) of the mutual orbit parallel + to the velocity. + transverse_axis (Any): The axis (meters) of the mutual orbit + transverse to the velocity. + inclination (Any): The inclination of the reference orbit, by default + a variable from 30 to 90 degrees in steps of 15. + node (Any): The node of the reference orbit. + satellites (Any): The number of satellites, by default a variable + from 2 to 6. + clockwise (Any): Whether the mutual orbit is clockwise. + altitude (Any): The altitude, if part of the layout. + phase_fraction (Any): The phase of the reference orbit, as a fraction + of 360 degrees. + constraints (Sequence[Callable]): Constraints of the fragment. + + Returns: + DesignSpace: the fragment + """ + children = { + "kind": Fixed(MOG), + "inclination": _node(inclination, Real(30, 90, step=15)), + "node": node, + "satellites": _node(satellites, Integer(2, 6)), + "parallel_axis": parallel_axis, + "transverse_axis": transverse_axis, + "clockwise": clockwise, + "phase_fraction": phase_fraction, + } + if altitude is not None: + children["altitude"] = altitude + children["true_anomaly"] = Derived(_group_true_anomaly) return DesignSpace(constraints=constraints, **children) @@ -354,10 +551,11 @@ class Layout: """ The satellites of a constellation, plane by plane: a Walker constellation (`WalkerLayout`), planes of sun-synchronous orbits - (`SSOPlanesLayout`) or of inclined orbits (`PlanesLayout`), or several - layouts flown together (`Layouts`). `layout_of` gets the layout of the - values of a design (of `walker_space`, `sso_planes_space`, or - `planes_space`). The functions of layouts (`build_constellation`, + (`SSOPlanesLayout`) or of inclined orbits (`PlanesLayout`), a + streets-of-coverage constellation (`SOCLayout`), a mutual orbiting group + (`MOGLayout`), or several layouts flown together (`Layouts`). `layout_of` + gets the layout of the values of a design (of a fragment such as + `walker_space`). The functions of layouts (`build_constellation`, `count_satellites`, `count_planes`, `plane_sizes`, and `DeploymentSchedule.plan`) take either. @@ -524,7 +722,7 @@ def __init__(self, values: Any): self.values = values def planes(self) -> list[Plane]: - return [Plane(int(plane.satellites), plane) for plane in self.values.planes] + return [Plane(int(plane.per_plane), plane) for plane in self.values.planes] def _orbit(self, plane: Any, epoch: datetime, altitude: float, anomaly: float): """Gets the orbit of a satellite of a plane at a true anomaly.""" @@ -581,6 +779,85 @@ def _orbit(self, plane: Any, epoch: datetime, altitude: float, anomaly: float): ) +class SOCLayout(Layout): + """ + A streets-of-coverage constellation (see + `tatc.schemas.SOCConstellation`): the values of `soc_space` in a design, + whose planes and satellites in each plane it derived at the altitude of + the design. Its satellites are named `" "`, in order. + + Args: + values (Values): The values of the layout. + """ + + def __init__(self, values: Any): + self.values = values + + def planes(self) -> list[Plane]: + return [Plane(int(self.values.per_plane))] * int(self.values.planes) + + def orbits(self, epoch: datetime, altitude: float | None = None) -> list[list[Any]]: + values = self.values + soc = _soc_of(values, _get_altitude(values, altitude), epoch) + members = soc.generate_members() + size, planes = int(values.per_plane), int(values.planes) + if len(members) != size * planes: + raise ValueError( + "the altitude of a streets-of-coverage layout must be the one " + + "its planes were derived at" + ) + # the members of each plane follow each other + return [ + [member.orbit for member in members[p * size : (p + 1) * size]] + for p in range(planes) + ] + + def names(self, name: str) -> list[list[str]]: + size = int(self.values.per_plane) + return [ + [f"{name} {p * size + s + 1}" for s in range(size)] + for p in range(int(self.values.planes)) + ] + + +class MOGLayout(Layout): + """ + A mutual orbiting group (see `tatc.schemas.MOGConstellation`): the + values of `mog_space` in a design, a single plane (launched together). + Its satellites are named `" "`, in order. + + Args: + values (Values): The values of the layout. + """ + + def __init__(self, values: Any): + self.values = values + + def planes(self) -> list[Plane]: + return [Plane(int(self.values.satellites))] + + def orbits(self, epoch: datetime, altitude: float | None = None) -> list[list[Any]]: + values = self.values + members = MOGConstellation( + name="mog", + orbit=CircularOrbit( + altitude=_get_altitude(values, altitude), + inclination=values.inclination, + right_ascension_ascending_node=float(values.node) % 360, + true_anomaly=getattr(values, "true_anomaly", 0.0), + epoch=epoch, + ), + parallel_axis=values.parallel_axis, + transverse_axis=values.transverse_axis, + clockwise=bool(values.clockwise), + number_satellites=int(values.satellites), + ).generate_members() + return [[member.orbit for member in members]] + + def names(self, name: str) -> list[list[str]]: + return [[f"{name} {s + 1}" for s in range(int(self.values.satellites))]] + + class Layouts(Layout): """ Several layouts flown together (such as the shells of a mixed @@ -613,16 +890,22 @@ def names(self, name: str) -> list[list[str]]: ] -_KINDS = {WALKER: WalkerLayout, SSO_PLANES: SSOPlanesLayout, PLANES: PlanesLayout} +_KINDS = { + WALKER: WalkerLayout, + SSO_PLANES: SSOPlanesLayout, + PLANES: PlanesLayout, + SOC: SOCLayout, + MOG: MOGLayout, +} """The layouts of the kinds of the fragments of design spaces.""" def layout_of(layout: Any) -> Layout: """ - Gets the layout of the values of a design: those of `walker_space`, - `sso_planes_space`, or `planes_space` (or of a choice of them), or of - several (a list or a repetition of layouts, see `Layouts`). A layout is - its own. + Gets the layout of the values of a design: those of a fragment + (`walker_space`, `sso_planes_space`, `planes_space`, `soc_space`, or + `mog_space`, or of a choice of them), or of several (a list or a + repetition of layouts, see `Layouts`). A layout is its own. Args: layout (Any): The values of the layout (or layouts), or a layout. @@ -643,17 +926,16 @@ def layout_of(layout: Any) -> Layout: if not isinstance(kind, str) or kind not in _KINDS: raise ValueError( "a layout must be the values of walker_space, sso_planes_space, " - + "or planes_space, or a Layout" + + "planes_space, soc_space, or mog_space, or a Layout" ) return _KINDS[kind](layout) def count_satellites(layout: Any) -> int: """ - Counts the satellites of a layout (the values of `walker_space`, - `sso_planes_space`, or `planes_space`, or of a choice of them, or of - several, or a `Layout`, see `layout_of`), for objectives and - constraints. + Counts the satellites of a layout (the values of a fragment such as + `walker_space`, or of a choice of them, or of several, or a `Layout`, + see `layout_of`), for objectives and constraints. Args: layout (Any): The values of the layout (or layouts), or a layout. @@ -666,10 +948,9 @@ def count_satellites(layout: Any) -> int: def count_planes(layout: Any) -> int: """ - Counts the orbit planes of a layout (the values of `walker_space`, - `sso_planes_space`, or `planes_space`, or of a choice of them, or of - several, or a `Layout`, see `layout_of`), each of which needs its own - launch. + Counts the orbit planes of a layout (the values of a fragment such as + `walker_space`, or of a choice of them, or of several, or a `Layout`, + see `layout_of`), each of which needs its own launch. Args: layout (Any): The values of the layout (or layouts), or a layout. @@ -683,8 +964,8 @@ def count_planes(layout: Any) -> int: def plane_sizes(layout: Any) -> list[int]: """ Gets the number of satellites of each orbit plane of a layout (the - values of `walker_space`, `sso_planes_space`, or `planes_space`, or of a - choice of them, or of several, or a `Layout`, see `layout_of`). + values of a fragment such as `walker_space`, or of a choice of them, or + of several, or a `Layout`, see `layout_of`). Args: layout (Any): The values of the layout (or layouts), or a layout. @@ -761,7 +1042,7 @@ def _plane_orbits( anomaly. """ interval = getattr(plane, "interval", None) - count = int(plane.satellites) + count = int(plane.per_plane) if interval is None: return [ make((plane.true_anomaly + 360 * s / count) % 360) for s in range(count) @@ -793,10 +1074,10 @@ def build_constellation( time_step: float | None = None, ) -> list[Satellite]: """ - Builds the satellites of a layout: the values of `walker_space`, - `sso_planes_space`, or `planes_space` in a design (or of a choice of - them), or a `Layout` (see `layout_of`), at the layout's altitude (or the - given one), each with a payload: + Builds the satellites of a layout: the values of a fragment (such as + `walker_space`) in a design (or of a choice of them), or a `Layout` (see + `layout_of`), at the layout's altitude (or the given one), each with a + payload: * an `Instrument` (or a list of instruments); * the identifier of an entry of the instrument catalog (see @@ -808,9 +1089,10 @@ def build_constellation( together (with the attitude of the first); * a function of a name and an orbit that builds a satellite. - Satellites of Walker constellations are named `" "`, and - those of planes `"

-"` (plane `p`, satellite `s`), in the - order of the planes (see `Layout`). + Satellites of Walker and streets-of-coverage constellations and of + mutual orbiting groups are named `" "`, and those of planes + `"

-"` (plane `p`, satellite `s`), in the order of the + planes (see `Layout`). Several layouts (a list or a repetition of layouts, such as the shells of a mixed constellation, see `Layouts`) are built in turn, with the diff --git a/tests/tradespace/test_constellations.py b/tests/tradespace/test_constellations.py index 47269adb..66f82a10 100644 --- a/tests/tradespace/test_constellations.py +++ b/tests/tradespace/test_constellations.py @@ -9,7 +9,13 @@ import numpy as np -from tatc.schemas import CircularOrbit, Instrument, Satellite +from tatc.schemas import ( + CircularOrbit, + Instrument, + MOGConstellation, + Satellite, + SOCConstellation, +) from tatc.tradespace import ( Categorical, Choice, @@ -23,7 +29,9 @@ build_constellation, count_planes, count_satellites, + mog_space, planes_space, + soc_space, sso_planes_space, walker_space, ) @@ -35,7 +43,13 @@ plane_sizes, remove_failures, ) -from tatc.tradespace.constellations import Layouts, SSOPlanesLayout, WalkerLayout +from tatc.tradespace.constellations import ( + Layouts, + MOGLayout, + SOCLayout, + SSOPlanesLayout, + WalkerLayout, +) EPOCH = datetime(2026, 1, 1, tzinfo=timezone.utc) IMAGER = Instrument(name="imager", field_of_regard=60) @@ -52,8 +66,8 @@ def _space(): ), sso=sso_planes_space( crossing=Real(9, 15, step=3), - satellites=Integer(1, 2), - count=Integer(1, 2), + planes=Integer(1, 2), + per_plane=Integer(1, 2), ), ), constraints=[lambda d: count_satellites(d.layout) - 4], @@ -132,8 +146,8 @@ def test_sso(self): space = DesignSpace( layout=sso_planes_space( crossing=13.5, - satellites=4, - count=1, + per_plane=4, + planes=1, phase_fraction=Uncertain.uniform(0, 1), altitude=700e3, ), @@ -155,11 +169,11 @@ def test_sso(self): def test_derived_planes(self): """Plane values may be derived from their index and enclosing values.""" space = DesignSpace( - per_plane=Integer(1, 2), + size=Integer(1, 2), layout=sso_planes_space( crossing=Derived(lambda d: (13.5 + 12 * d.index / d.planes.count) % 24), - satellites=Derived(lambda d: d.per_plane), - count=Integer(1, 3), + planes=Integer(1, 3), + per_plane=Derived(lambda d: d.size), ordered=True, ), ) @@ -167,7 +181,7 @@ def test_derived_planes(self): satellites = build_constellation( design.layout, IMAGER, epoch=EPOCH, altitude=830e3 ) - self.assertEqual(len(satellites), 3 * design.per_plane) + self.assertEqual(len(satellites), 3 * design.size) times = sorted({s.orbit.equator_crossing_time for s in satellites}) self.assertEqual(times, [time(13, 30), time(17, 30), time(21, 30)]) @@ -175,7 +189,7 @@ def test_catalog_payloads(self): """Catalog entries are built with their validated attitude.""" space = DesignSpace( sounder=Categorical(["atms", "cris"]), - layout=sso_planes_space(crossing=13.5, satellites=1, count=1), + layout=sso_planes_space(crossing=13.5, per_plane=1, planes=1), ) design = space.enumerate()[0] satellite = build_constellation( @@ -356,7 +370,7 @@ class TestTrains(unittest.TestCase): def _build(self, **kwargs): space = DesignSpace( - layout=sso_planes_space(crossing=13.5, satellites=3, count=1, **kwargs) + layout=sso_planes_space(crossing=13.5, per_plane=3, planes=1, **kwargs) ) return build_constellation( _single(space).layout, IMAGER, epoch=EPOCH, altitude=700e3 @@ -405,7 +419,7 @@ def test_interval_variable(self): """The interval is a design variable that may be evenly spaced.""" space = DesignSpace( layout=sso_planes_space( - crossing=13.5, satellites=2, count=1, interval=Categorical([None, 5]) + crossing=13.5, per_plane=2, planes=1, interval=Categorical([None, 5]) ) ) designs = space.enumerate() @@ -428,7 +442,7 @@ class TestPlanes(unittest.TestCase): def test_uncertain_nodes(self): """Nodes are uncertain by default, drawn for each replicate.""" space = DesignSpace( - layout=planes_space(inclination=30.0, satellites=2, count=Integer(1, 3)), + layout=planes_space(inclination=30.0, per_plane=2, planes=Integer(1, 3)), constraints=[lambda d: count_satellites(d.layout) <= 4], ) designs = space.enumerate() @@ -453,8 +467,8 @@ def test_designed_nodes_and_trains(self): layout=planes_space( inclination=Real(30, 60, step=30), node=Real(0, 90, step=90), - satellites=2, - count=1, + per_plane=2, + planes=1, interval=5, repeat_ground_track=False, ) @@ -470,6 +484,140 @@ def test_designed_nodes_and_trains(self): self.assertEqual({s.orbit.inclination for s in satellites}, {60}) +class TestStreetsOfCoverage(unittest.TestCase): + """ + Unit tests for streets-of-coverage layouts. + """ + + def test_derived_planes(self): + """The planes and satellites in each are those of the constellation.""" + space = DesignSpace( + layout=soc_space(swath_width=4000e3, inclination=60.0, altitude=700e3) + ) + (design,) = space.enumerate() + soc = SOCConstellation( + name="soc", + orbit=CircularOrbit(altitude=700e3, inclination=60, epoch=EPOCH), + swath_width=4000e3, + packing_distance=1, + ) + self.assertEqual(design.layout.planes, soc.get_number_planes()) + self.assertEqual(design.layout.per_plane, soc.get_satellites_per_plane()) + self.assertIsInstance(layout_of(design.layout), SOCLayout) + satellites = build_constellation(design.layout, IMAGER, epoch=EPOCH) + self.assertEqual(_orbits(satellites), _orbits(soc.generate_members())) + self.assertEqual(satellites[0].name, "satellite 1") + self.assertEqual(count_planes(design.layout), design.layout.planes) + self.assertEqual( + plane_sizes(design.layout), [design.layout.per_plane] * design.layout.planes + ) + + def test_altitude_outside(self): + """The altitude may be decided outside the fragment, before it.""" + space = DesignSpace( + altitude=Real(500e3, 1000e3, step=500e3), + layout=soc_space(swath_width=6000e3, inclination=90.0), + ) + low, high = space.enumerate() + self.assertGreater(count_satellites(low.layout), count_satellites(high.layout)) + satellites = build_constellation( + high.layout, IMAGER, epoch=EPOCH, altitude=high.altitude + ) + self.assertEqual(len(satellites), count_satellites(high.layout)) + # the satellites of the planes derived at another altitude do not fit + with self.assertRaises(ValueError): + build_constellation(high.layout, IMAGER, epoch=EPOCH, altitude=500e3) + + def test_constraints(self): + """Constraints of the fragment limit the satellites it derives.""" + space = DesignSpace( + layout=soc_space( + swath_width=Categorical([4000e3, 6000e3]), + inclination=90.0, + altitude=1000e3, + constraints=[lambda d: d.planes * d.per_plane <= 50], + ) + ) + (design,) = space.enumerate() + self.assertEqual(design.layout.swath_width, 6000e3) + + def test_fractions(self): + """The node of the lead satellite of polar planes is of 360 degrees.""" + for inclination, polar in [(60.0, False), (90.0, True)]: + space = DesignSpace( + layout=soc_space( + swath_width=6000e3, + inclination=inclination, + altitude=1000e3, + phase_fraction=0.5, + node_fraction=0.5, + ) + ) + (design,) = space.enumerate() + layout = design.layout + self.assertAlmostEqual(layout.true_anomaly, 180 / layout.per_plane) + self.assertAlmostEqual( + layout.right_ascension, 180 if polar else 180 / layout.planes + ) + satellites = build_constellation(layout, IMAGER, epoch=EPOCH) + self.assertAlmostEqual( + satellites[0].orbit.right_ascension_ascending_node, + layout.right_ascension, + ) + + +class TestMutualOrbitingGroup(unittest.TestCase): + """ + Unit tests for mutual orbiting groups. + """ + + def test_build(self): + """A group is a single plane of the satellites of the constellation.""" + space = DesignSpace( + layout=mog_space( + parallel_axis=100e3, + transverse_axis=50e3, + inclination=60.0, + node=30.0, + satellites=3, + phase_fraction=0.25, + altitude=500e3, + ) + ) + (design,) = space.enumerate() + self.assertEqual(design.layout.true_anomaly, 90) + self.assertIsInstance(layout_of(design.layout), MOGLayout) + satellites = build_constellation(design.layout, IMAGER, epoch=EPOCH) + mog = MOGConstellation( + name="mog", + orbit=CircularOrbit( + altitude=500e3, + inclination=60, + right_ascension_ascending_node=30, + true_anomaly=90, + epoch=EPOCH, + ), + parallel_axis=100e3, + transverse_axis=50e3, + number_satellites=3, + ) + self.assertEqual( + [s.orbit for s in satellites], [m.orbit for m in mog.generate_members()] + ) + self.assertEqual( + [s.name for s in satellites], ["satellite 1", "satellite 2", "satellite 3"] + ) + self.assertEqual(count_satellites(design.layout), 3) + self.assertEqual(count_planes(design.layout), 1) + + def test_defaults(self): + """By default, the inclination and number of satellites are designed.""" + space = DesignSpace( + layout=mog_space(parallel_axis=100e3, transverse_axis=50e3, altitude=500e3) + ) + self.assertEqual(space.size(), 5 * 5) + + class TestMixedLayouts(unittest.TestCase): """ Unit tests for constellations of several layouts. @@ -482,7 +630,7 @@ def test_list_of_layouts(self): inclination=65.0, planes=1, per_plane=2, relative_spacing=0 ), polar=sso_planes_space( - crossing=13.5, satellites=1, count=2, distinct=False + crossing=13.5, per_plane=1, planes=2, distinct=False ), ) design = _single(space) @@ -503,7 +651,7 @@ def test_repeat_of_choice(self): walker=walker_space( inclination=65.0, planes=1, per_plane=2, relative_spacing=0 ), - sso=sso_planes_space(crossing=13.5, satellites=1, count=1), + sso=sso_planes_space(crossing=13.5, per_plane=1, planes=1), ), count=Integer(1, 2), ) diff --git a/tests/tradespace/test_cost.py b/tests/tradespace/test_cost.py index aa60a84a..580a8fbe 100644 --- a/tests/tradespace/test_cost.py +++ b/tests/tradespace/test_cost.py @@ -89,10 +89,10 @@ def test_layouts(self): """Plane sizes of each layout, and of several.""" walker = _walker(planes=2, per_plane=3) sso = _design( - layout=sso_planes_space(crossing=13.5, satellites=2, count=1) + layout=sso_planes_space(crossing=13.5, per_plane=2, planes=1) ).layout inclined = _design( - layout=planes_space(inclination=30.0, node=0.0, satellites=4, count=2) + layout=planes_space(inclination=30.0, node=0.0, per_plane=4, planes=2) ).layout self.assertEqual(plane_sizes(walker), [3, 3]) self.assertEqual(plane_sizes(sso), [2]) @@ -177,7 +177,7 @@ def test_types(self): small = SatelliteCost(development=10, first_unit=1) model = CostModel({"large": self.satellite, "small": small}) sso = _design( - layout=sso_planes_space(crossing=13.5, satellites=3, count=1) + layout=sso_planes_space(crossing=13.5, per_plane=3, planes=1) ).layout mixed = model.estimate( DeploymentSchedule().plan({"large": _walker(1, 2), "small": sso}) @@ -578,7 +578,7 @@ def test_shared_development(self): } ) sso = _design( - layout=sso_planes_space(crossing=13.5, satellites=3, count=1) + layout=sso_planes_space(crossing=13.5, per_plane=3, planes=1) ).layout mixed = model.estimate( DeploymentSchedule().plan({"a": _walker(1, 2), "b": sso}) @@ -604,7 +604,7 @@ def setUp(self): operations=OperationsCost(per_year=1), ) sso = _design( - layout=sso_planes_space(crossing=13.5, satellites=2, count=1) + layout=sso_planes_space(crossing=13.5, per_plane=2, planes=1) ).layout self.deployment = DeploymentSchedule().plan( {"narrow": _walker(1, 2), "wide": sso} diff --git a/tests/tradespace/test_deployment.py b/tests/tradespace/test_deployment.py index 9cb2342f..905c98e2 100644 --- a/tests/tradespace/test_deployment.py +++ b/tests/tradespace/test_deployment.py @@ -115,7 +115,7 @@ def test_types_and_order(self): """Types are developed over their own durations, planes in an order.""" schedule = DeploymentSchedule(development_years={"new": 5, "heritage": 2}) sso = DesignSpace( - layout=sso_planes_space(crossing=Real(9, 12, step=3), satellites=1, count=2) + layout=sso_planes_space(crossing=Real(9, 12, step=3), per_plane=1, planes=2) ) layout = sso.enumerate()[0].layout deployment = schedule.plan({"new": _walker(1, 2), "heritage": layout}) From 8078f02337872bc7edc5067ef321e7d86702a1d0 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Fri, 13 Nov 2026 23:40:58 -0700 Subject: [PATCH 45/52] review the trade space again: prune only a study's own stale evaluations, fingerprint geometries by content, count availability and annual costs correctly, read design values by path, add the efficient designs to summaries of criteria, give an observation study the mission of a design, describe layouts, and share the logic of deployments, phases, and bootstraps (new modules simulation, dominance, and hashing) --- CHANGELOG.md | 21 +- docs/api_reference/tradespace/define.rst | 4 + docs/api_reference/tradespace/evaluate.rst | 10 +- docs/api_reference/tradespace/index.rst | 25 +- docs/api_reference/tradespace/judge.rst | 9 + docs/api_reference/tradespace/missions.rst | 22 +- docs/api_reference/tradespace/search.rst | 2 +- .../tradespace/CompareScenarios.ipynb | 86 ++- .../tradespace/EvaluateTradeSpace.ipynb | 79 +- .../tradespace/ExplainTradeSpace.ipynb | 70 +- docs/examples/tradespace/PlanDeployment.ipynb | 64 +- .../examples/tradespace/PlanForFailures.ipynb | 162 +++-- .../tradespace/RankUncertainDesigns.ipynb | 131 +++- .../tradespace/SearchTradeSpace.ipynb | 93 ++- .../tradespace/TradeCostAndUtility.ipynb | 155 ++-- .../tradespace/trade_space_example.py | 22 +- src/tatc/tradespace/__init__.py | 6 + src/tatc/tradespace/attribution.py | 50 +- src/tatc/tradespace/cache.py | 83 ++- src/tatc/tradespace/comparison.py | 11 +- src/tatc/tradespace/confirmation.py | 68 +- src/tatc/tradespace/constellations.py | 336 ++++++--- src/tatc/tradespace/cost.py | 110 ++- src/tatc/tradespace/criteria.py | 183 +++-- src/tatc/tradespace/deployment.py | 243 ++++--- src/tatc/tradespace/dominance.py | 109 +++ src/tatc/tradespace/events.py | 13 +- src/tatc/tradespace/failures.py | 25 +- src/tatc/tradespace/fingerprint.py | 100 ++- src/tatc/tradespace/hashing.py | 28 + src/tatc/tradespace/histories.py | 88 +-- src/tatc/tradespace/mission.py | 687 ++++-------------- src/tatc/tradespace/nodes.py | 96 ++- src/tatc/tradespace/observations.py | 350 +++++++-- src/tatc/tradespace/optimization.py | 42 +- src/tatc/tradespace/pareto.py | 224 ++---- src/tatc/tradespace/plotting.py | 82 ++- src/tatc/tradespace/refinement.py | 178 +++-- src/tatc/tradespace/scenarios.py | 41 +- src/tatc/tradespace/screening.py | 12 +- src/tatc/tradespace/simulation.py | 456 ++++++++++++ src/tatc/tradespace/space.py | 162 +++-- src/tatc/tradespace/store.py | 34 +- src/tatc/tradespace/study.py | 299 +++++--- src/tatc/tradespace/values.py | 155 +++- tests/tradespace/test_attribution.py | 48 +- tests/tradespace/test_cache.py | 24 +- tests/tradespace/test_confirmation.py | 11 +- tests/tradespace/test_constellations.py | 110 ++- tests/tradespace/test_cost.py | 45 +- tests/tradespace/test_criteria.py | 53 +- tests/tradespace/test_failures.py | 13 +- tests/tradespace/test_fingerprint.py | 72 +- tests/tradespace/test_layering.py | 2 + tests/tradespace/test_observations.py | 107 +++ tests/tradespace/test_optimization.py | 5 +- tests/tradespace/test_pareto.py | 16 + tests/tradespace/test_plotting.py | 37 +- tests/tradespace/test_scenarios.py | 6 +- tests/tradespace/test_space.py | 164 ++++- tests/tradespace/test_stages.py | 29 +- tests/tradespace/test_store.py | 18 +- 62 files changed, 4077 insertions(+), 1909 deletions(-) create mode 100644 src/tatc/tradespace/dominance.py create mode 100644 src/tatc/tradespace/hashing.py create mode 100644 src/tatc/tradespace/simulation.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 8bbc54e8..93d88c98 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -14,29 +14,30 @@ Added: - Function `generation.generate_points_rotated_lattice`, the points of a Fibonacci lattice in a random orientation: a stratified sample of the sphere (or of a mask), each point uniform by area, whose statistics have about 1.5 to 4 times less variance between replicates of trade studies than those of random points. - Analysis methods of the statistical sufficiency of observations (module `analysis.sufficiency`): `estimate_sampling_error`, the error of estimating the mean of a field over a period from each target's samples, for a field with a standard deviation and an exponential correlation in time (exact, see `sampling_error_variance`), with the effective number of independent samples; `sample_field`, which samples a field (an xarray `DataArray`, such as a nature run) at the time and place of each observation, and `compare_sampled_means`, which measures the sampling error against it; `compute_revisit_statistics`, the quantiles of revisits and the longest gap of each target (including the edges of the period); and `compute_local_time_coverage`, the distribution of samples in local time of day. The decorrelation time of `estimate_sampling_error` may differ between targets. The validation notebook `ValidateSamplingErrorIMERG` compares its predictions with the errors of monthly means of IMERG precipitation sampled by four constellation designs, and the example notebook `AssessSamplingSufficiency` shows the qualities of the methods with a synthetic nature run. `estimate_sampling_error` and `compute_revisit_statistics` compute the statistics of every target at once (the sum of the correlations between pairs of samples by a recursion over their times, and the gaps and their quantiles from the samples in order), with the same results 3 to 12 times faster. - Module `tradespace` (prototype) for trade studies. A `DesignSpace` declares design variables (`Real`, `Integer`, `Categorical`), fixed and `Derived` values, and `Uncertain` parameters (drawn per replicate, not searched), grouped hierarchically with `Choice` (one of several branches) and `Repeat` (a variable number of items, such as orbit planes, optionally unordered). Bounds, derived values, and constraints are callables of the values decided before them. `DesignSpace.enumerate` gives every feasible design (a full factorial design, including variables that exist only in some designs), and `sample` a Latin hypercube or random sample. A `Design` has a `key` from its decisions and `flat` values by path, and `realize` draws a replicate's uncertain parameters, with common random numbers between designs by default. `Study` builds and evaluates designs in replicates into a data frame, in worker processes with `n_jobs` (or on an `executor`; idle workers wait two minutes for more evaluations before they exit), giving the realized design to an evaluation function with a parameter named `design`, recording as infeasible the designs that its functions reject with `Infeasible` or that fail the validation of TAT-C's schemas (other errors, including other `ValueError`s, are raised or recorded as failed), and raising an error for metrics that would replace its status columns or a design's values; `summarize` gives the mean, standard deviation, and standard error of metrics over replicates. - - Class `tradespace.SatelliteCache`, which caches an analysis of single satellites by their content (orbit, instruments, and attitude, not their name, see `get_satellite_key`), in memory or on disk, so that designs that share satellites compute their results once. On disk, results are kept by namespace and by the definition of the function (see `get_definition`); a cache warns if its namespace has results only of other definitions, naming what differs, `SatelliteCache.prune` removes them, and results that cannot be read are computed again. + - Class `tradespace.SatelliteCache`, which caches an analysis of single satellites by their content (orbit, instruments, and attitude, not their name, see `get_satellite_key`), in memory or on disk, so that designs that share satellites compute their results once. On disk, results are kept by namespace and by the definition of the function (see `get_definition`); a cache warns if its namespace has results only of its function with other code, naming what differs, `SatelliteCache.prune` removes the results of other definitions, and results that cannot be read are computed again. - Functions `tradespace.pareto_front`, `pareto_ranks` (both with optional tolerances of objectives, within which designs near the front are efficient), and `hypervolume` (exact) of designs with several objectives to minimize or maximize, and `pareto_probability`, the probability that each design is efficient given the uncertainty of its replicates (a bootstrap that resamples the same replicates for every design). - - Criteria by which designs are judged (`tradespace.Criteria`): objectives to minimize or maximize, requirements (`Requirement`, output constraints that designs meet or violate once evaluated, by an amount relative to the required value or a `scale`), the statistics over replicates that they name (`Mean`, `StandardDeviation`, `StandardError`, `Minimum`, `Maximum`, `Quantile`, and `Probability`, the share of replicates that meet a threshold; other names are means of metrics), tolerances of objectives, and the columns that group the records of an evaluation (`by`, such as a sensor), whose designs are judged separately. `aggregate` gives statistics of each design (and, with criteria, the violations of their requirements), and `summarize` means with their standard deviations and standard errors. `pareto_front`, `pareto_ranks` (which ranks designs that miss requirements after those that meet them), `hypervolume`, `pareto_probability` (which also gives the probability of meeting the requirements), `refine`, `confirm`, `screen`, `optimize_optuna` (a constraint of each trial for each requirement), and `optimize_pymoo` (a constraint for each requirement) take criteria, or a mapping of objectives to their directions. Results with several records of an evaluation that `by` does not separate raise an error rather than being averaged. - - Function `tradespace.refine` (and class `Refinement`), which adds replicates only to the designs whose Pareto efficiency is uncertain, until it is settled, optionally with a tolerance of differences that do not matter (also of `pareto_probability`), and within a `budget` of evaluations (refining the least settled designs first). Designs about a tolerance from the front, which more replicates settle only slowly, are `indifferent` and not refined once their objectives are known to within a share of their tolerances (`precision`, from the standard errors of the objectives that `pareto_probability` gives). `Study.run` evaluates given replicates (`replicates`). + - Criteria by which designs are judged (`tradespace.Criteria`): objectives to minimize or maximize, requirements (`Requirement`, output constraints that designs meet or violate once evaluated, by an amount relative to the required value or a `scale`), the statistics over replicates that they name (`Mean`, `StandardDeviation`, `StandardError`, `Minimum`, `Maximum`, `Quantile`, and `Probability`, the share of replicates that meet a threshold; other names are means of metrics), tolerances of objectives, and the columns that group the records of an evaluation (`by`, such as a sensor), whose designs are judged separately. `aggregate` gives statistics of each design (and, with criteria, the violations of their requirements), and `summarize` means with their standard deviations and standard errors. `pareto_front`, `pareto_ranks` (which ranks designs that miss requirements after those that meet them), `hypervolume`, `pareto_probability` (which also gives the probability of meeting the requirements), `refine`, `confirm`, `screen`, `optimize_optuna` (a constraint of each trial for each requirement), and `optimize_pymoo` (a constraint for each requirement) take criteria, or a mapping of objectives to their directions. Results with several records of an evaluation that `by` does not separate raise an error. + - Function `tradespace.refine` (and class `Refinement`), which adds replicates only to the designs whose Pareto efficiency is uncertain, until it is settled, optionally with a tolerance of differences that do not matter (also of `pareto_probability`), and within a `budget` of evaluations (refining the least settled designs first). Designs about a tolerance from the front, which more replicates settle only slowly, are `indifferent` and not refined once their objectives are known to within a share of their tolerances (`precision`, from the standard errors of the objectives that `pareto_probability` gives). `Study.run` evaluates given replicates (`replicate_indices`). - Class `tradespace.ResultStore`, a persistent store (SQLite) of the evaluations of a study (argument `store` of `Study`), from which a study that is interrupted or extended takes the evaluations stored before (except evaluations that failed and designs that failed validation, which are evaluated again). Workers add each evaluation as it completes, so that an interrupted run loses only the evaluations in progress, and records are kept as JSON (with values such as dates and infinite numbers tagged, so that they are read exactly). Function `tradespace.sensitivity` (and `main_effects`), the share of the variance of metrics explained by each design variable where it is active. Tolerances of objectives may be percentages of their values (such as `"5%"`). `Uncertain.seed` draws a seed of random numbers for each replicate, and `remove_failures` removes the satellites that fail, the same in every design. - - Building blocks of constellations: fragments of design spaces of Walker constellations (`tradespace.walker_space`) and planes of sun-synchronous orbits (`sso_planes_space`, whose planes have different crossing times), `build_constellation`, which builds the satellites of either with instruments or entries of the instrument catalog (with their validated attitudes, and several entries on one satellite), and `count_satellites` and `count_planes`. The phase and node of the lead satellite of a Walker constellation (`phase_fraction` and `node_fraction`, design variables or uncertain parameters) are fractions of the intervals over which they give distinct constellations (`360 / per_plane` degrees of phase, and `360 / planes` degrees of node for a delta configuration or 360 for a star), so that a search does not evaluate the same constellation at several phases or nodes. Planes of inclined orbits (`planes_space`), each with its own inclination and node (uncertain by default, as of satellites launched as secondary payloads). Streets-of-coverage constellations (`soc_space`), whose planes and satellites in each plane the fragment derives from a swath width, inclination, and altitude, and mutual orbiting groups (`mog_space`), launched together as one plane. The fragments name the number of planes `planes` and the satellites in each plane `per_plane` (`sso_planes_space` and `planes_space` previously took `count` and `satellites`). The satellites of the planes of `sso_planes_space` and `planes_space` are evenly spaced, or follow each other in a train at an `interval` (minutes), on the same ground track or in the same plane (`repeat_ground_track`). The phase of each plane (`phase_fraction`, which replaces `phase` of `sso_planes_space`) is a fraction of the interval over which it gives distinct planes (`360 / per_plane` degrees for evenly spaced satellites, 360 for a train), from which each fragment derives the plane's `true_anomaly`, as for the lead satellite of a Walker constellation. `build_constellation`, `count_satellites`, and `count_planes` take several layouts (a list, or a `Repeat` of a `Choice` of layouts), such as the shells of a mixed constellation. The values of each fragment in a design are those of a `Layout` (`layout_of`, with `WalkerLayout`, `SSOPlanesLayout`, `PlanesLayout`, `SOCLayout`, `MOGLayout`, and `Layouts` of several), which gives its `Plane`s and the orbits of their satellites in order; other layouts subclass it and are built, counted (`plane_sizes`), deployed, and costed as the others. + - Building blocks of constellations: fragments of design spaces of Walker constellations (`tradespace.walker_space`) and planes of sun-synchronous orbits (`sso_planes_space`, whose planes have different crossing times), `build_constellation`, which builds the satellites of either with instruments or entries of the instrument catalog (with their validated attitudes, and several entries on one satellite), and `count_satellites` and `count_planes`. The phase and node of the lead satellite of a Walker constellation (`phase_fraction` and `node_fraction`, design variables or uncertain parameters) are fractions of the intervals over which they give distinct constellations (`360 / per_plane` degrees of phase, and `360 / planes` degrees of node for a delta configuration or 360 for a star), so that a search does not evaluate the same constellation at several phases or nodes. Planes of inclined orbits (`planes_space`), each with its own inclination and node (uncertain by default, as of satellites launched as secondary payloads). Streets-of-coverage constellations (`soc_space`), whose planes and satellites in each plane the fragment derives from a swath width, inclination, and altitude, and mutual orbiting groups (`mog_space`), launched together as one plane. The fragments name the number of planes `planes` and the satellites in each plane `per_plane`. The satellites of the planes of `sso_planes_space` and `planes_space` are evenly spaced, or follow each other in a train at an `interval` (minutes), on the same ground track or in the same plane (`repeat_ground_track`). The phase of each plane (`phase_fraction`) is a fraction of the interval over which it gives distinct planes (`360 / per_plane` degrees for evenly spaced satellites, 360 for a train), from which each fragment derives the plane's `true_anomaly`, as for the lead satellite of a Walker constellation. `build_constellation`, `count_satellites`, and `count_planes` take several layouts (a list, or a `Repeat` of a `Choice` of layouts), such as the shells of a mixed constellation. The values of each fragment in a design are those of a `Layout` (`layout_of`, with `WalkerLayout`, `SSOPlanesLayout`, `PlanesLayout`, `SOCLayout`, `MOGLayout`, and `Layouts` of several), which gives its `Plane`s and the orbits of their satellites in order; other layouts subclass it and are built, counted (`plane_sizes`), deployed, and costed as the others. - Function `tradespace.screen` (and class `Screening`), which screens designs with studies of increasing fidelity, keeping whole fronts of the best designs of each stage for the next. - - Searches of design spaces with optional optimizers: `tradespace.optimize_optuna` suggests designs with Optuna trials (`DesignSpace.suggest`, define-by-run over the hierarchical space), and `optimize_pymoo` and `make_pymoo_problem` search the unit hypercube that encodes a design space (`DesignSpace.unit_paths`, `encode`, and `decode`) with pymoo, whose algorithms eliminate the proposals of designs proposed or evaluated before (`distinct`, by design rather than by point of the hypercube, `make_pymoo_problem`'s `duplicates`). Each design is evaluated once, and the designs proposed together are evaluated together, in parallel if the study is. A search returns its results and designs (`Search`), which `refine` and `confirm` refine and confirm as for any study. Constraints of a design space may return the amount of their violation (`Infeasible.violation`), which Optuna's trials record (`set_constraint`) for its constraint-aware samplers, and which is the constraint value of pymoo problems. Optional dependencies `tradespace` (joblib, Optuna, and pymoo). + - Searches of design spaces with optional optimizers: `tradespace.optimize_optuna` suggests designs with Optuna trials (`DesignSpace.suggest`, define-by-run over the hierarchical space), and `optimize_pymoo` and `make_pymoo_problem` search the unit hypercube that encodes a design space (`DesignSpace.unit_paths`, `encode`, and `decode`) with pymoo, whose algorithms eliminate the proposals of designs proposed or evaluated before (`distinct`, by design, `make_pymoo_problem`'s `duplicates`). Each design is evaluated once, and the designs proposed together are evaluated together, in parallel if the study is. A search returns its results and designs (`Search`), which `refine` and `confirm` refine and confirm as for any study. Constraints of a design space may return the amount of their violation (`Infeasible.violation`), which Optuna's trials record (`set_constraint`) for its constraint-aware samplers, and which is the constraint value of pymoo problems. Optional dependencies `tradespace` (joblib, Optuna, and pymoo). - Deployment of constellations (`tradespace.DeploymentSchedule`): from the rates and durations of a study (the mission, the design life, development, and production rate of each type of satellite, its production on a line, and launches at a cadence and capacity, in number or mass, optionally in an order of planes), each design's deployment (`DeploymentSchedule.plan`, a `Deployment` of its `Production`, `Launch`es, and replacements), so that a design of more satellites and planes takes longer to deploy. A sustained constellation (`DeploymentSchedule.sustained`, such as of an operational program over the period of a study) is replaced after the end of the mission as before it, and its costs are those incurred by the end, which count the units in production then by the share produced and later blocks by the share of their development done. A deployment's launches divide the mission into phases of constant sets of operating satellites (`Deployment.phases`), evaluated over the study's representative period from the observations of the full constellation (`evaluate_phases`) and combined over the mission (`summarize_phases`: the time-weighted mean of each metric and the time until it first meets a requirement). - Simulated missions with failures (`Deployment.simulate`, a `MissionHistory` for each replicate, drawn from its seed with common random numbers between designs): lives of satellites whose failure rates vary over the lifecycle (`tradespace.Exponential`, `Weibull`, `Bathtub` of competing causes, and `Piecewise` rates by age, `Lifetime`), failures of launches (`FailureModel`), and a policy that degrades or restores failed satellites (`RestorationPolicy`) by spares in orbit (taking a failed satellite's place after drifting), spares on the ground (launched at the next launch slot), or satellites produced when needed (after procurement, on the production line), optionally replenishing spares and batching restorations in launches. A history gives the phases in which satellites operate (`MissionHistory.phases`), measures of the mission (`MissionHistory.metrics`: failures, restorations, spares used, time to restore, and availability), and, priced by a `CostModel`, the cost of what it produces and launches. Policies are decisions of designs with a fragment of a design space (`policy_space`: whether to restore, spares in orbit and on the ground, and other fields of the policy, without spares that would never be used), and `configure` makes a policy (or a deployment schedule, or another dataclass) from the values of a design. Many histories of a replicate's mission (`Deployment.simulate_many`) share its sample of targets: `evaluate_missions` evaluates them (with their measures and costs) with a cache that evaluates each set of operating satellites once (`PhaseCache`, keyed by the content of the satellites and shared by the histories, policies, and designs of a replicate), and `summarize_missions` gives their means, quantiles (the risk of the mission), and probabilities of meeting requirements, as one record of the replicate. The histories of a replicate are stratified by default (a Latin hypercube over the histories of each satellite's life and each launch, drawn from uniform numbers by `Lifetime.from_uniform`), which estimates the means of missions 3 to 15 times more precisely than independent histories, and means may be estimated with control variates (`summarize_missions(controls=...)`, such as the availability of the mission, whose expected value simulations alone estimate, `Deployment.expected_metrics`). `allocate_histories` recommends the histories of each replicate (and the replicates, for a standard error) from a pilot with independent histories, by the variances between replicates and between histories and their costs (`summarize_missions(spread=True)` gives the standard deviations of the histories). `expected_missions` computes the expected capability and availability of a mission without restoration exactly (the sets of operating satellites by their probabilities, from the survival of each launch group, with planned replacements), without sampling error. Histories may be drawn from stressed failures for importance sampling (`simulate_many(stress=...)`: hazards and launch failures times a factor, each history weighted by its likelihood ratio censored at the end of the mission, `Lifetime.stressed` and `MissionHistory.weight`), which `summarize_missions` weighs in every statistic, with the effective number of histories: the probabilities of rare losses with 30 to 70 times less variance. - Life-cycle costs of deployments for trade studies (`tradespace.CostModel`): the development of each type of satellite, the production of its units on a learning curve (`SatelliteCost`), launches (per launch, or prices per satellite and kg, `LaunchCost`), operations (`OperationsCost`), replacements, and spares in orbit, dated by the deployment for their present value at a discount rate (`CostEstimate.present_value`, metric `cost present`) and annual costs (`CostEstimate.annual`, metric `cost peak annual`), with growth factors for cost risk (such as uncertain parameters, whose quantiles over replicates give the cost at a confidence level). TAT-C does not include cost-estimating relationships: the costs are given by the study. Fingerprints describe dataclasses (such as cost models) by their fields. - - Function `tradespace.confirm` (and class `Confirmation`), which evaluates selected designs (such as a front) with new replicates that played no part in their selection, removing the optimism of the selection (the winner's curse, `Confirmation.optimism`). `ResultStore` keys evaluations by the fingerprint of a study (`Study.fingerprint`, a hash of `Study.definition`, see `get_definition`: its seed, use of common random numbers, design space, and build and evaluation functions, with the data frames they are given described by their content, the version of Python, and the source of the modules of TAT-C and resource files they depend on, found from their imports) and keeps each definition, so that variants of a study share a store without mixing their evaluations, and a study warns of evaluations of the same study with other code (of its functions, of TAT-C, or of Python), which are not reused, naming what differs (`fingerprint.compare_definitions`); `ResultStore.prune` removes them. Changes to TAT-C that a study does not depend on (such as to modules it does not use) keep its results. Namespaces of stores and caches are optional, for what fingerprints cannot see (data that functions read from files, and the code of other modules). `refine` treats designs with fewer than `min_replicates` (5) as uncertain whatever their probability, adds the replicates left to `max_replicates` in a last partial step, and warns if designs remain uncertain without a tolerance. `sensitivity` gives adjusted shares (epsilon squared) by default, without the share that the levels of a variable explain by chance (`adjusted=False` for correlation ratios). + - Function `tradespace.confirm` (and class `Confirmation`), which evaluates selected designs (such as a front) with new replicates that played no part in their selection, removing the optimism of the selection (the winner's curse, `Confirmation.optimism`). `ResultStore` keys evaluations by the fingerprint of a study (`Study.fingerprint`, a hash of `Study.definition`, see `get_definition`: its seed, use of common random numbers, design space, and build and evaluation functions, with the data frames they are given described by their content, the version of Python, and the source of the modules of TAT-C and resource files they depend on, found from their imports) and keeps each definition, so that variants of a study share a store without mixing their evaluations, and a study warns of evaluations of the same study with other code (of its functions, of TAT-C, or of Python), which are not reused, naming what differs (`fingerprint.compare_definitions`); `Study.prune` removes them (and not the evaluations of other studies that share the store). Changes to TAT-C that a study does not depend on (such as to modules it does not use) keep its results. Namespaces of stores and caches are optional, for what fingerprints cannot see (data that functions read from files, and the code of other modules). `refine` treats designs with fewer than `min_replicates` (5) as uncertain whatever their probability, adds the replicates left to `max_replicates` in a last partial step, and warns if designs remain uncertain without a tolerance. `sensitivity` gives adjusted shares (epsilon squared) by default, without the share that the levels of a variable explain by chance (`adjusted=False` for correlation ratios). - The schedule and cost model of a `tradespace.MissionPlan` may be functions of the design (`schedule_of`, `cost_model_of`), which size them by its values with relationships of the study's own, such as the costs of a type of satellite from its payload or the capacity of launches to the design's altitude; launches limited in mass take the masses of the satellites from the cost model (`masses_of`, or the plan's `masses`). The `launch_mass_capacity` of a `DeploymentSchedule` may be a function of a plane (`mass_capacity_of`), for planes at different inclinations. - - The start of the period of `tradespace.Observations` may be a value of the design (`start_of` and `end_of` give a design's period), such as an uncertain epoch drawn for each replicate over the mission, whose observations are cached apart, so that replicates average over the geometry and seasons of the mission that the one window of quasi-static phases misses (as `evaluate_phases` now states). The schedule of deployments states that a design life does not retire a satellite that is not replaced, and simulations that a planned replacement whose launch fails is not flown again. + - The start of the period of `tradespace.Observations` may be a value of the design (`start_of` and `end_of` give a design's period), such as an uncertain epoch drawn for each replicate over the mission, whose observations are cached apart, so that replicates average over the geometry and seasons of the mission that the one window of quasi-static phases misses (see `evaluate_phases`). The schedule of deployments states that a design life does not retire a satellite that is not replaced, and simulations that a planned replacement whose launch fails is not flown again. - Utilities of the metrics of designs (`tradespace.Utility`), for trade spaces of utility against cost: a single-attribute utility of each metric (`LinearUtility`, `ExponentialUtility` of a risk attitude, `PiecewiseUtility`, or any function), combined by weights additively or in Keeney and Raiffa's multiplicative form. A utility is a metric of any statistic (its `Mean` is the expected utility over the replicates, and a utility given as a statistic of `Criteria` is its mean), computed in each replicate, and gives the utility of each row of a data frame (such as a summary of the means of designs). Statistics name the columns they need (`Statistic.columns`). - Staged deployments (`tradespace.Stage`, argument `stages` of `DeploymentSchedule.plan` and `MissionPlan`, which may give the stages of each design): planes that are produced and launched only if a rule decides to, at times during the mission, from what it knows then (`Decision`: the satellites operating, the history so far, and, through the design, its uncertain parameters and scenario), after a lead time and at the next launch slots, and replaced and restored as other planes. Rules may also read the capability of the satellites operating at a decision (`Decision.capability`, the study's metrics of their observations, as of a phase), which the evaluations of an `ObservationStudy` give each deployment (`Deployment.capability`, a `tradespace.Capability` of its satellites, observations, and cached phases, which also caches the phases of studies without failures), such as for a plane deployed only if those in orbit fall short. A stage that is not deployed is neither produced, launched, nor priced; `MissionHistory.stages` gives when each was deployed, and its metrics the `stages deployed`. Exact expectations of missions without restoration (`expected_missions`) need deployments that are not staged, so that studies of staged deployments sample their histories. - Scenarios of studies (argument `scenarios` of `tradespace.Study`): conditions under which designs are compared rather than averaged over, each giving fixed values or uncertain parameters of the design space other values (`Design.realize` takes a `scenario`), so that each design is evaluated in each scenario (recorded as `scenario`, and judged in each with criteria `by` it). Each scenario's evaluations are stored by its values, so that a scenario added later is evaluated alone. Function `tradespace.robustness` gives each design's Pareto trace (the share of scenarios in which it is efficient) and its regret in each scenario (the improvement in every objective it would need to match the scenario's front) and the largest. The metrics of an `ObservationStudy` (and of `PhaseCache`, `evaluate_missions`, and `expected_missions`) are given the realized design if they have a parameter named `design`. - Criteria across the scenarios of a study (`tradespace.Across`, argument `across` of `Criteria`), which judge each design once by its worst or its (weighted) mean statistics over the scenarios (or the groups of another column), so that searches find designs robust to scenarios; a requirement may be met in every scenario while objectives are means. - Function `tradespace.attribute_variance` (and class `Attribution`), which attributes the variance of metrics between the replicates of each design to its uncertain parameters (or groups of them): the share that each causes, alone or with others, and the share that knowing it would remove, with standard errors, by evaluating designs with one parameter drawn as in other replicates and the others held (which works for seeds, whose values do not order outcomes); `Attribution.summary` pools the shares of several designs, and `Attribution.differences` attributes the variance of the differences between pairs of designs, from the same evaluations (parameters that act alike on both cancel, with common random numbers). `Design.realize` and `Study.run` take a `shift`, which draws named parameters as in other replicates (kept apart in a `ResultStore` as a variant of the replicates), and `DesignSpace.uncertain_paths` lists the uncertain parameters. - Structured cost risk (after Maier, Yeakel, and Wendoloski, "Cost Variance Analysis in Constellation Architecture Studies," 2023): growth factors of each type of satellite (by kind, for development, production, and launches, in `CostModel.estimate` and `MissionPlan.growth`), and the costs of types of satellites as sums of their components (`tradespace.Component`, `SatelliteCost.components`), whose growth has a distribution by maturity (such as `tradespace.Triangular`), correlated between components (`CostModel.correlation`). `CostModel.draw` draws the growth of the components from standard normal scores of the components and a common score, which `tradespace.risk_space` declares as uncertain parameters of a design space (named by `MissionPlan.scores`, also of a nested group), so that common random numbers give the designs that share a component the same growth of it; without drawn growth, components cost their expected growth. Types of satellites that share a component (by name) develop it once in a deployment. Production in blocks (`SatelliteCost.block_size`): each block after the first develops its type again (a share of its development, `redevelopment`) before its first unit is produced, and restarts the learning curve; `CostEstimate.blocks` counts the blocks of each type. Function `tradespace.exceedance` gives the probability that a metric of each design exceeds that of each other in the same replicate (such as that one design costs more than another), and `plot_exceedance` plots them as a matrix. The validation notebook `ValidateCostVarianceNSOSA` reproduces the paper's example of two NSOSA constellations that share a configuration. - - Searches with Optuna accept categorical options that depend on earlier decisions (a parameter for each set of options), use TPE with a constant liar in batches by default (which spreads the trials of a batch), and stop after `max_designs` designs evaluated (trials that suggest designs evaluated before are told their objectives without evaluating them again). A design infeasible in some of its replicates violates its feasibility by their share (`Evaluations.infeasibility`), and the first design evaluated in a search is evaluated alone, to check that evaluations give one record each. `Study` records errors of evaluations as infeasible, without storing them, with `errors="record"`. Enumeration walks the items of unordered repetitions in one order only (the same designs, in the same order, four times faster for three sun-synchronous planes), and `DesignSpace.size` counts designs without keeping them. Pareto fronts are found by a vectorized sweep in lexicographic order that compares designs only with the efficient designs before them, and fronts with tolerances by comparing designs only with the efficient designs without tolerances (which dominate every design that any design dominates within the tolerances), in blocks of bounded memory: 20,000 designs in 0.05 s (0.11 s with tolerances) rather than 17 s, and the bootstraps of `pareto_probability` (and so `refine`) about 20 times faster. - - Studies of the observations of constellations (`tradespace.ObservationStudy`): the targets of each replicate (`Targets`, fixed or generated from a seed of the design), the observations of each satellite, cached on disk (`Observations`), the metrics of the observations, and, with a `MissionPlan`, the costs of the deployment and the summaries of its phases or of the histories of its `Failures`. Plots of the results of studies (`plot_designs`, `plot_progress`, and `plot_means`, with matplotlib, now in the `tradespace` extra), and the hypervolume of a search as it proceeds (`hypervolume_progress`). - - The steps of trade studies share their arguments and outcomes: `tradespace.refine(study, criteria, results)`, `confirm(study, criteria, results)` (by default, the front of the results), `screen(studies, criteria, designs)` (with criteria for each stage, in place of a `tolerance` of its own), and `attribute_variance(study, metrics, designs)` take designs as `Design` objects, their keys, or rows of a summary or of results, and `Refinement`, `Confirmation`, `Screening`, and `Search` give their `results`, the `summary` of their designs, and the `designs`. `DesignSpace.designs_of` rebuilds designs from rows of their values, which summaries keep (also those of `pareto_probability`, `confirm`, and `screen`), and `DesignSpace.extend`, `DesignSpace.design(design, **overrides)`, and `Study.replace` make variants of design spaces, designs, and studies. `aggregate` takes criteria, a mapping of objectives, or metrics (as the other functions do), and other `statistics` by name; `pareto_front`, `pareto_ranks`, `hypervolume`, `sensitivity`, and `main_effects` raise an error given the results of a study (a row per replicate) rather than a summary. Studies with a mission plan record the years by which it is `deployed`, and the parts of observation studies that refer to values of designs are typed as a `Reference`. Columns: ` se` (rather than `sem`), ` mission` for the mean over the phases of a mission, ` histories p` and ` histories std` for statistics over the histories of failures, and `pareto_trace` and `max_regret`. Package `tradespace` exports the functions and classes of trade studies; the parts from which they are made (such as `PhaseCache`, `Layout`, `configure`, and the fingerprints) are imported from its modules. + - Searches with Optuna accept categorical options that depend on earlier decisions (a parameter for each set of options), use TPE with a constant liar in batches by default (which spreads the trials of a batch), and stop after `max_designs` designs evaluated (trials that suggest designs evaluated before are told their objectives without evaluating them again). A design infeasible in some of its replicates violates its feasibility by their share (`Evaluations.infeasibility`), and the first design evaluated in a search is evaluated alone, to check that evaluations give one record each. `Study` records errors of evaluations as infeasible, without storing them, with `errors="record"`. Enumeration walks the items of unordered repetitions in one order only, and `DesignSpace.size` counts designs without keeping them. Pareto fronts are found by a vectorized sweep in lexicographic order that compares designs only with the efficient designs before them, and fronts with tolerances by comparing designs only with the efficient designs without tolerances (which dominate every design that any design dominates within the tolerances), in blocks of bounded memory. + - Studies of the observations of constellations (`tradespace.ObservationStudy`): the targets of each replicate (`Targets`, fixed or generated from a seed of the design), the observations of each satellite, cached on disk (`Observations`), the metrics of the observations, and, with a `MissionPlan`, the costs of the deployment and the summaries of its phases or of the histories of its `Failures`. Plots of the results of studies (`plot_designs`, `plot_progress`, and `plot_means`, with matplotlib, in the `tradespace` extra), and the hypervolume of a search as it proceeds (`hypervolume_progress`). + - The steps of trade studies share their arguments and outcomes: `tradespace.refine(study, criteria, results)`, `confirm(study, criteria, results)` (by default, the front of the results), `screen(studies, criteria, designs)` (with criteria for each stage), and `attribute_variance(study, metrics, designs)` take designs as `Design` objects, their keys, or rows of a summary or of results, and `Refinement`, `Confirmation`, `Screening`, and `Search` give their `results`, the `summary` of their designs, and the `designs`. `DesignSpace.designs_of` rebuilds designs from rows of their values, which summaries keep (also those of `pareto_probability`, `confirm`, and `screen`), and `DesignSpace.extend`, `DesignSpace.design(design, **overrides)`, and `Study.replace` make variants of design spaces, designs, and studies. `aggregate` takes criteria, a mapping of objectives, or metrics (as the other functions do), and other `statistics` by name; `pareto_front`, `pareto_ranks`, `hypervolume`, `sensitivity`, and `main_effects` raise an error given the results of a study (a row per replicate) instead of a summary. Studies with a mission plan record the years by which it is `deployed`, and the parts of observation studies that refer to values of designs are typed as a `Reference`. Columns: ` se`, ` mission` for the mean over the phases of a mission, ` histories p` and ` histories std` for statistics over the histories of failures, and `pareto_trace` and `max_regret`. Package `tradespace` exports the functions and classes of trade studies; the parts from which they are made (such as `PhaseCache`, `Layout`, `configure`, and the fingerprints) are imported from its modules. + - Values of `tradespace` designs by the paths of the columns of results (`d["layout.walker.planes"]`, also in the callables of design spaces and in references), choices equal to the names of their branches, and reserved names of children that views and designs give otherwise (such as `values` and `key`). `Repeat` counts may be `Integer`, `Categorical`, `Fixed`, or `Derived`; `DesignSpace.design` checks decisions against their domains; and the constructors of uncertain parameters (with `Uncertain.triangular`) take nominal values and name their distributions. Summaries of criteria give whether each design is efficient (`pareto`, also of `summarize`, which takes criteria, and of `confirm`, `screen`, and searches), designs with a missing objective are not efficient, and `aggregate` takes `statistics` by name. `Study.realize` realizes a design as a study does (in a scenario), and an `ObservationStudy` gives the `deployment_of`, `phases_of`, and `estimate_of` a design as its evaluation plans them. `Study.prune` removes a study's evaluations with other code (and not those of other studies that share its store, `ResultStore.remove`), `Observations.prune` removes the results of its caches with other code, and caches warn of results of other code once, in the main process. Fingerprints describe geometries by their content, ignore docstrings, and describe the functions of a study's own modules (such as one next to a notebook) by their code. `Failures` restore by default, with importance sampling (`stress`), control variates (`controls`), and spreads over the histories. Layouts describe themselves (`Layout.describe`) and are built at their own altitude (the given one is for layouts without one; `soc_space` keeps the altitude its planes are derived at). `plot_designs` colors some designs over the others (`highlight`, `label`, `others`, `front_label`), and `COLORS`, `INK`, and `GRAY` name the colors of plots. Each design confirmed gives its ` optimism`, `robustness` keeps the values of designs, and `Search.summary` keeps the designs the search found feasible. The simulation of missions is in module `simulation`. - Trade space tutorial (`docs/examples/tradespace`): eight notebooks that follow one trade of constellations, each adding one idea to those before it: `EvaluateTradeSpace` (design space, study, and Pareto front), `ExplainTradeSpace` (sampling error, revisits, and sensitivity), `SearchTradeSpace` (hypervolume, screening, and optimizers), `RankUncertainDesigns` (probability of efficiency, refinement, confirmation, and requirements on statistics), `CompareScenarios` (scenarios, regret, and searches across scenarios), `TradeCostAndUtility` (costs with uncertain growth, budgets, and utility), `PlanDeployment` (phases and staging), and `PlanForFailures` (failures, restoration policies, and the attribution of variance). Each notebook defines what it introduces, and imports what earlier notebooks defined from `trade_space_example.py`. - The `RunOSSEMonsoon` example declares its constellation trade as a design space, caches the looks of each satellite, evaluates its replicates in parallel, and finds its Pareto-efficient designs. diff --git a/docs/api_reference/tradespace/define.rst b/docs/api_reference/tradespace/define.rst index 2719b850..ba462f52 100644 --- a/docs/api_reference/tradespace/define.rst +++ b/docs/api_reference/tradespace/define.rst @@ -52,6 +52,10 @@ satellites (see :doc:`missions` for the layouts themselves). .. autofunction:: tatc.tradespace.planes_space +.. autofunction:: tatc.tradespace.soc_space + +.. autofunction:: tatc.tradespace.mog_space + .. autofunction:: tatc.tradespace.policy_space .. autofunction:: tatc.tradespace.build_constellation diff --git a/docs/api_reference/tradespace/evaluate.rst b/docs/api_reference/tradespace/evaluate.rst index 8e1b203c..d7d9cfcb 100644 --- a/docs/api_reference/tradespace/evaluate.rst +++ b/docs/api_reference/tradespace/evaluate.rst @@ -6,7 +6,7 @@ Trade Studies ============= .. autoclass:: tatc.tradespace.Study - :members: run, replace, workers, definition, fingerprint + :members: run, realize, replace, prune, workers, definition, fingerprint Observation Studies =================== @@ -15,10 +15,10 @@ Observation Studies :no-members: .. autoclass:: tatc.tradespace.ObservationStudy - :members: satellites_of, targets_of, observations_of + :members: satellites_of, targets_of, observations_of, deployment_of, phases_of, estimate_of .. autoclass:: tatc.tradespace.Observations - :members: end, start_of, end_of, cache_of, context_of, __call__ + :members: end, start_of, end_of, cache_of, context_of, prune, __call__ .. autoclass:: tatc.tradespace.Targets :members: of, seed_of @@ -37,7 +37,7 @@ Stores of Results ================= .. autoclass:: tatc.tradespace.ResultStore - :members: get, put, define, definition, contexts, prune, clear + :members: get, put, define, definition, contexts, remove, clear Caches of Satellites ==================== @@ -46,7 +46,7 @@ Caches of Satellites :no-members: .. autoclass:: tatc.tradespace.SatelliteCache - :members: get, prune, clear, __call__ + :members: get, prune, clear_memory, folder, __call__ .. autofunction:: tatc.tradespace.cache.get_satellite_key diff --git a/docs/api_reference/tradespace/index.rst b/docs/api_reference/tradespace/index.rst index 0ec8a3ff..3a93e855 100644 --- a/docs/api_reference/tradespace/index.rst +++ b/docs/api_reference/tradespace/index.rst @@ -16,7 +16,7 @@ before:: from tatc.tradespace import ( Criteria, DesignSpace, Integer, ResultStore, Study, Uncertain, - aggregate, confirm, pareto_front, refine, + aggregate, confirm, refine, ) space = DesignSpace(planes=Integer(1, 4), per_plane=Integer(1, 4), seed=Uncertain.seed()) @@ -24,8 +24,8 @@ before:: results = study.run() # a row per design and replicate criteria = Criteria({"satellites": "min", "coverage": "max"}) - summary = aggregate(results, criteria) # a row per design - front = summary[pareto_front(summary, criteria)] + summary = aggregate(results, criteria) # a row per design, with `pareto` + front = summary[summary.pareto] refinement = refine(study, criteria, results) # replicates where efficiency is uncertain confirmation = confirm(study, criteria, refinement.results) # the front, with new replicates @@ -54,8 +54,10 @@ and a scenario), with the key of the design (`design`), the `replicate`, the values of the design by path (see `Design.flat`), whether it is `feasible`, and its metrics. A **summary** has a row per design (and per group of the criteria's `by`): statistics over its replicates, the number of -`replicates`, and the values of the design. Functions take one or the -other: +`replicates`, and the values of the design, and, of criteria, the +`violation` of their requirements, whether the design meets them +(`meets_requirements`), and whether it is efficient (`pareto`). Functions +take one or the other: .. list-table:: :header-rows: 1 @@ -80,7 +82,9 @@ and columns that TAT-C defines are named in snake case: * statistics over the replicates of a design: named by the criteria (such as `"cost p70"` for `Quantile("cost", 0.7)`), the means of metrics by their names, and ` std` and ` se` (by `summarize`, and the - standard error of each objective by `pareto_probability`). + standard error of each objective by `pareto_probability`), and of + confirmed designs, ` selected` (by the replicates that selected + them) and ` optimism`. * statistics within a replicate, over the mission of a design (see `ObservationStudy`): ` mission` (the mean over the phases of the mission), ` time` (when the phases first meet a requirement), and, @@ -95,7 +99,11 @@ Designs and Their Variants Results keep the values of designs, from which `DesignSpace.designs_of` rebuilds them, so that the steps of a study take designs as `Design` -objects, their keys, or rows of a summary or of results:: +objects, their keys, or rows of a summary or of results. A design gives its +values by attribute (`d.layout.planes`) or by the path of a column of the +results (`d["layout.walker.planes"]`, see `Values`), and a study realizes +it as it evaluates it (`Study.realize`, and, of an `ObservationStudy`, +`satellites_of`, `observations_of`, `deployment_of`, and `phases_of`):: confirmation = confirm(study, criteria, results, summary[summary.pareto]) @@ -124,7 +132,8 @@ their evaluations. A namespace of the store identifies only what fingerprints cannot see (such as data that the functions read from files). A study warns if the store has evaluations of the same study with other code (of its functions, of TAT-C, or of Python), which it does not reuse -(`ResultStore.prune` removes them). +(`Study.prune` removes them, and not the evaluations of other studies that +share the store). .. toctree:: :maxdepth: 1 diff --git a/docs/api_reference/tradespace/judge.rst b/docs/api_reference/tradespace/judge.rst index de2a04e6..458ff504 100644 --- a/docs/api_reference/tradespace/judge.rst +++ b/docs/api_reference/tradespace/judge.rst @@ -107,3 +107,12 @@ Plots .. autofunction:: tatc.tradespace.plot_progress .. autofunction:: tatc.tradespace.style_axes + +.. autodata:: tatc.tradespace.plotting.COLORS + :annotation: + +.. autodata:: tatc.tradespace.plotting.INK + :annotation: + +.. autodata:: tatc.tradespace.plotting.GRAY + :annotation: diff --git a/docs/api_reference/tradespace/missions.rst b/docs/api_reference/tradespace/missions.rst index 4ea04db8..2f16d22e 100644 --- a/docs/api_reference/tradespace/missions.rst +++ b/docs/api_reference/tradespace/missions.rst @@ -15,7 +15,7 @@ Constellations :no-members: .. autoclass:: tatc.tradespace.constellations.Layout - :members: planes, orbits, names, satellites, build + :members: planes, orbits, names, describe, satellites, build .. autoclass:: tatc.tradespace.constellations.Plane @@ -27,6 +27,10 @@ Constellations .. autoclass:: tatc.tradespace.constellations.PlanesLayout +.. autoclass:: tatc.tradespace.constellations.SOCLayout + +.. autoclass:: tatc.tradespace.constellations.MOGLayout + .. autoclass:: tatc.tradespace.constellations.Layouts .. autofunction:: tatc.tradespace.constellations.plane_sizes @@ -42,7 +46,7 @@ Deployment :no-members: .. autoclass:: tatc.tradespace.DeploymentSchedule - :members: plan, launches_of, mass_capacity_of + :members: plan, production_years, replacements, per_launch, split, launches_of, mass_capacity_of, design_life_of .. autoclass:: tatc.tradespace.Stage @@ -54,7 +58,7 @@ Deployment .. autoclass:: tatc.tradespace.deployment.Production .. autoclass:: tatc.tradespace.mission.Decision - :members: time, stage, operating, history, deployed, capability + :members: time, since_launch, stage, satellites_operating, history, stages_deployed, capability Failures ======== @@ -91,6 +95,13 @@ Missions .. autoclass:: tatc.tradespace.mission.Phase :members: duration +.. autoclass:: tatc.tradespace.mission.Failure + +.. autoclass:: tatc.tradespace.mission.Restoration + +.. autodata:: tatc.tradespace.mission.PHASE_COLUMNS + :annotation: + .. autofunction:: tatc.tradespace.mission.evaluate_phases .. autofunction:: tatc.tradespace.mission.summarize_phases @@ -102,6 +113,9 @@ Missions :members: at :special-members: __call__ +.. automodule:: tatc.tradespace.simulation + :no-members: + .. automodule:: tatc.tradespace.histories :no-members: @@ -120,7 +134,7 @@ Costs :no-members: .. autoclass:: tatc.tradespace.CostModel - :members: estimate, draw, score_names, discount + :members: estimate, satellite_cost_of, draw, score_names, discount .. autoclass:: tatc.tradespace.SatelliteCost :members: production, blocks, total_development, total_first_unit diff --git a/docs/api_reference/tradespace/search.rst b/docs/api_reference/tradespace/search.rst index 3bcf05d6..b06c50f7 100644 --- a/docs/api_reference/tradespace/search.rst +++ b/docs/api_reference/tradespace/search.rst @@ -39,7 +39,7 @@ Attribution of Variance .. autofunction:: tatc.tradespace.attribute_variance .. autoclass:: tatc.tradespace.attribution.Attribution - :members: summary, differences + :members: results, shares, summary, summary_of, differences, designs Optimizers ========== diff --git a/docs/examples/tradespace/CompareScenarios.ipynb b/docs/examples/tradespace/CompareScenarios.ipynb index ad389acb..b8e3eafd 100644 --- a/docs/examples/tradespace/CompareScenarios.ipynb +++ b/docs/examples/tradespace/CompareScenarios.ipynb @@ -39,7 +39,14 @@ "cell_type": "code", "execution_count": 1, "id": "4c97b966", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:35.251601Z", + "iopub.status.busy": "2026-11-14T06:30:35.251601Z", + "iopub.status.idle": "2026-11-14T06:30:38.321469Z", + "shell.execute_reply": "2026-11-14T06:30:38.320469Z" + } + }, "outputs": [ { "name": "stdout", @@ -84,14 +91,21 @@ "source": [ "## Compare the Fronts of the Scenarios\n", "\n", - "Criteria `by` the scenario judge designs in each field: `aggregate` summarizes each design in each field, and `pareto_front` finds the front of each field. `robustness` gives the share of the fields in which each design is efficient (its **Pareto trace**). The table gives the designs efficient in more than half of the fields:" + "Criteria `by` the scenario judge designs in each field: `aggregate` summarizes each design in each field, with whether it is on the front of the field (`pareto`). `robustness` gives the share of the fields in which each design is efficient (its **Pareto trace**). The table gives the designs efficient in more than half of the fields:" ] }, { "cell_type": "code", "execution_count": 2, "id": "8e021fe5", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:38.322469Z", + "iopub.status.busy": "2026-11-14T06:30:38.322469Z", + "iopub.status.idle": "2026-11-14T06:30:38.563207Z", + "shell.execute_reply": "2026-11-14T06:30:38.563207Z" + } + }, "outputs": [ { "name": "stdout", @@ -162,7 +176,7 @@ " 0.67\n", " \n", " \n", - " c576e2e2dbd1\n", + " d5bff0394d77\n", " 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00\n", " 3.0\n", " 2.0\n", @@ -172,7 +186,7 @@ " 0.67\n", " \n", " \n", - " 3690f1194419\n", + " dfd5eb7d33d2\n", " 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00\n", " 4.0\n", " 2.0\n", @@ -230,8 +244,8 @@ "design \n", "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 \n", "b85daf65c3a4 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... 3.0 \n", - "c576e2e2dbd1 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3.0 \n", - "3690f1194419 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4.0 \n", + "d5bff0394d77 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3.0 \n", + "dfd5eb7d33d2 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4.0 \n", "cb6bd361b577 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 \n", "5529c21520be 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", "de505bc89299 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", @@ -241,8 +255,8 @@ "design \n", "33b006848799 2.0 26.2 34.2 60.4 0.67 \n", "b85daf65c3a4 1.0 8.0 17.0 95.6 0.67 \n", - "c576e2e2dbd1 2.0 40.8 60.6 85.8 0.67 \n", - "3690f1194419 2.0 69.0 85.4 93.0 0.67 \n", + "d5bff0394d77 2.0 40.8 60.6 85.8 0.67 \n", + "dfd5eb7d33d2 2.0 69.0 85.4 93.0 0.67 \n", "cb6bd361b577 4.0 96.6 96.6 97.8 0.67 \n", "5529c21520be 3.0 97.8 97.8 97.8 0.67 \n", "de505bc89299 3.0 97.8 97.8 97.8 0.67 \n", @@ -255,17 +269,20 @@ } ], "source": [ - "from tatc.tradespace import Criteria, aggregate, pareto_front, robustness\n", + "from tatc.tradespace import Criteria, aggregate, robustness\n", "\n", "BY_FIELD = Criteria(ACCURACY, by=\"scenario\")\n", - "by_field = aggregate(fields, BY_FIELD)\n", - "by_field[\"pareto\"] = pareto_front(by_field, BY_FIELD)\n", + "by_field = aggregate(fields, BY_FIELD) # a row per design and field, and whether it is efficient in the field\n", "print(\"efficient designs:\", by_field[by_field.pareto].scenario.value_counts()[list(FIELDS)].to_dict())\n", "\n", "# a row per design: its share accurately sampled in each field, and the share of the fields in which it is efficient\n", "values = by_field.drop_duplicates(\"design\").set_index(\"design\") # the values of each design\n", "traced = pd.DataFrame(\n", - " {\"description\": values.apply(describe, axis=1), \"satellites\": values.satellites, \"planes\": values.planes}\n", + " {\n", + " \"description\": [describe(d) for d in space.designs_of(values)],\n", + " \"satellites\": values.satellites,\n", + " \"planes\": values.planes,\n", + " }\n", ")\n", "traced = traced.join(by_field.pivot(index=\"design\", columns=\"scenario\", values=\"accurate\")[list(FIELDS)])\n", "traced[\"pareto_trace\"] = robustness(fields, ACCURACY).set_index(\"design\")[\"pareto_trace\"]\n", @@ -284,7 +301,14 @@ "cell_type": "code", "execution_count": 3, "id": "8b9e713f", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:38.565404Z", + "iopub.status.busy": "2026-11-14T06:30:38.564395Z", + "iopub.status.idle": "2026-11-14T06:30:39.171554Z", + "shell.execute_reply": "2026-11-14T06:30:39.171554Z" + } + }, "outputs": [ { "data": { @@ -347,7 +371,14 @@ "cell_type": "code", "execution_count": 4, "id": "acf5055d", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:39.173555Z", + "iopub.status.busy": "2026-11-14T06:30:39.172556Z", + "iopub.status.idle": "2026-11-14T06:30:39.421539Z", + "shell.execute_reply": "2026-11-14T06:30:39.421539Z" + } + }, "outputs": [ { "data": { @@ -467,7 +498,7 @@ " {\n", " \"at most\": limit,\n", " **traced.loc[best, [\"description\", \"satellites\", \"planes\"]],\n", - " **regret.loc[best].drop(\"pareto_trace\"),\n", + " **regret.loc[best, [\"max_regret\", *(f\"{field} regret\" for field in FIELDS)]],\n", " }\n", " )\n", "pd.DataFrame(robust).set_index(\"at most\").round(1)" @@ -485,7 +516,14 @@ "cell_type": "code", "execution_count": 5, "id": "ae6ac96b", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:39.423540Z", + "iopub.status.busy": "2026-11-14T06:30:39.423540Z", + "iopub.status.idle": "2026-11-14T06:30:39.609483Z", + "shell.execute_reply": "2026-11-14T06:30:39.608489Z" + } + }, "outputs": [ { "data": { @@ -499,8 +537,7 @@ } ], "source": [ - "from tatc.tradespace import style_axes\n", - "from tatc.tradespace.plotting import COLORS, GRAY\n", + "from tatc.tradespace import COLORS, GRAY, style_axes\n", "\n", "fig, axes = plt.subplots(1, len(robust_design), figsize=(14, 3.6), sharey=True)\n", "for ax, (limit, best) in zip(axes, robust_design.items()):\n", @@ -552,7 +589,14 @@ "cell_type": "code", "execution_count": 6, "id": "2050e0b0", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:39.610483Z", + "iopub.status.busy": "2026-11-14T06:30:39.610483Z", + "iopub.status.idle": "2026-11-14T06:30:40.566392Z", + "shell.execute_reply": "2026-11-14T06:30:40.566392Z" + } + }, "outputs": [ { "name": "stdout", @@ -571,7 +615,7 @@ "FIELD_MEAN = Criteria(ACCURACY, across=Across(rule=\"mean\"))\n", "REFERENCE = {\"satellites\": MAX_SATELLITES + 1, \"planes\": 5, \"accurate\": 0} # worse than every design\n", "mean_summary = aggregate(fields, FIELD_MEAN)\n", - "true_front = set(mean_summary.design[pareto_front(mean_summary, FIELD_MEAN)])\n", + "true_front = set(mean_summary.design[mean_summary.pareto])\n", "true_hypervolume = hypervolume(mean_summary, FIELD_MEAN, REFERENCE)\n", "\n", "search = optimize_pymoo(field_study, FIELD_MEAN, NSGA2(pop_size=20), (\"n_gen\", 10), seed=1) # 200 proposals\n", diff --git a/docs/examples/tradespace/EvaluateTradeSpace.ipynb b/docs/examples/tradespace/EvaluateTradeSpace.ipynb index 2739eecd..f0bd5266 100644 --- a/docs/examples/tradespace/EvaluateTradeSpace.ipynb +++ b/docs/examples/tradespace/EvaluateTradeSpace.ipynb @@ -33,7 +33,14 @@ "cell_type": "code", "execution_count": 1, "id": "bc7b296c", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:29:55.928171Z", + "iopub.status.busy": "2026-11-14T06:29:55.928171Z", + "iopub.status.idle": "2026-11-14T06:29:56.411760Z", + "shell.execute_reply": "2026-11-14T06:29:56.411760Z" + } + }, "outputs": [], "source": [ "from datetime import datetime, timedelta, timezone\n", @@ -72,7 +79,14 @@ "cell_type": "code", "execution_count": 2, "id": "c05d366a", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:29:56.413752Z", + "iopub.status.busy": "2026-11-14T06:29:56.413752Z", + "iopub.status.idle": "2026-11-14T06:29:58.161052Z", + "shell.execute_reply": "2026-11-14T06:29:58.160059Z" + } + }, "outputs": [ { "name": "stdout", @@ -144,7 +158,14 @@ "cell_type": "code", "execution_count": 3, "id": "374124d4", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:29:58.162053Z", + "iopub.status.busy": "2026-11-14T06:29:58.162053Z", + "iopub.status.idle": "2026-11-14T06:29:58.175867Z", + "shell.execute_reply": "2026-11-14T06:29:58.175867Z" + } + }, "outputs": [], "source": [ "import tempfile\n", @@ -201,7 +222,14 @@ "cell_type": "code", "execution_count": 4, "id": "8967e528", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:29:58.176870Z", + "iopub.status.busy": "2026-11-14T06:29:58.176870Z", + "iopub.status.idle": "2026-11-14T06:29:58.784905Z", + "shell.execute_reply": "2026-11-14T06:29:58.783911Z" + } + }, "outputs": [ { "name": "stdout", @@ -335,16 +363,23 @@ "source": [ "## Find the Efficient Designs\n", "\n", - "`summarize` averages the replicates of each design: a row per design, with the mean of each metric and its standard error (`se`, the uncertainty of the mean).\n", + "The objectives are fewer satellites, fewer planes, and more points sufficiently sampled. A design is **Pareto-efficient** if no other design is as good in every objective and better in one.\n", "\n", - "The objectives are fewer satellites, fewer planes, and more points sufficiently sampled. A design is **Pareto-efficient** if no other design is as good in every objective and better in one. `pareto_front` finds the efficient designs, given whether each objective is minimized or maximized. (`describe`, from the module `trade_space_example.py` beside the notebooks, describes each design in a few words.)" + "`summarize` averages the replicates of each design by the objectives, given whether each is minimized or maximized: a row per design, with the mean of each metric, its standard error (`se`, the uncertainty of the mean), and whether the design is efficient (`pareto`). The rows keep the values of the designs, from which `space.designs_of` rebuilds them (and `describe`, from the module `trade_space_example.py` beside the notebooks, describes each in a few words)." ] }, { "cell_type": "code", "execution_count": 5, "id": "9e23a64a", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:29:58.785905Z", + "iopub.status.busy": "2026-11-14T06:29:58.785905Z", + "iopub.status.idle": "2026-11-14T06:29:59.048683Z", + "shell.execute_reply": "2026-11-14T06:29:59.048683Z" + } + }, "outputs": [ { "data": { @@ -462,12 +497,11 @@ ], "source": [ "from trade_space_example import describe\n", - "from tatc.tradespace import pareto_front, summarize\n", + "from tatc.tradespace import summarize\n", "\n", "OBJECTIVES = {\"satellites\": \"min\", \"planes\": \"min\", \"sufficient\": \"max\"}\n", - "summary = summarize(results, list(OBJECTIVES))\n", - "summary[\"pareto\"] = pareto_front(summary, OBJECTIVES)\n", - "summary[\"description\"] = summary.apply(describe, axis=1)\n", + "summary = summarize(results, OBJECTIVES) # a row per design, and whether it is efficient\n", + "summary[\"description\"] = [describe(d) for d in space.designs_of(summary)]\n", "front = summary[summary.pareto].sort_values([\"satellites\", \"planes\"])\n", "front[[\"description\", \"satellites\", \"planes\", \"sufficient\", \"sufficient se\"]].round(1)" ] @@ -484,7 +518,14 @@ "cell_type": "code", "execution_count": 6, "id": "6f877e2d", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:29:59.050685Z", + "iopub.status.busy": "2026-11-14T06:29:59.050685Z", + "iopub.status.idle": "2026-11-14T06:29:59.179938Z", + "shell.execute_reply": "2026-11-14T06:29:59.179938Z" + } + }, "outputs": [ { "data": { @@ -500,8 +541,7 @@ "source": [ "import numpy as np\n", "\n", - "from tatc.tradespace import style_axes\n", - "from tatc.tradespace.plotting import COLORS, INK\n", + "from tatc.tradespace import COLORS, INK, style_axes\n", "\n", "fig, ax = plt.subplots(figsize=(8, 3.8))\n", "for k, row in enumerate(front.itertuples()):\n", @@ -540,7 +580,14 @@ "cell_type": "code", "execution_count": 7, "id": "523cddaa", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:29:59.181946Z", + "iopub.status.busy": "2026-11-14T06:29:59.181946Z", + "iopub.status.idle": "2026-11-14T06:29:59.316707Z", + "shell.execute_reply": "2026-11-14T06:29:59.316707Z" + } + }, "outputs": [ { "data": { @@ -600,7 +647,7 @@ "\n", "* A `DesignSpace` declares the decisions of a trade, with choices between alternatives (`Choice`), constraints, and uncertain parameters (`Uncertain`) drawn for each replicate.\n", "* An `ObservationStudy` builds, observes, and measures each design in replicates, in parallel, with a cache of observations and a store of results.\n", - "* `summarize` averages the replicates of each design, and `pareto_front` and `plot_designs` find and show the efficient designs.\n", + "* `summarize` averages the replicates of each design and finds the efficient designs, which `plot_designs` shows.\n", "\n", "The next notebook, `ExplainTradeSpace`, measures sampling by its purpose and explains why designs differ. The notebooks after it search larger spaces (`SearchTradeSpace`), rank designs with the uncertainty of their replicates (`RankUncertainDesigns`), compare them across scenarios (`CompareScenarios`), trade their cost and utility (`TradeCostAndUtility`), and plan their deployment (`PlanDeployment`) and failures (`PlanForFailures`)." ] diff --git a/docs/examples/tradespace/ExplainTradeSpace.ipynb b/docs/examples/tradespace/ExplainTradeSpace.ipynb index 925abddc..24dc08ab 100644 --- a/docs/examples/tradespace/ExplainTradeSpace.ipynb +++ b/docs/examples/tradespace/ExplainTradeSpace.ipynb @@ -34,7 +34,14 @@ "cell_type": "code", "execution_count": 1, "id": "99a62858", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:01.484827Z", + "iopub.status.busy": "2026-11-14T06:30:01.483826Z", + "iopub.status.idle": "2026-11-14T06:30:04.485515Z", + "shell.execute_reply": "2026-11-14T06:30:04.485515Z" + } + }, "outputs": [], "source": [ "from datetime import timedelta\n", @@ -76,7 +83,7 @@ "accuracy_study = study.replace(metrics=sample)\n", "results = accuracy_study.run(designs)\n", "summary = summarize(results, [\"satellites\", \"planes\", \"sufficient\", \"accurate\"])\n", - "summary[\"description\"] = summary.apply(describe, axis=1)" + "summary[\"description\"] = [describe(d) for d in space.designs_of(summary)]" ] }, { @@ -91,7 +98,14 @@ "cell_type": "code", "execution_count": 2, "id": "7326121b", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:04.487524Z", + "iopub.status.busy": "2026-11-14T06:30:04.487524Z", + "iopub.status.idle": "2026-11-14T06:30:04.626821Z", + "shell.execute_reply": "2026-11-14T06:30:04.625814Z" + } + }, "outputs": [ { "data": { @@ -105,8 +119,7 @@ } ], "source": [ - "from tatc.tradespace import plot_designs, style_axes\n", - "from tatc.tradespace.plotting import GRAY\n", + "from tatc.tradespace import GRAY, plot_designs, style_axes\n", "\n", "fig, ax = plt.subplots(figsize=(6.5, 5))\n", "grouped = summary.assign(plane_group=summary.planes.clip(upper=3)) # 3 or 4 planes share a color\n", @@ -141,7 +154,14 @@ "cell_type": "code", "execution_count": 3, "id": "715976e0", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:04.627821Z", + "iopub.status.busy": "2026-11-14T06:30:04.627821Z", + "iopub.status.idle": "2026-11-14T06:30:04.656132Z", + "shell.execute_reply": "2026-11-14T06:30:04.656132Z" + } + }, "outputs": [ { "data": { @@ -371,7 +391,14 @@ "cell_type": "code", "execution_count": 4, "id": "92827f66", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:04.658636Z", + "iopub.status.busy": "2026-11-14T06:30:04.657133Z", + "iopub.status.idle": "2026-11-14T06:30:04.732051Z", + "shell.execute_reply": "2026-11-14T06:30:04.732051Z" + } + }, "outputs": [ { "data": { @@ -501,7 +528,14 @@ "cell_type": "code", "execution_count": 5, "id": "5555b886", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:04.734047Z", + "iopub.status.busy": "2026-11-14T06:30:04.734047Z", + "iopub.status.idle": "2026-11-14T06:30:04.886501Z", + "shell.execute_reply": "2026-11-14T06:30:04.886501Z" + } + }, "outputs": [ { "data": { @@ -517,7 +551,7 @@ "source": [ "import numpy as np\n", "\n", - "from tatc.tradespace.plotting import COLORS\n", + "from tatc.tradespace import COLORS\n", "\n", "sampled = pd.concat(observed.values()).drop_duplicates(\"target_hash\")\n", "sampled = sampled.assign(latitude=[point.y for point in sampled.geometry]).sort_values(\"latitude\")\n", @@ -562,7 +596,14 @@ "cell_type": "code", "execution_count": 6, "id": "40126ee8", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:04.888488Z", + "iopub.status.busy": "2026-11-14T06:30:04.888488Z", + "iopub.status.idle": "2026-11-14T06:30:04.917370Z", + "shell.execute_reply": "2026-11-14T06:30:04.917370Z" + } + }, "outputs": [ { "data": { @@ -688,7 +729,14 @@ "cell_type": "code", "execution_count": 7, "id": "b1adf213", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:04.919363Z", + "iopub.status.busy": "2026-11-14T06:30:04.919363Z", + "iopub.status.idle": "2026-11-14T06:30:04.992910Z", + "shell.execute_reply": "2026-11-14T06:30:04.992910Z" + } + }, "outputs": [ { "data": { diff --git a/docs/examples/tradespace/PlanDeployment.ipynb b/docs/examples/tradespace/PlanDeployment.ipynb index 6cc4fab0..b601c86e 100644 --- a/docs/examples/tradespace/PlanDeployment.ipynb +++ b/docs/examples/tradespace/PlanDeployment.ipynb @@ -36,7 +36,14 @@ "cell_type": "code", "execution_count": 1, "id": "6bc87f54", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:48.525293Z", + "iopub.status.busy": "2026-11-14T06:30:48.525293Z", + "iopub.status.idle": "2026-11-14T06:30:51.349054Z", + "shell.execute_reply": "2026-11-14T06:30:51.349054Z" + } + }, "outputs": [ { "data": { @@ -82,7 +89,7 @@ " \n", " \n", " \n", - " 163120bf9590\n", + " 8b0cd1e48b0e\n", " 800 km, 60 deg FOR, SSO: 1 at 18:00\n", " 1.0\n", " 1.0\n", @@ -165,7 +172,7 @@ "text/plain": [ " description satellites \\\n", "design \n", - "163120bf9590 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 \n", + "8b0cd1e48b0e 800 km, 60 deg FOR, SSO: 1 at 18:00 1.0 \n", "f7413b1f8466 800 km, 60 deg FOR, Walker 45 deg: 1 x 2 (spac... 2.0 \n", "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 \n", "d5d3fa915ca7 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3.0 \n", @@ -175,7 +182,7 @@ "\n", " planes deployed sufficient sufficient mission \\\n", "design \n", - "163120bf9590 1.0 3.2 3.2 3.2 \n", + "8b0cd1e48b0e 1.0 3.2 3.2 3.2 \n", "f7413b1f8466 1.0 3.5 16.6 16.6 \n", "33b006848799 2.0 3.8 30.2 27.3 \n", "d5d3fa915ca7 1.0 3.8 38.0 38.0 \n", @@ -185,7 +192,7 @@ "\n", " sufficient time lost \n", "design \n", - "163120bf9590 inf 0.0 \n", + "8b0cd1e48b0e inf 0.0 \n", "f7413b1f8466 inf 0.0 \n", "33b006848799 inf 2.9 \n", "d5d3fa915ca7 inf 0.0 \n", @@ -200,11 +207,11 @@ } ], "source": [ - "from trade_space_example import OBJECTIVES, cost_study, describe\n", + "from trade_space_example import OBJECTIVES, cost_study, describe, space\n", "from tatc.tradespace import Requirement, aggregate, pareto_front, summarize\n", "\n", "summary = summarize(cost_study.run(), [\"satellites\", \"planes\", \"sufficient\", \"accurate\"])\n", - "summary[\"description\"] = summary.apply(describe, axis=1)\n", + "summary[\"description\"] = [describe(d) for d in space.designs_of(summary)]\n", "front = summary[pareto_front(summary, OBJECTIVES)]\n", "leaders = front.sort_values(\"sufficient\", ascending=False).drop_duplicates([\"satellites\", \"planes\"])\n", "\n", @@ -222,14 +229,21 @@ "id": "14ec3893", "metadata": {}, "source": [ - "The phases of three of these designs over their missions, from the start of development, for the points of the first replicate (with the schedule of the mission plan, `SCHEDULE.plan`, and `evaluate_phases`):" + "The phases of three of these designs over their missions, from the start of development, for the points of the first replicate (`phases_of` gives the metrics of each phase of a design's planned deployment, as the study evaluates them):" ] }, { "cell_type": "code", "execution_count": 2, "id": "c7af361b", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:51.351053Z", + "iopub.status.busy": "2026-11-14T06:30:51.351053Z", + "iopub.status.idle": "2026-11-14T06:30:51.846335Z", + "shell.execute_reply": "2026-11-14T06:30:51.846335Z" + } + }, "outputs": [ { "data": { @@ -245,20 +259,14 @@ "source": [ "import matplotlib.pyplot as plt\n", "\n", - "from trade_space_example import SCHEDULE, cost_space, planes_name, sample\n", - "from tatc.tradespace import style_axes\n", - "from tatc.tradespace.mission import evaluate_phases\n", - "from tatc.tradespace.plotting import COLORS, GRAY\n", + "from trade_space_example import SCHEDULE, cost_space, planes_name\n", + "from tatc.tradespace import COLORS, GRAY, style_axes\n", "\n", "fig, ax = plt.subplots(figsize=(8, 4))\n", "for color, (satellites, planes) in zip(COLORS, [(4, 1), (4, 2), (6, 2)]):\n", " key = leaders[(leaders.satellites == satellites) & (leaders.planes == planes)].index[0]\n", - " (design,) = cost_space.designs_of(summary[summary.design == key])\n", - " realized = design.realize(0)\n", - " deployment = SCHEDULE.plan(realized.layout, kind=realized.field_of_regard)\n", - " phases = evaluate_phases(\n", - " deployment.phases(cost_study.satellites_of(design)), cost_study.observations_of(design), sample\n", - " )\n", + " (design,) = cost_space.designs_of(summary, [key])\n", + " phases = cost_study.phases_of(design) # the metrics of each phase of the planned deployment, as it evaluates them\n", " edges = [*phases.start, phases.end.iloc[-1]]\n", " ax.stairs(\n", " phases.sufficient,\n", @@ -324,7 +332,14 @@ "cell_type": "code", "execution_count": 3, "id": "eec3e4ab", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:51.848441Z", + "iopub.status.busy": "2026-11-14T06:30:51.848441Z", + "iopub.status.idle": "2026-11-14T06:30:51.891798Z", + "shell.execute_reply": "2026-11-14T06:30:51.891798Z" + } + }, "outputs": [ { "data": { @@ -493,7 +508,14 @@ "cell_type": "code", "execution_count": 4, "id": "37d6f8ba", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:51.893799Z", + "iopub.status.busy": "2026-11-14T06:30:51.893799Z", + "iopub.status.idle": "2026-11-14T06:30:52.078716Z", + "shell.execute_reply": "2026-11-14T06:30:52.078716Z" + } + }, "outputs": [ { "data": { diff --git a/docs/examples/tradespace/PlanForFailures.ipynb b/docs/examples/tradespace/PlanForFailures.ipynb index df25c28e..27d1bfd0 100644 --- a/docs/examples/tradespace/PlanForFailures.ipynb +++ b/docs/examples/tradespace/PlanForFailures.ipynb @@ -33,7 +33,14 @@ "cell_type": "code", "execution_count": 1, "id": "e20ee309", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:54.256305Z", + "iopub.status.busy": "2026-11-14T06:30:54.256305Z", + "iopub.status.idle": "2026-11-14T06:30:56.079832Z", + "shell.execute_reply": "2026-11-14T06:30:56.078839Z" + } + }, "outputs": [ { "name": "stdout", @@ -65,7 +72,14 @@ "cell_type": "code", "execution_count": 2, "id": "7c437e44", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:56.080832Z", + "iopub.status.busy": "2026-11-14T06:30:56.080832Z", + "iopub.status.idle": "2026-11-14T06:30:56.544061Z", + "shell.execute_reply": "2026-11-14T06:30:56.544061Z" + } + }, "outputs": [ { "data": { @@ -82,8 +96,7 @@ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", - "from tatc.tradespace import style_axes\n", - "from tatc.tradespace.plotting import COLORS, GRAY, INK\n", + "from tatc.tradespace import COLORS, GRAY, INK, style_axes\n", "\n", "age = np.linspace(0.02, 10, 500) # years since launch\n", "fig, axes = plt.subplots(1, 2, figsize=(11, 3.6))\n", @@ -125,7 +138,14 @@ "cell_type": "code", "execution_count": 3, "id": "35efa3e2", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:56.546058Z", + "iopub.status.busy": "2026-11-14T06:30:56.546058Z", + "iopub.status.idle": "2026-11-14T06:30:57.552578Z", + "shell.execute_reply": "2026-11-14T06:30:57.552578Z" + } + }, "outputs": [ { "name": "stdout", @@ -136,7 +156,7 @@ } ], "source": [ - "from trade_space_example import ACCURACY, cost_space, cost_study, describe\n", + "from trade_space_example import ACCURACY, cost_space, cost_study, describe, space\n", "from tatc.tradespace import (\n", " Failures,\n", " Integer,\n", @@ -185,7 +205,14 @@ "cell_type": "code", "execution_count": 4, "id": "4c9a47e8", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:57.554592Z", + "iopub.status.busy": "2026-11-14T06:30:57.554592Z", + "iopub.status.idle": "2026-11-14T06:30:57.600152Z", + "shell.execute_reply": "2026-11-14T06:30:57.600152Z" + } + }, "outputs": [ { "data": { @@ -461,7 +488,8 @@ "traded[\"policy\"] = pd.Categorical(traded.apply(describe_policy, axis=1), POLICIES)\n", "traded[\"base\"] = [base_of[key] for key in traded.index]\n", "bases = efficient.set_index(\"design\")\n", - "traded[\"description\"] = bases.loc[traded.base].apply(describe, axis=1).to_numpy()\n", + "described = {d.key: describe(d) for d in space.designs_of(efficient)}\n", + "traded[\"description\"] = traded.base.map(described)\n", "traded[\"full constellation\"] = bases.loc[traded.base, \"accurate\"].to_numpy()\n", "\n", "# four of the designs, with each policy: two satellites in two planes, four in two, six in three, and nine in three\n", @@ -498,7 +526,14 @@ "cell_type": "code", "execution_count": 5, "id": "a41c39e2", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:57.602146Z", + "iopub.status.busy": "2026-11-14T06:30:57.602146Z", + "iopub.status.idle": "2026-11-14T06:30:57.616209Z", + "shell.execute_reply": "2026-11-14T06:30:57.616209Z" + } + }, "outputs": [ { "data": { @@ -538,7 +573,7 @@ " \n", " \n", " \n", - " 2a310c00151b\n", + " c58eba60fcc8\n", " 800 km, 60 deg FOR, SSO: 1 at 12:00\n", " degrade\n", " 3.2\n", @@ -546,7 +581,7 @@ " 110.2\n", " \n", " \n", - " bc2076a0d3d8\n", + " 4098dd5b042f\n", " 800 km, 60 deg FOR, SSO: 2 at 06:00\n", " degrade\n", " 7.0\n", @@ -554,7 +589,7 @@ " 128.9\n", " \n", " \n", - " bb6574900ac3\n", + " bb0be3483708\n", " 800 km, 60 deg FOR, SSO: 1 at 12:00\n", " produce\n", " 3.9\n", @@ -570,7 +605,7 @@ " 146.2\n", " \n", " \n", - " 43f50c8bc38a\n", + " 8aca273a3613\n", " 800 km, 60 deg FOR, SSO: 2 at 06:00\n", " produce\n", " 9.2\n", @@ -594,7 +629,7 @@ " 175.2\n", " \n", " \n", - " eeb7c70a720b\n", + " c8774dd43adf\n", " 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00\n", " produce\n", " 47.3\n", @@ -610,7 +645,7 @@ " 209.5\n", " \n", " \n", - " 6d54bdbf4648\n", + " 669760831f64\n", " 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00\n", " spare on ground\n", " 51.7\n", @@ -618,7 +653,7 @@ " 212.4\n", " \n", " \n", - " 1afde0569e34\n", + " dc951db700b1\n", " 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00\n", " produce\n", " 68.5\n", @@ -626,7 +661,7 @@ " 218.3\n", " \n", " \n", - " e7721a705c31\n", + " 0a25f2a2d87c\n", " 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00\n", " spare on ground\n", " 72.5\n", @@ -680,18 +715,18 @@ "text/plain": [ " description \\\n", "design \n", - "2a310c00151b 800 km, 60 deg FOR, SSO: 1 at 12:00 \n", - "bc2076a0d3d8 800 km, 60 deg FOR, SSO: 2 at 06:00 \n", - "bb6574900ac3 800 km, 60 deg FOR, SSO: 1 at 12:00 \n", + "c58eba60fcc8 800 km, 60 deg FOR, SSO: 1 at 12:00 \n", + "4098dd5b042f 800 km, 60 deg FOR, SSO: 2 at 06:00 \n", + "bb0be3483708 800 km, 60 deg FOR, SSO: 1 at 12:00 \n", "638697713902 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... \n", - "43f50c8bc38a 800 km, 60 deg FOR, SSO: 2 at 06:00 \n", + "8aca273a3613 800 km, 60 deg FOR, SSO: 2 at 06:00 \n", "ad99c42082ab 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", "cc2e14e787ff 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", - "eeb7c70a720b 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 \n", + "c8774dd43adf 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 \n", "3a902b976460 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", - "6d54bdbf4648 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 \n", - "1afde0569e34 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 \n", - "e7721a705c31 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 \n", + "669760831f64 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 \n", + "dc951db700b1 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 \n", + "0a25f2a2d87c 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 \n", "46932f795a5a 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", "6e4564d2ae2c 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", "570a452fdb8f 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", @@ -700,18 +735,18 @@ "\n", " policy accurate accurate p10 cost p70 \n", "design \n", - "2a310c00151b degrade 3.2 0.4 110.2 \n", - "bc2076a0d3d8 degrade 7.0 2.1 128.9 \n", - "bb6574900ac3 produce 3.9 3.5 130.6 \n", + "c58eba60fcc8 degrade 3.2 0.4 110.2 \n", + "4098dd5b042f degrade 7.0 2.1 128.9 \n", + "bb0be3483708 produce 3.9 3.5 130.6 \n", "638697713902 degrade 10.9 4.6 146.2 \n", - "43f50c8bc38a produce 9.2 7.3 153.4 \n", + "8aca273a3613 produce 9.2 7.3 153.4 \n", "ad99c42082ab produce 26.1 19.5 159.4 \n", "cc2e14e787ff spare on ground 28.9 25.6 175.2 \n", - "eeb7c70a720b produce 47.3 38.5 198.1 \n", + "c8774dd43adf produce 47.3 38.5 198.1 \n", "3a902b976460 degrade 64.2 38.9 209.5 \n", - "6d54bdbf4648 spare on ground 51.7 44.9 212.4 \n", - "1afde0569e34 produce 68.5 56.2 218.3 \n", - "e7721a705c31 spare on ground 72.5 62.2 235.4 \n", + "669760831f64 spare on ground 51.7 44.9 212.4 \n", + "dc951db700b1 produce 68.5 56.2 218.3 \n", + "0a25f2a2d87c spare on ground 72.5 62.2 235.4 \n", "46932f795a5a degrade 79.5 69.0 253.5 \n", "6e4564d2ae2c produce 78.0 70.1 278.8 \n", "570a452fdb8f spare on ground 79.6 71.5 294.4 \n", @@ -741,11 +776,18 @@ "cell_type": "code", "execution_count": 6, "id": "58d5e989", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:57.618218Z", + "iopub.status.busy": "2026-11-14T06:30:57.618218Z", + "iopub.status.idle": "2026-11-14T06:30:57.910722Z", + "shell.execute_reply": "2026-11-14T06:30:57.910722Z" + } + }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "

" ] @@ -755,15 +797,16 @@ } ], "source": [ + "from tatc.tradespace import plot_designs\n", + "\n", + "on_front = traded.index.isin(chosen.index)\n", "fig, axes = plt.subplots(1, len(POLICIES), figsize=(16, 3.6), sharex=True, sharey=True)\n", "for ax, policy in zip(axes, POLICIES):\n", - " mine = traded[traded.policy == policy]\n", - " ax.scatter(traded[\"cost p70\"], traded[\"accurate p10\"], s=12, color=GRAY, alpha=0.3, lw=0)\n", - " ax.scatter(mine[\"cost p70\"], mine[\"accurate p10\"], s=22, color=COLORS[0], lw=0)\n", - " on_front = mine[mine.index.isin(chosen.index)]\n", - " ax.scatter(on_front[\"cost p70\"], on_front[\"accurate p10\"], s=70, facecolor=\"none\", edgecolor=INK, lw=1.5)\n", - " ax.set_title(f\"{policy}\\n{len(on_front)} on the front\", fontsize=9)\n", - " ax.set(xlabel=\"Cost at 70% confidence\")\n", + " mine = traded.policy == policy\n", + " # the designs with the policy, over the others in gray, and the front ringed\n", + " plot_designs(traded, \"cost p70\", \"accurate p10\", highlight=mine, front=on_front & mine, legend=None, ax=ax)\n", + " ax.set_title(f\"{policy}\\n{(on_front & mine).sum()} on the front\", fontsize=9)\n", + " ax.set(xlabel=\"Cost at 70% confidence\", ylabel=\"\")\n", " style_axes(ax, grid=\"both\")\n", "axes[0].set_ylabel(\"Accurately sampled (%), worst 10%\")\n", "fig.tight_layout()\n", @@ -794,7 +837,14 @@ "cell_type": "code", "execution_count": 7, "id": "c687c0ed", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:57.912730Z", + "iopub.status.busy": "2026-11-14T06:30:57.912730Z", + "iopub.status.idle": "2026-11-14T06:30:58.160645Z", + "shell.execute_reply": "2026-11-14T06:30:58.159467Z" + } + }, "outputs": [ { "name": "stdout", @@ -905,10 +955,10 @@ "\n", "began = time.perf_counter()\n", "attribution = attribute_variance(\n", - " failure_study, list(ROBUST.values()), failure_space.designs_of(trades, chosen.index), replicates=20\n", + " failure_study, list(ROBUST.values()), failure_space.designs_of(trades, chosen.index), sample_size=20\n", ")\n", "print(f\"{len(attribution.results)} evaluations in {time.perf_counter() - began:.0f} s\")\n", - "attribution.summary().mul(100).round(1)" + "attribution.summary.mul(100).round(1)" ] }, { @@ -923,7 +973,14 @@ "cell_type": "code", "execution_count": 8, "id": "608307dd", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:58.162816Z", + "iopub.status.busy": "2026-11-14T06:30:58.162816Z", + "iopub.status.idle": "2026-11-14T06:30:58.244015Z", + "shell.execute_reply": "2026-11-14T06:30:58.242980Z" + } + }, "outputs": [ { "data": { @@ -947,7 +1004,7 @@ " \"accurate mission histories p10\": \"Accurately sampled,\\nworst 10% of the histories\",\n", " \"cost histories p70\": \"Cost at\\n70% confidence\",\n", "}\n", - "shares = attribution.summary().mul(100)\n", + "shares = attribution.summary.mul(100)\n", "fig, ax = plt.subplots(figsize=(8, 3.8))\n", "x = np.arange(len(LABELS))\n", "for k, (parameter, name) in enumerate(PARAMETERS.items()):\n", @@ -992,7 +1049,14 @@ "cell_type": "code", "execution_count": 9, "id": "d53fe0cc", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:58.245020Z", + "iopub.status.busy": "2026-11-14T06:30:58.245020Z", + "iopub.status.idle": "2026-11-14T06:30:58.507210Z", + "shell.execute_reply": "2026-11-14T06:30:58.506311Z" + } + }, "outputs": [ { "data": { @@ -1091,7 +1155,7 @@ ], "source": [ "ordered = chosen.sort_values(\"cost p70\").index\n", - "attribution.differences(list(zip(ordered, ordered[1:]))).summary().mul(100).round(1)" + "attribution.differences(list(zip(ordered, ordered[1:]))).summary.mul(100).round(1)" ] }, { diff --git a/docs/examples/tradespace/RankUncertainDesigns.ipynb b/docs/examples/tradespace/RankUncertainDesigns.ipynb index 994a0d08..8ef7169c 100644 --- a/docs/examples/tradespace/RankUncertainDesigns.ipynb +++ b/docs/examples/tradespace/RankUncertainDesigns.ipynb @@ -23,7 +23,14 @@ "cell_type": "code", "execution_count": 1, "id": "cc653395", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:14.647890Z", + "iopub.status.busy": "2026-11-14T06:30:14.647890Z", + "iopub.status.idle": "2026-11-14T06:30:17.133649Z", + "shell.execute_reply": "2026-11-14T06:30:17.133649Z" + } + }, "outputs": [ { "name": "stdout", @@ -34,7 +41,7 @@ } ], "source": [ - "from trade_space_example import OBJECTIVES, describe, designs, study\n", + "from trade_space_example import OBJECTIVES, describe, designs, space, study\n", "\n", "results = study.run(designs)\n", "print(f\"{len(results)} evaluations: {len(designs)} designs x {study.replicates} replicates\")" @@ -54,7 +61,14 @@ "cell_type": "code", "execution_count": 2, "id": "4aef9718", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:17.135652Z", + "iopub.status.busy": "2026-11-14T06:30:17.135652Z", + "iopub.status.idle": "2026-11-14T06:30:18.300648Z", + "shell.execute_reply": "2026-11-14T06:30:18.300648Z" + } + }, "outputs": [ { "data": { @@ -270,7 +284,7 @@ "from tatc.tradespace import pareto_probability\n", "\n", "probability = pareto_probability(results, OBJECTIVES, n_resamples=1000)\n", - "probability[\"description\"] = probability.apply(describe, axis=1)\n", + "probability[\"description\"] = [describe(d) for d in space.designs_of(probability)]\n", "candidates = probability[probability.pareto_probability >= 0.1].sort_values([\"satellites\", \"planes\", \"sufficient\"])\n", "candidates[[\"description\", \"satellites\", \"planes\", \"sufficient\", \"pareto\", \"pareto_probability\"]].round(2)" ] @@ -287,7 +301,14 @@ "cell_type": "code", "execution_count": 3, "id": "19cf5721", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:18.302641Z", + "iopub.status.busy": "2026-11-14T06:30:18.302641Z", + "iopub.status.idle": "2026-11-14T06:30:18.721758Z", + "shell.execute_reply": "2026-11-14T06:30:18.721758Z" + } + }, "outputs": [ { "data": { @@ -303,8 +324,7 @@ "source": [ "import matplotlib.pyplot as plt\n", "\n", - "from tatc.tradespace import style_axes\n", - "from tatc.tradespace.plotting import COLORS, GRAY, INK\n", + "from tatc.tradespace import COLORS, GRAY, INK, style_axes\n", "\n", "single = candidates[candidates.satellites == 1].sort_values(\"sufficient\")\n", "fig, ax = plt.subplots(figsize=(8, 3))\n", @@ -351,7 +371,14 @@ "cell_type": "code", "execution_count": 4, "id": "104737eb", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:18.723752Z", + "iopub.status.busy": "2026-11-14T06:30:18.723752Z", + "iopub.status.idle": "2026-11-14T06:30:31.508193Z", + "shell.execute_reply": "2026-11-14T06:30:31.508193Z" + } + }, "outputs": [ { "name": "stdout", @@ -488,7 +515,14 @@ "cell_type": "code", "execution_count": 5, "id": "355e4987", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:31.510201Z", + "iopub.status.busy": "2026-11-14T06:30:31.510201Z", + "iopub.status.idle": "2026-11-14T06:30:31.616745Z", + "shell.execute_reply": "2026-11-14T06:30:31.616745Z" + } + }, "outputs": [ { "name": "stdout", @@ -949,7 +983,7 @@ ], "source": [ "refined = refinement.summary\n", - "refined[\"description\"] = refined.apply(describe, axis=1)\n", + "refined[\"description\"] = [describe(d) for d in space.designs_of(refined)]\n", "print(f\"{refined.pareto.sum()} designs are efficient within the tolerance; the designs refined:\")\n", "refined[refined.replicates > 5].sort_values([\"satellites\", \"planes\", \"sufficient\"])[\n", " [\"description\", \"satellites\", \"planes\", \"sufficient\", \"replicates\", \"pareto\", \"pareto_probability\", \"indifferent\"]\n", @@ -980,13 +1014,27 @@ "cell_type": "code", "execution_count": 6, "id": "807da56f", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:31.618738Z", + "iopub.status.busy": "2026-11-14T06:30:31.618738Z", + "iopub.status.idle": "2026-11-14T06:30:31.708091Z", + "shell.execute_reply": "2026-11-14T06:30:31.708091Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "39 designs confirmed, of which 35 are efficient by the new replicates\n", + "39 designs confirmed, of which 35 are efficient by the new replicates" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", "mean optimism: -0.02 percentage points\n", "mean optimism by number of satellites: {1.0: -0.39, 2.0: 0.85, 3.0: 2.09, 4.0: 2.45, 6.0: -0.18, 8.0: -0.34, 9.0: -0.34}\n" ] @@ -1017,7 +1065,7 @@ " planes\n", " sufficient selected\n", " sufficient\n", - " optimism\n", + " sufficient optimism\n", " pareto\n", " \n", " \n", @@ -1095,13 +1143,13 @@ "19 800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spac... 4.0 1.0 \n", "21 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4.0 2.0 \n", "\n", - " sufficient selected sufficient optimism pareto \n", - "17 16.60 16.15 0.45 True \n", - "20 30.20 28.95 1.25 True \n", - "18 38.00 36.70 1.30 True \n", - "22 38.48 35.60 2.88 False \n", - "19 68.20 66.50 1.70 True \n", - "21 69.60 66.40 3.20 True " + " sufficient selected sufficient sufficient optimism pareto \n", + "17 16.60 16.15 0.45 True \n", + "20 30.20 28.95 1.25 True \n", + "18 38.00 36.70 1.30 True \n", + "22 38.48 35.60 2.88 False \n", + "19 68.20 66.50 1.70 True \n", + "21 69.60 66.40 3.20 True " ] }, "execution_count": 6, @@ -1114,14 +1162,16 @@ "\n", "confirmation = confirm(study, CRITERIA, refinement.results, replicates=20) # 20 new replicates of the front\n", "confirmed = confirmation.summary\n", - "confirmed[\"description\"] = confirmed.apply(describe, axis=1)\n", - "confirmed[\"optimism\"] = confirmed[\"sufficient selected\"] - confirmed[\"sufficient\"]\n", + "confirmed[\"description\"] = [describe(d) for d in space.designs_of(confirmed)]\n", "print(f\"{len(confirmed)} designs confirmed, of which {confirmed.pareto.sum()} are efficient by the new replicates\")\n", - "print(f\"mean optimism: {confirmation.optimism()['sufficient']:.2f} percentage points\")\n", - "print(\"mean optimism by number of satellites:\", confirmed.groupby(\"satellites\").optimism.mean().round(2).to_dict())\n", + "print(f\"mean optimism: {confirmation.optimism['sufficient']:.2f} percentage points\")\n", + "print(\n", + " \"mean optimism by number of satellites:\",\n", + " confirmed.groupby(\"satellites\")[\"sufficient optimism\"].mean().round(2).to_dict(),\n", + ")\n", "# the middle of the front: two to four satellites\n", "confirmed[confirmed.satellites.between(2, 4)].sort_values([\"satellites\", \"planes\"])[\n", - " [\"description\", \"satellites\", \"planes\", \"sufficient selected\", \"sufficient\", \"optimism\", \"pareto\"]\n", + " [\"description\", \"satellites\", \"planes\", \"sufficient selected\", \"sufficient\", \"sufficient optimism\", \"pareto\"]\n", "].round(2)" ] }, @@ -1137,7 +1187,14 @@ "cell_type": "code", "execution_count": 7, "id": "99289e48", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:31.710083Z", + "iopub.status.busy": "2026-11-14T06:30:31.710083Z", + "iopub.status.idle": "2026-11-14T06:30:31.850872Z", + "shell.execute_reply": "2026-11-14T06:30:31.849857Z" + } + }, "outputs": [ { "data": { @@ -1156,7 +1213,7 @@ "positions = {n: k for k, n in enumerate(sorted(confirmed.satellites.unique()))}\n", "x = confirmed.satellites.map(positions).to_numpy() + np.random.default_rng(0).uniform(-0.15, 0.15, len(confirmed))\n", "still = confirmed.pareto.to_numpy(dtype=bool)\n", - "optimism = confirmed.optimism.to_numpy()\n", + "optimism = confirmed[\"sufficient optimism\"].to_numpy()\n", "fig, ax = plt.subplots(figsize=(7.5, 3.6))\n", "ax.axhline(0, color=GRAY, lw=1, ls=\"--\")\n", "ax.scatter(x[still], optimism[still], s=32, color=COLORS[0], lw=0, label=\"efficient by the new replicates\")\n", @@ -1200,7 +1257,14 @@ "cell_type": "code", "execution_count": 8, "id": "419f7f85", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:31.851924Z", + "iopub.status.busy": "2026-11-14T06:30:31.851924Z", + "iopub.status.idle": "2026-11-14T06:30:32.983034Z", + "shell.execute_reply": "2026-11-14T06:30:32.983034Z" + } + }, "outputs": [ { "name": "stdout", @@ -1315,7 +1379,7 @@ " requirements=[Requirement(\"reliability\", \">=\", 0.8)],\n", ")\n", "reliable = pareto_probability(refinement.results, RELIABLE, n_resamples=1000)\n", - "reliable[\"description\"] = reliable.apply(describe, axis=1)\n", + "reliable[\"description\"] = [describe(d) for d in space.designs_of(reliable)]\n", "print(f\"{reliable.meets_requirements.sum()} of {len(reliable)} designs meet the requirement\")\n", "reliable[reliable.pareto_probability >= 0.1].sort_values([\"satellites\", \"planes\"])[\n", " [\"description\", \"satellites\", \"planes\", \"sufficient p20\", \"reliability\", \"replicates\", \"pareto_probability\"]\n", @@ -1334,7 +1398,14 @@ "cell_type": "code", "execution_count": 9, "id": "da41d282", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:32.985035Z", + "iopub.status.busy": "2026-11-14T06:30:32.985035Z", + "iopub.status.idle": "2026-11-14T06:30:33.075455Z", + "shell.execute_reply": "2026-11-14T06:30:33.075455Z" + } + }, "outputs": [ { "data": { diff --git a/docs/examples/tradespace/SearchTradeSpace.ipynb b/docs/examples/tradespace/SearchTradeSpace.ipynb index 92c72fa5..8c151b22 100644 --- a/docs/examples/tradespace/SearchTradeSpace.ipynb +++ b/docs/examples/tradespace/SearchTradeSpace.ipynb @@ -32,7 +32,14 @@ "cell_type": "code", "execution_count": 1, "id": "01692fbc", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:07.178786Z", + "iopub.status.busy": "2026-11-14T06:30:07.178786Z", + "iopub.status.idle": "2026-11-14T06:30:09.702883Z", + "shell.execute_reply": "2026-11-14T06:30:09.702883Z" + } + }, "outputs": [ { "name": "stdout", @@ -44,11 +51,10 @@ ], "source": [ "from trade_space_example import MAX_SATELLITES, OBJECTIVES, designs, space, study\n", - "from tatc.tradespace import hypervolume, pareto_front, summarize\n", + "from tatc.tradespace import hypervolume, summarize\n", "\n", "results = study.run(designs)\n", - "summary = summarize(results, list(OBJECTIVES))\n", - "summary[\"pareto\"] = pareto_front(summary, OBJECTIVES)\n", + "summary = summarize(results, OBJECTIVES)\n", "true_front = set(summary.design[summary.pareto])\n", "REFERENCE = {\"satellites\": MAX_SATELLITES + 1, \"planes\": 5, \"sufficient\": 0} # worse than every design\n", "true_hypervolume = hypervolume(summary, OBJECTIVES, REFERENCE)\n", @@ -71,7 +77,14 @@ "cell_type": "code", "execution_count": 2, "id": "35495471", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:09.704893Z", + "iopub.status.busy": "2026-11-14T06:30:09.704893Z", + "iopub.status.idle": "2026-11-14T06:30:10.213052Z", + "shell.execute_reply": "2026-11-14T06:30:10.212045Z" + } + }, "outputs": [ { "data": { @@ -230,7 +243,14 @@ "cell_type": "code", "execution_count": 3, "id": "01e8217c", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:10.215053Z", + "iopub.status.busy": "2026-11-14T06:30:10.215053Z", + "iopub.status.idle": "2026-11-14T06:30:11.753419Z", + "shell.execute_reply": "2026-11-14T06:30:11.753419Z" + } + }, "outputs": [ { "data": { @@ -325,7 +345,14 @@ "cell_type": "code", "execution_count": 4, "id": "ce572cad", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:11.755419Z", + "iopub.status.busy": "2026-11-14T06:30:11.754420Z", + "iopub.status.idle": "2026-11-14T06:30:12.190220Z", + "shell.execute_reply": "2026-11-14T06:30:12.190220Z" + } + }, "outputs": [ { "data": { @@ -341,8 +368,7 @@ "source": [ "import matplotlib.pyplot as plt\n", "\n", - "from tatc.tradespace import plot_progress\n", - "from tatc.tradespace.plotting import GRAY\n", + "from tatc.tradespace import GRAY, plot_progress\n", "\n", "ax = plot_progress(progress)\n", "ax.axhline(100, color=GRAY, lw=1, ls=\"--\")\n", @@ -365,11 +391,18 @@ "cell_type": "code", "execution_count": 5, "id": "d8c9d612", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:12.191872Z", + "iopub.status.busy": "2026-11-14T06:30:12.191872Z", + "iopub.status.idle": "2026-11-14T06:30:12.467133Z", + "shell.execute_reply": "2026-11-14T06:30:12.466481Z" + } + }, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABW0AAAGGCAYAAAAAW6PhAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQeYU9XWhlfq9F7pIKCCiIIFuyKIBRU7ICqCP/YCVrzXhr1cFUEs1wqCDXtX5NpFwV6QolIHpjC9ZtL+59vxhDOZTM+kfu/zZJJzUmbn5Jz97bX22msZ3G63WwghhBBCCCGEEEIIIYSEBcZQN4AQQgghhBBCCCGEEELITui0JYQQQgghhBBCCCGEkDCCTltCCCGEEEIIIYQQQggJI+i0JYQQQgghhBBCCCGEkDCCTltCCCGEEEIIIYQQQggJI+i0JYQQQgghhBBCCCGEkDCCTltCCCGEEEIIIYQQQggJI+i0JYQQQgghhBBCCCGEkDCCTltCCCGEEEIIIYQQQggJI+i0JSQMWL58uQwZMkScTqdEI4899piccMIJEuk8++yzkp6eHrDP69+/v8ydOzdgn0cIIeFKaWmp5ObmysaNGyUaWb16tfTu3Vtqa2sl0gmkNgVaNwkhkU8g+phoH0Ofe+65ctJJJ0mscMQRR8jMmTMlmrnllltk7733DtjnGQwGeeONNwL2eSR8odOWRARbtmyR6dOnS8+ePcVqtUq/fv3kiiuuUEZgNHRw1157rdxwww1iMpm8Rg7aecwxxzR5XUVFhdr/6aefevd99tlncuSRR0pmZqYkJibK4MGDZerUqdLY2Oh9jdvtlieeeEIOPPBASU1NleTkZNljjz3UMfzzzz+btWfr1q3qOA8bNqxTRpnvNn67H374Qb744osOHhmRO+64Qw466CD13doy/HA+wGjGMcKx0vjyyy/l4IMPlqysLElISJDdd99dHnzwQQk1q1atkvPPPz/UzSCEkG4HffmECROUoQ3gvEVfDUdudXV1k9fCqIFxo7FhwwY588wz1RggPj5e9fP4rDVr1jR53yeffCLHH3+85OTkqNcNHDhQJk6cKJ9//rnfNkEL4uLipLCwsM32a+396aef/G4PHTpUDjjgAHnggQc6fGxee+01GTdunNIo/Wf6smLFCqX3SUlJSssPO+wwqa+vb/Kad999V0aNGqW0LiMjI+RGP47/unXrQtoGQkhoHIctTdpw/EuCQUNDgzqH99xzTzGbzX7PZTwP3fW9wU7WU1BQIGeddZbXlsRnfvfddxJKtm/fLscee2xI20CCA522JOz5+++/Zd9995X169fLCy+8oJyMiNxEdCqckGVlZRLJwKH4119/yamnntpkP8Tl448/VkZoa5E9cOzi+MAo/fXXX2X+/PnK4apF7cJhC2P38ssvl+OOO04++ugj9b6nnnpKGbW3336730HWGWecIVVVVfLtt992+TuiPWjDvHnzOvxeOJ9PP/10ueiii9p87XnnnSfDhw9vth8G7qWXXqqO0R9//KEc5Lj997//lVACxwKc0YQQEs3U1dUpzUEf7Qsctv/5z39afK/dbpejjjpKKisrlXNz7dq18tJLLymDST8598gjj8iYMWOUQYXn8brXX39dTfrNmjXLr/bC4XnaaafJwoULA/I9p02bJo8++qg4HI4OvQ/RuYcccojcc889Lb4GDlvoPZy7K1euVE4P6JrRuHMo/+qrr8rZZ5+t2vHzzz/LV199pbQ3lMC4hWOeEEJiYfyrD5ohoQW2MDQINvDYsWP9vuahhx5Szk/thkAxBELB9tQoLy9XwT8Wi0Xef/99ZUfff//9amI0lOTn56uJZxIDuAkJc4455hh379693XV1dU32b9++3Z2YmOi+8MILvfv69evnvvXWW92TJk1Sz/Xs2dP98MMPN3kep712wzaYOnWqe8KECU0+/4orrnAffvjh3m08vuyyy9zXXHONOyMjw52Xl+e++eabm7zn/vvvdw8bNkz9b7T5oosucldXV7f6/S655BL3aaed1mTfM888405LS3PPmDHDvf/++3v3l5eXq3Z/8sknavvBBx909+/fv9XPf+GFF9R73nzzTb/Pu1yuZtu77LKL+4MPPnBfd911qg1tobW3pW3w2Wefua1Wa7Pfsb34+0w9jzzyiPqNli9frr4vjlVrnHzyye6zzjqrzf/Zp08fd0JCgvukk05y/+c//2nWhjfeeMM9YsQId1xcnHvAgAHuW265xW23273HEucIPgPfvUePHuoc0sD5h99Q448//nAffPDB6rOGDBniXrZsmfour7/+unp+w4YNavvVV191H3HEEapdw4cPd3/99dfez9i4caP7+OOPd6enp6vzcOjQoe5333231e9JCAkv0JdBG3BLTU11Z2VluW+44QZvfz1nzhz3Hnvs0ex9e+21l3qdXtfuuOMOd25uruq78D70T1dffbXSsV69ermffvrpJp/xyy+/uEePHu2Oj493Z2ZmKg3Q65jT6VSfg/eiX8P/fP/991v9PkuXLnXn5OQ02af1Z9DU5ORkd1FRUZPvoenrjz/+qF6Hvq0lNm3a5LZYLO5Zs2a1S+fAueee6549e7Zq+6677tpq+/XtRXv8bQObzab6748//rjNz2vP/9AzatQo72/rD/yu+E2efPLJDv1PHHdoBn5vjCcWL17cTJugp+edd547OzvbnZKSos6Pn376yfs8HkOT8Dvi+ZEjR7pXrVrVonbfdttt6nzA6/G5GGvgN9fQzt377rvPnZ+fr87Diy++2N3Y2Oh9zYIFC9yDBg1Sxxvn96mnntqh700IaRt/9lF77R7YKnqbCzetX/ftY/DcE088ocbaGNvi2m7JbtHAZ0Dfpk2bpvoSjLUff/xx7/Pop6CheoqLi5VWaH10W3Zje/o/fCf0X2g/+lCDweB93/nnn6/6J/RT0Oy33367yXv04Hhodqn+2MOu0P73BRdcoHRGr8d33nmn+r/ow2ETQG9bo7W+E3oIOwR9Nvrd8ePHu//8889mGvXSSy+5DznkEPU/9913X/fatWvdK1eudO+zzz7upKQkZbvjWHfku2DcA9tbo6GhwX3VVVep3wS/Dexhzf7tjnNZAzYXfkP9mAMahe/bUe666y51jHF+Tp8+vZnWAZw3u+++u/o9dtttN/X7aOD44ByGDuL5vn37qt9bQ28jgq+++kp9Pl6L3wLP6ccU2jWJ8x/P41o78MAD3WvWrGmXnpPQwUhbEtYgivbDDz+Uiy++WM2U+c4uTZkyRUXUePotD/fdd5/stdde8uOPP8rs2bNVCoBly5ap5xCZAp555hk1m6ZttxdE4yBqE9Gn9957r9x6663ezwaIeEE06e+//65e+7///U+lPmgNpAxApKw/sDwU0bOvvPKK3+dxDPA9Wlr6CRCdvNtuu8mJJ57o93ksAdGDyF5ERWFGEstAXnzxxYDk6MN3RPSRPnIX+YuwLKWrYMYTv8WiRYuaRB21BM6Nr7/+Wg4//PAWX4N2IioMkUxYqjp69OhmUcn47c455xx1jqENjz/+uIpSxjJgLeoJaRiwH5HiSMuB6LCWZoOxbAeRB/jfiAL+97//7fe12H/11Verdu26664yefJkb2TXJZdcIjabzRt5jcgtpMMghEQW0BCsuEBUJSJBsOz+ySef9KacwaoBvYahX/vll19UlKUGNGjbtm2qP8D7b775ZpU+ANEh6GcuvPBCueCCC1RKHIC+/uijj1bP47OXLl2qVnygH9RAWxBhguhY/D+8HvqCPq4l0Ffus88+fp9D/zVo0CDVh7cUkYV+HTrYUt539LWIyG1Jb311DtG9+G7QOC2KtzPpe/ytKkFqB/1nQce1lBCdpbi4WP1eiFhF5HBeXp7SL0QLayAFEZZv4liNGDFCevTooZZN/vbbb61+NjQYkUXQfhxjRCzj/+lBxBH2IcLo+++/l5EjR6qoZm2lE8ZiSFmBcwbPY+yFiCR/LFmyRGkktAmv7du3r4pO9gXtwSok3ONagLbiBrAkFZFTOGcQUf3BBx+oVBGEkODSmt2Dvgo5Z5HKRYtixNi1JebMmaNW+UFXsDIQ/UpbqymhRbAvoH+wFbEqD30C+L//+z95/vnn1ZhYY/HixdKrVy+VZqY9dmN7+j+AVaDQIawGwdjc5XKp/herHfA/YSPcfffd3jR47QWrSqH1SIsHew6fj+OkcddddynbBytQ8RtgVQl0Danz/NFW34kxwJVXXqleh/+N3/fkk09W30cPxhJYsQjdwTgFKzrwu2N8AP3D8bjppps69F18wbgDK0xgh+KcwO+A1Sb6sQa0XdOFQIFVQbCBkYpR46233lLnGdoAHYbGIu1ga7z88stK/++88051PKHJ0FdfPcRxgibi2OC1N954o3f1D64t/G98Fn4vvL6l8QRWx6J+DOxM/C633XabXHfddS3akbh20C78fhhTanREz0kQCaHDmJA2+eabb5rNIul54IEH1PNahA5mKDG7p2fixInuY4891rvt7/PaG2nrO8u23377qVmzlsBsJyKkWgOzmYsWLWqyTx+ZgkggRAEhisY30tbhcKhoIezDLBxmqOfPn++urKz0fhZm70488cRm3w0zobghMkfPmWee6Z45c6Z3GzN2aE9XI20BIrueffZZ7/bZZ5+tvl97aOkzMROLmeXnnnuuySyiv0hbLTLMaDSqmfXWmDx5svu4445rdi7p2zBmzJgmM54A7UBErRaBgN9OHx2kRx9pgNlts9msIsg1Woq01UdS/f7772ofonTBnnvuqWayCSGRC/QG0fb6CFFoDfZpQNcQ1aSBKH5ER+h1DX0MInE0EMVx6KGHerehIdABrMgA//3vf1U/XVNT430NIvXRZxYWFqptRL0guslXCxEJ2RLQV0SZtBRVipUdiH7SInr0kbYAkU+ItNGinNB///XXX97nseIGEcl6XnnlFa/O4YYIYg18z7333ruJJuJ4dTXSVlvFAV3WgCYfeeSRrX52S/9DY8WKFWo/Ip8QGf3DDz8onYaerVu3rsmqGkTi4Lt/9913SscwBiktLfX7/xAdhfcgQkoDWoJ9mjZ98cUX6thCa/UMHDjQG9WG30Wv7a1pNyKGfaPfENnlG2mLcxfnp8bpp5+uNBhgtQnaVFVV1eYxJYS4uz06sSW7p6Wxu79IW/1KAmgQ9rW2igOfoV8xB71EVOOjjz6qtuvr65WeISpUA/aCfozclt3Ynv4PWgX90keWfvjhh0o30cf6o72Rtujza2trvfvw3RABCV1Hm6CL+tV2AFHB6Pv90dG+s6SkRP0Ov/76a4t2iKY9WOmojzDFeKO938U30harZ0wmk7ugoKBJe2B3XX/99d5t/I/XXnstYOcy/h/+r/6cAYhcxQ3/G/qL3x5Rxi3pHkAEq++4CPqn/91xHj3//PPNVqLgvdq4DuMHf6uFgN5GxPHEtYfzXh/F21KkrX6Mh33a+1rTcxI6GGlLIgJ9JG1bIM+t7zZmrwKBb75UzJrpI1IQkYTZV8zipqSkqNxyKI6FyNWWQE495JZtCcySlZSUyNNPP93sOczYImoYUVKI/MX/xSwdkqdjRrslMMOGmWDM7tXU1Hj3Iz8gZj4xS6uBx5h11EDUpnZDlFZHQLS0/lhgdhizxF3h+uuvlyFDhjRpc0tg9hezipiRxuw/ZnpbAucMirm0dm4hZyBmq/XHZMaMGerY43tiRha/7y677KL2I79iS7kOMYPap08fFT2tsf/++7d5HuIcBNp5iBl0RAQj9xJmwjE7TQiJPFDUSh8hiv4HESZatCn6FPRhKLSBHHqIKNJHSwBogX71ASI09dH+0BDkgNX6D/R7iDjCihIN9CWIskEfhUgORO5inx5st6azbekconWR0xURJv7ACgIUC0OUCY4DomTx3fTRUL7RtPhM6BwKcyF6SB+lCz311Tl8plYQDRFSWp/uW4ykozqHaCFEGHUFLcoJUdGIpEaUD1ZxYBWNNjbQXgN9R458RDZjfIDjgu/mD/xmiLLRR0GjOJu+cBB0DuMEnCd6rUNxOETCAkRmIaoN0UmIJtP2+wPnka+2+dM6HHd9VJp+vIXoaERBQVsxzsJ50do4ixDSPXTG7mkJ/dhWK7boG/Xf2nvQ12EMrb0HmoP2aH0kog+x8sB3hV9rdmN7+j+A/girQjSgPYhWxGq4rgA91uf+RdvQHqyOQDQrjjP6Q33bYFu11Ae31XdijIHVL3gex1+L6ty8eXOLxx3jCqAfW2Cf72/X2nfxBSsFodk4fvrvhghi/XdDMVJEAgcKRLhC/3wLlkFfEWENGxv6iyJ6GIPBnuysHYlxCb4LVnXqvyNsOO074lzFuQSth32HujStaSt+F/1YqzN2ZEf0nAQPOm1JWIMlkxDhloxB7McyTr1QdgYYtb6OYSy19MV3eQDaphlKqCSNZafoCLFEBksKFixY0GZS+uzsbJXgvCUgHnBMYglJS4MgDJYgvg8//LBaHgMjXhOSwYMHe5cKaeB44dj6FgeB0Y/3QmRgyOEGpzGWYGrVnyEe2q2l5awtgaVEXf2tfMFSLBikWnsxeNSOK5yWegYMGKAGFRBaLCHSVyfvDBhs4HfRHxMMNDDogWjCCYtjj+UwMOSxdAvLkPydWx1Bfx5qjgrtPITQongfzge0Bct5UJyOEBJdYBkcClBgMujtt99W/QqKarWlWa3pWHfRls4BGAdId4Qlqv6AQwDfGcsIYUgfeuih3pQ10DmkOIBjVwPGD3ROv8QRYJnqN998o5ZyaroBBzn0FcswAdJQaH36e++9F3Kd04yqoUOHNtmPCUvNmPb3GpwfML59De6O6hw+W69zuEHbrrnmGvUaaCnGHuPHj1eajDbgvOwKrZ2nOBfggMGkBdqGCWg4BPSF6Qgh3Utn7Z6W6Iw2tfUejIkxuYfgFkxiIS2CryZ0tf8D+olO4JvSr7N2Z1ttA5iY1LcNGtdSWr22+k5oLDQMS/+RkkdLaef7e/qzQ3z3dWVcge+GSTucU/rvBrsfKRi6A/wecPDDfkKqIz04Vq3pb2fQfj8ca/13xMQCxigAjmJMECDVASa/kT7Ed5wXaDuyO/ScdB06bUlYg5lNzArC6YXOSo8WdTNx4sQmETZaR6ffRseq76h88+LBwPKNTEXH2REgLOjwkCMGBiBmBxGR1BaYsYPAtsZll12mBL49QgUnNsRFy0OLGVMMLt58880234uI2quuuqqJeGjGsTZTDSNYu3WkIjRm6uAQxvcNJBgooo1ae7Wcj4iqRXRWS+C30ue58gXnjD7/rr9zC2KKY6s/JtpNi27DwA2DIOQlQh4n5GeCM9UXzKJitrmoqMi7r6M5lzXgLEYUNKKm8Xu2lXeJEBJ++Ot/4JzUog/hbJw6daoyRHGbNGlSm4ZiW6DfQ3+qz2OOnHzoz9BHIfKmZ8+eap8ebPsaNB3VOUSEnHLKKSp/WltA8xERqrUTRgy0HXlS26NzmDzT6wZuiC7RVpVgIlTryzti4AMYXIHWOUQ74bj7TsBiMlVrH6Jl4aTVvwZOADhWWvoOOIZY/YHxiwber3d+Qucw3sL55qtzcMZrYMyDyVBEAuF3xDnpD5xHvtrWGa1DexAJhFVGWFGC7wkDkxASHNpj98D51VIu8mCAQA0EL2Ac7G81Slt2Y3v7P1/gyIajWAt48QV2Jz5X77j1Z3dCp/T2L9qGCUmM86G56PPhOPRtG57vaN+JCGn0/8hViwAYHIO2Jls7QmvfxRdoKM4bRH/6fjf9isRAgiheRC8j8tUXrCZqTX87Y0ciGhm6jkAb3++IICMNjLvg68A5jIlt2L3+cj1DW2Ff6m3bztqR7dVzEjzMQfxfhHQKRI8imT2WOiKqBh0ZZoAwwwnDSiv6pDceIURY2oDZVURhYhZSb/xgqSI6YIgdnJyYeUUieiwpwdIFJI3vqOGFThYGEqIa4aRDO1pbNqGB76UlHG8JRG0iotPXCYkCVxB5LA0ZOHCgcoriO+D4aNGVMOThvMM9Inbx/yAUmzZtUp2/5gDA52D2FY5wGHJ64PhFVC2OP8S+M8CJiogftFMDRbzwG7aWIgGDEYgT7iHg2qAGxxtir/88sGPHDq9Yaks8MfOPYifa90JRHhTRwVKTlsBzOEfwugkTJqiCeEjYrwcz1IgywGfDaQDHBgYlOHdwrJAcH21G5DKWBOG8glPFn8hjcgLfBU4YnL9YpouBk79lv60xc+ZMtbQXgovBFoq46CctCCGRAfo8OBKxJB59M/p0GMd6EEWkXd++jtTOgAIUWKGAfgjRFkjNg0lDRJ5oSyChvXgN+isU3cJgHv0ytKMloDvQH/RJ0NyWgJ5jWbxeZ/DZ+H9oA4xUOAFgXGEiUSuygT4YxwYFZKAXWFKIsQIeo98F0Dpo9HPPPaf0bNiwYc2OJYq1QT87mhJBA8YvioHBINaPYRCl0lqKBE3jNIeHZhzCOMUNGqAdd0RF4bhj3ICloVpEFQw7TNbhNTCCoTMY1wCk6vEHjDwUdsE5hmJgOO7QEL3zH98F4yKMqaBNmmMG4yqMPXCs0DZoII45HBUwFJGiwR84n7DaBY4UjO0wDoHjAOOD9vLOO+8oQxfOd5xPiIaG8wjfhxASWLCKwdehiKCa9tg9sLkQUYj+T1ser18iHwzQtyNNDaJh/S2lb81ubKv/a6mQNApFon9CPwhdwbFCf42+HH0uCjFDX/GZ6DthX6DQGfpxPYhwhRMR9gD0Bf07vgvsDUTNorAbnGvo/5BiCL8Vvg8+Bzrekb4T2/hdUQgZwT/QpPZMoraX1r6LLzjOGI/AToS2wx7H8cJ5BIc4okAB7DrYkK2lSMCEMf43dBa2lXYuQ0f1YNIW9prv2ADgGEOvkB4B0a4oEIvjhFtLYDyCsQjOEdiTGCNhfKHXOtj2sDfT0tLUeQGHK9L4YayE8R/OHfwW+P44Tjg3MSbQpzDSQDE4pEdC6gb8bvj9YMN2xI6EU70jek6CSAjz6RLSbjZu3KgSiOfl5alk73369FHJuXfs2NHkdUjgPmfOHFWwAsnZUZzroYceavKat956yz1o0CBV9Emf8P2mm25Sn4+E+bNmzXJfeumlzQqRaQnSNZDQXF+8BIXRUIQqISHBffTRR6sCYy0VxdJAgRAkM1+zZk2riftRkGPo0KFNCpEhGTqS8A8YMEAlSEcC8sMOO0x9Rz1I8v7YY4+pBOgoyILiJbvssot7xowZ7tWrV6vX4Pvi8/2B4lhIqP/mm292uhDZuHHjVGJ6PTimbRV/wfP4zr437Rj44q8Q2bx589x77LGHOieQgH/EiBHuRx55pEmBHn889dRT7t69e6vf84QTTnD/5z//afa9UEDnoIMOUq/BZ++///6qyA1Acngcc+zHcT/ggAOaJH/3LcSAAjAoyILfBwXk3n77bfVd8D9aKlLjW5wOvyMS2+N8yMnJUcXefK8TQkh4g74RBSy0AlsopvKvf/3LbzEKFBZD/9aeohv+dMy3H0LBLhT7gi6hcAh0orq62vs8+k0UckFhR+gximq0VixGA30jdKitolvnn3++2q8VIkMhlMsvv9w9bNgwVbQERTJQcBH9sW8fjuKNKCCDdkPjoeko0Kn1oSjQpS+q5gsKvUH/O1uIDIUpof168D30Yw1/QDP96Zy+GBuAhkKToGUoVIIiOXpQ9PKqq65SxXhwnMaOHev+7bffWv3f0Pfx48crzUARM4xbfM8JFK3BmAtF6LQx2JQpU9ybN29222w296RJk9Q+aBdeAx3Sipr4Gw+gkFx2drb6PVGgDr8v9LG9xWHxvfEY1wW0F8WFfAvHEEK6TktjcBS7aq/dAx2DfaLv0/wVIvMtEo1+o7VCyL6f4a+IJYB+oc/0VyyzPXZja/1fS0XFNPtu2rRp6rtDT6Fh77zzjvd5FI7CZ8E+OOecc1SBT99CZOgHYZ/iM9BfQo/1RdEwJpg7d64qyIW2YdyP3+Gzzz7ze8za6juhodBB6AGe+/TTT/0WRNbrnj+7y7ffb8938R2fQM/w+v79+6vvhvMMhT71RUXxf9sqlo1j6u8c1lNRUaGOh2a/+QM2GX5DHBvYaK29VgO/qaZ1OAbXXntts3NlyZIlqjAq9BO/C+x4rbiaVjQV5wjGgijEBtu/pevmq6++Ur8bPmufffZRRc7wGs3H4O+3wm+Jffht29JzEjoM+BNMJzEh3QlmdBElglskgVktFHhB5Gw0gplFRDNjKQlmE0n7wGw5Zs6xXMc3opgQEr0gCgdRICiY2BoYwiFlAvJlIyojnEFkErQOKxH8RdZEOojkwW+BJbi+hdpI62ClCaKHEAVNCCGBBFGdGEMjYhDpDqLBbow0EHGKtDtvvPFGqJsSUyC6F8VLEYHd1fRZJLQwPQIhYQCWMyBvL5aoRKMxi3zBSNtAh23rYAktUj7A8IejFktrYPzTYUsI8QVLBVE4C3nxMCgPd7CcEUUakT6gtXx7kQqWIv7rX/+iw7YNUPANS6iRMgMpK1AQBxXosSyZEEICBVI3IE8rluMj566vw5aQaAO2NtIvIPUg0vUhhRTSOdBhG/nQaUtIGIDcNDD2ohV9fj/SMsi1BIGF8Y8CBzhuvjksCSEEoBAk+gnkVGstT2w4Ec3RTFoBEdI6yK2HPIrIX4w8/MiliMIqHCcQQgK9Wm306NEqP6qW+5uQaAaT+Ki3gnvkwkU+e9/aPyQyYXoEQgghhBBCCCGEEEIICSOibx02IYQQQgghhBBCCCGERDB02hJCCCGEEEIIIYQQQkgYQactIYQQQgghhBBCCCGEhBF02ooI0vpWVVWpe0IIISRaod4RQgiJFah5hBBCIh06bf+p2J6WlqbuCSGEkGiFekcIISRWoOYRQgiJdOi0JYQQQgghhBBCCCGEkDCCTltCCCGEEEIIIYQQQggJI+i0JYQQQgghhBBCCCGEkDCCTltCCCGEEEIIIYQQQggJI+i0JYQQQgghhBBCCCGEkDCCTltCCCGEEEIIIYQQQggJI+i0JYQQQgghhBBCCCGEkDCCTltCCCGEEEIIIYQQQggJI+i0JYQQQgghhBBCCCGEkDAipE7bzz//XE444QTp2bOnGAwGeeONN5o873a75aabbpIePXpIQkKCjB07VtavX9/kNWVlZTJlyhRJTU2V9PR0Oe+886SmpibI3yS8qaiokLvvvjuo/7N///7y008/dekznn32WVmzZk2n3vvwww/Lueee26X/TwghhBBCCCGEEEJIzDlta2trZa+99pIFCxb4ff7ee++VefPmyWOPPSbffvutJCUlydFHHy0NDQ3e18Bh+/vvv8uyZcvknXfeUY7g888/P4jfIvwJhdM2EHTFaUsIIYQQQgghhBBCSKQSUqftscceK7fffrucfPLJzZ5DlO3cuXPlhhtukAkTJsjw4cNl0aJFsm3bNm9E7h9//CEffPCBPPnkkzJq1Cg55JBDZP78+fLiiy+q14UKtL26ukp27ChR99gOFIhIvvPOO2X//feXAQMGyDPPPON97rvvvpODDjpIHSs8/9VXX6n9F154oVRXV8vee+8t++67r9/Pfe6559QxHDlypBx22GHy888/q/277rqr+ly9I1X7vR544AHZb7/91OfifsWKFX4/+4gjjmgSRX3aaaepzwHPP/+8+r8jRoxQDvy3335b7cdviv87a9Ys9fnvvfee2v+f//xHfTe085hjjpFNmzap/fh+EydOlN12202dB7/++msXjzQhhBBCCCGEEEIIIaEhbHPabtiwQQoLC1VKBI20tDTl4NOcg7hHSgS9IxKvNxqNKjI3FMBBW1BQIEVFRSrCFffYDqTjNi4uTlauXCnvv/++XH755eJwOKSxsVFOOeUUufnmm+WXX35RDtVTTz1VpYpApHJKSopKV6B3wGrAufvCCy+oKOUffvhB7rjjDjnzzDPVc0gxoDlYAZzE06dPV4/PPvtsWbVqlfpcOMunTZvW4e+CyOlvvvlGfvzxR3nzzTdlxowZYrPZ5P/+7//U7/rggw+qzz/uuOOUg3ft2rXqd0c7EWV98cUXq8+59dZb1XFBZO67776rvgshhBBCCCGEEEIIIZGIWcIUOGxBXl5ek/3Y1p7DfW5ubpPnzWazZGZmel/jDzgFcdOoqqpS9y6XS926AiJr6+vrmuzDdlVVpaSkpEogmDx5smonomDxfRFVXF5erpzVRx11lHoOEbc4VnBu9u7dW72vpe+GKFhE1sIhrs8VjPQVZ511luyzzz5y3333KefzunXrlKMVn/X999/LXXfdJaWlpaodcKjiPcg/rP0/7X/qH8OBrW3/9ddfykGMz8Zn4P9i3+67797sfa+//rpyOqM9wOl0el+zfPlyuf/++9Vnw0GNY4TP6ervScKbkpISWbHiazU5kZiYKPvuu5/3fCckUkDf3V10p94RQoLLunVr5ZdffpXGRptkZGTIIYccqsY8hEQK3al3gJpHSHQAO3/lym9l8+bNgti3Xr16yYEHHqj8BYTEmubF5FkPR+OcOXOa7S8u3i719V0rYobo2pqa6mb7HY5GFRUcCKqqysVgcHnTJRQWFiinFTq3oqKdaSEQgVtWtkPi4y3Kmal/Tg/ae+qpJ8v1189u9n8sFqPsuecwWbToWVm7dp2cdNIEKS0tVpG9iOR95ZWXVPoCpCfYbbehsmXLRhURjbaUlpao/4nHaIf2/+HArqpCFPI2mTjxDPnXv66X448fr54bOnSYFBRskYyMVGWUVFSUed/X0FAvF198oZx11pQm7cTzdrtdyst3/o/a2mppaKhr8TuTyAZpMRYtek5FiWvOe+16QIQ2JhuGDh0S0jYS0l569OgdkXpHCAkOWGH04osvyerVq5vsj4+PkzFjxshZZ50t2dlZIWsfIeGgd4CaR0hkA7vutddeVytwsWJZT3Z2thx//PFyxhmni8ViCVkbCQm25oWt0zY/P1/d42Lt0aOHdz+24STUXlNcXNzkfR5HZZn3/f64/vrr5corr2wyC9unTx/Jze0hqaldi4ZNTExu1iaAiOBARdqinZoDGN777Ow8GT58hHJY/fLL7yra9uuvv1YRsEceOVY5WFG8LSMjW6xWa7PPmzRpskp1cOWVV0vfvn3VTDQidLW0E+eff4FKi4AoWxR7y8vrqY4ZHKV7772Piuh96qk7m7TNZDJJVlaOeu3QoUNl7dr1Mn16T5X2YtWq72Ty5DP/+Rzk2h2pHi9evFgqKiq978vKyhaDwaQegzPOmKjSJUybdp6Kpsb//+2331Q+XOS3ffPNd2TChFOUA/mdd95T7dfeS6KH775bJVdcMVNFdYNhw4ZJz569ZMeOHfLDD9+rlB1It3H33ffIuHFHh7q5hISU7tQ7Qkj38/TTT8vcuQ+ox4gwQg0BjCfXr1+nxlTvvvuerFr1vTzxxJOq1gEhsQw1j5DIBbb9rFkz5fPPP1PbuGZhz8PH8cMPPypbD2kbV6/+Q+bPf9i7upeQaCdsnbYYeMLximXvmpMWwotctRdddJHaRog8IluxTF9bMv+///1POR31S/19Qe5T3HyBA7SrIcypqWlSXV2jokI14uMT1H50OIHAt514HB8fL6+99prKcXvNNdeo7VdeecU7QDnnnHPUcUxOTm6W1/bwww+Xe++9V0XOavlxx48frwp+ARQeu+SSS2Tw4MGyxx57qH1wzKKI3AEHHKBmvSZNmtSsbdrj6667ThUJQ6ExvB+/jfbcQw89JGeccYb6vCOPPFI5jbXnLrjgArnqqqvUa1B8DY5lpIFAVAlAW5FfF7/9TTfdpPLgwkGck5OjipFheVR3L8MiwWXLli1y+eWXKYctUiHMnn29N5UG2LRpo3Lsf/zxMpk9+zq1lGbPPYeHtM2EhJLu1DtCSPfywQfvex22Z545Rc4//3zJzs5R21hBhfHcbbfNkb///lsuueQiefXV1yUpKSnErSYkdFDzCIlc7r77TuWwxTV87bXXyYQJJymfBoB/4v3335M77rhdpU24+eab5D//uT/UTSYkKBjcgayQ1UGwpP/PP/9UjxEtieJZo0ePVlGUcN7dc889cvfdd8vChQuVE/fGG29URbawPEy7gI899lgVfYtiW5idQTEszMigaFV7gTMYS/orKysDMguLQ4qUA3AaotNJTk4JmMOWkFgGQv3CC8/LXnvtLU8//YzfgTkmbWbOvEL+97/laiJg3ryHQ9LWSAR9V1WDS1LjjeyzopRA6x0hpPv64xNPPEE2bPhbzj13mlx99TV++2msLps06QxV3+Bf//q3cu6SrmleOGsh2lZZ70kLlZZgUu0L5/aGGmoeIZHBtm0Fcswxnro5jz32uMrZ7g+sqjz33KnqdW+++ZYMHDgo6G0lJKYibREhACethracZerUqSr0/dprr1URdYgsQEQtoic/+OADr8MWLFmyRC699FIVfYkZVESLzps3T0IJBkxYusbaEIQEjrq6WnnrrTfVY1zzeodtRUW5SgGCviE9PUOlT4DT9tNPP5Xt27dJjx5Mk9EWfxbZZP6yEtleYZce6RaZOsoqPVOc3v4WRd8AjjvSrODeGJ8WFkbi5s2bVBFI9Lt9+/Zrdj4QQkiksWrVSuWwRZHNM6eerxxzfxU3NumnLzsqRwblZcq0adPVpOaLL76g0k+Fuk+OFM2b91GxFJTbpVeGRc49IE5p3rZqkyz8tlG2lNZLTpJBztrXJIPz48NC89Dmu94ulN8LGtT2Hr3iZcpBmfLmD5U+50Rciw5eQggJR5YuXepdLa132PqO6UeO3EeOOGK0svNeeulF+de/bghpuyMF3+Oo39bsPPjdsFoHq5bDxX5CO0v+sUG1dsWinRfSSNtwgbOwhIQ/mFk955yzVX7oV155VS2T0YQGOY40kK4DHfjkyRPl119/lXvvvU+OO85T6I74BzIwc0mBMlIddocaNKVYHTLzQJu4XHZvOhIIJKh0pclb6xKlyh4n/XKTmhiJoXDYIi2GBnJh63N3a+dDS8Ifa1DvCIkMFix4WB599BHJ32OsZB46S/LTzFJrc0l1g6cQLYCTbu6UXsrQOuAAT0qrzz77QrKyWJSsLc37v6c2K+dno8MlZqNIr2S7XHdogzz2faJU2CzicrvE5XRJmrVRTtrdJm+vD63moc1XLN4qK/+uE7vTY7qh3QlWo+SkWsTgc07Awe/r4L3+hPyQaXWooOYREhmcffZZ8uOPP8i///1vGT36yFZtvOXLP5YrrrhcBg/eVV5//Y0QtjoygP2D41hbW6P6QofDLmazRfWNoK6uTq2Ar6+vk4SERJVOE/mCk5KSQ2ovod2w8aqqqtQ2+vCMjEzlA/A9J6LdxgvbnLaEEKIHggIgMFgOCiAwMGT00SOaYxHOO/37SMtgWSUcto22Rmmwu6S83iBb3Sa591ODjO1dJj2T7ZKZmaUct0j7svTPLKmyI0ecXb0PkV8wEkMRxYMIW/1vv3XrZsnLy1cDDW2fP+FH5DaINlEnhEQHmnbZzR5HEyJCceuTafH2tYiuhBM3NTlZGbjo7+rrd9ZUIP5B9KnmsHW5Reoa3bK+zCx3fWKQaodT4swusVgtanyxo84gL/1illpnaDUPOo3fX3PYom2NDhG70ylZyWYxGXeeE1X1ThVFjO+ovR6Pse+hs3oz4pYQEnZo43KTyazsu/bYeHAykrbBcYPDtri4WCorK1TRdpPJKImJSZKW5ikgDxtP+x0w/kAADJy3obSX0O7GRk/wEB4jFSoctnDc6l8TCzYeM7ITQiICLUICOazRabcEDFeI/JYtm5u8j7QMlntiGSiOW0WDUZxugxjF83j51hyxwZnb0KAqlzc4jVLZ6JnvU7n0XG6v4yDYQKRxLqBtHmdFnVgsFiXaGJwAbaZeL/wAj7XBHyGEhBtxiZ4cW41V29W98R+nHJyMoouqTIk3qugSrT9LYW6uDuHUSVdlg1Hq7Aa12gRRtirdmcUh1fbQa57S6WS3mI1updVapG2iRcTt8qRA0M4JPKt38AI8xr5QaDUhhLQFiraDwkKP5vlDG9Nv3kwbryPguMHu0YJvEGlbV9cg1dWIvK0Q+MVh4+3E7d0Olb0EGw/OZbS14R8bz+l0qu+g2Xjad4sFG49OW0JIRDBkyFC1BAIOuW+//da7H0sgsB+zgdoSiZ9++kn++usv1ZGPGnVASNsdCcAQveDwVMlI9BiwMApTrHYxmQxS44yXrPy+kp6eJv37D5A9dx8suSlGNStrNBnFYDR4HQehWOqDQo/47TFjnJOTK3369FODOAw29KkRcC5YrRbv+/FYnx+dEELCiXFjjlD31ZtWir22TC1/xxJ35F8FWv5S9N+vvLJU7Rs5cqR3uSNpGeR3xbE0mzBZ6dlnMbrEYjZIksUtOalmVSejV2ac/N9BCZKXGnrNg2F9xp5O2SVTxGRwq9ugHJGLDoYz19DknMD3w3liMe2MUMNj7At2uwkhpD0ccYRH85YtW+admPJn44FXX/Vo3uGHe95DWgfHLS8vT5KTk1QErdlsFavVrGyh1NR06d27r7Lx+vbtL/369Zfc3DyvjRQKe0mz8TC+QV7/uLg4ycjIUCkSYeshQlh/TsSCjcf0CISQiAARlKeddro89tij8vzzS2TUqP1VgTHfpQ/I7XfPPXerx8ceexwN2HYycnCuzMsyyawXi6VMrSqJV9FGOckifXtkN8kPNNNaLI9/ViUltW7pk5XgdRwEE/0MKgRcv4QKqRH0gzugPY7mfEeEkOhh992HyJBhe8sfv/0khV89JvuedoNccXS+DMy1qmhJON/Q5/3553pZtGihes+kSZND3eyIAMcN+V0f+rBIvv0LgmeQjHijmI1WpXn/OsoiCanZ0jsvU702Nzc8NK9vhkFuPdYkxeW1Ym+0S6+8dNWO40Zmiik+zXtOgMvH5TbLaYt9TI1ACAlHTjrpJJk37yHZsGGDLF++XCZNmuR3nP7mm2/K999/rybSTj/9jJC0NRJBoWYEtaBo89atW8TpdCmHqMcR2tQmCnV+WL2NB5suMTGpiXb5tikWbDwWImOSekIihoqKCpk06QzZunWr9O7dWy6++FI5+uij1Qwclkt8+umn8sgjC2TdurWSnp4uL7zwkvTp0yfUzY4oUJ1aq06eleSWqftbZfdeSc3ED9KhdxwEG20WVgNOWhBr1UQ7CvWOkMjhhx9+kOnTz1X6horaF1xwoey33/6qz8WywbfeelMVLMN1vffeI+SZZ55VE5ykfUDHft5cL09/XiqFlY6I0jxES+HWmt6hzchvC1ITTDHpsKXmERI5PPnkEzJ37oPq8cSJk+Tss8+R/v37q23Yfgjaee65RapvO++8/5NZs64McYsjk1A7ZduCNl5z6LSNYUE/99xzZe+995aZM2d2+jPgJMMFdMwxx3T4vb/99pscf/zxsnHjzsrvhLQFEo1fcMH5SrwBlkdAcFCcDNcwyMzMlAULHpU999wzxK2NTEJtnHZE1GNZwDtDrOodIZHK//63XK655mqVh04zXpC3dvv27d5olOHDh8sjjzymJitJx6HmRS/UPEIiqy9+8MEH5Omnn/Lu6927j8rpvmXLFm/aBDh0//3vG1QaGxKdUO+awvQI3USjwy2VdQ5JSzSL1Ry+A8CuAqctoh8747QlpDMg185LL70sL774oixd+rIUFhaqCqOas/bkk0+RKVPOUss9SOeA0YqonHCHIk4IiXaOPHKMLF36qixe/Jy8/fZbKvpEi0AZOHCgSolwyimnqhUnpHNQ8wghJDz64iuvvEoOOOBAWbJksXz++WdqKb/GQQcdLGeeeabKZRvOE2yk61DvmsJI2wDPwrpcblm6qkLe/6VK6mwuSYwzyrHDU+X0/dK9lX+7wqpVq+S6665TbUYFvX/961/y0UcfyW677SZXX321eg1ywRx44IFqRurzzz+XG2644Z+qeo1y5ZVXynnnndcs0vaWW25Rzte5c+eq5x5++GH57rvv5Nlnn5Vff/1VLrroIqmrq1Ofg84Sn4liT3DWoh29evWSU045RW666Sb58MMP5bbbbpP6+nqVb+aee+6R0aNHq8/F/1myZIk6zscee6wsXryYkbak02DJKPL5VVVVS1JSkgwePFgtFySE+IdRR4RELsjZ/tdff4rN1iiZmRmyyy4DabgS0grUPEIiFyzhhz9DxC09e/aS/Pz8UDeJkJDASNsAA4ftq6sqvNtw3GIbQ+ozRnVtxgBO1fPPP1/ee+896dGjh4q0QKXgF154QS644AKv0xaO1ilTpqi8Znj+yy+/VM5TLB8fMWKEygGKfKDtBblkkBAcURxwxB500EEyduxYOeCAA+TCCy9s4uz9+++/lWMWjlsMjv7880859NBDlWP2448/lqVLl6rk4Vjad/bZZ3fpeBBiNptVsRZC/Obya3BJapgvdyWEkPaCycnhw/cKdTMIIYSQbgfp73AjJNah0zbAKREQYeuP936pkpP2Se9SqoSvv/5aOUURoaoHec4QcYgo3H333VcWLVokb7/9tnqutLRURdauW7dOObiwjVyyHXHawlF78cUXq8ha5I7BjBcew2nrywcffKActYcddph3H96zefNm5fg944wzvDPdcDTDoUwIId1VTK1HukVV+h6Ux6XDhBBCohPm/yOEEBIrVMSY5tFpG0CQwxaRtf7A/sp6p+SkmLsUObbHHnso560v06ZNk2eeeUbl9kSRimHDhqn9iIQ97rjj5NVXX1XRZoi81QpX6IFDF2kONPSvQQoGfOaPP/6oXoc0CP4+Q2vjUUcdJc8//3yb34fRb4SQQIM+SHPYAtxje+6UXuxzCCGERB36Sttajv9YMGIJIYTEHhUxqHksuRdAUHQMOWz9gf1pXSxygLQEyFeLNAMaiHhFrlqkGkDqgccee0ymT5/ufb68vFz69eunnBXIb/vzzz/7/exBgwapHLZw3CJ3LZy8+s9AZC4ctmvXrpVly5Z5n0PULPJEaSD1Atr3yy+/ePetXLlS3SOlAtpYXV2tHCv//e9/u3Q8CCHEF6REgKPW4XSI3e65xzYqgxNCCCHRBgIpamtr1Hgd9y0FVhBCCCHRkOu4/B+9A7GgeXTaBhCkPkDRMX8cNzy1S6kRQEZGhrz77rty5513yl577SVDhw6V2bNni8vlkp49e8r+++8vb731lkyePNn7nrvvvlu9BgXHnn76aRk1apTfz0b0LD5jyJAhcvzxx6vctxooOoYo3uHDh6vPOvLII73PnXzyycpxjM+/9dZblfMXUbZIfYA24vO0fLeI+D3ttNNUtC/SOPTt27dLx4MQQnxBDtusJLdKGeN0OdU9tlPiKXeEEEKiDwRvoOBWQ0O9usc2IYQQEo1RtnV1tV69g+MWKRKiHYMbIY8xTiAri7pcbnllVYXKYYuUCIiwhcP2tP3SxWjk0lxCCOluvvl9qzzxRY2U1LolJ8kgMw5NlgP2aH8e72iGlbQJISS6KCzcLkVFhdLYaBer1SJ5efmSn98j1M0KC6h5hBASXXpXU1OjnLXQvPT0dBk8eFeJdpjTNsDAMXvGqAxVdAw5bJESoasRtoQQEgyiJan77r2SZPaYOqltFEmyovpsUqibRAghJIyIFr0D+A5JScmS9I/UxULUESGEkNjTvPj4eOW01TQPdZdiATptuwk4artSdIwQQoJJNCV119qdEgWDE0IIIYElmvRO3/ZoMMgJIYQElmjSvPQY1Tt6FQMIckgtW/aRKvaFYltWq1VycnLk2GOPlYEDB4W6eYQQ0iK+SdwjPal7rIg4IYSQ2NY7QM0jhBASC5qXHoN6R6dtACguLpYlSxbLa6+9qirZ+fLYY4/KfvvtL2eeeaaMHXuUGAxMl0AICc/lJvptQgghJNqg3hFCCIkVqHmRD522XeTXX3+VSy65WMrKStU2kv8fc8zRkpWVLXa7XX7//Xf59NNPZNWqlep20kknyc033yIWizXUTSeEkA4tN4mWfEiEEEJiF+odIYSQWIGaF/nQadsF1qz5Q847b5rU1dWpqnWXXnqpHH74EWI2Nz2s27dvlxdffEGeffYZeeONN6ShwSb33nufGI3GkLWdEEJ8aU2koykfEiGEkNiGekcIISRWoOZFNvQadhI4ahFhi/t9991PFi9eImPGjG3msAU9evSQWbOulIcemq+e/+CD95UDtzPccsstQclDgvy8xx9/vOy5555yySWXBOxzN27cKI899ljAPo8QEhyiLR8SIYREMm63WyrrneqeBBbqHSGEkFiBmhf+0GnbSd577z0pKiqSnj17yrx58yUpKanN9xxxxBEye/a/1OPnnluk0id0lDlz5rR4ITkcDgkUP/74o6xfv16lf1iwYEGT51wul7p1BjptSXeBWcLCwu3qngQe3/xHzIdECCGhcdSuL2yQmUsKZMZTm9X9n0W2UDctqqDeEUJIeEE7r/ug5oU/dNp2ctD84ovPq8dnnjlFUlNT2/3eU089RbKysqSkpEQ++eR/Hfq/F154obo/9NBDZe+991YF0M4991yZPn26HHbYYTJs2DD1PAqdVVRUeN+XnZ2tnKUAjtjx48fLfvvtJ8OHD5eHH3642f9ZvXq1TJkyRTZv3qz+z6JFi1SE76mnnipHH320+j9I+fDcc8+pz8ANn1lQUKDe/+yzz8rYsWNl8uTJKlJ33333lb///tv7HdauXas+98QTT+zQ9yekJQHfvHmTWtaBJR24p6B3TyQX7nFDn4JlM4z0IoSQ7kPfx8IxCwft/z25SWY8vUU2lHgctdsr7DJ/WQn74QBpHLbT0tLFarWKzdag7kO9TJRaSwiJRWjnBQdoXDhpHmkOc9p2gj/++EPWrFkjcXFxctJJJ3fovShAdtppp8vjjz8mr7zyiowbd3S734sI1ccff1y++OILSU9P9+7//vvv5csvv5SUlJRW3+90OpUjdfHixbL77rur1A4HHHCAjBo1SjlxNYYOHSpPPvmkzJw5U3766Se1D07bFStWqAjcvLw8+e233+Saa65R/7tXr15yxx13yP/93//J+++/r16/atUq9d4BAwbI7Nmz5Z577lFtx3fQfy4hHUVLlI4UHriB8vJysVotkpSUrLa5rKNzxxWTSbW1tWrlQLWky8JvG5VDICvJLacPc0jfDIP39XAgwFGA53ukW+Syo3JkUF5c0NqqT5aPwVx1dZWkpKRK3779lGFb1eCS1HijmsQihJBIQ9/H5qeZpdbmkuoGlzhdbqlucEqD3SV9sqyCHg6vwXOpCaZQNzti+GF9sSxYXiolNSJ56XEy6cBseevHKh/Ni1fjjPLyMjHGp4mroVJsNltQC7X4au3UUVZJEU9gRk5OTpvtoB4SQiIF/fgeaHlWaecF5thu3LhBrfTOzc2T9Nw+Xk3TbOq4OI/m4bXQllAVJ/M9D0pKStqtedEKnbadACc8GD58rybO0/Zy6KGHKaet9jld5fTTT2/TYQsQ4fr777/LpEmTvPuqq6tVZK3eadsSxx13nHLYgk8++USOOeYY5bAFF198sdx6663KMQwOPPBA5bDVHs+fP7/T348Qf4nSNQEH9fX1Ul9f5xVzdPKsgtl+cKw2bdqoovcrKysE2U9e2zJIal0JKg93QalTFq10ysX71UlcnEWqq2tk3gqrlDeY1YysFuk1d0qvbjcKfZPlb9u2TUpLPdt4/MuGMnn37zQprTV4DdyeKU7vecDzghAS7sDRpjnqQEG5Xd1yUkxSXOWQRodb3eobXZJoNaq+ztlQKYWVwXUoRipwws77qFi2VrilosEom8sbZNWGAumRZpB4i7GJ5pU0WOW1jx1SUlMkmQlOOWd/q/TNCE6hFt/zYEtpvcz7qEKm71mqIqKw6q1///5qxZ/ewNUe77AlhmxylRBCujK+R/8Hm6K2tsZr5yUmJkltI4LgbCoCl3rX/mP7xx+rpaBgq2yvscoXnxqlXuokK9ElJ+3eIEmuUuWwTUtLVbY0Vmjb7WvF4XBKTk5uUIuT6c+DoqJCFWTocDiUrvlqHhzMsENjwcaj07YTIBINJCe3ncfWHykpyU0+p6skJ3s+T8NkMnmdp/rZKHR+mZmZnY5y9f0/enwdNfpcKGhPIPPtkthFP7MKh21lZZXg1MPNbLaocxwR8JiRq6tDxGgyq2C2A4/w2dUxUze7UUpq3GIyNYjbHadyWBdWOqW8pkHsxYVS5zBKYWVfxO+r92uO22BEevnOrldUlHn3Q9hf/M0ttS6bcjZvKXXIguU1MnuMUZ0HVVVV3uhsnheEkHAFkZGaow4YjQalb8VVTnG4RMwm1BcQ2VHtkBF9LHLirrWyeXMJNa+d7KisVxG2cNjieOLYOt0ixdUu6ZHi9GpeWXWDLP7ZJJWNDjXOLapyyaKVjfLvcdagRHr5ngdul1u1u7zGJgaHx5DdtGmDpKamqd8eBi7AYwRlPPClWU1ggmBOrhJCSEfx16fCYYuxO7qsorp4WbjcKaV1RslKbJAp+zQGbQItGo4tHJqIqv1kex+pshvFZLJJkcMkL/1skFP6VChbDse5rKxMaQtudrvHZoLjNljRzfr/A9sUDnun06mc9nrNAzg34MCF5kW7jcectp0gMTFR3dfW1nXq/ZqzVvucjoCI2srKylZfM2jQIPn222/V49dee837/3bbbTd1Yj/zzDPe1/7555/q4uwoo0ePlg8++EBFtgGkPRgzZoxy0LYG/n9b7SekJfSTAeigLRazWuYBBx0EBXiWdVSozhtiD7iMpu3jqkUtO51uSTC7JNXqET5tpjsr0S0ZyfFiMhkl2WpQEUee13vuEcWTEt/9kuKbHD89PVPdq1lYp1EqbRavcasM3Fq3mpUHSKGgh+cFISQcwVJ29KkacLENyjGL2+1SfbLVbJS+WRbJSzXI+fvbJdVQqSYxi8o90Uns21onOy1BMhJFnLqaujBWsY30E5rmIfKowmZR25qjE05TaEowCrU0Ow+MBslJFrGIx5GLsY/bbVCGLcC99hhtLKxoGjChTa4SQki44dunIggHNh00DenP3t+QLmX1JtUXY2y/5HuPHlLv2ndsTSazNLhMUmn3OGc9f0QdU5cpXhISEiU+PkGNM/B66AuA01T7jGC1VQO2aUJCgjf4T695et2LBRuvSxY2vPWxSJ8+fdT9r7/+ohxDHeWrr77653MQqdYxrrrqKjnqqKO8hcj88eCDD8oVV1whI0eOVDloUfhMO9Hfeecd5chF8bA99thDzjvvPO/F2BFQjOy+++5TKRLwWciz+8QTT7T5Pu3/4v0sREY6CmbMUAQLUd+YEcTEB5yGcNKWlBQ36eTRWZeWlirHLatgtn1c+/Xrr245OSgyli7jB1YpoxWDIxiJZ440SGZmhhJ0u90mo3sWSarF4w3Vll0GI3rH9xzA6oGsrGy1r09+ttfAhXGrDNwkgyRZPe81GIwqrYbmzOd5QQgJR9CXok/V+jPkWJ2+n1MGZomYDCJ2h0tKqp2SGmeQ5DiDFNdb5fEfUuX25Ra5e7lTtlUzt21rZGRkyqxjciUpzpPn1Wo2SHaiWxItbjEZd2pe77x0pYOIvMUNZCeJ9OvpKcYZ7PMgL9UkZ+9nkYyMdDVhmZubq5azapOuuNcei71WTa46nDsdt8GaXCWEkK6O77Wl7/A3bS+tkqIqp3dsD7BdUFzhja4krR/b3XcfIn3ysiQ70VNjKSE+QQXbZSd5gnLy8nIlIyNDRbEiUhXHHU5xOE21AtTBPg+g1dnZyGPbXPP0uhcLNp7B3YFSpCgy9eKLLyoH3ZYtW9QABgVrRowYIePGjZNp06ZJz549JdKA4zUtLU1FgCIStC1wyE4+eYKKUp09+3o566yz2/2/MFNw9NFHSVFRkdxzz70yfvzxXWw9IbEJchlhKSAmL3BdIfIWeW4g3uiw0UchKhSd/5AhQ6NqiUQwCpIBDJbsYpGs1ATPzPY/aSfKykqVMOKYZub1VQYshDXY7dRyHgEIPPry1Vuq5NXf46Sy0dIkp62WZB/nBmZlkZ8bRctijY7qHSEkdGC8icjI2ooiZUTd9L5T/ioVtaQf0ba75pnkhiOdcvOHLvmzxC1Ol0EsZoMM650gT57Xl8vg22B9YYM8+GGJbC+vl9xko0zZxyg9M+OaaN667XXywo8GlTIoJ9kg0w9KkJGDg1sMBefB1qIyaagu9f6mngg0l4pA881pq2l1aWOSikYrt5mkT1ZCTOa0peYREpk2HjQPY3bYeUajSZ5bky9Vjjgxm8yq/0sy1sn5I6okPT1VBZ3Qzmuf7bSmoFYWrmxUqXMwITx1f4+dpDnKcduyZZOy8+DE7dOnX1Cdti3ZeY1+NE9z7MeCjdeunLavv/66XHfddSo/EopR4TGcs/C8Y2n9b7/9Jh9//LHcdtttcu6556p7VHeLVjBgmjRpstx++23y/PNL5JRTTlGJsdvDO++8rRy2iA476qhx3d5WQqIVGCfomDUjBR04Om7co8gIltXgOTh0YcBQzNsHjlNLxwoCif4Pxx05hBF1iyivUKy6QFs0ccYsq5bGYVBevFyb65b4lFTpnZfpNXAxAFSDvKRkSUryOKQJISScQf+FPOEuW4IUldVIrV0kL0XEaDKJ1WyWBodB7JZU+bu0TOVkRQQSHLq/FzRIVb1T0hJZuqI1BufHy4JzeivHOCJQfZ3c0JndDAa5PL5c5XRHNFJmRmLQl12iXRZplLK6WqV5DodHg2FQa1Fm+fk9mrQb74HWIae7wZooA/v2pBOfEBIRwH6D01az82DboQgk8q+WN4gqoDWub60YjZ6JGdp57QPH6ID0DBk11O1X9zRbKTk51WvnhSrVgN7Oc7ShebFg47VrNHfvvfeqJffHHnusGHF1+HDGGWeo+4KCApk/f74sXrxYZs2aJdHM8cefII888ohs3rxZrrrqSnnwwYfaDMNeufJbue22W9XjM8+cEpUnFCHBFB7MpGESBE47dNRatUjcoi2XTTgNojzpJ+q9S1JCsQQF4qylp0Fb4LRNTk5pYuDqByJa2/XbhBASMSls3G7pkVamcvmZjCZxuUV6pZulZ26GGAzlWno60knHuD803YiLs0iirV7da/tDqXloE5aLaviOd/R6h++XnZZIhy0hJGLQHLAY29fVWbzOuLtPzRRTfJoUbvlTiop2Fl0ngdG9cLXzajqgedp2TDptV6xY0a4P69Wrl9x9990SCyDPxvz5D8v06eeqdBHTpk2VK66YKaNGHdBsYITw8ldeWSqPPLJAFU064ojRMmPG+SFrOyHRApY+YPYVM6z6TC+I9MfSQC0KM5oj/0MxiNLyDGHiSXOUBxstqlr7jX1XO/gTbO0cwfnAGXlCSCSBPveaE5LkrrcLVSQtSE80yY5qp+zRK17tszvdYjaK7JYfx9ylUax5qFGBqKOWC3RmKGMXhVmwlJR6RwiJNLQgHH3aNu/qk9xcqa+vU/2hxWKRuJQs74o70nmoeVGS09YftbW1qhBQJOcJ6kq+o1WrVskVV1zmnQkYMGCAHHvscar4F06y1at/lw8//MAbyo2UCHfddXdUzgAQEgr85TbVRF6f7yZUohNpaMetpeMFyahqcKmq1hgc+W6H8ncH/tre0jkSizC/HyGRC/rbKxZvlYJyuxhRkOWf4lKXjs2W+ctK5O9im9TYXMqoHZATF5M5TAOteeGCr45hXNPS2IaatxNqHiHRa+fp87NqRZGpeYHVvHCx86wxrnmdTna1evVqOeecc+SHH35QP+DQoUPlmWeekX333Vdiif32209efvkVWbjwWXnrrTdlw4YNKqLWFxyfyZPPlAkTTvKbYoIQ0jl8l0ho25qge3IiNXqXTURbJx5I9KLn73j9sL5YHv+sSi3PRVGTCSPT5M0fKmV7hT0kg6X2Rs62dI4QQkgkAcNpe6WjyT70v3lpFpk7pZdc+lyBlFQ7lDMX++HIxX5GH3Vc8/TRXXqNCaWTl5pHCIk1WurP0tLS5YV3apXDFlDzAq95fxbZ1DENtp2n6WxrjtpY07xOO20vuOACufTSS1U+WzhEkPN26tSp8vvvv0us0bt3b/n3v2+QmTNnqUJjv/76i5rZtVrj1EmP4m3Dhu3JDoSQbgAdeVFRoXeZvBZxGSudeCDB8YFRWNsokmRterxQ3G3Bck8+RbB5R53c+ka95KSag+4g0AYd7f0/sZDriBAS/RRX2tWtusEpFpNBOWsRUYtUCHDo7vjHYauBfhnFRlrK2RrrtDRGgMZs2rTRu4oO6ZY0WpvY7C6oeYSQWAV+JqSa1Ncv8U5iVtibvJaaFzjNgz04f1md9xgHy87zjZrFCon0NnQ2FjSv3U7bCRMmqMJbyFsL4Ik/8cQTJTExUd3gmFywoHmEaSyRlJQkEydOUjdCSHCAwFRVVYrbbfAmTI+lTjyQbKs2yYLlLuWYzUkyyCVjTJKf73luR2W912ELnE5P5dGsZJOYjIagDpY66ozXxD4SlsASQog/YEDd/U6R1NtdYneKyl9bVuOU+ydne/L8xRtVJIzeiMU2c9t2fNIXWmGz2aXWbpBEs1s9709ngjURTM0jhMQicOAhaKShoU7q6w0qz6rWn1HzAqt52KeBx7D7QuEU70zAVXoMaF67z+qzzjpLjjzySJk3b54aOCLKdo899pBJkybJqaeeKsccc4zMnDmze1tLCCE+Yl5UVIT03N7K2frOHZ02BAkJ1aMxv00gQb++8NtGKbfBCWtS99jWlmNmpyVIZrxTnA6nuJwuMZkMkhJvUnkVgz1Y8nW+t8cZj98+P78HzwFCSERSWe9UxcacLhGr2aBuDpdbclM98Rdw3GLpIvphoC1l5Cqvzk1gPrIqUR76Nl0e/yFVius9yzNxgybW2NzqPlgTwdQ8QkgsgiBBT/Snx86z2Wze56h5gQOa4nDYVaCTJy2BRdl9OKbQOqfLo3nBsPM6o3exoHntjrQ9/fTTZdy4cXLdddfJAQccII899ph89NFH8umnn6pCZLNnz1b5XQkhJFhowtLQUC/wLZbX2KVv36a5dqK18w402jIjs8ksYmo6o+qyVamlKscPqpG31iVKWb1J8tPMctm4HFn6bYkUVjgkP90ctMFSLMyoEkJIR0GuOSxdRL8Nw4rGa+tAQ7DcNilp5zYM0ye+rFE6h8nJaodF3vkrTo47NF3+Km6UB740ezXvquMSJT0I7aTmEUJIc6h5Xdc8AMe43e4Qs9kkcXHxKqIZtwkjLXLrG4UqJRMCdS4ak9btx5h6F4Cctqi+CWftl19+qfLXHnXUUXLbbbep9AiEEBJs0JlDfLZWGuSln41SZY+Tfhvq5LKjklg9tIO0tMzI2VAppaWlUlFRIXmJNrny0DgRS7zkZcZLQoJD+hzi+CcHrkOy4+pEJDjHnSJOCIkl0hJMskevePl1a4PUN7rUvgSrUYqrHJKWuHM4r1IlMJ9fu/CXQmlLUZkUlNkQ2CVGk1HMZrMqdFNV71T5/PDYYrFIaa0EtegNNY8QEmugNhDyq1ZWVqrtuLjmNgY1r2uap61ahYzFxyeoHLIo/oUJTBSbRu0SpMLDykpsjx6SHDTHLdlJh+Kby8rK5Pvvv5c999xT3eNHHTFihLz33nsd+RhCCAlYp56VlSVvrUuWGleCEhktUbq2rJ+0j5aWGWlLkbR8wXa7XZLjDJKQkKBmQfE+bOOehd4IIaR7QB87+/g8SbR6UiMkxRklM8kkD3+8g3rXSfylULK4bSqnu4bb5VkSiiPcUn4/QgghgQd9MiI+ExISVfAgipLByUgCp3naqlV9Pls4c7UVmFBD1C7Rik5T88I80vb555+X//u//1OOWvy4ixYtkptvvlkmTpwoF154oTz77LMyf/58ycvL694WE0KIDmN8mpQ3VIpZN8nK6qGBW2ZUUeGZlUVEM0hMTPIKPQZOLPRGCCHBITfNIjkpiHoRQTpx9NHUu8BG9GBCcso+NbLke09RTi31DyKdWfSGEEKCCwJyMjJ29tMMEAms5mmrVjWHLXx5eI2Ww5aaF2FO2+uvv16efvppVXgMUbbTp0+XE088UXbffXeV1/aJJ56QAw88UP7+++/ubTEhhOhg9dDA4rvMSJ9byLeYG/MOEUJIcPWuZ4ZnRYkG9S6wQMdGDhYZ0rteHIY46Z2X6V0KCuctVvLg+LPoDSGEhGZJPwkcmu2G6Fu9LaetwKTmhQcGdzvXVGEJ8scff6zSISC3IYqOrV+/vslriouLJTc3VyINJF9GyD3ypSCSmBASWfxZZGsmKsxpGzwQcRuujttwblsooN4REtlQ70JLeXmZlFbVS1Zqglq2G25Q85pCzSMk8mG/FjrCWfMqYui8aHekLQqPjR8/Xo444gj57rvv5Oyzz272mkh02BJCIh9WDw2NOGK7pKREFQnA0hptJjxchBPt27Fjh3ocbm0jhJDOQL0LneZt3rxJFWxR+f/snmIs4aQp1DxCSDTCfiw4RJLmVcSY3rXbafvAAw/I6NGjZc2aNXLuuefKuHHjurdlhBDSAVg9NLjiiOgVT0GACmloqFf74bgNp1xTvm0Jp7YRQkhnod6FRvNgvELvNM3DctJwgppHCCEkFjSvIcb0rt1OW3DCCSeoGyGEkNgS8oKCreJwOLzJ6qurqyQuLl7NvkLMkbw+KSm8ck0xDxYhhJBAaZ6md/oK2+EENY8QQkgsaF58jOldu5y2L774oipA1h62bNkimzdvloMPPrirbSOEEBImM68Qcsy6Agh6SkqqirTVxD0xMalZobJQw0JphBBCAql5vhW2wwlqHiGEkFjQvPQY07t2OW0fffRRmTNnjkybNk1F2g4ZMqTJ80ju/tVXX8nixYtl2bJl8tRTT3VXewkhhAQRbbmJ5pw1m81e56yW+8hqtapbOBLtIk4IISR4mof6zYmJErZFrah5hBBCYkHz0mNI74ztedFnn30m99xzj3LIDhs2TP1ogwcPlj333FN69+4tWVlZMn36dOnbt6/89ttvcuKJJwakcU6nU2688UYZMGCAJCQkyMCBA+W2225TJ48GHt90003So0cP9ZqxY8fK+vXrA/L/CSEkloA4FxZuV/f+lptA0Hv16u0VSdzjeczEYokKZmr17yWEEEKiRfO0fMK4Ue8IIYREst4Bal6U5bSFIxY3/GBffvmlbNq0Serr65UnfsSIEepmNLbLB9xu4ChGlO/ChQtljz32kO+++05F+6alpcnll1+uXnPvvffKvHnz1Gvg3IWT9+ijj5bVq1dHfW4LQgjp7iqcbS0/ibVE8IQQQmJT86h3hBBCokXv9PfUvCgqRAbgpD3ppJMkGHz99dcyYcIEGT9+vNru37+/vPDCC7Jy5UpvlO3cuXPlhhtuUK8DixYtUjk33njjjXbn4SWEkFinNWFubflJrCWCJ4QQEpuaR70jhBASabTlfKXmhT+BDY0NMAcddJAsX75c1q1bp7Z//vlnFeV77LHHqu0NGzZIYWGhSomggSjcUaNGyYoVK0LWbkIIiTR8hbi9wgyhx2RecnJy2BUiI4QQQgKledQ7QgghkQZtvBiMtA0ms2fPVlXsdt99dzGZTCrH7R133CFTpkxRz8NhCxBZqwfb2nP+sNls6qahVcpzuVzqRgghsUZqapq4XG6x2RokLi7+n+329Yd4LW6AfWjHCXRqIT3UO0IICZzmUe/CV+8ANY8QQppCGy/yNS+snbYvv/yyLFmyRJ5//nmV0/ann36SmTNnSs+ePWXq1Kmd/ty77rpL5syZ02x/cfF2qa/fGQJOCCGxiM1WJ0VFdaFuRszQo0fvbvts6h0hsQPShtXYRJLjPMVDSPug5kWH3gFqHiGEtAz1LjI1z+DGCC9M6dOnj4q2veSSS7z7br/9dlm8eLGsWbNG/v77bxk4cKD8+OOPsvfee3tfc/jhh6vthx56qN2zsPhf5eXlkpqa2s3fihASTCoqKrwzi+np6aFuDiEhj7Sl3hESffxZZJOHP94h2yvs0iPdIpeOzZZBeXGhbhYhIY+0peYREp3QxiPhTkxE2tbV1TX7okiToIVmDxgwQPLz81XeW81pC3H+9ttv5aKLLmrxc+Pi4tTNF/yv7h5MEEKCWy2zrKxUPa6trRWj0cB8PCSmoN4REv0g/mLB8lIprHSoCFvcY3vulF6MuCUxBTWPkNiANh6JJdrltL3yyivb/YEPPPCABIoTTjhB5bDt27evSo+AiFp8/vTp09XzGIgiXQKibwcPHqycuDfeeKNKn3DSSScFrB2EkPAUa1S/RDL1lkS6rWqZhBBCSKRrXlWDS0XY6sF2dYNLUhNMQW4pIYQQ0r12Hm08Eku0y2kLZ6meH374QRwOh+y2225qe926dSoCdp999glo4+bPn6+csBdffLEUFxcrZ+wFF1wgN910k/c11157rZpdOf/881WI/CGHHCIffPBBu6viEUIiU8h37NihHtfUeHKU+RN09APa89o2IYQQEk2alxpvVCkR9I5bbKfEM7KQEEJI9Nl5tPFILNHhnLaIdP30009l4cKFkpHhuXiQJ2jatGly6KGHylVXXSWRBlIqpKWlSWVlJfMdERIBFBZubyLUycnJkp/fo9MRuaRteByjA+odIdGpechpO39ZiTen7WVH5TCnbReg5kUH1DxCotfOYz8dGHgco9Bp26tXL/noo49UugI9v/32m4wbN062bdsmkQYFnZDInYEF2dnZFJluhMc7eqDeERK9fTCG9EiJgAhb5rLtPNS86IGaR0jkwT44ePBYRwbmzohfSUlJs/3YV11dHah2EUJIi2hiwlnBwAFjH3kRU/0Y++jfkX7GarVIUlIy80YRQkgYah76buaw7Tqa5lksFhFLkiTV13uPeWtaGUz8tSNc2kYIIV2Bdl7wwDGura2Rxka7svMQ1UyiwGl78sknq1QI999/v+y///5q37fffivXXHONnHLKKd3RRkIIaQYFPHD4LqudOsoqPVOc3vxQdXW10tBQr2Zj4+MrpV+/AWG3pMZfO8KlbYQQ0lX0TsPKemcTx5zL5ZKCCof0TDNJTaMnxy2ddq2j1wegfwzN+7ukUd5aZ5HKRrv0yWmQq46zqefCIQWFv1QY/to2MNdKJy4hJCJpz7idE1Vd17zGxkYVlIlt1KyyWKzeVBThZEdVxLid1+H0CHV1dXL11VfL008/LXa7p+CB2WyW8847T+677z5JSkqSSINLZwiJXFrqxBEpgyKF6JNycnKivjPvLJCAmUsKvAVsHE6HZMQ5ZfYYzwAIz+O+pKRYRR7hePbs2UusVqvYbDZl3CL6NpRLavRLe9DeuJQsSYkzSGlpqfc1aBuIFXFvCeodIZGLP2fd5tJGufWNQqmqdwoG9HmpJtmtRwJz2rZTMxBhBDQd08yiOz5qlJIaUYWWYeekJ4hYzUYpq99Z3A2/wdwpvYLmLNAc9je9ul0KKx3e/flpnhgc/T6kyEiKM6p9sZzjmJpHSOTSklNu8+ZNsnpLlbz6e5xUNlpiuo8LhObt2OFZXaK0Lj1D8vLywsbG822/3qbzty9a7bwOO2014Az566+/1OOBAwdGpLNWg4JOSGSKOGYHcfPtsP/4Y7UUFxepiaW0tHTJzc2Vfv36R10HHghgAM54arN3G8cMt0v32SGJFrdaHmo2W6ShoQ6SofpITN5B3BsbPZFHubl5kpOT22pBuO48FwoKtqrZ4a2VBnnpZ6NU2DwDuIl7uaRvxs5lo3rDOlZzNlHvCIk80M/V19fLrR80SGmtoYmz7oeNNVJrE7E7VRctJoPI4Dyr9MqMC6pDMVKL3KCYckVFmZhMZklISJCEhESpqLXLf75KEqPJKHanQUpr3dLocIvJ4JbsZIOkJSd4P+vJ8/oGJSWF5rDfWtYoBeV2yU4yiMXk0TaXW8RgNEgc0jlA70RkS2mj9MqwiMloCImDOVyg5hESPTYexu2rV/8uGzdulOfW5KvxflxcnAokidU+LhCaV1ZWKk6nZ4Wlw2EXeAdh6+H4Z2SkS58+/UJm4+FcqK6uVg5kpHBA+9CXW61xTX7raLfzOpweQWP79u3qdthhh6kf3PdAEUJId8+2QXi0PKtA69jhsC0vLxOHw6X2o9NmHlb/YEkRBjpapC368hRzg9hqyqTG3ijx8QmSlZUlbrdBLBaPZBQXFysxt9s9Tlt4ChITE71O82CfC3DYFhUVy+LfsqXCZhSTySVFVU5Z8r1bLjugXjmh0fbk5BTve3k+EEIiAa2fq7G5paDMqSJhzCZPX7x2W71UYD5N3MpRJ26DwHcL6UOfjqJkzHHbHBimmgFbU1OtHHow+mG4Qu8yMrIkM8EplXaTlNXBIQ6HrUsZsjtq3BJvtUmcNU5pJyJauxvoshZhDR8stourXZKb5FKGdm4KdM8kZfUeW8wN772Ieq0GzwdCSKTbeHh+06YNsm1HpRRX54nJ5FR9IGAf13nNgy8PwTiwpxoabColXnV1lXo9nKSwBUNl44EdO0q87a+vV4MeZXfCFkVgEc6TxMSmAaTRZud1eKSB5aZjxoyRXXfdVY477jjluAVIj3DVVVd1RxsJIcRvJ4xOGrNuelHCso+6Oo+jDk7FqqpK5cDVz9aSncDAw5KirCS3OmZZiS6ZsFu9EnNE2XqWhlqkZ8+ekp2doxwGmJU1Go3qMWZqNbEM9oymdi5gQOc0JUh5A9pjUtFR+F6ldQYVMYX2YVtbEgS0nE6EEBLOePs5q0hOkkHcCKv8x5FX1+gSo0G/YM4tatPtCJpDMRKBVnlS/DQozcCKHOTxg+bBMYuIonMPiJfsJNM/Dlu3pFrtkhZnF8SnYEJYW44bjIAV5GzUJlbx/7KSPP/T6XIr5/LJQxrk1D1skmqxidPllKwEh+yaZ2rSNp4PhJBIt/GQ+k69prFGkk31KqUbnLa4Zx/XPs0zGk1iScwQs3mn5mG1JOy8uDirpKenq32ajYdIZrPZFDIbD5jNiKiOV3oNGxTbwG7fmRII7dQTbXZehyNtZ82apX7gzZs3y5AhQ7z7J06cKFdeeaUqUEYIIcGYLYSzzmJpVCKUkuJZ9qZFVcKJiHw8WD6BGUI4bTFrF01LJQJFdlydXHmIQ2rh17Y3SGFhpVRWVonL5VQFbrAsF4MnpJjQlhtWVmJGVpSxixy3yBscynOhR1aKZCeJlDe4xeV0KcdGmrVRrAa7JCXtLOADYzwacx0RQqITrZ+DA27KPkZ54UeRHbV2SY93S5LVLSZxSlm9SZz/+G7T4uG0E1VQkivg/IOxAMYEMALr6mqktLRMGXwYK+CQIcIry2qR+07vKze8XScbt1eK3e6JYt010y7/Hp8uQwcHbxmu74qYeKtRhuW75MyhVdJYWy4ZielSU7NDJg10SFxypvTtkS2ljfHqXNHnP+b5QAiJZBsPfbfJZFTPHZK9RVaU9xebIUHV4qDmta15RXVx8uQPqVJS45b0OIcc3b9ckDVGi2ru3buvel1lZbkKdMFxzszMkry84KZF8D0XrFaLivgFcNJjG6tqPYXTzJKR4XFKI21CtOa07bDT9qOPPpIPP/xQevfu3WT/4MGDZdOmTYFsGyGENEPrhLV8RxqIpsUNnTYML0wuwUGHWUIA8cE2aQ6OJQY6yXEiJVV1Ul1do5zftY0wUiGSblWRXEuDgyUpeXn5YrPVq9nZUOUL1p8L+N0njyiXl352SXGNWzLiHDKub6Xs2FGpjHC0kwXpCCGRhr6fG2RtlGtH26SkolbsdVXyzG9ZUlwtkmB2SIPDoG7JVhSQFK4uaUcEDwps1tTUKsMPE5QwBDF+0MCKkv87KE4WLDfL9gq3irSdOipO9th1QEhWxGgpEvpkJchpw+wSbzeLwwqHbbXSbURDOSqKZIfFLUOGDJW5Q9PVcmFEn9GZQQiJBhvPaERgToLsmiiye68dYkl0SH5WiuSneNIkkObgeMKGW7SyURXTdItT5QP+eEuWDO298zjD6YnAnMzMXHEaEyTe5JasrGzp27dfyG08gMhrOGmRFsFma1TBRdDxaMxh22WnLQqQwWD3pazMM0tNCCHdjdYpI7G6JuraEhrMtvXp00ftx7IJOGthq0CEMjIyQ9rucEU/m4mo2gpnkizbPkBFb8WbHGLZYhW72yq9fi6TaQdiyajH+d3YCOPW4M0zFWyx1FeVBbv1TJIbe7hl7d9bxOjEzHyyNDQkitvt8uZiwjkTjTOwhJDY0TyL2MVpFDlp9wZ5e32yipqptoukxMPxaJQddSILVzbKqKGsN9Ga5kHvnE6Xt5gybByLZaeWYSluz5QUmT3GKCUVDjG7HWK1GkKiI1gRg3Y4DKnSOy9TiooKpabG8//xPZCTEMtZ4YDWKoBrGumyUfMIIdFp48Vb3Sr/amYmbbyWgF4VllZLSQ0CcJDv3DORV1YvUlhaKdlpiWK1pim92FZtkicQjVubolIynZlikMwQaJ6vjZeUlCz/SLUUFxeqApN43p/mRaOd12Gn7aGHHiqLFi2S2267TW3jB8fs9L333iujR4/ujjYSQki7lk5ooGPv1y9bddwwbCD2eF6bqSNN0RuoWC66bEuaVNhM4haXbKtLFEO9QbLi7bKt3CALVxrlghE1aoCkRSvBJ6AVCgiWSOoT1OMc0H5ble8vFeeFw3uOYLkP0L8+mG0lhJBAah70DIVCBmSbZHZfo9itGXLzW9UqnylSwxiMBimtNbAoSwtofT+WVyKaFsY/cuAbDCZVjAU3pFjCckwEpKBqtbOhSmpDpHl6vROplcp4Y5PxDxy2WuVvgJUwvhoZrLYSQkggoI0XOND393O7JTtpm1o1gmAWlb/d1CAN1WVSbKtWKRKQ53bhygQpqfXkW0JR5+dWueXfGdVB1ZGWbDyN9PRMKS3dEVOa12GnLZyzKET23XffqVmOa6+9Vn7//XcVafvVV191TysJIaSNpRNaJKV+hg0duH5mLtqSkgcaODyT0nOlxmkTkwmGv4jLZkR2BATUqgk6CLjbnCjx8XYl+DBeMWDCMQ5mpU7f/6XPZYRzAZHVcCwjDxaW9WDGvrX3E0JIpGgeUv1g5YgnHVC8J7d4hs2T8/QfHy2LsrRNbm6e0r3t27f9E6mT7o3UAYjgQW58OHChc6HSPN//g+38fE+OQWoeISQaoY0XWKB1yPv71Fd2KakxSJrVIUf1KReL2axWnFgsolIvFVVZlR6qoqdukbIGUTVPkEIvVJpn9ZOvdvPmTTGleR122g4bNkzWrVsnDz/8sKSkpChP9imnnCKXXHKJ9OgR/CTFhJDYprVZNL3gR+NSie6qUA5jHzmPIPCWhsYmS2mwVKZ/rxwpLTWqmW0YitoMeDAHTPoZeG1b//v6/tb+Xk8IIZFGSzqmz3nKwlPt1zzkO0fat6qqSjU7ieKlWu52DeRDx75QaV5L+kXNI4REM7TxAgeOU98Mg1xzhEhRWY0kmF1is1mkrg6ahxUbiZKeZFF2XnmDSU0AY9UOirzBNgy15qX7/L6+eXajXfMMbmQljnEwAENejMrKSuXFJ4SQWEO/rGRzuVuW/mZWy2st0iiNjTapd5gkL9Ukl4zJlJGDc73RSFhxoUV7hTKnbXv+dzTnOmov1DtCohcM6Vl4qjMpBzyRPIiqRY5E5Ig1m7Hc1uIttBlqzeuMflHzqHmEEOKredA5rCBB+p+yslJvP4nI5Sp3miz8ttE7AYzo3J4pnvQ71Lwwj7T95Zdf2v2Bw4cP70p7CCGEhAhtDm/k4BwZve/OqtMQwdKqeslKTfAWcwsHMexoG8KhzYQQ0l3AUcscth3XPETS6vXBn+EXav3ozP8PdZsJIYSEn+Zpk5FaxKpe8walZ8iIQaGfAKbmdcJpu/fee6sfrK2gXLwGifAJISSYRPPMWjBnX/XCrDf+4ajN4GElhJCQQ73rHs3Tw+NKCCHhATUv+JrHCeAIddpu2LCh+1tCCCGdINqrRYaqyAkhhJDI0TsEVlQ1uCSVqRHahJpHCCHhD228wEDNixGnbb9+TRP9EkI6R0VFhbz22quybNlHUlZWpnLJ7LnncJk4caK6p6HV8dnW1oSIs7PtoyPJ23lMCSHt5e+//5aXXnpRVq5cKXV1taqA7SGHHKo0r0ePnqFuXtTo3Z9FtmZFyAblxYWk3ZEANY8QEmgwcfbtt9/I0qUvq6LtdrtdFTocP368nHDCiZKUlBTqJoY1tPFCr3k8plFWiGzt2rUyf/58+eOPP9T2kCFD5LLLLpPddttNIhEmqSfB4LnnnpMHH7xfFbHwx/77j5L7739AMrgOvV1FQ7Kzs73FQTqyn0inhZrHNPKh3pFggIJON998k7zzztt+nzcajTJlylly9dXXiMnEJXi+dETX0tLSZeaSAuWw1YDjdu6UXpwIbgVqXmxAzSPBoKCgQGbOvNzrG/EFDtubb75FjjtufNDbFgnQxgu95vGYRkGkrZ5XX31VJk2aJPvuu68ceOCBat8333wjw4YNkxdffFFOPfXU7mgnIRHNk08+IXPnPuid5Jg4cZIMHryrVFdXyfvvvy/vv/+erFz5rUybNlUWLVrMgaUfWppt1c/Gtnd2ljSnPcLMY0oIaQtEF11++WXy1VdfKufs4YcfLhMmnKyKPcGwfe21V9S48bnnFimHyu2330HnYhf0rrLe2cRhC7CNIiLMSdcy1DxCSCAoLCyUc845W4qKCiUxMVFOPHGCjB07VuLjE+TXX3+Vl19+UaWavPbaa8Rud8iECRNC3eSwgzZe6DUvEo+pO4bSQnU40nbgwIEyZcoUufXWW5vsv/nmm2Xx4sXy119/SaTBWVjSnaxZ84ecdppnMuPyy6+QGTPOb9ax4LqZMeM8KS4ultNOO11uuWVOiFobvnRkBhCvLSkpUctxk5KS23w9aR+ROAvLpT5Nod6R7mbhwmflvvvulYSEBHn44QUyatQBzV7zwQfvy3XXXauK19533/1y7LHHhqSt0dDXYhh/8bMbpLDCIQajQcwmMyNtY1TzqHfNoeaR7uaiiy6UL774XAYM2EWeeOJJyc/Pb/K8y+WSu+++U55//nmxWCzywQcfSV5eXsjaG47Qxgs9kaZ3f8ZYWqgOR9pu375dzjnnnGb7zzrrLLnvvvsC1S5CooYXXnhB3R911Dg5//wLmuS3feON12XFihUqz0xubq5y2r799lsya9aVapBJdtLSbGtbFTJh0CLCK5yFJ9p+g3CBBQwICS4wTl944Xn1GKkPNIct+uHf1v4t77/1iqxZs0alCerbt6+KPnr++cV02nahr62srJDThzlkyfcuKal1S16qSRkvdNjGluZR7wgJPps3b1IOW/S38+bN9zpsoXmrVq2U119/XQoKtqp9mZmZqp7Jq6++IhdffEmIWx5e0MYLPZGkd2632+uwBbjHdjRPVnfYaXvEEUfIF198IYMGDWqy/8svv5RDDz00kG0jJOKBYfree++qx2effbbXqF2w4GF55pmn/ea3RS7Af//7epk/f0HUdjzBWs6IGdjk5OSwFp5II5KOZSQu9SEkkvnuu+9k69atKqINS0TBT3/tkJlXXyc71q/w+54ff/xRli5dKqeffnqQWxsdfS36tb4ZBpk9xii1jSJ5mfHSI4qjTYJNpGge9Y6Q4PPmm2+qexTYHDBggHqMiclrrrlKTUr644kn/ivHH3+CmrgkO6GNF3oi5VhWNbhiLi1Uh522J554olx33XXy/fffywEHeCIokJsMA+45c+bIW2+91eS1hMQypaWlUl9fL2azWUaMGKlmhm69dY688spS9TwEfsyYseq+urpaHnvsURWB++mnn8pdd90h11//bzpuu7EqNInupZU8FwgJLlpE0fDhw1V6BOjahTOmSU0xUmcZJLnfftJ32OEyY2wvVbDlqaeeVCkSbr31FklPT1MrUkjn+jmMFZLjRB130jbUO0JIV9m6dYu6HzVqlDcl3tSp50htba26Bo84YrQcdNBBkpCQKP/738eqjgnyvk+ZcqYsWfI8HbcdhP1c54kmzUuNN6qUCL4FWFPijRKtdNhpe/HFF6v7Rx55RN38PQcweMRAnJBYxtfh+u677yiHLYqzXHrpZTJ69GiPoZWcLPn5PZT4Izc0QO6jfffdT8aNOzpErY9MIml5RzgRjUsreS4QElx2Lln0bN9+513KYWtKSJe+42+VhOyBav+oQ/oqB+3y5R+rnO6Y0Lz++tmy1157q1RBpP2wn+s41DtCSGAweFdROhwOmTnzCuWwHTJkqFx//fVq1Ylm4+23337KaQvKy8vk6quvlJdeWsrgnA7Afq5zRJvmGQwGlQbKN6dtNF9LHXbaolMihLSPrKxMSUpKUgL+7bffeB2yU6dOlSOPPFI9hrHaKFYpKyuVzz77zLvM5ssvv5AlSxbTadsJIlmIImFpZSTN1oZ7+wiJJvr27afuf/zxB5Um4aMPPOmBeo+73uuwzU8zi8vtlj/+WC1///232rfbbrvJ2rVrVa6/iy7aGQBA2gf7ue5NJRApmhfObSMkGunXz6N5X3/9ldI/6F56errccMMNyv4D6DfQh7z33jtqu2fPXsrmW716tUoPNHLkyJB+h0iD/VzHiUbNG5QXp3LYIiUCImyj2WELojeGmJAwwGKxevP6PfLIAvntt19V5dBp085TVRl32BLkgS/NMvOlMplx7weyZcsW1UFecsnFYjKZVBoSzaglHhEpLNyu7klg8V1i1NKSI222FjO1uOdvQQjRJiB32X249O8/QOrq6uSee+5Sy0AH77aHDBoyQr0GA+tam0umP7FBLrtjoXoPUilMmjRZPf/KK6+ofcQDNS+0egeoeYSQljjppJPU6kmkily48Fm177TTTlfOXETYwtarqqpSeW5ffvll9fwJJ5wgxx03Xj3GRCXxr3kYC1TWOzkmCADRqnkGg0HlsI12h22nIm3BqlWr5JNPPlGV7n0jbx944IFAtY2QiEabpRo/fry89NKL8sMPP6j9e+wxTFUQhQi98E6tlNYapL5ovRQsm6eeR47bnJxc2X33IfL777/Jpk0bZZdddpFYx9/SDqCfCYyEmcFIX3LEYieEEF/+LLJ5l6nF7TpeZOPDKjc7GHvk4XLxlF5SVe+UG1/drl5TsfoDKf7pbfX8+PHHeyONiooKVR74xMREiXWoeeGxxJaaRwjxB/pfOGxRiB0rJX/55We1/7DDDvP2KXhNQUGBPPnkE7Jx40aJi4uTsWPHytatBfLaa6/Kxo3+i5XFuuat3lItS38rVzaytvQdkZXUvM5BzYtBp+2dd96pQv6xlC0vL6+JZzsWvNyEdFR4MNM6a9aVcv/9/1HbWBL69NNPSY++u8iaVRul8s/PpGbzdyJul1izB8nJZ5ylOlSz2VP9kClJ/ItGSUmJt8+BQYuZ7MbGRu82oKB3jPYcLxYBIITowQSk5rAFxgFHS+7uv0jxms/V9ptvviE9evSQxNQsWf3Vr1L+x4diK/WsIEkdcpwM3Wu/Jk5aRtV4oOZ1L+09VtQ8Qkhrdt706efJX3/97S1Khpo/Z5xxhsTFxcs333ytirRXVlaq/vv8889XelhYWKheSxuvueZhDLDke5eU1TvU6lSMLTDGuGV8oirwDah5HYeaF2NO24ceekiefvppOffcc7unRYREobF17LHHqry2jz32qNhsNnnggfubvSex7ygZPOZC6ZGdKgaDUS2lAT179gxau8MZXxHxpbq6Sg2QNDgz2D2wCAAhRE9Vg6tJBV/oV9ZhV0uOpUJ+//UX2bZtm9x0041N3mMwWSRt2Mmy6yFnSP9eOfLLL7+q/WlpaYyy/QdqXnhAzSOE+KLvb6FbDz74gEyfPl2qq6vlm29WqJuelJQUOf300+XQQz1RuFi1rOW3JU01r7ZRpKTWLWbzzmBAjDFKq+qbvJ6a1z1Q86LEaYtlAAcffHD3tIaQKMHfLNUll1wq77//nmzatEkGDBig9rmNVqm09hNT/zHSq1cfmbKPUS2dQY4jOHcR0Y40CaS5iABtlhukpKR6o44AZwa7Dwo4IUQjNd6oli/qHbc9M+Pl2v/cL8ccM05Fzeyxxx4qogiaV5e2lxj6HSn5Waky49Bk1Z+g6CY46aSTuWrrH6h54QM1jxDSmp3Xo0dPmT37evn3v/+lJh4HDhwkTqdDUlNTZd9995W99tpbEhMTVHo8vO+NN1735sQlTfvZpPp66ZXZoFIjaGCMkZWaIKWldd591Lzug5oXBU7bWbNmyYIFC2Tu3Lnd0yJConiWasqUs+TOO++Q7du3y4IFj8ioUQdIeXmZbNq2Q5KsnhQjP//8szz88Hz1+smTz6QBq8M3hx8S/LeU3w8gmT1nCQkhpPuARiHfnJYiQcs/1ysvTkaPPlL+97/lqjDZE088JfHxcWqZPyJpoHnZ2YmyYMHDqvI2ggImTpwY6q8TVlDzCCEkMuy8o48+RqXCKysrk549e8jdd9+jVlnqJ9sweTlr1kyV3qZPnz5y8MGHhPBbhO9xnbq/SxaubGyS0zYjI06NN6h5JBYxuDuYPAydDQorrVu3ToYOHapyjeh57bXXJNJAx4mlDcg3gxkxQrpKS4nSHQ6HXHbZpfLFF5+LyWSSI44YLSeffIokJSXIli1b5aOPPpSvv/5aXWdHHjlGHnxwrnodaZ5DCmRlZYkxPk1Feumd276vg6FLQSeEeke6B/S5KCDmMMRJ77xMb39cVFQkU6ZMVvn7kN/9xBMnyMEHHyRGo0kV2Xzrrbdl9erf1WsRpXTWWWeH+JuEF+3VMmoeIf6h5pFg2nlfffWVXHLJRcre6927t5xxxkQZOnSINDTYVEHqd955WxVyT0hIkKeffkb23HN4SL9HuKHXMrio4lOymowp/L0OUPNItNNhp+2ll14qTz75pIwePbpZITLwzDPPSKRBQSeBpC0hQdoD5Pd79913WvwMLBG9+eabxWKxdnt7IwnMqGrLkTaXu+Wln41S3mBqUlnU93UAzoL8/B4hazch4QL1jgRb87ZtK1CTlWvXrvX7fqvVKtdeO1smTZoUlPZGEnotq62tEbPZLL169W5mnFLzCPEPNY8EW/PguL3uumukoqLC7/tzc3PlwQcfkr322iso7Y0kqHmEBCg9wsKFC+XVV19V0baEkOb4Jkb33UbO2nvuuVdmzJghL774oqxY8bVaPgPBOeigg2XixEkycODAILc6snJIaZVFy20GMZs8CeqxNHfulF5qIgl5/srLy8VqtUhSUjLzHhFCSIg0D4VWli59VVasWCEvv/ySrFnzh+qjYegee+xxarVJRgYjZFotzFJbo5xPcDppzgLNiIUDAcVv6upqld5p7yOEEBJ8zUPtn2XLlqs6JshdW1BQoGyTfv36yamnniZjxx6lJitJc6h5hATIaYsE2nQoEdKxImT+GDRosNxwQ9OK2qR1NMEuqaiTcludmE07uzA4bqsbXOKyVSmHABy2jY12yciwcskMIYSEUPO0IrYsZNsxNO2y2RqU8aoZqJqTQIv40la9YUIzJyeHmkcIISHUPKQ/OOWUU9WNtB9qHiEBctrecsstatk20iCgOiIhpH1FyEhgwPFMS0uXPlkFTaqVI0VCSrxRiio9wg6hT0ryLL0lhBDSPVDzuhfteOqX42pOAn2EFzQPK3Z4/AkhpPug5nUv1DxCAuC0nTdvnvz1118qn23//v2bFSJDkm1CYh0KSGiqlWO/vxnwlgoGEEII6TrsV0PjJKDeEUJI8GHf2r1Q8wjpotP2pJNO6uhbCCEk4KDoGHLYIiUCImzhsMUyGUNcqmRluVXBN21mFlXKkSoBKRMARZ0QQkgk4U+3fA1bLToJ+QCheQiw6Nu3X9DbSgghhHQFah4hXXDaIjUCIYSEA3DUpiaY1OM/i2zNIm/z0+Nk/fp1Kpk9aGiol5KSEjptCSGERDy+EUaoqK0VcAFFRUUqLyA1jxBCSKRDzSOxijHUDSCEkK6CCFvNYQtwj23sJ4QQQqINrSALloriHtswZBFtpIHVJb6VzQkhhJBIg5pHYpkOR9o6nU558MEH5eWXX5bNmzerKu16ysrKAtk+Qghpk6oGV5OiZA6nQzaX2GVrUZmqKlpXV+tNj4BtQgghJJLRG6aINEK17V69eqvloYg2gt6hUIu/yuaEEEJIJGqelgoBgTmDB+9KzSMxQYcjbefMmSMPPPCATJw4USorK+XKK6+UU045RYxGo9xyyy3d00pCCGmF1HijSomgOWwdDodkJrikobpULZlJTEyS9PR06devP5fMEEIIiXg0w1RbGgrdQ/525HOHEZuXly/Z2dnUPEIIIVGheZreId0dAnI2b94kVquVmkeing47bZcsWSJPPPGEXHXVVWI2m2Xy5Mny5JNPyk033STffPNN97SSEELayG2LHLZw3LpdbslJMsiUfYxK0DH7iudxI4QQQqIBGKYwUDEWRw4/AGO2oqJCrYJjJW1CCCHRAvQMQTjx8QlezYONh3QJ1DwS7XQ4PUJhYaHsueee6nFycrKKtgXHH3+83HjjjYFvISGEtINBeXEyd0ovlRIBEbZw0paXe1IiaDDPESGEkGhBM1CR36+8vFw91jSPekcIISSaQIo7LQgHmkcbj8QKHY607d27t2zfvl09HjhwoHz00Ufq8apVqyQuLi7wLSSEkHYCIe+Tn6VEHZNKSUlJKu8RltMA5jkihBASjRG3SAGEqFtN86h3hBBColHvYOMhJYLmvKXmkWinw07bk08+WZYvX64eX3bZZSq6dvDgwXLOOefI9OnTu6ONhBDSYVGHeCPPEWZhPUXIrFw2QwghJOqAtmGyMjExMdRNIYQQQrpV7/Lze3hTJBASC3Q4PcLdd9/tfYxiZH379pUVK1Yox+0JJ5wQ6PYRQkirVFSUqyUxvrmMtGUyqCSalIQlo9YQtpIQQgjpXs3T9E7bJoQQQiIZah4hnYi09eXAAw+UK6+8stsctgUFBXLWWWdJVlaWJCQkqHy63333nfd5t9utiqD16NFDPT927FhZv359t7SFEBJ+Qo5cfkhCj3tsa/guk+GymegFv3th4Xbv7++7TQgh0QA1jwBqHiEkFqDmEVBBzet4pO3ChQtVLpHx48er7WuvvVb++9//ytChQ+WFF16Qfv36BaxxyFFy8MEHy+jRo+X9999XS7/gkM3I2DnLcu+998q8efNUuwYMGKDSNRx99NGyevVqXryERDm+s6r6bW021t/sLIm+AR3AoA7V01FFVtsG/O0JIdEANY9Q8wghsQI1j1DzOhlpe+edd6qIVoC0CA8//LBynMKRO2vWLAkk99xzj/Tp00eeeeYZ2X///ZVTdty4caoAmhZlO3fuXLnhhhtkwoQJMnz4cFm0aJFs27ZN3njjjYC2hZD2EouzP6GirVlWLe9RLHTmsYrvgK66uqrV5wkhgYWaFzyoeYSaR0hooeYFD2oeoeZ1MtJ2y5YtMmjQIPUYjtHTTjtNzj//fBURe8QRR0ggeeutt1TU7Omnny6fffaZ9OrVSy6++GKZMWOGen7Dhg1SWFioUiJopKWlyahRo5RDedKkSX4/12azqZsGPPbA5XKpGyGdpaKiQkpLPbNB1dXV4nK51WObrUHi4jALmB7iFkYXqalp6hhrx9ezzWs4lrBa48TtrvZuJyWliN3e2OT5cD8njMYuZypqEeodCbXmYYK9qsElqfFGMRgMIW5x9Gme0+nk8Y0hIl3zulPvADWPBFPzKioqJS7OShuvm6DmBZ5IG5NR8zrptE1OTpbS0lJVgOyjjz5S+Wy1mY/6+noJJH///bc8+uij6n/861//klWrVsnll1+uCgpNnTpVOWxBXl5ek/dhW3vOH3fddZfMmTOn2f7i4u1SX+8JsyakM+DaqK+v826Xl5eKvj9MS/MIOsL6cR6npKSEoplRic1WJ0VFdWoQxePbNSLtGLrdTm974+LM0thY793WzotwpkeP3t322dQ7EkrNq3Sly9JfzVJc7ZLcFKOce4BV+meZQtPYKAN927erq+XZbxp5fLsINS869A5Q80iwNA9+D4fD4e0zYOPhcaT1J5ECNa/rbCx1RuTxc1PzxOCGu70DTJkyRdasWSMjRoxQOWw3b96sioQhKhaO1d9++00CBX6IfffdV77++mvvPjht4bxFJC32I8IX6RBQiEzjjDPOUDMHL730UrtnYZGGATl0U1NTA9Z+EtszsACXl34Wy3c7KyubM7PdePx5fDsOj2H0R9pS70gwNA+P7//cKGX1Ow2CHukWefDMnhER3RHu4PjOen6bbK+we/fx+HYcal70R9pS80h39BdIj2CxWCQpKdkb2IZoUPYn3QM1r2vw+MVYpO2CBQtUDlmkSXj11VeVwxZ8//33MnnyZAkkcMSiwJmeIUOGqP8L8vPz1X1RUVETpy2299577xY/Ny4uTt38HdTuHkyQ6CYzM1OMRoM3KTrQkmdr6DvGxkabVFVVSklJidpGsT3m5ek8OJ6+x5fXdMfgMYwuqHckVJpX2yhSUitiNu3sTworHbKtpEIaqkvVNjWv81TWO9Xx1PfX2MZxT03gtd1eqHnRBTWPBEvzcJ5pBZEAav5gP+287oGa1zV4/CKbDjttMVuE4mO++FuK0lUQRbt27dom+9atWyf9+vVTj1GYDI7b5cuXe520mFH99ttv5aKLLgp4ewhpD/7EuCUnLsS+qKjQm3Orrq62xc8gbYNjrFWS1LZJx+AxJIR0BL1eabnSLG6bZGXFS5+suiZRHVlJbikt3OwtJEHN6zzIR4coGd+omZR4Gl8dgZpHCOkISINgiHNJXrxRKisrvDYedAzRt/r+hHZe4KDmdQ0evxhz2gaTWbNmyUEHHSR33nmnSnmwcuVK+e9//6tuADMFM2fOlNtvv10GDx6snLg33nij9OzZU0466aRQN5/EKBBsbQbWGJ+mjFgNTaQ1gcd9Y+POzhOPY6UKYnfge3w5KOo4PIaEkM5oXkGVUZ5a0SglVXbpmWGVy45KkkvHJsqDH5ZISbVDeqZbZPIIEXsdNS8QYAx82VE5Mn9ZiTLCYHxhm8scOwY1jxDSXv4ssjXpc6eOskpPXdpa2nndBzWva/D4RTYdzmkbbN555x25/vrrZf369copi6JkM2bM8D6P5t98883KkYs8M4cccog88sgjsuuuu7b7f2D2Ky0tTSorK5nviHTZeEUk7eZytyz53iWldQbJSnTLlH2M0jfDoPI046afkd24caMUllVLotktaWmp0q9ffxoNhJBugXpHukPzNpW55OYPXAJ/rNVslNxUs+SkmCUpzqiMg5xUi8w6Okdy4utl06aN3qgjnIPUvK6BcXB1g0tFy9D4IqQp1DwSyL525pICpWkOp0McdodkJjjl3+Osqu/1tfFAeXmZrP5zkzjrq1SRTmpe16HmdQ0ev8gk7J22wYCCTgJFYeF2VTX07uUuKal1i9vlFoPRIDlJBrnsgHqx2+2SkeER6uzsbNlhS5T73yuQglKb5CSLXDImS0YOzg311yCERCnUO9Idmnf7Mqf8ut2zD0aAxWRQhkHvTKuYjB6jAFEdt4xPVE7e2toaVbyF+f0IId0JNY8EMifojKc2exy2Doc4HU5xuVxy41inJFk9UbS+Nh6iGreU1ktGnEPOHGmUfXbNpeYRQjoMk1gQEkAwu+opvrJzLgSiXlTllIpau1itFu/++vp6JealtQb1vmpHvCz8trFJOgVCCCEk3DWvvE4Evlm7U8TmcEutzSVOTFrKTj2D4bpp2w7l1E1OTqHDlhBCSMTlBEVADoCWpcfZpb6qVE0K+LPxEJVrNpmVjffWuiSVD5cQQrrdaYtUBJs2berwPyIkFoAB2q9ntvRIs4jRYFRRthD1NGujWA07cxoBuyHOmwwc8g8Dd1uFXS1ZIIQQQiJG89LNO5fZubH8Ds5bka3lDmmwezQNK04QjaRe4nZLSUUdJylJSMB5h6g5nn+EkI7mBM1P95QEyk5yy7EDKsVisYjT6ZCqqkq1isTXxtPANm08EgqoeTHotH3zzTdl4MCBMmbMGHn++efFZrN1T8sIiVAyMjLlmhP6SF6qySvqJ+5aq0QdoMPEspk+eZlqxhYG7ZbSRtm4AwVcHFJU2VTkCQlWbkosdcY9xZ0Q0hHNu/CoXioNgtVsEKNRxGIWT4oEESmuckh+mlkuODxVGb3I+X7Xx065+vVauWLxVlXYhZBggfMNeSmxzBn3PP8IIe1lUF6cPHLuAFkwJVeuPtwte+2SoeqRmM0WNVmJFAnIa6vZeAA62Gh3SEa8Q5wNlaH+ChEN7ZOua976wgYew1jJafvjjz/KM888Iy+88ILK6TJp0iSZPn267LfffhKJMN8R6Q6QfB5LQRtrK8Rmqxez2axEPT09XQYP9hTKQ8c54+ktUlXvELNRJDNBZMA/AwImB+98FXNWgO5cMSEAh8rS38wqbYdWWRSD1EiG58VOqHekO8BQEg7YzaWN6gb9gqb1SIOOGWXhBQMkLdGsdPGyF0plXZFDHC6PY3dY7wR58ry+1LxOwL6t84WENLKS3HLTMfGSkJAQNceQ58VOqHmku8fO5eXl6nF8fJykpqZJXl6+5Of3UM6yu94ulN+21qvct/3THXLuvi45eHi/mL8uOwOOp5ZyIlrsk2BrHgLFqupdkpNikp4Z1qg5hhUxoHmdymk7YsQImTdvnmzbtk2eeuop2bp1qxx88MEyfPhweeihh5QwEhLrIPqof68cychIVw5bTHA0NNRLXV2t6lxAbppFMhLdkpfkksw4uxjcdtlSUi9bi8pC3fyIHTzV1NSoe+0Yk7aB0GnivuR7lxRWONQ2RB4DpEiejeV5QUj3A4fr5eNypW+WVaxmo3LYZiS4laGaleAUl63K87q4VFlf7FQOW2B3upVBW1XvDO0XiEDYt3WcqgZXE4ctCgoVlNmkqCx6jiHPC0KCA5xDWDlpwdIShUFNEjQ2NqqtgblWSYozSnaiW7LiHVJjE3n+B7cUFxeHtN2RCOwQzWEbLfZJsDVPW/lU3eAUpGWOlmNYESOa16VCZPiR7Xa76pzwGBUTH374YenTp4+89NJLgWslIREs6Iiqzc7Okfj4BElJSRW3OUklqNeS2ucmG8VocIsWZJSZ4BSzm8v12ruU39fx6Lvt77WkKZiZBFoRPeRijtQcXL6/d0vnBSEksCBa46Gzestj5/aRvXubxGr25LGdso+RqbS6QEsaRs3rfCEhDRQU0udajkR9oOYRElo7D1G1ubm5ys5DNDfSI2gOs8JKh5iMmNj0vL6s3qTG2qRl/GmY74Sb3j6h5rVP81wut5ooxwonzcyLdBsvljRPmxrqEN9//703PUJcXJycc845smDBAhk0aJB6fv78+XL55ZfLxIkTA91eQiISVMneUiGy5BuXFFXZJTelUqYdZpJDhuaqPH/zPmqQoiqPw3biXga1TI+0vZQfs2raoAmOR20bYLul15KmaMckqb5eemU2qNQIGhD7lHhjRCxF8fd7+zsvCCHdF3G7d79EufvULJUeSOy1Ul1dKYWFqeraQ+Xs3fMt8sf2RrE7RUXk7pZnltQETw540pTWNIya1/lCQlrEFgoKnT7M4U3N0Zo+UPMIIQCBanAiwiGGvgPXWFJSMq5CldO2rMyzWhI+Eoyht5Q61KoTvC8nWdQqTOKfljRMcz7qHbfYRo7g0tLSZq8nzTUPxc5T4k2SmuA5b1uz8cJR8yo6YP9HIx122u65556yZs0aGTdunEqNcMIJJ4jJ1HSwPXnyZLniiisC2U5CIgrfjg6G6tLfyqWkxiaNTpHfCkWuerlMRvarkavH95YHzzTL6vUbxSJ2yc/PD4vOMVxpaUZNO2b6447ZuNbeS3aC44XbVcc1zxnlm2syXB0D/s4NREBoj8Nl4EFINOFvYI/0QNXV1bJx4zYVZdvQUCJVVdXSv39/ufHk3nLra1tkTaFd9S0o0vlXcWNU5FULNK1FkFDzOgfOs7lTeqnoIhirlZUVbeoDNY8Q0nJe1QyVFqG83C4Oh11KS3eofgV1TE4bliOv/JYgW0pFMuIccubInQ4z0n7N851w0469zdY0nSA1r3XNQ7Hzhz/e0aqNF66a19AB+z8a6bDT9owzzlBFx3r16tXia5DfBTNKhMQi/jo65PFD9CImOCqqxZvPb1u5QwnQLeMTJS8zRe1DuhF8RrR2Ol2ltRk132MWK7Nv3WnQ+hPzcFmK4ussaun35rVESPfQ2sAeS0QTEhKV07a+vk7ldS8qKpJBg1IkPTlO+mQZxWg0qL4GOoh+h8asdEjDqHmdA+eZFt3dHn2g5hFC9HlV8XhrWaPM+6hYpQWC3iFNJIqS4ZqE3iUnJ0u8wMYbJDW2BGmoLlV9j6aZvE6b05qG+bNPKiqoeR3RPNzasvHCVfPiO2D/RyMddtreeOON3dMSQqIErWOrrfUsk4GwDxqUrma0NpV4KmYDLAs1mQxK/Eur6v1+BmlOR2bUYmX2rTsNWn+Eg2OgNWdRS793uC31ISQa9U6/fN9qtSjjFaAgJ7Z3VNb/k+evee5spknomoZR87oHah4hRMur2mB3qYJOyA9aUG6XnzfXS/80Tx+haR70DmAbE5fIKmrTOcho5/mnrT4N9gmcjVp6Cmpe4G28cNW87OxsdWvtt45mzWuX0/bKK69s9wc+8MADXWkPIREPOoqiokK1VAbU1VnUMhksQcCM7PbKWlXDMTvZJBazRTlzs1ITpLS0rslnkJZpqyOO5k47HAiHQVJby2QiYakPIdGod9pKEe36QmFiPJ+Wlqry/mWlJUiPdHez3HQt5VWLddrTT1HzuhdqHiEETsL8NLOs/LtOOWw1nv68VEXbAkTXWixWqa2tVQ5baJ5m04XaCRYptNZPtZSegsSG5uX/k/4nFjWvXU7bH3/8sftbQkiUgA6ipKRERR1pgo2OZlB+hhJ1zMhC4BFppAlORkacmvmi0dV1or3TDhdCfUw7OgscLkt9CIkFvdM/v/feGc2cipcdldRm7mzSPqh5wSHUx5SaR0hogUZNPyxLOW2BxWSQ3FSzsuewUkTrI+BYamkijXZeYNJTANwztVL3EepzlJrXCaftJ5980p6XEUL+ISenqQGqdTRaZe2HzkpoM58M6RzR3mmTzs0Ch8NSH0JiSe/0+F6fyE2HXO5IDYSVJpi4JJ2DmhcbUPMICT179U2Q/XdJVGkRkJPd0MJKEf31CWcjlvPjnnQ9PYUeplaKXqh5XcxpiyJkDz30kKSkeIomaWAZwGWXXSZPP/10Rz+SkJjMyaMXmM2bN6kCLVqkkv4zSMeI9k6bdH7ZcFu5kAghwVlGp9c8sScrTeQ12TmoebEDNY+Q0AKtunxcbrtXimjL+beU1ktGnFOm7GOUvhlcEdHZ9BQ43kytFDtQ83ZicHdw2sdkMsn27dslNze3yX4szcrPz/cWnIgkPLnW0qSyslJSU1ND3RwSY6CzWblypdTUVInVGid9+vSRvLz8VvO2kNZhfr/AHq9IPZ76ZcMAYh5J7e8OqHck1FDzAk+k9tGhgpoXO1DzSHcA90lbKybxmplLCpTD1tbQIC6XW/JSjfLvcVYV/EbN6zj+c9pypU5btKZpkaZ37n8i1+HER82gWNE8c0dEDwdJdVLV1U1m8p1Op7z33nvNHLmEkLbZuHGDVFVVSGOjTRoa6qWoKE769esf6mZFNNHaYXenkadVf8/Ly5O+ffs1ez6S8iVqAxBolX4wzWXDhIRmYK2/Dql5gSfc++Rw04dNmzZ68zD7Hj9qHiGkLXxXTPoD+geHbaOtUflKXC6XFFYapaTCrtIKkY4DBy1y2DLFYGA0L9L07k8fp/3kESLZOp99NGteu5226enp6sLAbdddd232PPbPmTMn0O0jJGpoaSbLbkcnahW73SEOh10MBndYd5gkusA5CYetVv0dS5YRjaJf8qynvr5eDHGpzRwx4YJ+AFJXV6vutZQjXDZMSOijYah5JJSgcJ6md5g0wLZvoSA94W4EUvMICU87D+PknCSDbG1wi8GAJfxuSbU0SoLZQs3rZoc5aZ/mRZLeuf0Uolu40i1XHuL22qPRrHntdtqiGBkO1pFHHimvvvqqZGZmep/D4Ltfv37Ss2fP7monIREt4I2NjeoG9Lnn8BwG10ajSYxGoyQkJEhycop6HwWdBAMIHGZfNTALqxdtfb7EzeVuWfpFg5TWbg7bZUla27XIYYvFLMnJyRGz7IeQSAbahYmd+z9AP2FoUuEZhcdsNhs1j0RUjmCM3QoLt4ethmgTr1oUVWJiEjWPkCA7aYE+YhFOMvhHztrXJE99JVJY6ZL0OLscP6hGjMYMah4J25z44ZouoUpXiM7hdIjb5ZaiKoPEp2SJRRrDrr0hc9oefvjh6n7Dhg0q/xgG24SQ9kU/lJeXNykyhlkubVYIoo5JkMTERGXA5uTkhvVMF4kuIHBIiaAvhKefqdQEEI4Yj8O2qSMGy5TCKeIWbS8qKvTOKlutqVEv5ISEk+bV2NxSUOYUs9ksZpNnmIklopu21UlynIGaR0IKliUjIlVzcvouU9ZHIGkT7riF69JRtE0fRZWRkclcmYR0M77LyhHYpo2FMYlSXm6XjIwM6ZEsMuf4ZNmwtVCMzgZJS8tQ42xqHgkHzfMtJAvCNV1C6j+F6DCe1Gpo5SQY1LgyIyP6Na/dTlsNRNRWVFSoIhLFxcUqP4uec845J5DtIyRi0QsyOkl0lklJ/l8Lo1Xv+Irm8P5AEK6zgJEKctgiJUJLxxTbSImACFv9DOeWUofKKxVOy5TQVkyKaIMTDo4JCQ7adZZkFbUktKzeLfJP14DtJOvOurfUvI5BzQscvkaqv+Op7UOELZyiWiQrHDPhdvwxCQL91jQP24SQ7qW1caU+dyiIi4uTvffYrUnBJGpe61Dzgqd5+m1onn7lBlZthAsGg0Gt8Lzv7S2yvdIzrpyyj1Gt4IoFOuy0ffvtt2XKlCnK+45Bgn7Qjcd02hLSfMkBHEcWS6PYbA2SkpKqrh29eGuzXhSotom0pOmRQlvHsKUZTmdDpUjCznQ54QCuJzqECAmN5uHaO2Vog7y2Ok7KbQbpk5UgU0clicFQ6X0tNa/9UPMCT3uPn+/Kjbo6S9gta0YbMcbUggKod4QEf1k5HLOa8wir17SUeNpr2zNZRDxQ8wJPe4+fv5Ub4cSgvDi5+9RM2bRthwoQwHgzVjSvw07bq666SqZPny533nmnWtpGCPGP7xI7De1xdnY2xbsTRFLS9GgikmY4OTgmJPho1xki3XunuWX2GJPUNrqlX89ENfCvqPDky+Y12TGoeaEjElZuUO8ICT7+0qhowQIIzPF3TfLabB/UvNARCSs3MjIy1bUWa5rXYadtQUGBXH755XTYEtIOfJfYaaCjYc6xzqFFvmiCAuc3CQ6RNMOpF3HM2sPw1iL8YkXgCQk2uLagb5rxmhwn3okdPIfl5Sgmoc//R1qHmhdaImHlhq+mbd68Saqrq9TKLqQ/IoQEz8ZDDYjE9DzJS0unznUCal7oiJSVG+kxqHkddtoeffTR8t1338kuu+zSPS0iJApz8mhijjwxVVWVqlPROsJYmykikU2kzXDiGty0aaNueWutug/3dhMSDXoHo0vb3lZtkoXfNqoihki1gsh9TAQREs5EWiQrjFdoHigrK1P30WrEEhJumrdhh1Pe/cstlY02yUpyy9T9rbJ7r6Sw7zcIiUS9iyXN67DTdvz48XLNNdfI6tWrZc899xSLZWeibXDiiScGsn2EREVOHgBRr6ys/CfqqFr++GO1N2Idhi1yIEVjJxNoICT6WUBEUEaSuERq4v9ILQrgGVDbvdt4zKVWhHS/3uFaczjsUlq6Q20v+CZBym2eymSbS+xy/3sF8si5AxiJ1AbUvO6hLU2LVM1DtFFr24SQ7tE8m80ub6xJlLIGpxgNbimwueSJLxrlsgNKJCmphCu92gk1L/SaF0mrgatjRPM67LSdMWOGur/11lubPYeBt9PpDEzLCIlwfB1DbrdLEhISvQYqls/Y7XbvdlFRkcojQ0Fqf/J/zGoDHEMmq+++xP+RXBQA5wuWVyGhPsDjcF3uQ0g06V1GRoaUl5erwoUVtXYpqY0XcTtE/vHRFpQ5ZWtRmfTJzwpNoyMApJFoFKs3nQQ1LzC0pWmRrHlYyaVFG2nbhJDu1zxrUrpy2AL4QwxGgxRVOaWorFoydfZepPQloYJ2XuCh5sWg09blcnVPSwiJItD5VVdXq6XYmC3UOhEYr5rzKCEhQTltNTyOJUYAtoY2C4jE6Lj55kXk8euexP+RXBRAXxwJMNKBkODoHSKPtAmT9CSLKl5YUuP2vg/bZnf4FTIMF/4sssn8ZSUqnURWklkts81KpOYFgrY0LZI1T1uxFe35/QgJN83DSkqlc7VuMZlM4nK7JDPBKQlmt9LCSOtLQgHtvO6BmheDTls9Wgg1IUSazVZpIgPB0RxFiKTVO4+QZxMRtlpVYl5P7V+KhGOJ46Xfx+MXmJltbbs9z0XCkh/so6OWkODqHZ5LTk5WebBhfF0yxiRPfFkjBWUew3bKPkY1eUmag+OoOWxBaa1BXvhR5Jbx2VJaWhq2fXGk0JamRbrmRavRSki4a96MQ2tl4cpG1Wcjp+1pexglLS7V69wNt74knKCd131Q82LQaYtw/zvvvFMee+wx5Wxat26dKkp24403Sv/+/eW8887rnpYSEiHoZ6cg0jBatarZhrhUGTRoZzVRzZHLXD1t428WUMu5w+PXvcnnwzkxfSQv6SEkWvXO33WYny/yyKAclRIBEbZw2PJa9U9Vg8vrsNXAtik+TbKzI6cQZLjSlqZR8wghndG8A9IzZNRQt1Q3uCQl3qjsvUjNjx1saOd1H9S8GHTa3nHHHbJw4UK59957vfltwbBhw2Tu3Ll02pKYx99slX6Zo2/V7FjseDpDS7OAPH6Bo7VjGa7HOZKX9BAS6bQWneHPUIUByxy2bZMab1RjBb3jFtvKCZAQnn1xpNGWplHzCCFd1bxw7kvCDRw3pJ2obRRJstLOCzTUvMjG2NE3LFq0SP773//KlClTVL4Wjb322kvWrFkT6PYREnGg08vOzlazr7hPS0tvsswR99hG5K0vEPzCwu3qnvg/rjhu/o4diU38LfEhhIRG73yLF8K4xX1LmkbN8w+c25jcxfJa5L7HPbb1uf1IbELNIyR0UPO6jx22RHngS7PM+UjUPbYJoeZ1MtK2oKBABg0a5LdAmb6oEiGxjH62qrLe6XeZI5bOpCbsnPhg+H/70IxW7VjxGAUHfQQBJiKwfBfRYKF2IoTzkh5CYgF/11x7IiOoea2THVcnVx7i+CfqyKG2RTwrdEj3E65Lmql5hIQWal735XFHLmCLxSKltaK2507pFXI7I1ag5kWZ03bo0KHyxRdfSL9+TRP+vvLKKzJixIhAto2QqF/mqIfh/23DYxQa9APN1VuqZelv5Wpg5ZvqI1TEqoATEq60p6gF+/PWwfGAsZr8T/fK4xM8fJ0rKBqLYnrhYjCGQxsIITuh5nVPHnffACfSPVDzotBpe9NNN8nUqVNVxC2ia1977TVZu3atSpvwzjvvdE8rCYmCZY76nLZTR1mlqKiwSWcY7pUbwwEeo9DMuiLHFM5jzIQv+d4lZfUONROupfoI95nwcJ09JiRa8Y2MAFgSSs1rPzw+odc8UFtbI+XldsnIyIiI6DjqHSGh1bzGxkZ1j2tRfw2yT+96gBMJLNS8KHbaTpgwQd5++2259dZbJSkpSTlxR44cqfYdddRR3dNKQiIcRCLCsYUZQ2dDpZSWlgr6QX1nyPD/tuExCq4Ibtq0URob7eJw2CUxMVHc5iQpqXWL2WyImJlwLkcjJDT45voD1Lz2w+MTes1DdXhsW62WiIiOo94REjpwreEaxLUHx63vNcg+vWMBTszj3r1Q86LcaQsOPfRQWbZsWeBbQ0gUA+GBY2t7RYPU2NyqMib26TvDaO1oAgmPUXBEcP36dVJRUeGNBEDtt9yMJMlLs0lFgyFiZsK5HI2Q8L0G2Z+3Do9P8KJ0CgsLpbq6yrsfmodiQ1giCgdMJETHUe8ICe9rkH16+wKcYFfQYds9UPNiyGlLCOl454gOcFu1SZ76qk6Kqp2Sk2SQKfsYZWR2+HaGJPbQZi3r6xukvr7OK9hbK0Ue/a5etpZ5CuNgKdPA/MSwngnHd8GSn7q6WjV7HO6DD0KiTfMw+C8rK5Pa2loVuYHrkNcgCccoHeTws9k8EXCeSLg4de663S4xGIySmZkZ9tFxuObKy8t5rRESIs2z2WyyY0eJmM0WdR1mZ2eHunkRGeBEgq95SIEn4lbaERcXF1Y5bVsiljSvXU5bDFTWrVunOh7kt2jNQMcAhxDi6RhLSkqUwwhUVlbJf39Ml/IGkxiNRimrN8nS38wyet/0UDeVkGazlGlpqUrMTSaT2O12eeEXkfKGejUVm2IxSVaiW24+LkEyM+PCemCi6RUGIzk5OWE9+CAkmjQPBoHD4fA6wJKTUyUjw8prkIQN+qgcaF5lJR65leOlqKhYGho2SVpaujIEEYGUn99Dwvn680yUWNTyVl5rhATHUYsb8oBqmof7xMQEyc3NC3UzCWlT8xoa6tXKSpPJrM7rhIREyc3NlX79+oe1hlTEmOa1y2n74IMPSkpKivdxuEZVERIubN68SYqKiqS+vl48l4tbCstqpKgqRUwmzGSZRQwixdUiVfVOSUtk0HtHiZXE48FGK5SAGcvcXM9yme2l1WqSweVy/nM+G6W8XqSsukEyMyXsByb4LjC4eZ4Q0j0gL9qGrcVicNSLUWVLcauJSk8FYk9utMxMRB5ZQ93UiIWaF3j0hYGgExkZmapIbEODTa3SaGy0SV1dnXqdfhlpOGsevkdSkvBaIyQIuUBh58H5hceVlZVezXM4rFG/XLu7oeZ1v+ZZLFZVJBZ6Ad2DnYd9OJ/D/dxtiDHNa5enaOrUqd7H5557bne2h5CoEBk4bHFfX18rRqNZdSSuhmpJszZKld0qDrdbdtTDAeaWG1/dLpePy1W5fEj7iKXE48FGXygBqys0UcxMcEppnUE5cTFxh/QeWakJEq6wSi8hweGH9cUy94MqKamJl/Q4kxw7oFLykxB5VKv6Cji+jEaTKsAJpxjpONS87sFfYSBE2WLbc48UQZhoF0lJSZVwhppHSHDAipLi4mIVVet0OtU+i8VMzQsg1LzgaB7u7fZGdR5jVaXT6RKzGX4LS9hrSHyMaV6Hq8e899578uGHHzbb/9FHH8n7778fqHYRErGgA0QVRuQDxUwVRByD/ry8HBk/sEoyE9xSaUO+HoPkppqlsNKhqmV6csmQ9hBLiceDPUjCjCvAMlCIu7Ys9MyRBslNMaoJiF6ZcXLJmEw1OMXr8b5wA22H0xnXFa8tQroHXFuPf1alIvEB0v+8+1eqyoeWm4t0JFhanqieS0hIUEvZwrG/CHeoecGL5EIandTUVMnLy5cePXpKz5491TLRvn37eTUyHM9htB/6jLRGuKeDg5DuAXYdbDykRMBjp9Ou+gxqXuCg5gVH83DvWVmZK3l5edKnTx/p33+ANzVCqDUPY8zKeqdfOy7WNK/Da7Jnz54td999d7P9LpdLPXfssccGqm2ERCToAJGAHrOsmLFKSkpSwp2amqaWkvfPt8sD3xhVjj8t0ciW0nr56fd1khxnYN7NdhBrs2uhmNX2LPHyJKGH8xOO22H9bGIXi4qwhcMWr8egFZMTEHsYteG2dEpL56N9N15bhASOqgaXlNS6xWgyqnGgyyVS7YgTS6JJkv5ZqYZoI2hgTk6u2sY1q+W/BdS8tqHmda/mISUCzkf9uagvpofjrb0+XDVPy+8XFxfvdRTxuiIk8MCu02w8k8koJpNFReLj2kP/QM3rOtS84GmeZuPBUat3kIda8/4ssqmgtu0VdumRblGFr/WrkmNN8zrstF2/fr0MHTq02f7dd99d/vzzz0C1i5CIBR0GOjbkP0O0EYQGM7CJiUkqN3TfvnGyy8Y61QkBh9MhqWabVJeVSo1BvEVcornj6Y4ljaRr6GexIdDl5UjqnqEGTRD0nQMou5SW1qlZT5yrcO4CpATBeR6s36I9S6c4U09I95Iab5Q+WQlq4tHtcqsim3mpJslJ9wysoXlYHooBtQYew2DQ+g5qXttQ8wKPpgdaASEYpdoknxZhBG3B+Yr7cNc86h0hwQGOru3bt6tCvVhKjpy2mNxBfwDnFzWv61Dzgqd5sPGwutJXY0KpefjfmsMWbK+wq+25U3p5dTrWNK/D6RHS0tLk77//brYfDlvMPBFCRM1EDRo0WHVs6OA0IDwQ86mjrJIR71QOW+QGPWn3hn8KPElEJP8OB3BstSX8pOvoZ7FxDmrFgwDOR3/npHauQtyREiSY521LYq1fyuM7M8+ZekICCwbPiH6A49ZitSiH7ZR9jF6jFNcc9FC/hA039B0a1Lz2Qc0LLJoeaOeipnnauejvnEShIegdnsPrw0nz9E4iQL0jpHtAH9y/f3/Jzs5Ry8oBChcC9NGw+7TUXHCIUfM6BzUvtJqH83fbjiqprg6+5mEVl+aw1dheYZfqBlfMal6HI20nTJggM2fOlNdff10GDhzoddheddVVcuKJJ3ZHGwmJSGCoQrix/AAGrLacHDNWqYZGufpwt9Q2imQkW6SiwiT/TGRFRPJvEt2z2p4B5k4x1M5H/VIlRBpUVlaoiHKrNU4VZPAV0GAvnfKdJcZgWSumxpl6QroHLFdD9AMG086GSnUN1tVJE83TL2EDnsF/vfcxNY8EG00PPNFEFpXXD2jnoq/GoEgLJh5QZAjRdfrXhoPmAW1ShHpHSOhsPOicFg0IcD1S80gkad7mcre88KNBCsoyJcWcpGryYH4iWOctVnEhJYLecdsj3aLGmEg/Eoua12Gn7b333ivHHHOMSofQu3dvtW/r1q1y6KGHyn/+85/uaCMhEQs6EDiM9OLtSZsQr/Ylx4lKoYA8Mhs3bhS73aYicaO94yHhif68ayl3nrYPIC888njBYeupNmoNelv1bdSKqOnbill6Qkj3Aj1LTTCJJGSKzWbzq3ka6Ce05aMWi8Vb8IKQYIPzTkuF4Kt3vrlty8uxeiNBFZHF+YyUV8E8b9ujebi2qHmEhN7G8x2Has5cah4Jd82rr6+XpV80yI5ah5gtZql1GuXjrVY5YI+4oJ232iou35y2NltZzGqeuTPpEb7++mtZtmyZ/PzzzyrR9vDhw+Wwww7rnhYSEsGgU8SSGczCajNacHL5i2JEHiSR5JhIpk3CH72oa+ej/pyEsaiPFkDxvWBHDvheI/j/yBumpXdAlC0hJDho/YVvxL2v5uExbnDcEhKueqft1+sdIuWgM3DeYrVJKNqph5pHSPjbeFrBJGoeiQTNM8SlSmntZjEYDSIuUYVmKxqNkpCaHbJVXCnxRuXI3bzZM4EKvcM1F0sR6x3OaQtw0MaNGyfXXHONXHrppUFz2N59993qfyM9gwZOtksuuUSysrKU0+vUU09ViZIJCTXasjVtBlbLbaTPdYQZIpzDWkVRDeY6IuFy/mKpDO6xre3XcglBMHE+w4BF8b1QTzQgkqGyskoaGupC2g5CYrm/QN8AbcOYzJ/mIRIJhTA0qHckXPVOe07LVxlOegeoeYSEr42nTaIUFGyl5pGI0TxXQ6WquwOwitJkNEmvzDjpnZcZslVcBoNBtbG8vExFAldVVarxZDjocFhF2s6bN0/OP/985c3G49a4/PLLpTtYtWqVPP744yqqV8+sWbPk3XfflaVLl6ooYDiRTznlFPnqq6+6pR2EtBe9KGMZnViSlIgjFws6n5KSYlW8KTU1zfs63/wyhAQbbeYVRqo2GMVgE0KJZV3Yp52nHsdMfljkEkK7MWHnabL/yqKEkO7B91rTlqzpDVtN8xCVj5QqINYiJUj4gXMUThWck5q2YSIdN2ifXvMwluvXLyfkegeoeYSEDv21hv7Bs1pSvHqHvmPjRuS63TnBor2WmkfCycbzp3kT90qSJd+7pNxmkr45iSo1gf71oaCkpERdR5rmIRVXLNEup+2DDz4oU6ZMUZ0MHrcEfszucNpiFgD//4knnpDbb7+9SRXXp556Sp5//nk58sgj1b5nnnlGhgwZIt98840ccMABAW8LIR1dIopk3p6Or05ykupl4l5uybLWSkVFxT/vMKiZWRgDEP1wcICR2ERf1ESr/g6Ki4vVvd3uELtYpF9PTzqPUOcSwiQIKowiYf3OyqaeQg9YLsqBMSGhWSIK/UNEvmYYwBDQNA99B6I3cEMkEvWOhFrz4LDVnCqgrq5O7YP9gfMUBVg0x0y4nK/UPELCJw0QtktLPX0JQH+C4oUIdoCNhxs1j4SbjQddw/isueblyuwxSWKwJsrAvj1D7rAl7XTa/vTTTyqKFWzYsEGCDdIfjB8/XsaOHdvEafv999+rDhH7NVAgrW/fvrJixQo6bWMAdDqrVn2nwuQTEhJlr732CkmeMQ3fSr4Q65d+dki5zSBmk1lKah3KgXvBSEQbmdUskadSo1slpge++WUICVXkAJyiqJSNYnnba8zyxpoEKas3Sd5fRjn3ALeMzA6dgfhnka1Jgvqpo6yS6nUY2cNm+SohgQSRdb/88oty1KSnp8u+++6naguE0xJR9Bda3lrNMMA16XQ61Q39DK7NXr08xWzh3OVkJQml5mmTDZ6Cmjh/7cqAxflaX1+nCguFQ4ScvngMbjsnSah5JDpZs2aN8j24XE7p0aOH7L33CDEaO5XdMeA2nla5XtO7nZM/bhWQA13UbLwePXp50yVQ80i42HiYiPTYev41LzstMWQOW99iaTk5OWpMqeVwD6W/J2ydtpmZmbJ9+3bldUdE62uvvaaMhWDw4osvyg8//KDSI/hSWFj4Tz6Lpm3BwAXPtQQcZfqQam123eVyqRsJfxD599RTT8pbb70ptbU7IwIx4D7yyDEyffp5MnTo0KC3C3lW0Plp2FwWKamxq302h00NNHbUilgSUiXJYVdC7nA4xWQyS0VFpdjtnplbRCe5XO6gXWeEABirbrcndx/IyvIMMCGQj/9gkAqbSUwm3Jtl6a9mOXxkakj6TFxP8z4qVg5bsK28UZ79xi03H5cpSUlJarCBaydS+vPuNECod9EBHLXPPPOUfPLJJ01+NxQ9mTBhgpx33nne6zVUmqetFoF+VVZWeKOMkA4B2hwXZ1Wvg2GASVZoHCKTADWPhFrzcP5q15AnMrxenE6HsjMwVsN5jHRWoeo3Eamuv17Q1szMrIjTvO52uFHzIh9oynvvvSeLFy+S33//vclzCMyaOHGSTJo0WelLKG08/P/c3Dz588/1Xs1zu12Cl+A5vNZsNqlt9B/UPBJuNh7OP+wPN83z1TvXP9dKnz79xGZrUJoXSj0Ohea1y2mLQTjycMJp++mnn6pOKRhs2bJFrrjiClm2bFlAZ7fvuusumTNnTrP9xcXbpb5+Z6JwEp5gxnX27OulrKxMbefn50vPnj1UMYa//vpLPvroQ/nkk//J9dfPlkMPPTSobdOMVQg7DFOrNV6STWlSUuMZMOLCzUkWSbRaxW42islkVIasxWKSgoLNauZIw2arF5uNxSVIcHG7nd5CQtr55zYnSIXNIdAdTDDgvC2stMvfW7ZJclzwZ2CrG9yyZUfTa2PLDruUVYtqD9pdVBQ5106PHp6Iw+6Aehf5/O9//5N7771PRUCAwYMHSUpKihQUbFORt4sXPycffviB3HPP3dKnT5+Qah4G0hj0o7qvFiGRkZGhijdB6zyvgUHglG3btqiIDg1qHgkXzUtMTFDjNThekpOTJCEhTmpqKqWoaFvI2gk7zPd6QRFmz+PI0bzu1DtAzYtsYCvNn/+wvPPOO2ob1yBW0ZpMJlm/fr1s3rxZ7rvvXlm+/GOZM+eWoEa/++pdRkamVFdXqshZX82z221KC6F3Wv+BGzWPhJPeaboRbprnT+9sumslFjXP4NZPGbXAqaeeqgp7IVfsZ599JgcddNA/Xnj/xkWgeOONN+Tkk09WHbUGjBaEaePE+vDDD1VqBHSU+pmqfv36ycyZM1WRsvbOwsLQwecg5wwJX/AbnX76aVJcXCQDBw6Sa6+9VkaNOsA7i7Fu3VqZP3++fPbZpyqy55lnnpW99to7qG3EgKKkpEh1fJjgKKqzygs/ioqwzU4SmX5Qogztk6KMW20WCVgsVm+krX4GjJBQA5mY9fw2b2QrQEqCB88MTZ6jcGtPpEXaUu8ih1WrVsr5589QY5+xY4+SSy65VAYOHOg1bjE2u/fee2TTpo3Ss2cvefnlpUH/XX01D/fQaCwLTU5OkQEDdlHXrP7a1CIa9RpIzSPhhD7SJxzOz3BrTyRF2lLzIodHH31E3XCezJhxvkyefKZa8QuQd/Odd96W++//j3KcHnXUOLn//gdCpnfaEnMs2d6+vUCtSoMjt0ePntQ8EnGEk8aEU1siKtJ28eLFsnDhQhXFCKftHnvsIYmJidLdjBkzRn799dcm+6ZNm6Zm3K677jolwug0ly9frhzLYO3atapDPfDAA1v8XORbw83fQQ1VnhzSPl5++SVlDA4YMEAWLXrOm2tZY/fdh8i8efPlqquulI8/XiaPP/6YPPbYf4Paxvj4OCXaAMsNUuurZOrQBimvaZCM5HjJjsuVhIRclZ/FaDQ0ydfim7+FkHDh8nG5TXLIopKofkItEtoTi9cX9S6ygfEKhy3y+t911z3qN9tZgM8khx9+uOy5555y5pmTZOvWrfL666/JtGnTQ6p5WPViMBjVxCmMVhi0+pzt+uvPVwMJCRfgKAqn87Oj7YlFvQPUvMgFDvZnnnlaPb7lljlyyike216/8hdpEXbddVeZPn2aLFv2kaxdu0aGDBkaEr3TNA8RuGYzAm8cyi8B3dPybVLzSKQQTprXmbZURLnmtctpi8iJCy+8UD3+7rvv5J577gmKtxvL/4YNG9ZkH3I3YTmQth953K688kr142IG9bLLLlMOWxYhiz6wFOWVV5aqxxdeeFETh63vhXrllVeppTNffvmlbN68Sfr27Re0dqINnsTzWqJvUYViLJYq9RgGt9aZ+HYq0djJkMhGu7ay4+Nl7pReUt3gkpR4Y8gjWgflxXWoPfoCEtr1yeuNhDNYCooxFyYjZlw8S53jvgX4MFkxKC9T/u//zpdbbrlJXnrpJZk69dygOif8aZ7dnuDN5afXPF94DZJwI5wNv/a2h3pHIpE333xTXXuDB+8qJ598SovX5MiR+6go2/fff0/Vvpkz59aQ6J2medBmpADyaJ7rn3o71DwSGYSr5nWkLRUxoHntGtUjNwsKP4FQG+q+PPjgg3L88cerSNvDDjtM5TdFoTQSnblskb8PUd6ILMIFqr9QcZHiHttIVL/ffvur57/99tugthOdBCqEYkYY9/3791e5apHQW5uB1dpOSDjje20hl1dqgilsdADtaG979FVT/W0TEm5888036j69/z7yr7dtcsXirXLX24XKYQtH6NayRlWQD4+PO+44ZShu3bpFRdwGE2oeiRb8jScjEeodiUS++WaFd6UtxputXZOaU1d7T6j0DhG1cNxqmofHyBkaqX0HiS2oeZFDhwuRIT1CsAqR+QOF0PRgVmDBggXqRqIbbeYEEdgQRG1GBRcmlqcglxBEE+cr0Jam6GdEg4Xv7E5JSYm3fRD0aOxMQkG4zg5GC/rzFNcYKnaCSDzWvtERwSxeQUhnqKnxVPl1Wj3XW0G5Xd1yUkxSUu0Uu9Ottn/eXC9790tUq42gi0hHEGyoed0P9a77iRbNo96RSERz1MKOa8vGy80NHxsPoK+ABkPvADWv61Dzuh/tPNWusdZWRoUz8TGgee1y2qLY1+jRo1UhMvyYKA4WjEJkhOhJSfEIYWVlpSoygJxV6GzgwEUeJNDQUO/NNYRqnp73pUiogQNZHw0YjZ1JsImFpRDhIoIQc6y2wDWHNCWReKy19nIASCIFS7xH8+w1Jeoe+b0wBiuucorDtbOG7NOfl8qdJ7uUNgIU/wo11LzAQr0LDtGiedQ7EokglRzYscOjea3ZeNu3h4+Np11fWh8NqHldg5oXHHCeFhUVqmsM11t9fZ3SvWCmlQwE6TGgeWFdiIwQPahAjfQXhYWFqmL2kUce6RVFzG5qs7CYUEAqhe+//14ZjQceeFBYdyY7i8qEPk9otC2F4Cxt+/F3rLT78vIydY/zE8KOKLpIOZ766ytS2kwIOPLwQ2Tu/SK1W3+Sxupisabkyu494mVtoacyusVkkNxUsxRWOuSV199Sq6CQmqBXr14hv97S0jx1D6h5wV36R81rP9GqeRqR1l5CYK+tWLFCPv74Y5kw4aQWbTygpUI8+OBDJBygnRdYqHnB0zzomzbpj/MTqShxzUXa8UyPsPZ2i9MWM1+hKERGiB4UY5k4cZI89NBcefnll+Woo45SFyg6ISxHSUryvA4Vq++99x71+PDDjwipAevbSebn92jyHIrK3P9egRRWOCQ/3SxXHddLFVgiXV8KwVna9oNjtWnTRu+gGOgFHbdIXOrlv2gTry8SGeyyyy4yfOT+8ssPK6Xo6ydkv9NvlMvG5alzGmkREHkL8y/TVCXPPfukes/EiZNDZhT6vd7ym/a51LzuW/pHzWs/0ap5gE4MEqmcccZEefTRR1Re9s8//0zOO29GMxsP5/WKFV/L//63XG1PmjQ5rK43zUGLe2jxD+uL5fHPqqSk1i19shI4Dm0n1LzAgqLscMZqKav0xworoyoqKrxjR7wmkvSvIkY0r8PlhT/55BM6bElIBb13794q9cEll1wsy5YtU0tBkQw+KSlJLZe57rpr5YsvPlfh/RdddHFYJfhGp4m2Yz8EHcZrQZlNnC6nusc29pOOFwPw7ahjISl5oMAsq2dpTL03qkgPBB2zrqiOi3stX3Q4g+tIcyAB3GOb1xeJJK6ZdYUq5lW94WuxfXWHNJSs+3/2vgNOrqre/3vvnT47s71lU0lCCUgVkCYdFBR58HygqBEVRFGfYPmr7z1sT8GCoj5ULBQVBQQEEUF6VUEB6ZAEUjbbd2an11v+n++5ezezm90kGzJt93x1mLkzs5kzZ+493/Nr3x8+dVIHFrZ4AEOHOvBXrLnlM6K8jVm2Z5yxpeN2LVxvzFiUnFd+viMk581vzptLTWUk5ie4vjl2GxuNMwEnm81OrH3MsmWGLe0/wzDwzneehpUrV9bM9UYH7aev78N5v9wk7p9aM4Qr749iIF4UMiu9kazch+4gJOft2vOUDluH7yj/UzpXnNvOzs4JvqNTt17kPWLziPN2KNO2FB/60Ie2+frVV1/9RsYjIbFNNDY24qqrfobzzz8PmzZtwkUX/SdaW1uFI3dsbEw8R3Cx+frXvy6kPGqpqcXYWBHNzc1icWEkltlGpeBxkiU0fq0Ko60/bCuiNh9EySuFetQK4vXlOJAc8FheXxL1hAMOOADf+c7l+PznP4vHH39M3OicDYcbMbi5F2NRu4zbE16ABW/7GgZSLqwYz0iq9vVGA3VjfwYNXkVy3i7A9tZdyXnzm/MI6cSQqHece+6HEI1Gce211+BXv7oOv/nNr7HHHntA01xYu3aN6GniSClcdNFFVR1r6fVFRywzasdyNpeRD3/8YBYjKQuiJIbvMS25D50FJOftuvPUzp7NimNWmEydK2rY0mErOW8OOW3pGCsFNdReeOEFkVZNjVEJiXJjyZKl+N3vbhRkfuuttyASiYgbwSjsUUe9Faef/i4sWrR4IuJSrUWolFBKy/AIt5UX5aF9UWPiOR6HfLNOgJeYQ0ZXNcAsInacd87R6bKK6m3+qB3GEu1SRxKP5fUlUW9gM1hy3nXXXYu7774LGzZsmHjNE2xBeI+T0Lrv6YghJDJXL3mbT8haVfKane56aw8qCHq2ZBRJzisvqCNMxzjnudK/f71hLnIeIZ0YEvUOlmh/9rOfw0EHHYRf//rXePLJJ/Dyyy9PvL5ixQqcfPLJOO644yeaJ9H2q7aNly5ASCC4Snyx0ayF5gAwZvvKoKiK3IfuQkg7b8fAuXEkEch5zKqdbq7qcf5884jzFGsX5OibpomPfexjWL58OT7/+c+j3sBFnxmcFGFmlEGifsCuos8++6z47dgcr729bZKen6Mp5GCmEotKaK1wrLyVjmU0H5D6fmXCfNG4qdZ81eL8Th2T1LTdGpLv6hsMkL/44guIxDPid/y/fzZD0exgoG7oogTza2/TRHZrpflu6vW2+lAPword3IKQnFc+yLVu9piLnDfTc/MZkvPqG5SVW79+A0zTQHf3AjQ2hpFOpycqGOmEYgVjtW08SvJ95c7MVokCHzjUg59JTduyQK515ec7nteqr7FmmujF5jHn7RKnLfHqq6/imGOOEZqi9QZJ6PWN0ouVcETJp3PaUhtnajOwajlwncgws2NYKhOqkQVxLqBUnL5aG7n5Mr/cNAcCQZGpVM05nuk35xogr68tkHw3d5xzXY0upPOmOL+dyqcWv4kvHG+f69Xgu6nXm+S8ysw59ROnOguuOKdHzu885DyJyZCcN3ftPFb/ljZWqraNV8rPrUELqw/xYM+eoOS8MkCuf+Wf201jFq5/ysRYXquJgENsnv/ms5ZHmAmvvfaayPCQkKgkpnaO5AXM20xO3GqnzXNx4Zg5Vhqxpd0u50ukqBKYTxo35cRM56QznyMjwyLzj00AnY1otc7dmX5zjktqh0nMBUxt9jUY14URSOctHzNz9d376BPXYjX4bur1Jjmv/JD63bsOc4HzJCTmg53HBmV5yw0PCjVj49GhxWDZ5qEocskIFMXA6Oi4NgKAobjku10Fuf6Vj/N4zP0mHbZDCQOKYqI3ArH/rGYwODfPf/NZO20vvvjiScf8UZlde+edd2L16tW7cmwSEjt1ATPKWroIlTpxq1U2M3UxnDrmqZsSQpL6zmM+adyUC9s6Jzmf7FZP47VYLCCfd4nsI2Y5VAvyN5eYj845Oua+994eJBJxuKy8yLatlr7f9hxepceS83YdpH73roHkPAmJ2sN0/JFSWvCj+9MYiFloDbomMlprgfPo0HKjgHyJY2tkZGTC0SX5btdArn/l4zzO5WAkKRy2hmFA0zSRmMnmstUMBvvm+W8+a6ftM888M+lYVVVRInT55ZfjQx/60K4cm4TETl3A00Vlq1Eus63FsHTMzD6KREbFguiU+My36NGuhhSnL29Ek/PJTSjP13zenuPpupFWEvI3l5ivzjkzn0A+FYXdUxuiBLgaxqvDd8lkUjiYF3W2CENVcl55wTlm2eJUTVtZhjs7SM6TkKg9TOUPamxeeueWipNIWsHvngGuWNVUU0GeiQZlQnfXlgeSfLfrINe/8nEe53KJZaG9YQAjKQ2qpk40l61mMLhpnv/ms3baPvjgg+UZiYTELrqABwcn6ypXixxLP5ekzY3+1DE7zclovFJ3iyCpz7foUTkw3xbzSkc0GayjU8BpBDFTN9JKovTzZem1xHxxzuXz0apznvOZjgZaNBvB4vYsPnFCGzoaw2httZDP5yXnlbksV+om7jwk50lI1L6dp3jDGIhtaXBZLTmYbdl4zpgZ6CHosJV8t+sh17nycV5zcws+eaKOK++PiiZ6dNh+9Ohw1fcWTfOY82bttKWGDCURAoGAON64cSP+8Ic/YNWqVTjppJPKMUYJiW1i6oVaK+nzzjhI5iRrZj9t3LhBkDg3/8z+pYOZBqwTfXW5XPNOWFuitrA9aZGpr7M8tNYIU5ZeS8wn51wsVn3O42cyw5YOW27wXS4F60fyOO/qXrSHXVgw7mAOuiOIJvMIBoLi7yTn7TpI/e6dg+Q8CYnaRum5TB9ELcjBTGfj8RrkY0eiKBQKTXJySb6TqHXOK33twJUd+G6bC5FEFq1hv3DkVgq8zlmxxQqz6RzFsXnIebN22r7rXe/CGWecgQsuuEBoOx1yyCFiceLEfe9738PHPvax8oxUQqLO0uedz2X01elYSzJnhkZpo5j1618XwRC/34+99lo15xcdidqFQ4KlmUSLFy+Z9DoDD3yNHXuXLFlatU6924qwznexeom5jemafVWb8/iZ3GAzw5YOW03V0B8romhYaG3QhIF96R2DUM0c+seKaG8APnBIEAcuaZecJ1GznLdp00YMDQ1NdKivltyWM1bJeRLzHbUiBzPVxuP6wHVkbKyI5uZm4Uiif4TNC6WNJ1Er2JYdN/U1go7a5gqfsuuG8ltd3ys6vZjvnDdrp+3TTz+N73//++LxzTffjK6uLqFze8stt+CSSy6RTluJmtjE1gopOuOgUTA2NiYecyG0iT0qmsZEo1Eh8k2xbzp1a2XsEvMPvJacrAGCxmqpPiazxJ3XcrksNmzYgK6uyjuKthVh5WvM+Mtk0hMZ7LIUTWKuoJY5b2FHM7pbMhhJFGFaEA5bt6bAMg1k8zrWD7PEzoKqKBhJWUKH8Ng3V1aHUEJiRzmP1xqPyXW8ZTKZrWSuKgXJeRLzFdNxXq3IwZTaeITj7LLXlDiyWVsGT9p4ErWCqXYcj2vJxmOGreOwJXjP4yvO6Zm4zucr583aactNC9P9iXvuuUdk3bIZ2Vve8hYhlSBR/+Am9d577xEkxCjhqlV746ijjhKkU0uoh9R4Z7PBeWxqakImY0euhoeHxT0XHdM00NjYNF5eai+WEhLVgNNcxQE3nzNFL/m8ZUGUilb6+pspwuqsCQ6xk/wpRVJr64JEbeHFF1/EX//6uDiPeT4fccSRQvKp1lDLnOdkRmyOFpDI0pBmwwoNDR5LGK1F3YBpqjAMHarLDc2lYTSNqnYilpDYFufZezf3uNM2J3SYKQ3nXIOVvPYk50nsKvA8fuyxR/HSSy+JtZnZ4yeeeJLIMq8nzqsFORgm34zGs/C43aJBGm09PkcbL5vNiAxbVdXgCTYj6PVKG0+iblAtG48VW6XSJ1M1q2PzmPNm7bRdsWIFbrvtNvzbv/0b/vKXv+Ciiy4Sz3OBckrAJeoTvb29+N73LscDD9wvIoKl6O7uxurVH8Q557yv6iLUtZ4a7zhquRkieZeWIADt6OvbLMidTVn4PmZuuN3ucf0jeQ1JVA8kPW7cS8tBS6OXJEZGNnlOk8wbG8NVuf5m0q0uHQPHzs3GfCByiZ3DX//6V/zoRz/A888/P+n5H/zgCuy77774xCc+hcMPPxy1glrlPPLcd+6wm1W4VKDZb6EtpOHy93Tj8jv7sDliodVvwKcWkS6IXTbc8KCnxVvVTsQSEtviPN47WTysiiKfVKv7u+Q8iTcKOjd+85vf4LrrrsHg4OCk177znW/juOOOx8UXfwaLFi1CraCW7byn1gzj1/8oIprTRJOmC48P4MCVS4RtxyQnvz+A/qQLf9nYgrTpR3uDgguOsdcPCYlqodSOI+fxuJZsPGrYbkuzOjePOW/WTltKILz3ve8Vztrjjz8ehx122ETW7QEHHFCOMUpUAGvWrMFHPvIhUapPHHTQQdhzz71EZvWDDz6AgYEBXHbZpeJ9X/3q12rCcVsrDcdmigr39/cLhyzH5ZQgrFy5u3iN5QfDw0MATGiaC1ldRUtL2yQtNYldh/nWYfKNgOcgA3DbKsF2ghK8VeP6m0nDsxbXBInaxO23347/+Z//gmmaImh2zDHHCucNjdmHHnoQzz33HC644Hx8/evfEFr+tYBaPL+FBlr/KAbiBkzDFM+pmoqhuAG/ksFlZ7bg5XUbkRobxrqhLO7b3ImU4UWTV8d5RzbUxF5irkHy3a7hPOeeRiF1/arFd6VjkZwnsbMO20su+R/84Q+3imNW/h177HEic/yVV17GU089JSosn3rqn/jFL67G7rvbtkq1UYvnN9dX2nPXPZHHSArQNAUjaRVXPZzAT1e0Tzi+hoaG8UA/+c4lKpITRQ9ufsGNI/ezJO/tYkjO23FsqwdCLdh429Os9tXgmlCzTtt///d/x5FHHimcePvtt9/E83TgMvtWov5Acvn4xy8QDtu99toL3/zmZVi5cuXE64wa3nTTTfjud7+NW2+9BUuXLsWHPvRhVBu10HxlKkojQIpiiTKkqeA429raBclEiw24b6hDkHnPiIovtuW3EtuWmLslxbWKbc1P6WvV3ChN93m1uCZI1B6ee+5ZXHLJfwuH7WmnvQuf+cxn0draOvF6JBIRVSe3336beN+yZUux775b9jvVQi2e3xxL0AORaTQYtyae57HLyqO5eQFWrVSwdm0BywwdF3QmEM8U4VUNqGlW9HRUdfxzDZLvdg4zzVGt8N3UsdTymiBRe7jmmquFw5YZoJ/97OfwH/9xlqj4c7B27Vp86UtfwMsvvyzswdtvvwPBYBDVRi2e30IHuwBEs5RmMIRDnGClCUu4nTGOpQpI6j643Yp4D/cbvZGslATaxZCcN/dsvG1pVjfV4JpQKexUXRqbjzGrlpEjB4cccgj23HPPXTk2iQrhjjvuENlFPT09IsJa6rAlSOzvf//78cUv/pc4vvbaaydFX6oJXqzselgrF21pxCccbhTRbJ/PL7I4ppYgdHf34MGBLsTyJG8LQwkTl/+5b2IDIDE7kFwGBwfEfT2UV82FuSbsTPLcVvNeLdTamiBRe7jmmmuEBNBJJ52Eb3zjmxMOW6698ayBlpYW/O//fkPo/PF91157DWoFpee3M95qcgavf26ozzlIRXuDnSVBhy2P2S3bGTOrTBYsWIBCIY9ihrJBOZGttGmT7IWwKzlP8l15+c7psj3dXqNakJwnsS3QXnM4jHbc+9//gUkOW4J23y9+8UthB9Ie/NOf7kCtoNbObyGb4gE6w5pwgvPmcrmwqNU/UcLNse63aiU6w6roW0Itd97CrjyMXLzaX6EuIW28+WXjOZrV02WlN9XYmlCzmbYScw833nijuH/f+z6AxsbGGSMszLL+2c9+KvSL77vvXpxyyqmoJUwdbzUiRKURIIr7O4+5aXIWPb6Ht5YuE4niADSNEgmaKCkdjOkyCruLI63zuZRiZ0EnEMXgzVxcZNqXXkOlcz00NDihKyQj3BL1APIXdduJj33swokNodNIq7Qc6+Mfv1CUjN5///3i7zo6aicrdOp4Vx/qwYKQUfHMgy0l5Dl8f4UXqbyFbIJNIqZ/XyQyCtPU4fcHZfPNMnCe5Ludx3R7xqnzTGkrJ2lBcp5EPYD2GispKf9DO26m850NkWkHfutbl+KGG27AWWedjVpD6ZirlW3nfNZ5R6Vx3ZMFRNIKWoMW3nMAEI/HJl6npMr7Dx7BLx4vYCyrojVg4fQ92cckX7GxzhVIG686nCdtvNqCdNrOc7Cz5Zo1r4rHp5566nYXyLe97e341a+uw7PPPltRp+32HLC1tLGe+jkcG8fA8ZSOZVFnCxZ3xNEX3ULgXU0u2ZhlJ7CtSOt8LqV4I84glnE1ew2RMbe4ect5Wzq3Ttdtp4pORrglah0vvfSiyJ5l5qdTVcIgheMAJXjP4yvOWYHdd99DcCT/rlJO2+3x3dTx8lq98v4UvnC8WpWNdelnKbEx5FM2hzmcXKoRumLF7ti4ccPE+2XzzV3LeZLvdg7M+C5tRjYd3xEMMni9W5wCkvMkah2014iTT36byAjdlo1HO5BO27Vr1wj70KmWKDd2JMmmlpxJ/Ky3NDXj0FUWNg9FkUtGoCgGRkezk8Zy0O4daPVswGAkAdbDdLeGpFNxJyBtvPLoMlMec+o1JG282oV02s5zlEb8QqHQdhdI5z0scawUpttcMCLMTEB2GWSm1NTx0mmrK15RwjLd65XETHPJcX3mlB4hidAXyYvSUtmYZeewvUirJPEdQ6kzyDItodF1/VOmcAY5523pXNPALUWtb0arrUkoUX0453FpV1xySWmnWoLHQk8rVNlu8dvTZ+M1unmsiP5YEQ5TONcqdfYavNXdWG+vVJFNn/i9YrEomppaZPPNMnCeXNtmf83RYcuGsbw5zcemm2cGGarZkGy2kJwn4dh5lGnbURvPsfMq4bTdFuc5VV+09WrRmUR7zY0C8iV221SHohks4vd/j4imZT2tXnymO4Cmqoy2fiFtvF1/vcVisQm+o+NW2ni1D+m0nefgxpSRVzbMeu211yZ0iWdaINetWyfuK3kxTCXjV/rS+N2f0sKoZknK6kPsslAHm8Ys/O4ZL4aSxoS23oFt1Vtops4ltaSoQ8hNCMW2v3l6k+i+bTuY44jF3HNysanE4jzdYj3XF/FdCW6O+8cKMJkSML4HdZxB7eNrwEwSILU+v7JZgQTR3Gz/5uvXr0exWITb7RZrMSUGSh23PPZpBjZs2DDp78qNmYxpnr/kPpZjjqaAkaSBsF+Fz61CURU0uw2MjSWBBvfEdVmLxhW/h8fjQUdH18SxvA53DJLzygPOFY1Tx4ClQ8g5b6eb53qZX8l5EqXc5dhv21qnX3vNfg/tQifjvFqc9/TaYVz1cELsQakXSwmg8Pi+lNdrJpPB2Bj5pHY5j07n656wG5Lx6Uga41U8PTJBZwdQutbyN55p3a2XNbkW4FxfDueR7xj8mI7zpI1XW5h1HfZ1112HO++8c+L485//vGi2dPjhh2PjRtlQot5AYj7uuOPE4xtvvGHieZ7ovFjp1OU9j3kx3H//feJ1NmipFLYiwCcLwrjWDV1IC/z0oRgGB4dE9gO7nf7uGWAoYcA0TIykLPz+BZfIzK0WnLnk2DdGTXzpthjO++UmfPr6PlGKzih4g1eZIHBZfrDjizMXZt6ztHEm47X0fbXSOKRWMRwvCmfQhtECBuIWDEtDd6MbSxbYa4ADRzvROVfrQRBeNiuQIA444EC0tLQiEongwQcfEM9x7aWGLR21hKNp+9BDD4r38f0HHnhgRcY31cnJY6eU7eePpgTn0dkccJuIZXRRcunXTCRzOr79qA9XPO7G6yOTs4YridK9A52zvM64PjsNROR1uHOQnFc+cO9Iw5X7YTaOpfbnVL4rbUBGSM6TqBeccMKJE9q2pZI1U2084qabbhL3tAsdKYVqcN7YWBRX3h/FQLwokoo2DqeFA5dBVo6ZHMhMQVZsVBvb4rzeoeiMVTwS28ZULmMF7Y68T3LetsHrK51OTXAefXila8BUzqsHh+184btZO22/+c1vTpRL/O1vf8OVV16Jb3/72+IHv+iii8oxRoky4+yz3yPu//CHW/H4449P252vWCzgy1++RJDnvvvui1WrVlWFEL2hViH67pSE0jE7lDAxlsohnU4jmrIduiR06haaJl83aoYgf/u0JYxuOpwd3URm3nIBZcSY97VeflALKF2MOWcsbSRhi27kg5GJburzYRHfVeCc/d99oyJ7z60pKBrMsFXw2XcsFA0V6m2TNLXT7HSGgcT8A42qM888Uzz+zne+LTplE6x6YPbLLz68WNwHzah4nWDzFrfbU5HxTWdMc91itjszjsh55DdNMdHgNvHZt5pQzTyyxXEd2bQijFtnDawGnKAOnWHUHqSGLe+5Vjil5Q7nlZaaS8ye86auv5LzZgfOHc9BZh25XG7hsJ1OsqPWOW+6zuqS8ySIvffeW9httN9oxzlr7tQO7I8//hhuvfWWSXZhJTBtklA8K/iOcDiPDtyxVEE0VeNen3YpdXeZcVvtdW4mzssnI6IilKDdx+/BY9m7ZPuQnFd+BAIBtLe3b7NXUK1xnmVZolqZgZ35ZuPNOozW29uLFStWiMe33XabMH7OP/98HHHEETjmmGPKMUaJMuPggw/B299+Cu6668+48MKP4Zxz3oezzjpLbFxJMMxGuvrqq/HCC88LB+MXvvDFio/RKUlLDA8j5DIxlneJklBevE3eIoxcEimF2RJ5NHoaEM1q4u/4OiUSqk2QJJHhWBqDcbfI6rJUC9DsiCu7bUvsfDkSo4U0uCiLQf3VaDaCxe1ZkSnXJruK7jAcXU+WWy9q9aBY1KHAgg9pztyk99bqJsnJ5LMzp6ZvRFgvUWOJ8uGDHzwX9957j5A+eM97zsKHPvRhnHbau9DY2AirkMJvbr4dV1/9S2EYLlmyBKtXr67o+Eq7+LIhDA0W6pW0B/0YjFvI6xbi4wbt/z2cw1BagwZjgvNo7DJQGfbbPFgNcO6YCUWjmkUkTgkenebE2Ji9bvM6lRIJO8d5BM+NfH5LEzLZSXt2cLjLLgVPiUZj052Ptcx5MzWUkZwn4YB227nnfhAPP/wQPvCB9+NDH/oQjj32OJG5yqzQG2+8Eddf/xvh2KU9SLuwknDOTY6lr2+zyClrD2qCy8hpvIW0HBKROHTdzhCk05Ygx9TCOlfKecRYqohAAELCjxWifVFd2KPv3kdHPB6T1+N2IDmvPCAfkCu4H+Nc2tcbaorzSrWsS2VE1m2nUfZc57tZO20ZCWO54OLFi3HPPffg4osvFs9zgpyFSqK+wAviG9/4pshK/ctf7sZ1110rbpQaYOk+SZzg8fe//wPsu+9+FR8jiXzjxvXI5fI4aXEQd6wNIVH0oDVg4s3NjL4lkcmk0NrahpOXjOGu9Y2I5d2iuddHjw5XXTuIhqmRTaDJG0YkY4+FTmfqNLms/MQCWkvGQC2jdHGmE4Dn6Q//ZooNnsullHR/75nzi/iuQqmup2HoME17g8muuDGfOmnuqr1Jmk6/qlTPyNE5czTZpnZWl5jfoHP25z//BT760fPx+uuv41vfukxk1TLrgFk75EJit912w09/elXF5XUcR8zo6IjgX56/3MSevKILf3xRxcsj3MiaaPJZiOU0ZIoKGr38S0sY4eSVagYqOX46kaiXRuPKboRjIZ3eoj1YqhEsOW/2nMc9BQ0uloyywVBp2bPzPsl524fDZduay9L3lR7XCufN1FBm6neQmL+g3fajH12Jiy76T5GAc/HFFwnHp13px8C8jZNPfpuwByttM/FcZhB1ZGR4Qnrrbcsacff6RgzGgaCawRGtzKqzxPqnaS74/QHBj7UgVVLKeRsihrBBqWPbGTZx4fEeXPI2FUNRvSaaY9cLJOfNT85zHLO0RR2pMlbCWTvQKHuu//azdtqeeOKJ+MhHPoIDDjgAa9aswSmnnCKef/HFF7F06dJyjFGiAuCC+N3vXi6yjW644Xd47LFHJ4i8tbUVZ5757/iP/zgLXV1285BqdPaNRu1Nq9udxHtXxjFcbMKf13hwx/ouNHpacNyCQXRoGvbbrRF79hTgDjQILU7N3yQu9mo6bjm/7Fb+zpVp3P6qH4miS0SJKKzv97snbZpklHDHULo4UxKBGbZ02Lo01yTdqLm+iO8qOLqeJMVNI8WJJn7TbTCruUmaSWy+dIx2Bp+d2UfIa0piKrq7F+CGG27Cn/50B373u9+JjFbnfFq5cne85z3vwTve8U7hyK0kSh0xw8PDonpkJOfDw0MLkSiqaHAV0eDW4NFMuDWWdLvQFAA6GjREssCiVh8+eNRkOZNqZXIQjkqDzxeoGQdYvWKqdi0d4jS4ZHBq5+HM1UxzWQ+cN1NDGQmJUrD3zO2334GbbroRt9xys0jAotOTe7wjjzwSZ531Hhx99NFVcdjy/I5GIyIDlY5ZjqEhWMTqVTkMRlIw80kYRhGq2oTW1nYRnCT3Kd4Q9lqxtZxJJSGqW2IZBAJBwXf3/UtDUtfEGMfyimhE9pVTA2jwSjtvtpCcN784r9QxS5QmYCXGq0GdpDeYWzfKnuuYtdOWGrb//d//LWQSbrnlFuHQI5566ilh5EjUL0iSJGzeGH2hXgidje3tHRUTpJ8OXDBYDsMMKC4yyaQuyPHPfR2I5TU7jb7oxUODC7D34oxYgJYsaRPNWL546xhG0lGReeREa6qjNTYo5rQnbOFjb07B5VfR3uRBKGSgqalj4nvKKOHOZZws6mwRkghTu79XWxaj3uDoem4eiooMW2fzPt0Gs1rn6XQlOzwnksnkRIkob83NHrF+yWtKYibQIctg5Lvf/R+IRKjdlUZDQ1BUbFQryOec3w7n8faXgR5kLDarNBA3FOQNFR7VtIORqoLOkAcBj4LhTBHPb87hy7cOYFm7tyqc51yLzBKmRqiiWOjo6JhkGNRbg4ta5Dzn3nHmEdIRsHPY0bmsZc4juC+e2lBGQqIUTLz51Kf+Ex//+IUiq5XZi+xZQOdNteCc3+Rcns+szCC3seKF49OzKSiKJmR2WAXGIIUR6MHPnyiIMun24GuiovLAlbYtVUk4WYFslBZ25/HOVQpiBTc8XtekBBLN14i2NjsBQnLe9iE5b35yXqlj1oGTgGXm4mj2GXZF7fi11RYAmluaq9psvpKYtSeOjqcf/vCHUNXJzpCvfOUrwpErMTdAAq8miZeCCwm1dd1uahjRcFUQzbsQzaqic7aqKOJ8TBl+hFtJjG2C8Nl51BGyJ7E70ZpKGuMkHgrSUyeNDmeSED8+DAsZD4QAOCEJfHYReafzpdM0pDRLtLSkotqyGPUIztmirlYhibCtDeZ0m6pKYGqWHjf1PHZ+a6FjPX5dyRI0iR0Bz522tnZxqzac89vhPEP1IV70gXFTyzLBs9zvMtHoNZGDhoUtPqTzJgYTBkaTumggmC1Y8LiUinOesz7T8OZ38Hp9wsgeHh6C1xsXshSOPILkvDfGeYQsC9112JG5rGXOW7Jk6SSHrjwXJLYFJuKw2qQW4JzfmqYJW05RVMF1zB4nD6qqhmDQD8tShKwO17+v3JkRdp1e1NE3Blx5fwTfbXNt1TS3ElmBHIdpsZ+Ghj++CLT4LESzuhiby+2akCtS/PKa3BFIzqsMtjeX1eC7Upk+Bzw2cnFRGXDWfrYkwlgeaA56RCeHz92SRHdTrmqJeTXttF22bBkGBgZE5kQp2M2RrxmG3QxDQmJXgYsFHciUEIgWg7hvqANDaTfGCh5hwLo1S2j7LWlyYWmP3QVx7Ya+iU7boou2tSVaU8nmLHZTpC2Lj62VaIksZjpxucGQpLPjEF3Ux3V4CMpm8NzgHDpZovyNxQZJOmwrXq5ZjY2G03iMYMYRddeJao1PQuKNwDlPyREZrR33jYaRNLyAoSDkLsKlmGjx5HDefjEsXLYHQq0d+Mzv+mGaFgq6JZy2eVjojRTEcSU5zwmSkPPsrA0Lum5MZAxLztu1nEfIuawMJOdJSJSf80KhMHy+IhKJuHDYulweWJYheIRB1aVLl0H1NWIgFkeuYGI0BegmMJwCntmQxnEVdNo6WYHU1yRUTcVYDnj3nlHcvc4vnLhhdwGrD22U9sgsIDlv/vLdTAlY+XxUvL64WREatnD78aNHLQzG9a1kFObytTZrp61wgE0D/qgyTV2iXCBRs3v2b14F4gUFacMtHLbMOzIsBVndwnsOUPDSuo1obxwR4votPgNDCbuhDC/i1qBV8XJ5XhOO3pjd0M0SAvqmaW9CppKRxPbns9QJbs/tlmxK/s7V7Jg+Xwi72p20p+pcTdXHrPb4JCTeCEQQasVKXPlkP5K6iSaviVhBQ7LoxrJQGsd0DWAw04gb789hNLsB8SzQ4NOgG5aoPiE30nmbyJpo8CoVz5hyOI+ZUeQ9yXnl4zyJXQPJeRIS1QPPb2rJs6n08DBtOJ9IcqEuLDNwnSabdOzy3G4NuLFx1BIOWwc3PVPAsftXrn9JyKugLeTC4JjtOCJa/Aa6vGmcvXwEOUNFyOdCCH4AlZduqFdIzqs+51WTT6ZLwIrFtlSb8Njj82Mwbjv1HVQjMa9mnbYXX3zxxGRdcsklk5pzMLv2iSeewP7771+eUUrMe3AhaekykbEi8HhNmFkLqmpBhYKOoAHTUnDtkzoiKQ0t/gze/aYkTl1RxB1rgiLa2RnWsPoQT0XLRJ1sCEecPhQKIZvNigYzNGBZniTJaPbnAUtlaPhz7phlQoIXusZcrGWG7S7B9gi7lhoJTVfiM51RKyFRT2A2UUKPwOez4LUseN1F6IaO9+wVhWYC165tQX8KKBgmWMAxljbZlwEMS9LG9bhUhP0qUnkLYdqMZQavuZGREZEhY2tKtwhtQmrbSs7b9ZwnsWshOU9Corrgebxw4WIR5GNVRiaTFX0JCHIHHbrkEq6Bxy1pxFMb7VJotwa0NWiIZtSKOW0mtGxHsuIzgx4Fi1tceN+bfUCSlZQZIWNEiSOJ2UFyXvU5r9p8NzUBayrnNTY2obtp/vWx2eHV5JlnnhH3dI48//zzEwspwcf77bcfPvvZz5ZnlBISJc2m+scK8LiLKOjsnq0I4zSasTCaNIV+3mDcxG/+qeP8A+K4+Cgf4PYhKPRjx1vJV1CPh+UdzCpi+Zqj5bdhw3rxPPX9CDaTkNo8Ow5qG3FOncV7NB/Al6/vmyilWH2oBwtChpzTN4DtEXat6UpN/fxaG5+ExGzBABS18JxNKUsvwy6goDbgllc7sC7q7MHs7Frm12oq4HUpWNTihqYqWNDsqcgm1tFud8oZueGmrjSvO947nMdMKWbQOKXdEjvHecTg4MDEY7nOvXFIzpOQqD7IF07iBRul2drubqFnSYk8Zt8yEEjd293CeyNpBuBxa3C73BVz2pRq2WqKgUYf0BIALj2jGS0trdi0iZq89ns5dkLqTM8OkvOqy3m1yCdNU8YwH/vY7LDT9sEHHxT35557Ln7wgx/UTJMqifmDUq2TvD5e+umx0BJg4xUDRV2Haeii0ReblI3GM6D0cldrqKKLTqmun3MfDG7pmr3//nZWBA1ZNigjRkfthaYWFsZ6gDNP3Dw5DluCm6gr708JzRup67bzKCVsOlima25S6/Na6+OTkJiNthcbjv37ASH85m9eJHR93FFbKldlV55Qx5YkSIdtpTaxU7Xb+djhQV6H5LxNmzZiw4YN0PWiKHGVEgmzgzNXpSWNQ0OD4p6ZSJLv3hgk50lI1NZ16CS6sIKDWbYM/CUSMVHdy8zbw1s24MnECqRNf0WdNlO1bPmRY1kgmsyhpWWLw9Gx8diYU9p4s4fkvPLCmTdeX9t6vVaxYh72sZl13v4111xTnpFISOyA3ECbzycu0s1DLBHNYSiawubRPC59yIVM0QsVLjRoBbT6cvCqJoLBoHCUVhJTdf147zxfimKROkjKRHaS00xCYhbyE/BMOGxZOlwsFDGUt5AuqGjwbumkXEvRwnpBacml063aeV5CQqJyfPfspiyufiSCHzyQweYo5YBs3dpSly2PFcWCz63hh+/rQU9z5eSASrXbCT6eyneUSrCHY3MeDQW5lsz+nGBlDn9XVvIw+8zlsstHCcl3bwyS8yQkqoPp1i3nOaKhIYTh4WGRaUunrcfjRWeggHMXj2D3vQ/Aws6WivGd0+G+N6KzsYpAe1BB6xQdImnjVYbzGAQejWfR1ugXskwSs4Nz3TiO8XriO2We9bGZtdOW5QmXXXYZ7r///okFtBSvv/76rhyfhMRWYtkkQKe8UtEzuOFfENpBeV2FYarIW24ct6AXwaCvKmUp/CyOMZ93obW1DS0tLVsZUCQaZhzx+zBi7PP5pWbPTpwPzLRtDbowlGCTG10cN3oKQLEAeBvEecLILDO/HOd5PRFStSGbm0hIVJfvuKZd82hGdMlVVXtznStCSCEY5hbHraZYcKkKdu/UKuqwLeW8QiEPt9uLJUuWTrvO2rynC86T2LlzgllbmUxGzCOdF7w5OsKOo5HH5DzqAjLrS2LHITlPQqL6DZGI0jWPmbaqqgqHHe8py8h7v99X8Sw7pwrm8j/3oS+io70BuPD4lkkOQ64btDn43Zwm1ORFiV3LeWsHc7j273GMpC20B5O48HgdB66UTd92FJLv6guz3jl/5CMfwcMPP4z3v//96O7unhfpyBLVxdRFhOUm7Cwq4A4iToecZqA9wEYsdonoXss60d7kF+dnpaNHJBsaT84Yp8t44euO8cp7ZgRLZ+Lszwf+vmwwd83fchiIQzScO2OVArdbE6VVzOZyotzMApPZXbNDtcXoJSTmO98xg8SpJuBuqyPswsZIEapiwe2y4HcZKBgqmnwWeppdeN9BJuLxWEXXOYfzmptbZ3yP1+vd5rHEjp0TjnOWzgtHpoz7CPKdk3XkcB4buUgZitlBcp6ERG05jrjmeb1x0dTZ1kWnzeRDR0cX2ts7qpIh2ObN4OIjdaQL2njPFDspZKZ1g+u1xK7lvNbWVnznoahw2BK8v+rhBH66Yu5rm+4qSL6b407bu+66C3feeSeOOOKI8oxIQmI7i0ooFJ7ItCVZskxlIGZnXboUBYva/dh79zaRFV6N6NGORK4YJSb5MMOW0Vhm40rM7nxwsokWdHpw2Zkt2Ng/Ks4HRQkKA5YbOEerx8nw4t9IzA68rginsZCEhETl+I4lf91N1oTj1u/R8KZuHXohj1hORVvAwNn7G1jUHhxf/5SKZ0vsKOd1dHRMVD2UNrOV2P45UVox0tnZNamZm8N3tvO8OPEbcOmWgcrZQ3KehET1HUeTeLCtHblcHrriQ1tYRUdHu5BMcFANziPXUoZtus937A/ec82m41FmMe5azlO8YYykIxPPmYatNUz5xEVdMweQJbbPd3yO2s2UApEO8Dp22jY3szuidDBJVA7TdTGkceI45M7e38Kv/2FhKGGixW/g1N0oO6CLkgpH96aS0aMdiVzxOY6NDcoqPb56h1OKOzZmkzmJnKSytKd9K00skhA7zTpZzXyf7OI6u47wW6Ql2ieel5qJEhKV47tPnhic6FZN7byjlgL3vuICctT3M5FOZ6A0A4q38nznfJ7kvMrByTaaug7znpIIGzeuF8e0tbgPkpy3Y2CzPGYnO04WB5LzJCTKh5k61XOfz8pKJuqM5v341cs6RtMQdt5/aAaWKXaJfK1yHu2PUoeX5Lxdy3l0LC5q9Yt9kS70g4H2BgW5ZAQxnyrX6p208dYN5Sca4DoN/tj0S6IOnbZf//rXcckll+C6665DIBAoz6gkJKZgusXXIcOAMYIzF0eQKVpQjRyQ9COTWSRe46Je6WyJmTYgs32PxMxglhYDSA44j6UN50qNLEboWVYjo92zw3TSEsRU7TF57krMBdRSZsHUa4ob5q+cGsDG/gwCbhPfvFfHSMqCAhPRrILbXw1gcXNGlI9WIztQcl55wTkrdXhP5btSzqNx29W1ALFYTHLeLMD5o8OWXOc01GPjoOn0NuW5KyGxazH1miqVmWMTy6se1hHJkJdN4bi9+QUPPnu0WRUbr3S8kvOqx3mUgXrPAcB1T2oYjFnCYXvOQfb+TXLeztl4jY1NEw5bgvc8ZkPcau+LJXbCaXv55ZfjtddeE9H8pUuXCn2ZUjz99NO7cnwSVUQtZxdwXCx1z+eLiGUMaJqKsEtBoeCGYeiiwyT1bkKhUFXGPt0GZLqsGIk3HuXmecCNW2kWdqmRRe3EUgevjHbvPKRovcRcRD1kFtBwVfQ0+mNFjKaDUBSWtCmiGctYDogmc2hvrx6vlH7uTHsHyXm7JquLzozBwQHJebsQTuMgx2HL7CPOm+Q8ibmKWrfxnP39WKqI4aQfmqahULSgqKpw4MbSReHUk5w3fzmvzQtcfKSFIjxww666dP5eYvZg4oLjsHXA4yQTGvxa1cYlsZNO29NPP322fyJRh6j17AIu4K/0pfHHNUFEMh40ef04eckYGtUsTNPuLskIUmk3z1qfy1reQNUanPlxsj9LG85NNaoc/WA5t7MDsxdYWuuUzvCY2NZGqpYhry+J6cCATz1kFvBaGx4eRrGoI+TSkCh6xfgoj9DkLcKj6DVRCj+bvYO8JncMpRlbPA+cmzO/kvPeOBz5DoKcx8QUxzlQj5wnry2JerbxHE1Th/O86gL0Jr3QTTc0xcSiUBGqkUUm464LzuM+o3coCreVh9/vr6m5rnfO4z6opcELn69Rrnlv0MZjpZndJ2iL47Y1aCEdG4KZr+3zNjYPOG/WTtsvf/nL5RmJRE2h1rMLmOF91/omxPKAqlqIF1Tct7kd5+xeEIRIgXpdLwo9pGoTeuncMWrMY0azFnW2TDgFqKW2YcMGkT0VDjeK5+bqovNGUbr5IWhoOU3JnFKpqVpTci5nj22Vds20karVeXY21c55QoN88eIl1R6WRA2gXjILmGnr4IiuCP461I5E0YOwO49TlyfR2dkhXuvr21zVa3HqXoGBtalriKNJT71xR7qmmmOuJ/A8KDW0WMI/nb6inMvZwZkvZz6nVkTVE+eVOpHo+OK1JpuqSdSTjcdzdcOG9aIfhaa5YFiKaKxIm0lRVLhc2oTOaS1x3nQ2Hit5Lv9zH3pHskKP96z9TByxb22uHbXogCPGxqKS8ypk47HSzElkoMP23fuwiXd6orl7Lc5zbJ5w3qydthLzAzsisl5NFBUvojkNmgsojndLjhc8aGrvgZuFEuNlbiR8Cm1X6wIm0QyMJqDoGdEUhNnBdDZHc8PoaYnjM6f0oM2bEQ7bWCwq/oYdUqlNONcWm10BZ/PTF82LhjxnrMqhxZ0WvzPBqDvF1NlZdK5H3KoFZz6ZbVTazbXWNv3Tyak4+k3ULuSGX54bEtNlFvA45FNRa4gWg6K6ZDStoC1o4YIjXFgYdKFYtLto8/zmeV1NzuOaMDY2NuGIzWQyE/qqDri5HhgYEJzn9wfEOu102paYDMfB7TRWpaObezO7dD8rqokcrT/JeW8MTmYt57E02F9vnFdaWs41gc4OJ0FAnhsS9WDjEVzvElYj/vBSAzbF3XBpChY0uuHWTOQNBZmiASOXEE2GM5m1VQnGM1EkkswjPTYGwyhi05g1yca7+O0L8H/3jaIvkhcVoCMp4LdPW1jZNSyvxR1sCMk1t1R7VXJeeUFpMFaaMXGBGbaOs5aQnFcHTtuWlhasWbNGOEKok7WtksFo1HY8SdQ3al1AnRFMEiKJkOcjibPRU0DAzfO1U2TYOlHYal3AT68dxpX3RzGSttDic+Nde2THydzO3hqM6SKa9YXj1XF9QhuOA1Ji+jJmzhvBeb31JR8+emBuq0ZjMzUlq7XzuJaxvZKvetj0l46Na4ADO6hTm5sPicqCvFCaWeBo2taSNALB/ddd9xREdYmm2dUlf3jewheODwoN01rgPMfYYpULwXvyGW9OowvqzBMO50m+2/4aTKe3o7VKrmNzHp/PL9YxSiEQpVnM9VC+X4uYK5znjNPhPCdgIjlPol5svFLOSxYgHLaGBYymDCxqcaOr0YWwX0dSd01wTKWD8aVJJC2+AE5YOIq7NzQjoW+x8b7/lxGMJCdzXDSrIb0l9iOxnYaQdMrzd3UybSXnlZfvSpvymn7/JKet5Lw6cNp+//vfn9hoX3HFFeUek0SNoJYXPxqjzFL9zh29GIgDYVcBb18WZ96UiLQ6ixEzfnjRsqzGKauoBLjoXfVwQjgWCTpqb1vTgGiWYx//DqoinAS6EhaSCPE4De0CQiHfhH6oxNZlzJw3mPZznN+G5i54lOK0pFLrul31WD5X6gR3Mpp53k7NTio3ZuOM5+vMwnAcSiT20owpifmN0swCZtjWmsOWUH2NSOgReDxsxKLANEwMJw0U4cPKEs7r7+8Tm2waOpXctJYaW0QgEBCdvqc6ZZ3NtcN5gCXGKjlvazi/nVM5tMVotQOUhOS7ynOeo6Vfaewo5zmvcR9qVx9hPPvddnZISNTD2lDKeZ0aMJIyUdBNNPktfOaUhaJKce3atWKtI8+QRyrFd1OTSGjj3b2pTdh4rvGiEvL0SKKI9rAbg4btXDZNE21BYGmP5LsdbQjJzFru19l0jpCct3ModcZyjzsd303XlLdanDdbG28+cN4OOW1Xr1497eNy49JLL8Wtt96KV155ReiUHn744fjWt76FPfbYY+I9/EE/85nP4IYbbhBaXyeffDJ+/OMfCwNdYm5h6gVMwv7MWw30Do4JSQRb60iZ5DhyFnHa4JVqTCbKGWMZDCWMSc8nCy50NakYTRqCzF2aSyyKDV4FEeFU9qKx0XbgSsxcxtwb0YXDgovzgmYPutvCE6Q9tRy41nW7agXTkeN0WUVTN0gk8y0Rzsrp/O3MRs0pm3PKrjjeautdS9QOyB21pGE79Zrk+tcZ1oSRyPXPtEx0hFTRMdk5j8lx5DoarzQQWSrGa7QS40wmk1sZW52d3ZO06Jz1meMcG6MRFkBDQ3iSdILEFjhrKyUmUqmk6J6+cuVKMX/MrA6FJmeVSb4rP+fRCHSCOs7zleCQ2XIeX+OttNRYcp5ELWNbnOdSLXQ2WGgOAJ97qy7sP74nGAyOa6PbnFeJYLxj4/VGspOSSBJ5DZ2NKmI5ZZKN94FDPfjx/SkMZIGOkCI0bWsxMFwLcByy2WwWhqGjtbVN7N25jknO23lM64ydwnes2Lr0zq2b8n7l1EDFOW9nbLymecB5O6VpS12W2267DS+//LI43nvvvXHaaaeJDeWuxMMPP4wLL7wQBx98sFiMv/SlL+Gkk07CSy+9JBZq4qKLLsKdd96J3//+92hsbMQnPvEJnHHGGXj88cd36VgkqoupF7Bd/lmAqqrwKAWRSUtnp1MeT/Ai7eoaz5RIF9EU3FJWUfZxWhZaAxYiGTuiRQJf1OrHJ05oE/pGJPtmn4F/3weIRCIoFovw+32iBKT0O0hsAedx9aEe/PCeGIYyphD0P3lJCps22Vp/06FeyhmriZnIcbryOZYglWK687QS5+7ObtR4/VPiZ7Z/JzH/shBq7Zok2BDi+qdMDMZ1tDcA5xxkO5Cc85gNOhuau6FmMiKQWW5t9NJxUnOVcMoYHX1BHpdmafBvbMNa2UrWRmIy+Nv19/cLeQTOFffePOY6RomEqQaJ5LvZn7cMNjhNg3aE8+g44Nw7qNR5KzlPYi5jRznvAwd7oKpbOI/n9li6ALdVhNdbWRuv2WtiLK8Jh7FlWuhqck1o2JbaeI1KFh89MImxVA6dLSFR8Smvw5nBICW5jpxXLBaEE45cJznvjWWFT3XGsrqslO8UbxgDMVYsbwHfG0nYgfh6sPHmOufN2mm7bt06nHLKKejr65vIeGVG7KJFi4TzdPny5btscHffffek42uvvRYdHR146qmn8Na3vhXxeBy//OUv8dvf/hbHHXeceM8111yDvfbaC3//+9/xlre8ZZeNZT6ilrRAp150pRtnOmtpJJaWCzpjf/b1KK5/SkM06xER2wuP19DVVf5x0pA+5yAVNz6rYiynTUS2WIbLqNXG/gyCHks0Ykmn3ZPKHxmPkMQzPRaEDHz84IzY/Phd1nipuzpRNjO1U3k96HZVG1M73+bzW4IeU+fL2SBxE0BNrtZWrzjXK71p2tmNmtzgSexoFgLX6mphpg3r4mZFaKCPxIpwWUW0NHsnzmNqqH/nrjjWjVpQFB+Wt/nwubc1VWyc5F+uC5TSmrrWlmZp8D08lpy3Y7Asc5KsE/cMHR1bNjFTOY+QfLdj5y2bBtEhFM1GsLg9O37dT895DpjpVZrNV6nzVnKexHyy8XaU8668P46BmAttQU1ksC5ZUt7ze2sbT7FtvNZt23h0KAfyWZGg44xfYvr5pbPW4TzuD0rt/ZlslFo5j2tZWpDQDV0EGFixSjmw0vni3my6prytYT8ikUxd2HhznfNm7bT91Kc+JRyzdIqyQRnBTMH3ve994jU6bssFOmkJ53PpvOUCeMIJJ0y8Z88998TixYvxt7/9bUanLWUUeHPgdCWk1gxvEiTzGCKRLZkIpmmhqam8BuC2QOkAy0pOHAeDIRGBI5hN1NjIzBM7+4Rj5dh50f7qSRKqSzQ9GU0D1/49j/12M8qWSVU6zkVNwDf/rRmaLzyhk8jzi+QSHA8Gu90uYQBw4UynM8JAI2HRES3Pxenn1+Nxwe8yJxZjzqFwIqa3LNKl5yzn0pGckHM68znrdN10MuOmu+Y5j68NF/GzR+KiC+7C1rTIHm9raRUbKV5/lTh37c+wZv2ZO/t35QYrBsoFyXfbBteOH94zPLFR7R8riOPvv3dB1TJup/Idj+2x2s+1NwXhdm/hPMMw8X/3RfBaBNBN5rACr0eUivIdwVJGZ81wzi2WOXKOHTiPyduS87YP7nW4x3YQDtuNQohtcR4h53Pm89Y0E8JhSx5zuZQZr3uHM1iCTTQ02P09Ks0hc4nzysl3hOS8+rfxdoTzrrw/gqGECcM0MJJScdNzLrxl7/L+xtLGKy84v5yzbNbmOD527P2ZbBRp420bDR6Ixn2bI7mJHgPtfqCYicH0TnZyX3h8q8gU536Y2stn72+JSuaWOrHx5jrnuXZGsqDUYUu0trbisssuwxFHHIFygRP+6U9/WnzGPvvsI54bHBwUadBTiYZleXxtJjAz+Ktf/epWzw8PDyCb3bIJns+gkZDNboms5PNZ5PNbjisNbiq4yXBKQHlznPhseNIl0mdNMUZn7EPRFEbTbVAUE5qmwjQN9I5m8Hpvv9CRLRcsyxAkzXOzUMgChSyyicnfhSV3jnA+MzfGxiLQ9Tzcbj9GRgbE3znN/yQmIxDwo1CwN+TOtc/zk88xc4sbURJ9tc/ZegLPWdsBYKJYzCMWy087f3QW/OyRHIaTNgHyerr8zs348ik+sWHl+4eGKjvnO/uZ1RjrTOjuXli2f1vy3baRzFniPC5F72ix7DyxPaRSCVEmSPBaJJ+wwRifm8p5G/sj6I+pKBq2RJUFC0UD2DBcWb6b7poi38XjMeG8JedRV57yVuRzyXnbh9fLPULDxO/e2tok5pRzLjlv55HKs5EftSVV4UjRdXPG6945h4l4PIrGxiZxrlaLQ+qd88rJd4TkvPqz8XaG8wbjqnDe0qvE/42mLazbuBmLaXeVETti45VyHh1H0sbbORuPj8mBnC/HRkkk7IAD55RV3hLbx3sOMHHVIwWM5E20Bky8c2UOAwPcQ0y+VnhGfuF4YCiSRzEbg5IFXnsNVeW8N/KZ+TnGebN22lKomAvSVDgC/eUCtW1feOEFPPbYY2/43/riF7+Iiy++eOKYkRte+B0d3SKCI8HfOTARhZ2aQVNp0LhLpTJobm6dyCzRdUOQtaMBy/E643PG7nJ5RaQoXnCJKAcdpAtbfdhtUXkzqLbXA8/rjSGTsctk6HxevHipiAiVpvOzNKSzs4w6DnWMmeZ306ZN2LRpg4jGEw0NjejsXFDZwdXxnLa1dW73mo9nDUSzvXC5tuiXs1tuoLGrppo4SWyB5Ltto8OysKitf6uSsHLzxPY4jw266FDi70W+0/WsOHZK40s5z+PxY0HTMKI5lr8JuVh4XCqWdgSqznd8nWvzyMiQyDCCOyjWllCoUXLeDmIqjzlzLjlv59HRYWHZv3b0uh+EomzhN3mu1jYk59WXjbeznNfVOGxn2hqG6KnTGVaxYknHJD3LanMebTxHOqh0XZFryPTgPPnCnVi+fHJvAcdGId/x/CDn2ZWXfqjMdPYqSOatmuhJUIvg/O3ePYZNA6MiC1xR/Nu85hVlEKmU5Lxaw6ydtu94xztw/vnnCy3ZQw45RDz3xBNP4IILLhDNyMoBNhf705/+hEceeQQLF27xVjPqZotSxyadeOwaZ0fkZnY88zYVdOyVu2ynXsBMakfsvdo6MYy4OYswtW0KBR0FuBF0KygWdfEa3+P8ds7YGRW64JgcfvNPAyNpSzQCo+bQrm6Yt8PdRkuasbDEjg5o6vVw48Su2owoO/D7/fJcnKUGl8/nFc0InU7lPE4k4mLeOdfcODndyyV2/JqfNOeNTVjQ7NnK0G0MUIJEbpRqEZLvto9PndSxlaZtNXhiKueR7xxe8PsD4t65zko5j9VOnzjBwPfujWPtsC2HsHePT3yvan2PqZyXRDOuf8LESNpEd+MYPnp0GOGSNUNy3uw1JyXn7frrntfc1DnnuSn3Z/UDyXn1ZeNNx3ksybZcAQTctJem57wLjzdw1cMJDCUM0bOEnMLnq7lWOxm4LOdnVQnXYfooRJPQEm1yuYbMvrcAz1nay7T7yXeRQhA/+cMY+mIRodva4FOwtD2Ai05ux8quuaNjuqvAa4NVx9u08STn1TQUq1RsbAfAxWf16tW44447xCJEMP2fDls2CuMGcleBQ/vkJz+JP/zhD3jooYewcuXKSa+zPJ4b0t/97nc488wzxXOvvvqq0LXdlqbtVDBqw3Hz35NR2C1zPxLL4K8P3yOym1OppIhs7bfffqIR3YIFdtfBSsDp1knye/b1Mdy1vlEIv7Mz5/verGGPBUG0tbXNuOngd6HgtqM5VGlw/Bs32tFBghm/hKMtw3NuyZKl4nGtbKBqEaXnQWl38qmvO+DGaWwsiuHhYVGqxPWqo6MTe+21Ss7vDmLqnPI6G80Haqppk8TsIPkOM/LExr5h3HvX7aKqhwYijawjjzwKRx55pMhKqDRncO1iCauqakLLj8G+9vYO8Z7pOI/fIZFlqi1E5nv1MoUnc56mufCzZxoRzWkTHMggKhu2UHtSct7s+a70PQ4k580epftDztlUvtuWYStRH5CcNzPWrFmDP/zhVvT29oproaOjHSeccCL23nvvip7npZy3IaLjgf4uxAsedIQUfOAQj2hINhPnVdO+m7pWO5qrBGUdSu08OnG5Rss1ZGvwd/z09X3CrnCaZXU1ufDjDy6b9Ls6c833X3a/CSpbDcQtFAzKaAKaCpFE8vMPLZKO25208STnzaFMW2a03n777Vi3bh1efvll8dxee+2FFStWlEUS4be//a34PGZNOjq1JF96/Xn/4Q9/WJTBMALDRZFO3sMOO2yHHbYS00e7/t+3rsa6h6+FkZ8shfHggw/gqqt+irPPPhsXX/zZipBkaXfIB/o7kNQVKIqBWF7FrS+58d03tc64oJQuOoq/OouOHX3dkpkoSkRhiXtGC5kNw/d0dXVXZXz1As6RsylyMup5zTu//dQuos68ZzJp4YChLjaDTsxCkgS08x19V3Q144pzeqq+UZaQ2FWg4/BrX/uKaKTqGFkO7rrrLhEc/sIXvoiTT35bRcbD9clZpyhFksvlReYRM0woKbB06dJp1zBei1YhKa5Tq1C9jfZUzitYbkSzmsj6VVQFLs0ljDPN14iuZimrsjN8R0jOe+PgNeNI+8zUwZ6Q8ycxl/DKKy/j61//Gp599tmtXvv9738vkp++9rWvY9WqvSvKeY2NzXj4JS9ieQVM7Ivl3bjxWRWXndky7TXIQAuvUzNfXb4jHM7jPSUamHVbaufRYSvtvOnBTFnHYevswfqiBjYPRbGoa0v2tPMbM6lsLG83disaFsaljcGVPJkz8P2/jODKDyyU9sl2IDmvvrDDTltu/r7zne/gj3/8o1iIjj/+eHz5y18WztNy4Sc/+Ym4P+aYYyY9f8011+CDH/ygePz9739fpGwz05aG18knn4wf//jHZRvTXAejVxd9+XtY/9ivxbG7oQML9z8ZZ76lC5s2bcSDDz4oiJW/AbWNv/zlr1bMcctFPZobFkLkXKipdTQQN4XzqHk7ESRHO68aixCNKZI2G4YQfMyIK6+j0vdIbBuco1JHgD2nuWnLkwi7TMmuBiAcXWOJ2c15qe6kc56WGroSEvUMrhPnn/8RPPXUU+J4jz32EM5Z7nleeulFUbVDzvvc5z4rMl5PPPHEioyLjmKHW3V9TOxvqN23LdQq5zUF3ehp9SKS3rJXYJY+gz4iOzhnSi26WfIdITmvMnwnITGXQHD8j94AAHD8SURBVF776EfPx9jYmFgj3vrWo4WdzcDQk08+gWeeeQavvPIKzj//PPz2tzdg8eLFFRmXkIkr0FFbhGUVYZqqcOCNpFUR4KtlvrP7+tic56zB1ACVdt6OgfzPPcGmkS2c1x5U4LLshmRTk7DaGv1oD2YxmLDgUiEarzrbB7emYCSpC9+AtFO2Dcl59YUd3s194xvfwFe+8hWccMIJwlH7gx/8QJQxXH311WUb3I4oN/AEu/LKK8VN4o3j3ocem3DYdhyyGq37nwlF1XD828IY7H0NRx99NB599FHceOONuPnmm3HIIW8RcgnlhLNQh7xe9DR7sWE4jYKhIFGwF+Ov3DaCL50R2qpEe1sRpEpiIjI4ru/naMyVEhAxODgwoYckyxG2BueDJaLcWDqRa2fupitP4ut0jnMZYUMAr5fZ+WEx/xI7hqmZXPKclJhr+L//+5Fw2PL8/n//7ws44IADhCwCg5J7770K73rXu3D99dfjySefxBe+8Hnss8+d6O4ub7MnhxvIBaxuYsm7aRrCICRHbNiwHvvvv/W1WMuc95nuybIqqw/14ImX+nDdkwXhzJVSKzvOd4TkvF0PyXcScx20q//rv74kHLZ0xv7Xf/03li9fLjJA165dg333fRMikYhImurr68NFF/0nbr751rIH1BzOa27woMWfw/B4kaeuF9HiN2Dk4oC/pab5jvuGqRIIU+08zjEhtcYng+cX+f/yP/eJDFs6bM85SJ1IDCx10A8N2VXXZ+0XxPVPAQVdEc5beoy8bhUdYRcWjAeFJbYNyXlz1Gn7q1/9SmSwfvSjHxXH9913H0499VT84he/kOLEdYypWS633GA7bJtXnYK2A/9DPKYxtbCzBVYhJQyId77znSL6Saftb37zq7I6bUsX6pd6k0gXVESyLuSKjK5ZQtd2NK0KY5Al26UbCy5A69e/jmw2KxZ+arVUC1wIpy6Gpbox0xlfpe+RsEFNP87PVIKZrjwpGLQ1/vbf/wCpzfMG4MwX14p41phYK2SGnEQ9ovS8JTf8/vc3iec/9an/FA5bgk1sCvAglE6jWCyKZqisNHr++edx00034T//89MV4TxyQiAQFPJQuVxGPMdLjc1a+L6tmzHWLuexVawjq0IDnN/xskfZmIxSQZRLwLQ8Pp8xE98RkvPKg9K5khwnMdfAAOXatWsFx335y18RzYkchyIdiZRW8fn8+OIXv4jPfe5zok/MP/7xJA455NCKcd4pu6Vw+6sBjOWAsLuAU5fnEYn4xTVYen1y3HTgsfmiZSlCNqhamGmNLbXzSnXeOc/b+rv5CAZsqWFLSQRm2HIPM9XGK+U86hx/4XgViicI09OCK+4ZFRm2dNjSASzX7B2DPAfnoNN206ZNk5xzzLjlBdHf34+FCxeWa3wSFezUeNa+RTz++GPitT2P+g/Exx22XPyoG0RjgJkfvF+9+oO47bbb8Nxzz4kyGuoflQPOQs3N8/VPmYilGIED+uIAl2O3apcA8js4pRCOsRKNRkXaP8mRWVONjU01uTjNZHxVK2pc65i+i7Zd4sGoPO/pBODmj+fN1Ij3dM4OidmtFe86sBG3Px2Xzcgk6vo8XmX8TXDDokWL8I53vENksfYnNfzozox4T2uwEasP8WBlTxAf+tCHcdFFn8Ytt9yCT3zik0KftRxw1n2uX6xm4ufQePH7AzT1RBYldfKmk4apdc5zZFUG43lRBkuHLcGmIxSjK+VxCRsz/X6S8yq7VjAzfEHIkE5wibrC1OCNE6Q86aSTsWTJkq3WitJM0dNOexduvPEGEagsp9N2Kuc1qkW8d+UY0gUTPs1CZ7PdfJPBSMUbFkEU2qSs5IhGI+OOUAVut2sr3e9awVY674WitPFm2COUathOV8ZPzmMw3ZGh4M6oozGAb5wWRCSRRWvYj+ZmaY/MhG0FI6dmhsvAb506bZlZOVXrgp1peeFI1OdF62xICd7/+LZ/iccrV67Ezz5x8IwddUmKLKVhNsc///kPvP76a2Vz2joLNQ28oYSt56dRp021oJuAYZnI5wsIuooY2LQWMb9/QkNo48b1SKXSIjOJmxDKDyxYsKDii8/2Ml44XpYqkYgIh4iktsyOz6nQPE4khDOD5cScS3ZuZcYyz12+5pwX1dS+qse5nbpW9I8V8LXbBtEedonACZ+XGXIS9ch5a59+Xjw+5phj0dLSKt5z6X12B2OCZfu/ewa4YlXThLY+jUQ2d2KGUjk5j9lD2WxGOGt5TE3bfN42VFi+StAxK7KC64jz+BrHjWIa7UG/cNyyOVmpzq3E1pCcV7lzdepa0RvJ4sr7UyKrS86lRL1gOs3X115bJ+6p2+40xZraQd5xfB533HHCafvaa6+VdZzTcV42m4SiF2AqHsG3r48UcU9vJxLFFLoaXXj3Pjpc2QHh5KX+fDAYrFrTxe3ZeA7nOTYeQR6XNt7s55W/byBANy3E+UL+I+cxi5ng40gks1VWtsT0wcjShJvpJCg4n5Lz6tBpy00Mm3/RQHDAi+mCCy4Qi6WDW2+9ddePUqJsnRpLEUnaG3y327NDHXXptCd0fdvNUd4InEUimM2iMxzHSBowDRMhdwGZoopC0UTCUJAtmLjkjhxOXd6H/XazdY8MwxQagJpmG4HMVqp0ZJPN22hIs3SH2nKl38lZJEubhzAzqqWlRUa2toGZmg/QScGOrQSd4KVgObHXu2WDJCPcOz63zGwoXSsKuo5E1kCTH/C4bQqRGXIS9ch5qWxxEpdN9x7n3A753KKqgwbi9hqCvRE46/7YWGQ8u5YZRsywtYQzlnyRSo0JnVs6b8PhxgluqXXOc9YX7i/4Xd57oIKbX/RM0rSVgZ+tITmvsvM6dR3QizoGcwZGYkV0NDfIuZSoC0xnu5EjCK4d23pfKS8ahl7WcU7HeUwIY5UJtdxfGy7g1+sWoWCacGkWsjkDv8oYeM+KHJJ5C6qeF2N1/raS2CJ7sEWigbI2pa87nEdnIytl6DORmrY7tzbz3HT2CFMzlwnHHSXX6B1LXChNuCmds3g8MRFkoONWzmedOW1Xr1691XPve9/7dvV4JCrcqbF0Y9rd1YVeQGTOxuNxNDY2zthdkFk/7EBKdHV1lnWsTlbJhce7cOX9UQzGLbT5Cjh6yQDu6+9CIq9BgYKxnIo71oawpCUOyiyT8Pkd6FQOhRrQ3t5R0cgmSYcNY3hP5PM5oU9YStSMGjI6TKctjS8K2TvRb4npQfJgGRVJmvPGOZuufIa3dNqOwoZCYdnFdQcw3ea9s7FpYq3QDR2mYSDgZvBEh64CLs0lM+Qk6pLzWts7EQXwr389M+N7nHObUkB02DrNwcoJcsTKlXsIY5COWdsYtUR5aCKRFPxrmhoSiZh43nbOZmqe86au3XsvDuO4g7smqnqkw3Z6SM4rD2ZyVpWuA4LzTBNN3iL0bAJpD6qqFS0hsaOYznajvcZmWM888zQOP/zwGd9HPPOMzYudnV1lH+tUzqNj0wmO3tffjbxp7y91w0Ikw3vgmpc6EU13IOzO49RwHCs7OiredJE2HLN9GVglNmzYkqk83drd1dUlbbxdwHl8jXseZtoSTuKTA8l3W2NbSQlMuCmdW+7dxN+MazBLzqszp+0111xT3pFIVKVTY2ma/CdOOBSff2x3Qei33fYHoVs7U3dBvk7Hbnd3Nw466M0VGfOBKzvw3TYXNvSNYGw4hZEYkNLdUBRzIoqU1D0oogiPpQuNNy70vG9raxeLTiUjm1MNAkqMlIKGLbUHmRnFGyEXxu2DhqhDJJw3anCVdlunQ8MpnyHhu92FCcIv7eoqsTWm27yXrhWbRoroaFBw9gEKHlhrIZq10N0qM+Qk6pPzzvnomTjv4V/i6aefntBmn/oe59z+7W+vF//O299+yqQspXLBWaPo9CRPsPSdhqGiWBOZtOQUOmpp4NKhW+ucN93aXVrVIzE9JOeVBzM5q6ZyXmdYwxmrFBEcmRp4l5CoVUxnu73znafh0UcfxS233Izzzjt/PAhpv48cUlS8ouKvWCxM6N+edtppFR2vw3nUaO8fiSOte6ApFgxLAVXQdUNBztDA4lCPR0EOHjw22ojTj++syrVZynPk58lNs7ZeuyXeGOfxNfIcq4wc25+vkwf5WGYxT49tJSUQzpzRYdvRYetIc54l59Wh01Zi7oE6Jk43ZyfL5T3veQ++9rWv4kc/+iFWrdobBx988FZ/9+KLL+Jb37pMPD7rrLPL1pBlOjhGnmowwqahxWcgmtVgsHTUAtqCChZ3t4kyVkaLbM0brSqLODdJzHoikZDUmZ1VGgUm+TAjhpAL446Dm0xGsp0ILOe3VI+LcOYVYNQwPeFkqdUmBbW8yS9dK9jVNZeMiGvwkMUWfKFWLOy0r0kJiXrkPDZV/ctf/oLPfe6z+OUvr8aKzo6Jc110MPZmcNNNt+HOO/8k/o2zz35PxcbrVJlQcoDrXXt7p8iiTaezyBkukHqZTUtJHa5xtc55U9fuSji/5wIk51WW76bnPNbdBmVgXaKuMPXaP+GEE8U5zOzQL33pi7j00kuFJN5oPoAf3Z/GQCyBzlASxtM/wuDgoOAWNi2rFuct8/rQtEFHrmghbXhgQkXAC7SEPHCppmhiSUddNKsglbdQ6ZWO/DY6aldMMlhKR2JplqfkvF3PeTa/2RUlBH9/OnKlHTL7xIWpCTfOeuHMNeUmJOfVDqTTdp5japbLGWeciQcffEBEYs8778NCrP5tb3ubWECpoXfffffhkUceEQvkAQcciPe//wMV73boODupDbR3yyj+vKEDeVODTzNxzHK7c/LQ0NC4HosCj8c7sQBV0ngpjRoTjvHK5jAco5Plwe8iF8YdB+fNmTPn3JgJDuE7kLo828dM14jT1TU2fg3K7C2JeoVVwimf+9z/w7/+9SzWr38dZ5xxOs48899x5JFHCiNh48aNuPvuuybKRD/84Y/gTW96U8XH62iX0ikbKfjx55F9kNS9aPaZWLSqER2TmlnWNueVrt2yhHHHIDmvfNjW9SE5T2KugVzyzW9eho9//ALBba+++irOPvtsPDi6HEMJHZm+f+G1F+9EfmyTSMj5xje+OamXTaU579X+NPJmUThsiZ5gDucfGcDd6xQhlce10LRMtAcUEVzhtVppzttrr1VCJoGQnFd+ziO/kedK2ilNguS82SUuzCaYKVFdKNa2dn/zBEzBZ3YIy/0Z2ZlPKC03cMrofD4//uu/voS//OXuGf/uLYcdge9/73sIhUIV73a4+lC7m+g1f8vhpWFVLOYhjwGvBnSEgE8dVoBhFEWpD8vZmIlEVFsvdmqHVsdJKxfGN9ZVlKAOlmOsLlmyVDy3pYxmi65fpcuFJSRqDfOZ7xwuWT+SRzxjoMGnYnmHF/+xTwHf+cqnZ+ySzY3tRz96AS688BMVy+aYusaRO/r6+vDDv3kRL9hN0Yj2BgWfO4ZjxLj+reS8uYjS84HXMAPTTrZR6bxKzpOQmIz5zHkz2XnPP/88Pv/5zyGZTE77N6rbj8su+zZOOfn4io/T4bwNGzbgWw9aGEnZbgrd1ESCTktARdivMj6JRMZAewPwgUM8WNysSM6bJ5zH89g5l4mpcy7nWWIuQmbazmM45MLsHZbK+HxeUdrBzpeX/O938MEPfhC//vWv8Ne//lWUIzDaumLPfWGuOB3xxlX479vj+OSJHhG5qWS3w2v/bqFYdCGac8OEJf6XKirwuw1EMgrGUjkE3HZzFkekvBYinNM1vZCC9DuHUkK2tYEzE0766V6XGyYJifkNh0v6xwqCR1huGU0biKQMpPM+3HzzrXjkkYdx/fW/ERJANHAZlGSzln/7tzOwZMkSxOOxiqwhUzsn0wihgZI1FCR16kybMC0LqqIKeaChaAxdrSG0trZO6qgsOW/uwDnveG6w6ol8x0YslIyaek5KzpOQkNiWnbfPPvvg5j/+BQ/d8yf86Jc3IhXtE+9Xgl1wLzsBBx5xAg7Yt038fTU4T8j9FIFYzgVVsRuSJYsuGBadtYp4rS0AfOLYItwooqXZW3XO4x5jJJbhg4ngruS88nAe/RRTITlPYq5DOm3nKbgIsuFYNptDPp8ViyE16PqTLnzv0X4kiqPoamrA6tWfxvnnf1SQ6FiqiF8/H0LK8DHAKQxfGsFMtS9X9tF03Q77xuzjgN8LT6aAom4J562iAq1+A36XHZWlw7azs7NqjTg4x6UlM4XxElYnUli6uZBG1s6Dc8xz1+12i3sel84hHzul0LyXukcSEvMPvUNRrB9Miq7TuaItkUAUDQvP92bw9POvYOXKlfjmNy8V2UfDsTTc1pbOxeRAp2lRudfo6Zyd5LHli7qxoLmAoYQJ0zSgqhpaA5bgPDprWU7a3LwlA6WSXDJdNpfkvF0P8huzjmwaU4SMx1TI+ZSQkKAu7ObNm6AoKopFXTSy5B55/aiJyx/RkDL96Go6Gh3vPAyszRhO6IIPXSpw+r6KSNbhrRqcl0wm0NEUxIJmE0MJQwRZC6Yt5TeSBloCwGiGmptBtIS8VeM8x8ZLognXPVFAbySLZq+Jcw5SReav5Lw3Dsl5EhI2pNN2HoLEwXJySgyQxPN5CngzQhnAbS/4EcubcHsM9EUN/PJxHWfvb+G3T/sxlPRhJK2gs9GEz22XZtKhSm2UcnV/nq7bYU+znT07GNfR2ejGULwo9G07GoBTdkvC7XZNOGyni8ZVco6d7pcUqmd3Z0eLh4Z1aRSxNMJMSALaOXBDFItFJ2UHTJXXoPB6ObPDJSQkagtcD6KDmxByASN5cpULsBTBe44mHp2LhXQUGa0NNz2nYSTtQ3vQj/ceqMBp8VQpvbSZutrzOZaB/urJAoaTCpp9Ot65Mi04j02/qlUWWJrNRc4rLUGWnFdecM4d/URZYSIhIeE4bGmDcA2gnefI6bCR5Z/WNSCpA26PjsGxHBJZoDlgoTuswIKKzhCwR4dVVc4LhdiEqiCcn9c/ZeGFQQWqYoFfw7AUjGWB/RdqWLKgVWReVtPGo/159fMFJHQvXJoLY3ngxmcVXHbmlioIyXnls/EcSM6TmOuQTtt5CDsbpjhhCDJDkV0v3YFmxPJuIT7vYDQN3PCcC9GsAU0zxXN0ki5u9YiMRTrBKGZd6W6HhPPcfj0aTltlYo8ODZlMUHyXnp6FVV20nTnmPSPbzOuiI5mZUBRPL+0gOl1WlcSOg1nMmUxadE0nSpvwNDY2bSWvUe7scAkJidoC19RisYjTdi/g9leDiORcKJqAS1WgKSYWh4tCUofG1w3/AuJFDbB0oaV3w79UfP7YLRn6lSi/3FYjiIaGHL7UmECmqABFHcUinaFNWLlyd1QLDmc5nMe5piOZgWDJeeXhO841G8/xvJyaBS4dBBIS8xvMVC3lK01T4fcHEEnkkCh64HLZdh6Dlg0eIOyhVJCJFr+BM1ZpUJQt63W1OI/rGPnukoVuXPz7BAq6iZGkIbKBue597MQeNDcHUE0bjxhL5TEYN+Dx6MJpKxy3OUDzNU56vzPf6QIQzGblmrwLbDzpFJeYT5BO23kIEiKzX3K5rHgcDneISCVJpSNURCSz5b1tIRdiWUBRFVi6hWY/EM0ABV3H0vaAcKCW2/k1U7dD5zkjFxcNWAhHoNyOxlVGi2nmqHEC0WhUbJZYxjo0NCAi3myIwLG9/vo6NDW1YMGCBYJkmDHjNEqQkcIdhzNPfX2bhYOc5wCxYcN65E03Xh/QhCOf5zA3U+XODpeQkKhNzlsQyuKCgxIYKjbigY1hDMQNNLp1HN8ThaJoSBcVjFFDj0vDOK0N0UiEHy0N3oquy9N9jvMcxyEMFK+91pHzpsu2rBScLCmH81iyyiwpch8di6wyGRkZRm/vRnR2dguO4/v5HKWZqPkndf9m79ygjIezH+L+gbp/fJ2PWQ7tyFJIp7iExPwCM1W5Fjvrs9OgV9MG0RZUkNDtZBvui3tCCi44KI3hsaSQ2vG7/fB4bFuqmpznHNPRubAlJ/bui1pUYX92NihYEua6Vh2nLeeF3MY5JteF3c2IFyyYpgmP14POsIbXXnkOup6f4Lyn1gzhxmdtHfpF7Tl85pS8rPqbpY1HXrNcQVs/eGRE3Gy+oyyTd8L+k5wnMRchnbbzeAEs1VslSDyrD7VLL6NZoKfVi4vfvgD/d98oNo3YnlyPC3hTN/CFtwWwYknlshX5OVOdbBPP+VvE49LOydS8GRhNoCVrYHFXa0WzKh2dIzoQKfrvRGMNwxD6UCzt4HPcEDmRQWomDgzExbhpiLHshpCO2x2DM0+cN5Y503nAMjBmzvnRjFTeD5fbXu4WtfrLmh0uISFR25y3b3s7TjjQwsb+UQTFOuwVgZ3FizuxpN81wXdEe1BBc4OnppyKpY47h/N4q2aGCT+b46HD1tbIt521w8NDk/g3Fotjjz32FOOlRBPnPRIZFeW81ZIzqjeUOu/JefF4QmQhsVks55T7CD52MuScDuYSEhLzA85ayoxbOnDpNKS90dLSgvcckMatLwFjeZfYD9Pu02NRUW1CMNhD+6RWOK+04pKasW1+E2fvr4pkHb5WDb6jLAI5zlHHP3bBIB7s70S8ADR5dRzVFkNvb3SC8xYsWIjfP+8SSVGkQ+r0yqq/HQd/49dHirjy0ShG0gZafAbesSKFRjU+Lv+hCc7r6LCTt6rdhFVCohyQTtt5vACWEh2zdBi5orj7pw4riojhfrt3oKXFJwj9B3+JYSihi6YnZ6xS0N7UVXGi2ZZejXM8MNCP53pz+M1TJl4bJZkOY68FMVzyb4sqEtF0SjRoODFVKxAIMgcGmUxGbJxsA3VENAbgpoiGKxsFLFu2XJSSOuldTpmpxM6Bc0c5CsPQceKiETww0I206RIOmEpkh0tISNQWyBHsmt0X0xEOu4QzscFrrwMsG82bLmHYfvLEIL51+0ZsjhTR5C3ixEUZFIv+qox5RziP3E0eYdYq39/fvxn77rt/xQxZh/MoicA11+Vi1mdaBC01zSXWYBq4drazR3AhOc/t9ohg5dRyXonZg84D06QMk3d83jURMPb5/GIPIoO/EhLzD6VBMPKEg56whY+8WUe4rRV7LW4TercvvTQiuIPgul2ApyqNe2fiPKfi8rVN/bAKtKnS6O9PiDF3d/eI5KNKct7Q0NCEjVcojKFJjePdSzPwBJvhsgqIJDLIuyx4vTbnrd2wGaPphdDY5Y2uXtOSVX+zAM9FNnoby2vQVEsklv1xTQBnL7erbB3Oo41dLW1/CYlyQzpt5ymcbFCWFZB4NseBm19woz+hIJlziYjroqcG8OEjEggrMZyz+zAGIxRcV+DONSCRmOz0rcR4nazUoaFBMfZSkubrr/Sl8cvH03i2zxSdRimpz/3GS315XHbbBvz8/N3LvgFxHK2MVHPTQQkKu8mbTxil8bgpspBo4GazOQQCPqEpzA2IHbXFpL+X2HHYWV4NQj+Rc+lkcXUGMvjkoVkEGhuwZEELmptlOZKExHzDH5/sx3fvSSCVt9DgU3H+oRaWByNYO5jDH9c0IGm60NM0hHMP8+HCQ9JYu6EPRi4JI+3Fhg2G+DcqmQm6I5zncDjL4gcHh8Qa6HZryOUK2HPPPSsy3uk4j7IIdOCS82iwssoklUoLAzYUComgJZ2LjnFOMKgpsXOcR3COOafkPIIBCr4ms2wlJOYnyBGUCWPQjOsCqyDWDubx62fc6EtTti2CvbqT+M/jQ8jHYyJZZFPSh9+86kHx76NY0pGtaOPe0oaWHEtpM2nHmVtIx0TiC6sLWJVoWQZGRyPwN3Zg1YrFEzIQ5QTH4UgMErQracexdH94NI2HBhcgmtMQVDI4qr0Xy9pcaAmF0OgpIF7wQNVUIUtR7p4wcwmJnCmc3JS4g2bLekSzJopwQ0FBnN/kvGr3s5GQKCek03Yewul6OTw8jHg8JkrIb+1dIbJroxkFuqmiaFrQxnT89KEY/vPwIjbHFdz2+kIkiy60bTZxjjYispIqtTg6hqHTnZqEXuqApfH680dNDCUtIVJviooVBRos6KaFjSMZvLxuI1atXFoRbT/HkOJxR0enMFw3bdok7p2oYLGYh8cTxqJF9qbEzsq1Ucmo8VxBaffZ9vYO0YTMskzhIGBJmNQJlpCYn4hGI/j23XFkinbGRjJr4CePA5/fP4KbXurEQDYAw6LWnIX/eziDzxxWRLLowW2vLRWc17rexBmZEbw9FKpYp+rtcZ7TuZoYGBgcD8AyYFXA0FC/yDqpBEfPxHnU+mNGLTX+7GGbIpjW0BAU6zPh9/uFsUuHrZRGeGNzz7JQ7uXomGGZaKX1KCUkJGrLznv55ZeEDmihkB/X+wziphe60Jf2QjcBxTTx8kABVz0cx1HtRdy+fhleT7CqREFLoFjxxr3kPIfvCGazksMIx5nL15jwEo+PiftoMYi/ru9Cxgqg66UEPv22YRy40uaXcoHrqsN3TMCho9Ae7zAe3NSNeIGORBMp04/HRhdjnyVxwW/vdaVx8wtsdGrLUsiqvx1H2KcKJ7fTVJrO2852DXutWCKSnvh7SLtZYq5DOm3nIZyul8zK0HUTsYJbCKOrmgLDIoHQ0anAtExEMipeGTLxk+e6kdXtEo5Y0cR1TxWwatFwxRZIGiGDkSQKeXvBZpTT+S6MtvYNU77BdnpqioUiVFtpyLKgKhYa3QWkxlg+2ljWMfPf5qaCGUY07h0dKc43HYfcPPHmctGg8sLr3VJ2KwmnfB3XJSQk5i82jmSFw7YUPB7J+zCQDY7zHoQhuz6qYkPcIzgvM855w3ngu49ZeKg3gs+fFqxI5pHjkHM00adyHvX8mF1JUNONjThsB6kiDHTqmjKYWe51cFucx8wXXY/CNA3BeXTYejxbKkiWLl0m1+ldxHmyJFRCQsIB1wRW9RmGKY55n8hZiBc9wr4jaCMxyaVvTMedqWZEsvrEa2w47XPn0GvoFSvhJ+c5fEfY2axbgpcO59GGosOW2ZePRhchbXqELA/t2KseTuCnK8rvDGXwl4k25DzKE7GXhi/cioxFO5TfgY2PVWTRAEMtiL/ZY0EQ33tTKzRf46Sm2hKz0zWm45YO3EpmgUtI1AKk03Yed9Ieyfnxx42tiOXdSBsaQj4Fbk1BQbeE41OBgs6wC/dubERWt7aQvKliU8KDkVgGHbGxshsK64by+NG9GfRGFDR7QzhjlQfdrIEfb57GKJtqZNHI75QCGlyAYbrEOFWY6AnmcNruLM1sLrtOLKPbHJPXy82HTdQ0pkjwnHPDKGJwcFA4oRn17u7uFrp+0sm4ayDnUEJCYiqWtPsRcCeRKpAb7IxESssVTdsRWmoYUN/vznUBZHRqhG5B3lCwMVrZ5iHkDWaikjuczB6H82i80llL/Vh7LMqEjmxra1vF5HW2xXnMrBXOgkRMcB7XZza3kZy36yDnUEJCYiq4vrKSgYG8fL4In09DZ6MfXWEVkaydmEPQ5usMaxhNe6EqurCZTKgigFkoFtERUmDk4qLhcyXgdruQy1kT8i78HgwK8kbOY3Vof1LDfQOrECt4kDT8CHuK8LncQnZgJG2V1cnsSDg4/O9kAttcnRbOxL4xE6ZhiL0E+8AsW9glOI8cqEqH7U7D0TXm7yvnUGI+Qjpt5+kmnwTzw7/5kFNM0LZzmSoyuoLWBhXxtAmfaqAtaOIde+n49bNuKIop/obgf/mYUdxyO0H5OU5kjeUQSd2FP73mxcouu1R03bo1SKczQsfv3W8K4nfPWIhkFCzyJbFfcD3CHgN7LG7FkiWLK9JR0invYbSYhjaJ2unAysbly5fvjra2jolypYULF00Yr9tqOiMhISEhsXNoaWnF596Wx1f+GBe67KoKtDYAj490YkljAZsSbpFtSwN2j24v4mk7U8aGzXs87otZ8HryZc88KjUMySEsdWfmLLmFDdRovJInmpubRXkmnbV2BYdL3KgdS2OS1RvlxnScx7FRu5ZGaltbu2iSRuczObhUqkZynoSEhMSuB9dTlu0nkylks2n4/UEsX74C72kwRTZqb4Lmv4JlzQY+fmwLfvZIEmtSFJRzKi4Bl5XDGavo9M2XfbwO5zU0UPPcbvBF3nvppRcRiYwKZ25rawdME3hoXRgpgw2pKPGgIG340OJ1C51Tyg6UUye2NPOXnEcbdeXK3Sdef++BFm5+MYSBsSLC7jz+Y18DPT0LMJoP4NI7R9A/FkN72I2LTm7Hyi7Zt2S24LkhG7dJzFdIp+08BaN9ST2OQMA+zhVNjOWKCPlM7Nmp4u27W1gSMtDU1IBH+wPoH0shN554ROGBLn8ahTQzbHoqIj5eiqGEgUxRwdjwJmze3Cueo6Ha3e3DJW/vxt+fegb9YwU8GV8udI7+pbvwyeXtWNJW/i7KzDRy9JgoUs/SmU2bNgptJmYdsTkLxfWdElI2mCHxM+uWG5TpBPglJCQkJN4YjnlTJ5b/PSsyiHTDxGjKxEvDJla0ebGyHUjmgZ5mDZ99Rxcuv2sIa4edTNst2Rx038YzBhq8lWlo6YBGM7NrN2/ejGjUbk5Go5ZG+V577Y0nn/y7yKhiZg8dpXTisiFLJRyhUznP7fYIqQZbgqkonLarVu0tXp/Kec77HOkH6biVkJCQ2DWgTbHbbruJx5vGLHzzXh3DSRMtIS/ee0Ae7b4CFnQ0YvfdO3G+ouATv8kKp61bMRDQ8vCqBkKIo1Ao/7pcynkM7tEZ+tprazEw0C/4jGA1R0NLB1Li0LYLG7QCMpZPjHtxBXRiGWAkh7ERGhOdmF1LxzIbbRYVN1o9wEVHBKArXtEii2PZsGEDfvR3HwZTGiJpC6+PFHDe1Tn8/EOLpONWQkJihyGdtvMUIa+CtpALg2M5YewNJSxBLl6XitGMjrvX+vCF4wMiU+dTJwUwMpbCmmE727bTm8LbFw6gublTbAoqKT5OtAcVBD0WelNp4axlArCmucXYGNFseuUl3LZhEVKGXzRAoS7v754BrljVhHKD80GHbCJhZ3SxAU4ikRTdvWl009BmhjJlEXjsGLvUA2Qpk7M5cQT4pRG745BZWxISEtvivI5GDwaiWQwnDOG8ZWZtrmihLQh8/jgVS3ta0dzsw3nHtOLxtZnxhpZboCpA2K8ilbcQ3iJHXtamig7o3KSD1OE8Omj52M7E9U40uSSfO1q3lQA5j+Mgr5HD0ukkYrE4YjF2I8+LTC/uLcjPpZzH7NsiPGhu8ApnbyX0d+caJOdJSEhsz8FIeYTrngwgVqT+pyJk5O5et8XGI1YsbEVrcBSBXBbWePPIjOWHy+8ru503HeeRL4ZjWVvKaJzzWFWy/4olaH1sA4bidv8Vl2pgWSCNL53owtKeAJqby6txynX2qTXDuO5ZTWjotgUt7N8axT8GG8S8NnqKOHPvESzv8EwEIwejSQzE3BjN2rr55MNkzsD3/zKCKz+wUJb5zwKS8yTmM6TTdh7C1ogdEc1ZmDXkVdmQTEGz3wIUnyBIdtH2hVrtRTE2hs8flcXaDf3IZbNQzaxwjrIDdLnlBqYTH199aBCZTJ/YVNDJ6ZTRUAOJmTyBpg4hBq8oFlTVjnT2RrIVEdN35oNRWBqso6PDwqBOpZLCMKVBHQgExstcR5BKJca7ugbE2Pn3juZwuaUn5hKcbOZS7UdJ6BISElM5L5I0kCnY3lgFltA+H8upaGujw7ZFvPe6x8bg1YC8Dpgl+bZLWl3YrcNX1vLL6ZoqEqOjI8IZ63BeKBQWax3XPRre5Bc6dSlDwIykSjlB+ZkcE53GNKhcLk04mGmAm6Yu9GzJd35/AOs3jwh9xDEjhPs3d08YvdSc7+oq+1DnFCTnSUhIbAsMkNEWeWXIwPODQRRNOynE51agW8oWG4/BvlwcnWEFfYZLOG3pJO1qdKG9iU2Ty58NWsp51Kz9+eMprB9cjABacXTnZvSELSxcuFjYc+/aPY2bntMwlnMh5MrjxEVxqIa7IjIOdCbf/KIbo2k2/tTRH7OwZqQFIU9RNNwcy2m4/VU/PtlsN4JjEJNO8wZ3AwZSPtErhv9nwHgkWbkmb3MBkvMk5juk03aewdGIpXwATAN+NQ+/kkM4YCKpe5HL2pkzFKZnCaijM0SjrLnBDW9rgzAKmQVaqW7FU8XHKUS/cSPQ2dktHMwcb1fXAqGVR0OxuzWM1kABYzk3NE2FpmkiO7fchjbB+WCpDJvD8LO5iWAjFjpmaciydJXo7d0kMpE4r9RqIthZO5ezdQkrob87V8BzlEROpwVvBLPPJCQkJEo5z2Lnad0UhpOmWqIp2UjSwL4LLMF3znsH4zo6wipGkqbItqUDtzGgYHln+csvHZRyK9c4Bvsom0NDPBwOYenS3QT3UWKAXMHn2FGbjudKcgfHQBkEh/OyWbv5mN14056nFzbG8efXgeFkK4JaAwy4UFRc4v2xvIK71jfhpMPaKjbmeofkPAkJiR1ZI+LxOO5a246iwRAlg5V2dUkqDwQ9W94biUTwzpVp/P55DbG8B80BC2ftZ4mAYKUcY06/lUvv60MkTV3bAHJZFX+Pr8B/H+oVMjuDgwPYa2EDVuvrMRrPCgmHzrZOYV9VgveEZN8YOc4QewPTtJDVFYQ8KlSVIV4FYzkFmwZGoOgZYeNZlomj2zehN7EcOUODW1XQEXZhQZO7InbpXIDkPAkJ6bSddyDhrB/JYyheREG3oMKFoOrG2xe8hqfii5HUNSGeftZ+PkHiJFAaqDTA7CxQlvAXRVYNjcdKkXmp+DgjsXRqBoMQjVicZl9c1Om05fF/7BvBH15WEC+4hQP6o0eHK1aCwvlxQCctNf5oSLtcI6KklVm3bJ7mEA9LfoCYyBRuavJX1CE+F8pkksnkeGayPZ+V2rxJSEjUH+cVTUV0yKapRPctOe6EZWnBd8m8JSo6RCdol4LOEIQD8pMHRdDYGMKqlR1lL7+cDls4rwELFvRM4jwn44RjNgwdDQ1hsR5WogkZwbWWwUYHHA8NVXIfZX903cQdG4OIZCwxxljBjUTRh/agAdd4wDKhu6D5Gisy3rlQFsp7yXkSEhIzgWsEK/kGI3HECt2C8wzBejZ8moVNAxFhk/C9XJvbwxresSKNO17TEMtquPkFDZ2dRRxYfmW5afuYsPk0uY5iP4t2W2yP2+cTHNPRQXm+GHw+r+A8BjQrYTNRss+r6dicc4ugL5uheTU2KHXDNDXoho6gkkEhHROZuHTqiuoYt44Pr/LigcEepIpuLGv3ViwAXK+QnCchMRnSaTsPdf0SWRNFw3bGGqaCnOVCTyCHVd0DgDuAJQs60NCwhUic5ljMAKWDkcdcLDdu3CBer2TDLC7idNJRG88xVp2Fu7GxSRC+28rjhEPbcPwhFiKJLFrDfuE0rdT46KRlBhGNfTZb6erqEuN1nmc5KWUSSOQkdJbUkLc3blwvNJqYQbX33m+qyHjrFZxnnn9OsxtG5Onsdpq4Tc1SkxpIEhLzE6WcZ4scMN9IRZMnJ9bjVr+BVV12QJDcwcyXF/ty4v2aAiwMFeGysjDzlijPI29Wch3ZFuc546Bhy8ZjRDXWOhrO41K1wllLzqOeOx0Bqi8sql4syxC8J/QmLAvFog7LtPchrQFLZhxtA07Fk7MX477CORck50lISEwF7QwG04IeBSEtj7jqF+zHm0sDFjXbmbaOHMGV95sYTvkQTXtFzxCPBoykgSvvj+K7ba6y21DkCtpv5OvWoIXBmA5FVYTjlrJ4Dj84dt5S0ciSTSw9FV/nOCbAaVQKdIUVtASAwbiJRncBx/dEoJmstNTF78DvRjsv6BrGqW0RqN4Q9t1rBVZ0LqzYmOvZxqOzluef5DyJ+Q7ptJ1nYCYRG6lkCwryRQumpaJgunHn6Jvw/iXAvstaBMk4oAFGYzGbzZQ850O6qCDgskQmTSXABZkafaWGq4gMj5fuOJqFju7tJ08MoM2bQYNXrWgkk6RBrV9nzHTMRqNRoW3kDEPTXBNau8yMUlVNGLC6zoxRD/r7+4XEgtNxW2Jr8FxwGto45wIzz6YStmPsEk6TA0noEhLzl/Ocplhx3YflYRPvP8iWptniDLUzbXmjhaup2oSTlMZCJbTGHQOEXMybw2GlnFf6Pmfd43Glwc9ftGiJqMKxx5NFNGoJqQZKE1nFtKjeGTPoGCfvmWj3JOBRDKR1P5q8Og5r7kNvb7CiAeB6AueYDttSzqOjvqGhS3KehITEVqAt0dTUhMG0G4rbD+QVmKYCr1vBijYL5xyk2c2nvV5cd18GkQztEVOU+lPvtp2UaNFxaye/NJdxCSm13+iwPXJxEQ/kLfHZrJR0MlK3tvO6EPayajEn1r1KrHN0GLOBZk8zM2hNwDKRzRdx4pINUDrYJJscx+bSmrDvKKNgS+Apwo5moNivmFi3bg1CoQbJeTtg43FPQR1/7n3Ie5LzJOYrpNN2noGlHe0hF4YTOgwapSJqqCCPAO583Y1T37pYaMaWliQQjtH42oiBO19vRLLgRmvAwAXHlF9TxlmQqQHLx14vNf3CgDsooq6ODqFTUsP7y//ch4uP1MW4K7mIOx1QmfnJcltHRoIlSNQCpsOZGcvcTJHMVTUHRVGFLiGTkCyLGysTsVi07GOdS+C80mk7k7HrRGulBpKExPzmPLKeSsctgOEs9dBpCJhi7Va8YYylI+hsYECTRquJdAEYS+XhUexqk3KX5JUaIGNjDPzxc91i/QqFQpMctqWGCnnGCbjWAueR1wzVB59m4LieYTw82I2RlIKQq4DDWzbAr4+K11tCXjQHmyoWAK5HcI7JYQ54Ltha/pLzJCQkpl8z2Pzxvs0B5E0FC8KA5tKwoMWHb5wWFFzhcF5vJALTMqFpClQFyBSAPp3NsoDlbRDViuXCVPutL5LHX1JFXHSkAcUTRGeLD92d3pqx87ifoMN4IMYEHB2ZdBoBpFFIR8WabGgBKJ4G+P26sOsUJSt4zq0UxZyrqlck87BRtuS82WGm31ZynsR8gXTazlPQX+sUi/KBbpiCLF9et1EYUSQXlmSOjAwLIXsaq5FCED9/vh2ZIuBSAcXlwc0vuHHkfnb2UrngOI5pvDJSuTmu4L6ngbSZwpKOPpx7VMsEkTtgaQ2N7YZx+cFKZEeVksrYWFREWZlpRDLRdTpoVbHx6OlZiGXLdsMrr7ws3sfMWxEpzuhocLtEGSkbl0nMDEZcmXXtkPRM+o08j0ujtZWSyZCQkKhNzuM9K/TJfmxu+dNHUvjaqX6xTkQi6+E1gZzuFnqrpgE0+3T4XSb8/qBwTJYbpVxFzmOwkkYInbTkDyfLZCqn0QBkFcx0/06lOW9j1MTjkSVIGj40e3WcuXceXz8kjH+9uAbZxKjIREqn2QWHewdAVV0IhcIVGW89gnPMctDSztkzBQ8k50lISBDpIhDNssLBZjzaFgPRLKJJDW2NNpe9/sqzNucV3cLOE31MxhN1uDYz2aScjtBSDVvqwTJpZSQF0ciruSGOltCyrd5XTTuP88LMXzqQ1w/mEHLl8ZbmTSgU8kJm4slkJzJWEN2NC3BgewIP96sYy7vR5MnjsOb18Gv2GCXn7Robj5CcJzFfIJ228wwkPhqqi1pc6I0WRbloTrewOWYh4Lbw6sZR7NauYXh4GPl8Xujw0OHI2y2b2oTDlqTFBi5jWUV05Oa/5zQJK2cmD7ONfL4A7nu9HfGCB263Ikj86kci6Gp0iY7fJH3q5LUFbb2mLdG38TapFQA3OHapagyjoyNiI2FrL/lEhDWfz6G3d5MgF25QElYQj8X2QjSrIpTO423LxkQGscTMcDaR29Mw4u/uaN062UkSEhLzk/M2RYpIF+xs27xuV5q8NlTA+s0JRId6xZp8VJsXD/R3IZnzoslr4OQlcfj9doNIOsvKbRg6fEeQ81iV4TS3pIyOk13rvK9U55SoJufRqZhMpvDoyBIkdQ9U1UKi6MUdaz3oCvZC0dPCMcASUZblkg/p5G1paZFlotsB54fnoOQ8CQmJ7YHrREdTEO0NOQzGLWHP0XZrb2CAD0iNDWNsLCKSc45qUwTnxXM+wHKhPWDB53XB49aQ07Wy2nhbMleLwnZTNVVI5rhBzrMTiBiwpE3E9/VGsrYWuqqgq8kFFOMYy9hrHRs4VwIrOr244pweEYTcvH4I0WgWiUQej0f3QhZeaJqFgbiB64fD0A3AtBQkdC9MbRXev3ydcIZLzts1Nh4hOU9ivkB2fphncAiSWZ8djW6Y4xIJmmLBZeXxu2cskVlLY4qRQ8LlUmFqPiQLLpFh64CNWtrDWwTiywUu1iRjGq/B5g6RvUNiJ2kzKrw5WsC7D2lCo6eAbCaLgJLG6XtmhKPUWcQd4q8UHO0dakQ5xreYR9NENpvHUDQpXmNzsocGezCWo86tJgzceze1Cz2faugT1hN4XrA8dFtk7nSabW5u3mZ2koSExNznvM7GqXFqC5GMhUI6LviOa/LCRgtn7bYR5+y2Fh/eN4LuBn1cX9Z2nJZ7DXH4jvzB7EpqpDNYyc8llxEcj6Nh29u7EamUrYdua+BWh/PohOUta2hIkaOp265SUx4Yy2kYGI2J93Fs5EEGL8nfdiAzL/luByA5T0JCYkfAtZhZqCcvGUNQTYsEHM3MIZHR8T9/1nH5Ixpe7GdzSKA1qODdSzfi35e8hhVNeXg0C4pFvTZMagJWzsxVfg5tuvaggn/fpyj0Xhsbw4IjRmJ2T5XVh3oQQEb0COH9ew+ws4GrAY6bVam0jZk1W1Q8SJsBUb5KqQnuJTJFFYbFslQFuqmgN+FGLG2gYJHHFcl5u4DvCMl5EvMFMtN2nsEhSGoB9UV1uFULDe4CXApzZy1hXA1FU0CRJG+KzB5qr1IEvMlbQNFUkCi4RKZtyKfhopNtgfhyw1m0U6k0mjxF4dzUTRWbxwrIFS185rebsSCQxSmLh7C4IQdPPoDRUY8oaa10uagzXtE5W1XGM2wLwonMpgB/GuoS8xx2F3Bwcx8iGUDVdKjUADQMRLMKRmJp4biVYuqVi9ZKSEjMbc7rzRm2HpDzGv9jWdg0moFLOG3tjtBch1vCIeEMLW3qYgcPy7+GlOrWbtiwQcgCsUyVGBjoE5I669e/Lipi7KYnCSFlxCzW8W9Vcc6j45Vzy+7fjeMcLbQoQIkJQzRoSaWy4ilbw92WRqD2Lb8Hv+f++8v1+Y1Ccp6ExPyG3bArg96IAq8ZwlHt6xD2FPGnzcuQ1DUoloVXUi68OLwQHtUQdiBtO1YnNriKIoGnqLuxqN0/0QSsEpmrm4eiQj5ndDQHw7DQG1Pw+8cNjKTi6GiI4aRFI3j30jHkDBU+zYSVaAJKqhIryXec40vvyqJ/rAsNWiMOCb+GkCuHtOkXHKdoyrjMhK3bSximhT9sXIgc/OjsVfEh1zCOP0Suz28UkvMk5guk03Yeos2bEeLtw2MZXPGQjlhehWGagmha/HlhXJkunzBceWMpY6GQxVua1uPhwmKoHh+6mn34nzMWYmVXZSJaNF43btyAVCqBU5druO2VANZEPCiYikgXL+jApoQb97wWxGndm4STOdjUgRZkRcmr+N4VKp2htt9LazcgGrGF6e2NhCKyah+ILhPlM+ygTa2pR3NtaNBsojfGdafC7qJwmrPMVeKNQxK4hMT8hsN5Q9EMPnunC1mdrGGL3FKvttVvwfKFRAYPwUAbg2zkGzpIuY4zc6mSa4nDeXTI0mgeGRkSjcmy2ZzoRs3qDcsyx5ubaMJpunDhIpG5WmnO27Rpo3AiJxJxYaC+pel1/D22m6iKaQ0C71yRRCaZFXIOHCud4/b4acwyK6koNOkq1QF8rkPOoYTE/MTUhl3xvBt/LSzGgeFN2JQJicxPC6poOGaw8bGlIKMDmgroeWbYFtHo1vG+3Yew9z57Y3lHZUrN2QA7n4qKACXtzsG0D9/5qwuZou3wHIhbGBr14PTOIbhcCnIuu3qGQb9Ka5nSxrv0D0MYiOmiYSnl+v4aXYKj2jfh8cgiYc9Ry12DgdGcR8wzRQVZ0Zo2PHBpttbwb582cdzB5e0JM18gOU9iPkA6bech6EQkSbAb9r/vU8BNz2mCQBo9eRzZNoB02kJTUyN8Pr8wXJnh88KmOB4daUes6EPOZCduE1feHxFRWEZJyw1mnfb394lMW1PXcWRDHn2xN0E36TSmTALAHKpYwYONCTeeHViEDIJo9Zs4Y1UeXV3BiizqT68dxpX3R9EX1dCgdeC4BYMIahqCwQDCrT1IDHGuChNNyRKGB29tfgX/Su6GtOkT0XCWM7HhDcs8JCQkJCR2Ded51SLOeVMO1z8fFI5br6bjxM4NyOd1tLe3Cd08h/OYuUqHLZ2LxObNm4RuWqWMg1LOoyM2mYwLx6ztpKWhapeG8ntRF5av0elM7u7uXmhXx1RgrLZzeT1iMRrcdqZTdwPw/q4BuPyNIiMql8sgmrezbClDwfHSY+7MbTjcJEphK5kpJSEhITHXUNqwi9qvbKiZyvvx9+giW0qAjTjHb3YTSEXorrpVRThLLUtBtODHrRt68JvXstitu68idh7XfiaqbNiwXkjI3bh+mZAXcOpimAk8mGtAJJEVjcd0lXq3g0gkYmhsbMaiRYsqomUq+K5/FBsjRYxlbfkDTVFRcAewvKcJS1v7xN7Cpxl4fSSPv0Z3E3q2foXJOQFoqioCl+TAsbyr7D1hJCQk5g6k07aMoFPuueeew7/+9YwgJBqExxxzDLq6uqo6LqeBCbXlWtxjePfSKDJFEy5LF91FLct2hHLMdBzGswYeGV6IpA4kiy4YpiIih2xCxoguy1rKGSkkSbKhFxuwsJsktYL4aSE1jSS8YvPBJ1SYCGlZPJ1YhozFbFYDkayGW1/y4bB9PBX5va96OIGRNHdDEIR8f18nzliUgN8fgE+z4FNzSBWo3WRCN0w0qBm0KhEcHRiC4mnAoq5WLF26bLvdMiUkJCRqDXR4PvroI1i/fr0wABcsWIDjjjtOOBBrhfP2bBrDp/bcgP4k0KhSC9YFXfcJByKdo2w6xnsGzuxmkYYwDBl4c5qAldsZOh3nMTuV4yIoXWRzriIcuJxr02S2KiWNCsJ4XblyJSrlXI7HE2K/wIZpdMxy30AHNz0EsVgcxWIe+Xxh3ClrifHSyczfpbOzSxjcUotOQkKi3sAeIA88cL+QeGGwb4899sBhhx0+HlirPEobe1EjlgV8jT4T0bQXYY+BeJ72m200eV2281YbL+Fnti2HnS6oiGVN+P2a+HcqYecxGNnb24tIJCIcmZHM5PmzxpNz4kYDHo+uENmsrFI8sLEXPXk70WXJkqUoN8hhViGNdMEl7GCC93nThdZwACP5BKxCEjkFaLASOLbhSRThgssq4oHkm5G1gsJh6/F6sKjVX/aeMBISEnMH0mlbJtx77z246qqf4pVXXpn0/KWXfgPHHnscPvWp/8Ruu+1WlbE5BicbnZCo2RDEiMfHM3b84020whjKuHHzSyH0x3QMp4Cw14RBfyQjsqKsBoLQyx0pJEnSGcBSUILjpNF3YOAlFMx9MKo3ig1ImyuBA0Ib8EhsL6HPa+8vTMTyLhRhZ/SUO8ItHLZs7MYSUMUQun4ufxhx048bn29BouhCWtdE1Jhj9LjyiBT8aFQTcKMgDHSW5B5wwEGy3ENCQqIuQGfiL3/5C9xww++EE68U5Jl/+7czcOGFnxCPq815vTHgjsE2DCct0bzy2O4hLG4PCSdjKBQWzkRm/NCBKJq5CJkaVXAiUYls0KmcR57mjc5a22GrQle88Cq6cA44YyI30jmayWQqyh80QumYT6fT4rHX6xH35DM6yh1nraMnzO9AUDOf2bkcLw1uyXkSEhL1AAbUfvSjH+LOO/+0FScsXLgQH/jAarznPe+teOm7o+FuSyQAnWENR7WP4uYXvUgVXWjzF6BbLtEMK+xXkSoAHtUSvUEavCqavRrMJIQD2slcrYSdx89ipYiuG1AUFxrdOcR1Hwy4BGvQXmpxxfFcdgUyll/0NOkttmBjrh3uERNLIjq+s3cAWxRuywPuC+KZIgJuDQXDErYwG3QH3BayuiJe5x6CQWJCUSy4rYJI5Hlzwxo8ndkTOV1Do1vDJ09cLKURJCQkdhjSaVsG/OIXP8cVV3xfPKbRd+SRR6GxsVGUfTz99NO477578cQTf8dPf/oz7LffflUdq8fDjs/sSp0VhhMlEVpaWoUBdvULLozlFPi8KpR0EcmCBq8bKBoW3JoiNJHK3VmUcEiQcLpNM/upzWvgbdoTKFguYbgWtBD+PrYMKdNvaxWqObiZfevKww27XKjcEW5GTnsjWZiGKbSA2YDFq1q4fWO7cNh6XQYSBXvuwloORXjwVHpPnNj0tHg/m7OwHFZCQkKiHsDMzk996lMiw5ZobW3F4YcfIdYz8t2mTZvw61//Ck8++QR++ctrREOvaoH8ccuLXiRYWeKym2U9OtKDo/Z3o6dn4YQx3tAQEs5aciFv1Ful85GoRDaow3k0YOngZJYtx85s4JGcD09n90TGDCLszuMA/8tosGwNWzp6CTYkq5Q+LIO8zApmplQwyLH7xfMMrHI8/A48R1iGy9f4veiMJmfzHOF3c7SEJSQkJGodlK0599wPoq+vTxyvXLk79tlnH7G2PfbYo9i8eTO++c1v4KWXXsTXvva/Fc+6LW3s9erGEVz79zDiBSBVUOB3GVjYZOHcw1R0N3tF0zEhQ1BII6sDbY0BfOsBC2P5LQ7aSth5nLvedAAPDnYjWvQjZ7idLl7QqAcLA1nTizGjEUE1h7ThhQFNZODScbo56cUP7xnGD963sKyOUHLqsoUd6GoYEw28RaUngI4Gzq2JrEsTvzdtVN6Ti8mFHFObO4NTG16AP9SGns4WtHm76SUo21glJCTmFqTTtgwZto7DdvXq1TjvvI9OMlLXrVuLr371q3jmmadx4YUfw2233Y62tsqWwdull3aZZyQyIsiSmTEklVAohHy+iGiuiM2jJBoITaSOMHVsdTQHFCSzJho8FtoaUJHOogQNVhIfDUPeE3Q2E6rJbCMNj9Bha/gRUHPImD5kTR+aXFGcvCQNr3dpRSPcm0YstAUtHN05jLypIJqlYD7zfiniYG9+3B4PTFNH2gjAUH1wu2nEKmhoCEptPwkJibrAZZddJhy2dDT+13/9N97xjneIposEHY40Yv/nf/4br776Ki666NO4+uprKp5d4nDe0FgKg3FNfD45Q1FVpE0vIokEgiMjwlHL7E86aBm4TOUt0VGbGaTknuZmT8WyQSnNwACl7fjUbR16jxfPZPdC2vALPkkUPfiHsTuODT4xkcVKQ7GpqbViHML52GuvVcI4ZdZsPm9nS3HOGYTkeBi85thZwso9h60xrIpsLv4dJSkk50lISNQ6GID6+Mc/Jhy2lHX53//9Bg488KAJTmMA6ve/vwmXX/5d3HbbbVi0aDE++tELKj5ONvbKJSP41ZMFRDIK3C4LjYqJJp+JT76liIagC8lkAUYuMZ5V6xYOW8q0rT40j+ueyGMkpaOn1Vt2O2/dUB7fvqeIf2xYJqoQ6Yjlf10w0epOI1V0I6DmBeflLIj+H4ZdTyn+S9Bx2zdW/oxgglUhHzo8j58+lsf6MfuzmgImNkZNEUBlcFX1huFV7UbeTIhyKmU41wGPhUBAcp6EhMTsIJ22uxBclH/yk5+Ix6tXfxCf+9znt3rPihUrcdVVP8M557wXa9euwU033YSPf/zCio6zlCgoOs8yRma7kFD6Ux5cvyaAgXgRibyGgMuE32RWkgu7txRx5m598PGscfvR2RJCm7e5rJFCGn4vv/yS0BRMJpPjWbaWKO2xrJzI3iGYbSsybFmqCRNBJQNLUfDW8HNYEFpaMa08Rri//94FeKU3gnx0M0ZHqemXF9pLkbwXiYIbOqURROdWFT6PV5To9nQ0C92/9vYOLFq0RGr7SUhI1DwohXDLLTeLx9///hU46qi3iseiySKNJ5+Kt771aPzyl1fj7LPPwj/+8aQIWNLIrQbnua0iWvx252aOkYZoewOQiY/i+dE+ccws22gxiLvWu4WuHrNZT15SwLI2Q3SNLnczMofzotHouJ6tMTFWGqQpwzcu/WO7adOGT/AfG4vSQUqHOUsyK8khnA9mm23cuAHDw3ZDGXYBJxSFmUd0OLuFc7a7u0c4wOnc5Z6jq6tb8J7kPAkJiVrHfffdj3Xr1qGlpQXXXHPdRI+SLZznE9IIDPp95SuX4LrrrhXHXPsqCdHYq2BzHds0W+M66Cndg00pA7f9zXbmNmgaTts9JRJ37t7gRSSTQNhdwDtWJNHsN8tu53HemOiycSSPorml8RgdsjqTXCxAhwuKmhcVigEwKccrUl8sWHD+gtWfPc3lzwh2cODKdoSfHkJH0YRlGkgXFNyxtgFHtkXx0NAiJIsetPhNvH1ZDEvayXe85YTN3draJjlPQkJi1pAK2LsQzz77LNaseRUerxfnnXfeJCNscHBAGHxs6kXyPu+888VrN9/8+4nmIpWCQxQ0rGjc2TcaVyruXt+IwbguCN6r6kLvKJcrwIsMjunqRy4VRTIZg2pkRQZQuSOFdAqw1IhZUoVCEaP5AO5PvBl3xw/DvfEDEdUbhNNZM/NoULMwoCJhBhEzqSMbwv2JgxBFp2gCVwkwYnzRb/vxlTtS+L8nfEirrfD7fTi+ZxhZXRPRYOpHsawmUdDQGrBw+p5ZLF++Avvuu78gc25iJCQkJGoddNiSv/bd7wAcccSRgt/WDubw6ev78JFfbsKFv9qMNQNZtPfshlNOOVX8zQ033FDxcTqcZxhFHN3ZJyRzaPI1eYs4sr1XcBozpJLJBMbGxvDHNUGMphXhVOT9n9Y1iCxSclAlOI9SShwLOZZjcDRtybsMANoKf5bw2vLYo9h7CDur1YPW1vaK6sNyjyMatFiWqIBhNpHfHxR7Cs45QYeBy6WhsTEsJBVWrNgD++yz74S2voSEhESt48Ybbf46/cyz0NnZObHvn8p5x7/9XUJyh9I6d93156pwHnVWm/x2hqezxDa4ddz8jCEctnx+LOcSfHfH2hCGk5TiMTCSsnD7q374XVbZ7Tw6utf0pzCcEow2CXTcJg0fXCrzam24VBPd7igOCzwLD4pgW2rTUrCwCfjUSR0Vq+JJ5i2MpACXZksgcLTxghsPsWl30SukHZK6Dw8PLUBLS4eQWVq2bAUWL14sOJoavlLDXUJCYjaQmba7EPc9+g9x7+4+CF+8dQyrD02ju0HHWKqASNrCb5+2EMmMoDOs4uyD9xWkyo6j1EdavHhJxcZJoujv7xddOulAZtdmTcshZ+qijJ/sSIJXrCI8igqfVkQs58e9va04qj2DVo9dtsnMmXJHClmWymwjWwfPwtOZvZAyA8LJnLGC+Gd6L5zsfgaqauKQ8Dr8KXIwdMsuV6FZO1hoxg+fAB4bWIcLjmnEgSs7yjZWJ2JM0X5iLO/Cba/48N6VPrQEcgi5dTS4Dbg0uzyXG5QL3mLAzBsTeokkcr5WqS7lEhISEjuLx594Stz3+t+C4y5bJ7JcmA3q0hSkciZeG8rjrHVp9DRpCLsPpZtXZNpWGg7n0TG7IGTgg3tTtkaFVzWRTMahebzCKZtKZUTGDI0xTbN16Mg1bGaZypvorBDnpdOZCX3aUpAn3uJ9HU/EliOh+xF2ZXGA/xVRecJGlmQ9OkqdQDHHWm4OKZVb4vwym4hZZorCTFs6DCwEg0EhkcAAazjcOEkjWHKehIREPYB7/GeeeUY8fiR1INZeux4fONiNXz1ZRG/MwmhSn+C8hc0uuJe8Fej7rfibM844s6JjZYLLdx5SMJQE0kWXSBSh9EDRAhJ5VpBQJ92EaVgYzahwFUx43KoI/JHzIhkNkayKZeHycl7IqyCRNURCi107okxx2wJNrhwCWl5UmYS0HPb3v4qnUrujQcvCQk44TQOqB62edEU0Ysl5+WQE7Q0KhhK2XB/llsKeAhIF8pxdwcpxRXOArpDraDfbUkes1mG1SaV05yUkJOYGpNN2F5L5n58eFo/TZhCPr8tj02hedMBkeUqy6ELQY2fLPBPX8ExvUuiYgqUemco24bDLL19GPB4VpZRtbW2IZ3T4NEtkIDHySk06w7KQM90iskk9pFjejUeGF+EdCzeI78G/LTfh0NijUWcYFvryrRjU24QmLEtiLAOIFYO4e+wAHNzwMkKuLHxqHnnTFqd3bkXDRF9Mx5X3R/HdNheam1vKFjF2HLaES3MhmtXhCTZjUUMRHZuobavBPW6sdoY07LaoBcVii/iOlH8ojRJLvSMJCYlaBTng1c1x8ZiNQ5A0EMsYKNo2jIBYzixgY0SHlrK3G+lMdpJ8QiUyY0o5j05N8goDk5rfJ4yoRCIunLZsHqIZOgJKChnDruLgl2j0FIW2LbmjEpzH6hfDMCc97zTh5P84dh6zC/Xf0/ugYNJozeJA/8tQ4jGsWfOK+HcYkCXKOeZSnqKWH52zfn9AZNDS8cyAq2P0s5KEZcWcR8l5EhIS9QS7p4Zd1ZA1VKwfTON797mwIcq1eMs6xvV5KF5EwLTXvUo3WiQ3XP7nPmwazcDSDQRUIFl0I+yxm2ORWoazLqEaSycpA35dKp2KbErtEYkvGV3Bz/7VgqXtfnymO4CmMmaskluzBcoMsOfH5P2AYQE5Q8Pbmp8XlRqUAaLWfNIIiNfJlewN0h8DXl63EatWKmXnaFuTXcE5B6m49u+UmVDR1ejC25bquPVlVUgjqOMZuJ1hDcsWNgo7j9Uz5HCHlyXfSUhIzAbSabuLEMvooquzQKoPpmVhwxjQHWTaqo50QUOuaOvS0Rlq5ePQswnx9nTRwsBAv8h6rUTU7emn/4mRkUFhUI3mgRteDyNr+USZ5W7utRjTFyOhN9mlKoqCgl4ErAKKpgfDaS9+mVqGNn8R78wPCcOsnFnCLKNMa224P7EQ/flmoW1EWtdhZ9O6oCOte/CP5O44IfyU6DDKjqKl4PsLuQJGVD8iiSyayzTFdECwy2qp45Yi/j0ddmbth4+w8LtngNE00NXkwmdO6UF355aoMA1bJ9vIOZaQkJCoRTyzIS2qHQRS/eKu1GFLOCWZwskYt9+TVxvw8et6MZoysKDJLZqcUAu8EpxHeQMG9SiB4Ha7hAFLI4rGuAMh9+B5Af/K7Y10MSAye47qGkQup6Kvb3PZNW3p9OTaT4exrk923DJr9R/plaJ5GkOSEaORcoUIaWnRnOzp7J44TvuH+H6vvPIKDjrozWU3DDnWVColHjN71uNpnDBKGRBmVi2N1VAovNVeQXKehIREPYASCF+/bQDQfICRQ1/fILTW3dGXsODSmJBjv8/JFS3ogBLdLJ4LhhonJGQqUf3QOxTF+sEkioUCdNMS8gFZ3YOCYTdCpiPUzmG1UYQHQzkFHV4GKy2kDA8MU8FgkokmBVx6xyB+8eHFZQmw0m5a0upGMZfBWME77rR1PkeBARdihob7o6twSHgNVMWHx2J7YcwIiXe4YCCoZRGyUkiN5ZHL2RrDleC8xc0KLj7KQKZooL2JFSOt6Opy4Tf/NDCStrCo1S/2N46dV1qV4vw7EhISEjsK6bTdRegbHoPV8WYA1wDRl2Al+4BQDwyTZM7IpoLiOBHxv9rG+wHLhNq8ApfcDXSFEjjnoBQOXFn+8kCWXzISO5IL4M9jB4smJppiIq9Sv2gB3NDRoGWEpZ0yg0L0XUMGiaIG3VIQMdyiXPSGFyzs2TNYVqcttWgfHV6INLIwFRUqO3CKPFu7a6hfZcST2c1+6Ip3IvpaCr+IICtC87Y1bGtQlQPc0JCgHYkEOnB53ObNiM3agW0+HPvmJlE+zDLiqRsg53ev1MZOQkJCYmdA/vjxAxFYXYdAGXwS2HQfsPLfAEXbqrzRObY23iMe5VsPxhOvpeFxqcgXTbFeXnFOT1kzbsl5LBf929gyoTMXVDNCVqDZZQdOpzpGPVYaR3geh6l5RQdoIwZsznhFF+i2tvLqxTLTqbW1VTg7s1lT6A46c1OwPKLhpp3ArAgutEFReks4bvOmC6ppN03r7d2EAw44EOVEKW/RSTuVw7Y1V5LzJCQk6oHvfnjPMF4ZyAHdhwCbH4G16T4YLXvYr5t2Qo7juKWFohdz0F9/VBz3LN8Ha9euFUGtSlQ/uK08vEoRQwU/ipbTqosJROZE+66pKMCF0UIAPqWALIOC7HUCSzifX+zLCQmDxsCudxnYCS0BfOdPMUQKHNfW+wC6mimL98/kHiKYGTUaxXPsYcIEnrzpxgH+pzE62lARR+i2OG/FimYcuZ81rZ0n+U5CQuKNQDptdxFavEU0NLUh1XkgMPRPKM9dBeXQL4mcz5juQWm+jJXYBGPt7eKxuuwkWokYSau4/ikTey3Mln0h57+/adMmPJHcXThsCcNSkTF9wgwkw6sKRW1th2fW9Au9IZbMiNdp2FoKBrIB9A5uxiFlHCtLaJOGF36vhURRJBWB4geqwnFaoqkXBxrSsjA0v8jEdcGEszXh5kRTWd5awKnL02WTRnDAjDE6ICYT9uQssrB/ciZwKSSJS0hI1Dq4LsfSOpSew2G9eC2U7CisV24A9nzvuCYCsaUPNHofgjL6nJ3ds+Qk8WzRsDCc0OF12zq421oX3ygaG5vxRLxJcAnHwyDfM9k9cWzDk1uGSx1yPYRnsnuJ14Mq9WJfhsuVFK+xQUs0ykZhw1i5cveyjZXGXGtrBzKZnPgsZgGrKh0CFtymJTJ/qe3HTtoaeZqOXrdblO36kYbfZY5LFPiFZmElOOWNfIbkPAkJiVrnu76xIlj4oC57O8zNjwCbH4bVfRiUzgNhKQqaPQUk85pw3LKaUnnuF7D0LLRQNx4aWYo9FyeRy9kyCaxQLCfIIaqmjTtsHa1YJrwowqE8Pah364LHygv7SbHs9zJoaJrllTDasyeIzx8DfPP+FDalAmIcpaO0bT4Ixy0sO1uYnEjbme/zqQU0+00hCVQpPtnW59Dum2k/I/lOQkJiZ7F1uE1ipxAIBHDeIToCb3oP4PKLbNvwP78I1/ATKOq6oE21kIC67jbgr/8DFNNQWnZHy/LDJ4xbllMwW7TcoMHp8oeFk1YrcSfTcRtUcmhQ2UDEBsXrO12jOMj3vBilKf5isu4QSz7KBZbOsMTEH/ChI+QS2Vm8rWxTsChUEJpBrQELxy0YxPKukNBGEgLw1BNSVQTUIj644jWcu88IDlhRviZk0xF2pbqYSkhISFQSXJd7WrzobvZD2Xu1eE5Z9we0v/QtaLE1UERGD6Ake4Hnfw7lX/9n/+GKdwEBrsPKhOO2PeQSAa5yonvxCqQdKYdx0DHLBl4OaGw7DlvndR5vkXiwxhuJbN0gbFeCRh27ki9atBj77rsf9thjL6xcuQdWrFiB1tYWwXWtAQh5h56GHJY26XC73WhvUHFs9wBCoQahHdvc3IyurgVlHauEhITEvOC7ZjfcmgK1ZSWshUcLjlP+8W0or/wGVmZUJJAsDCRwuHI3tCe/DmvzwyKA2fzmcxHNupAd17ylRE+5s0FVXyMypn8r9ywtN9p3vJ8OtO1SsHmSzl5msjJBpzOolzWoSs7r7u7EuYe6sFsL4HUxIMnkIQUezUSjT4fX40ar30BXCHC7VKisvFRVuFULrT4dXa2NgiclJCQk5irmTKbtlVdeie985zsYHBzEfvvthx/96Ec45JBy5oBuTTpnHgEcucKLu/a4EL+95seIj/Qi/tCPoLh+xo4nsApJsHuWoO7m3eE59HOwxomH7NreADR4y+/oi0ajomt22JUTpSU50wvTUuFRdRwSekVkFNnGa0B059zP9yr+ldtTaAfx/U6DLxamJAqusmrmTZUc2L3HhQ+9tRX7LfYLZ/HTz78CFDMIBBZjr71Wof1NLnzttkEkcwZCPg3nHgSsDC1EU1MLVq3au2zjlJCQkJgvcNblH95jwa0ch5wngeF//Aajr/8TeP2fUL0NIsCHfHwivGctfbvIxGX2jkuFyFpq8Km46OT2sge4CukYwmyyaYxn8FgQOngBtwVV9QhHLGUFyHml1ZmOY5elps73Jj+WG5Qconbu1DLKTZs2YsOGDTgYebj8Puy1wpYm2tA3gqDHi46OU9Df349YLCo5T0JCQmIXgOv+p07qENquz2/OQt/vY4BZBPr/CmvtbbDW3o4hbxiWWcT64njSi+qCduAnEAsfgEDBwmjKRHeDLgJq5c62DHkVpPOOiJz4BoL0PIouGkt7rSIKFjuATJYzYiVlKRMLRVmFFY2oGOcduiorNHbD4UasHyngqgcGsXlUQYvfwFn7aejuXoArH84KyQa6oZc2KThzTxV7LzpA8p2EhMScxpxw2t544424+OKL8dOf/hSHHnoorrjiCpx88sl49dVX0dFRmexKB42NjTjj1OPR3eLFvffej+effw7pdAbQ8+J1q3E3YOnJUBceCUNzI1M04XEV0RXW8G9vcguRcm4QyknqLJlMqy3Q4UbO9IlMoi5/Gu9aNowOf7PIVN2/OIJoMge/y0JRCeOJ9SE0aHnEJjRjLQTcJu7pbcPpXm8VJAfsTt4H7bvXJMP2uCbgmD2DGIjr6G60G81ISEhISJQHLreK7v3fiaNXNeOlf9wveFfPpybMPlf3gTCWvB1oe5Mo3W/yZADFjc4mN849VEW7jyWj5dahM0WG6j2b2pDUvWhw5XBs9xCWtC0VUgJEPB5H60ZTOGpZEqobhshKomOX5aHMZqXkgKZVZts03R5gJmduqeyPLL+UkJCQ2PUIelX0NLkQcatwH3MxhtYeAaz/C0Dpn3zcfpPLD2XhW0WQ0ggthAcGfJqBP65pwEfeXBA8woSTcq7TybyFBg+QyZsojEsb0EV75uLX0OrNoqCG8Je+BehLB0QFSVdDAbGMgpxpV1La6ngGmlwZeFzUjPWXXcKImKqBfkDQjZ+cuxs2D0XhsvITzbp/scISGruErGqUkJCYL5gTTtvvfe97OO+883DuueeKYzpv77zzTlx99dX4whe+UJExOF0h2VFyMMoGIjkcfPAh2GP/I3HPxmaMZDQUXY2Av02UzLA4xWQI1AD2DW/C+nQrrnzEj86wiguOSeMtZST0hoYQHh7qAat1mtw5MZ6mgIY379EFwyiKRis0ZKmll06nhP5t4+YC4vDCJQZtCS29gEdFSvdA8zWi3JhJI2i6jQ8dtT3NnrKPSUJCQmI+goYeqx82jBYwnAR6iyrW4i048+gQjjw2jd+/2i6Cg5avBRmtFZaloMMdwzGtr6PDn0feVNHc4IWaXoBcLlz28SoKncM5nNb9MjJFVrSo6OrqEhIERCAQFJzXvXsev3qygM2RPBrdBby1cxABw49iURfOUmrm8b6akE5ZCQkJicrz3WBcFw26gm4T/TEAXYeKm5WPAbkxkV0Lfwcs15ZEFlZpsBH1upgXlz2iorsxi0+cUF4bT8jKtWjQC1kRfGRiTouvgH163Ghr64bL5caxbw6KniabYxZ+/wwwLBKELYTdBaSKbqH17vd6wbwX2qXlljDalu23qKt1q+fK0RRNQkJCopZR96seHYtPPfUUvvjFL05y2p1wwgn429/+VrFxMPPl1f40fvNPEyOpBpj63ogbPhRNFwyXCq3RGpeunRwR1C0FD/YvQNhbhKYWMRjX8MvHMzh0ld2NtBxo6liEjJWGy1UQn0GDNmWo8AQ9Qp7BEcnn3LJbNo3vY7oG8EB/F+KqnRHV7LdE1HNJR7BqZC4hISEhUZ3GLP1jBdFILF+kUWghb7nw8PBCnNz8NBqbd0dS9yOu+4XByvydnK7h8cgiHB/+J1wuDRk1gN7ejQiFQujq6i7reFtaWtDa2i72Bs2qhoaGINraOiY6eTuc1+qJ4r0rh9HXGIWRS4qsKI+nCcFgAA0NYcF5S5cuK+tYJSQkJCRqi+8oz6YbOnRdh6EXYFka3Ird3Ev3NgG8Tfe3ho8NQ0QDmYJuYSih46qHE2W18fjvfviIAH50bxojKQ2NHh2n7JYSPEutcyKfzwl777YXLESzCpq8OmJ5FRnDjYUNOaGZnjeplQ5ceHyrzGaVkJCQqDLq3mnL7FZqzLFxRyl4/Morr0z7N/l8XtwcsCySiMVioixyZ5DL5XHdX5MYTVko6gYihQAs5KEgJ8pNWMhBw5XC7qXgK1koCFh5WOyG6XJhIGKidzBatlIUGtgUlu8f04Ujmd+5yW/BzLuRLCgiCkskk0mMjIwinU5jcbMf7w32YiA7hqdjC4SWbVeDgdWHuCfmT0JCQkJi9qAzkc7LchhG5eA7ckjYlUU2nRH/Bo/Z3CSu64h5CniT+3n8I7sCxXyTeN6t5mAoJmIFIO4qosFrQlU5JkVorHMs5QT5ORDwwzDsqhByHI1WcpxzTESjY0gmE6Kc1fB54XZ7sGBBj8jILRTy8HiYQaWUfbwSEhIScxXl5LtycB75rcWTxeZITvy7hXwBbl2DSykga/hgWNs3peneTRQtuLxFDESMstp4RFdQxwUHJTE8lhIydwxATuW8wUgS/aOmsKFdioIWzYRhmrjwUAN7Ll+MsWQOzSHK8Hgk50lISEhUmfPq3mm7M7j00kvx1a9+davnlyyxm3rUApZ8qfKfecNO/M1VZRiHhISExHzD8PAw2tvb657v/rqd1ytX/yIhISEhMZ/4rm5svEtQs3jwf6s9AgkJCYm5heFdwHmKxRBiHYMl/IFAADfffDNOP/30iedXr14tIoO33377dqOwjLwy26e1tXwlIIlEAosWLUJvb2/VNfHm2njlWMuHehpvPY213sYrx1r+8ZKv2MhyV6MafFdvv0M9jbXexltPY6238cqxlg/1NN56HGu5+I6QnDe3xlpv45VjLR/qabxyrOVDYp5yXt1n2no8Hhx00EG4//77J5y2JGgef+ITn5j2b9hwxOkY7aCpaXo9ol0Nnly1foLV63jlWMuHehpvPY213sYrx1o+lMuYrCbf1dvvUE9jrbfx1tNY6228cqzlQz2Nt57GWk7nqeS8uTnWehuvHGv5UE/jlWMtH8LzjPPq3mlLXHzxxSKz9s1vfjMOOeQQXHHFFUKH9dxzz6320CQkJCQkJCQkJCQkJCQkJCQkJCQk5p/T9qyzzsLIyAguueQSDA4OYv/998fdd9+9VXMyCQkJCQkJCQkJCQkJCQkJCQkJCYlax5xw2hKUQphJDqEWwFKdL3/5y1uV7NQq6mm8cqzlQz2Nt57GWm/jlWMtH+ptvHPxe9XTWOttvPU01nobrxxr+VBP45VjrQ3U03erp7HW23jlWMuHehqvHGv54K2j8e7KsdZ9IzIJCQkJCQkJCQkJCQkJCQkJCQkJibkEtdoDkJCQkJCQkJCQkJCQkJCQkJCQkJCQ2ALptJWQkJCQkJCQkJCQkJCQkJCQkJCQqCFIp62EhISEhISEhISEhISEhISEhISERA1BOm0rgEceeQTvfOc7sWDBAiiKgttuuw21iEsvvRQHH3wwQqEQOjo6cPrpp+PVV19FreInP/kJ9t13X4TDYXE77LDDcNddd6EecNlll4lz4dOf/jRqEV/5ylfE+Epve+65J2oVfX19eN/73ofW1lb4/X686U1vwj//+U/UGpYuXbrVvPJ24YUXohZhGAb+53/+B8uWLRPzunz5cnz9619HrUqhJ5NJcU0tWbJEjPfwww/HP/7xj5rnAM7nJZdcgu7ubjHuE044AWvXrkU9ol74jpCcVznUMufVG98RkvN2PeqN7wjJedWH5LzyQPJd+VBvnFcvfEdIzpt/fFcpzpNO2wognU5jv/32w5VXXolaxsMPPywWlb///e+49957USwWcdJJJ4nx1yIWLlwoiPGpp54Si/dxxx2Hd/3/9u4GJqvyjeP4pSjgS4EyB8RCJUU0i6SWlTkqauTMNJumY4aibZYuzFlphNSmNm2yFNdMKywtzSzKbAsV0WU57dX3QSplmyZW4EtMyLj/u+7/YODfWvV/HrgP5/vZjvi8+Jyzw/Oc3/G+nvs6I0fKwYMHxWV6gHnllVfsyYjLrr32Wjl58mTjsnPnTnFRVVWVDBkyRDp27GhP6A4dOiSLFy+Wbt26iYu/+6b7VD9nasyYMeKihQsX2hPnZcuWyeHDh+3tRYsWSUFBgbhoypQpdp+uXr1a9u/fb49fGox6wudyBug+Xbp0qSxfvlx2794tXbp0kfT0dLlw4YJ4jVfyTpF5LcMLmeeVvFNkXnB4Le8Umdf6yLzgIO+CyyuZ56W8U2Se//KuxTLPoEXpLi8qKjJeUFlZabd3x44dxiu6detmXn31VeOqc+fOmb59+5otW7aY1NRUk52dbVyUl5dnkpOTjRc8/fTT5vbbbzdepL//a665xtTX1xsXDR8+3GRlZTW7b/To0SYjI8O4pqamxoSEhJhNmzY1uz8lJcXk5OQYVzNAf/cxMTHmxRdfbLyvurrahIWFmbVr1xov81LeKTLPn5nnpbxTZF5weCnvFJnnHjIvuMg7/2Wel/NOkXn+yrtgZh7ftMWfOnPmjP3ZvXt3cZ1+xX/dunW20qFTaFylFe7hw4fbypDr9Gv7+jX/hIQEycjIkOPHj4uLNm7cKDfddJOtYup0r0GDBsnKlSvFdXV1dbJmzRrJysqyUylcpFNPSkpKpLy83N7eu3evrcYPGzZMXHPx4kV7HAgPD292v05DcfUbBKqiokJ++umnZseEiIgIGTx4sOzatatVt81vyDz/Zp5X8k6RecHhpbxTZB78knnknX8zz6t5p8i8wLno0bwLZOZ1CNL2wePq6+tt3xCdkjBw4EBxlX49XgNcv17etWtXKSoqkgEDBoiL9ITj66+/dqb/yl/RA8mqVaukX79+dnrH888/L0OHDpUDBw7YXlguOXbsmJ3eMXPmTHnmmWfs/n388cclNDRUMjMzxVXa76a6ulomTpworpo9e7acPXvW9roKCQmxgTl//nx7gucafV/qsUD7MfXv31+io6Nl7dq1NhD79OkjrtIgV7q9TenthscQfGSefzPPS3mnyLzg8FLeKTIPbT3zyLvg8FLmeTXvFJkXOFd4NO8CmXkM2uJPq4V68Ha9eqGB8+2339pq8YYNG+wBXHs2uRbqP/74o2RnZ9teLJdWiVzUtMqmfZk04LXx9/r162Xy5Mni2omnVmEXLFhgb2sVVt+72jfG5UB/7bXX7H7WSrer9Pf91ltvydtvv237X+lnTU/ydZtd3Lfa50gr2nFxcfYEJCUlRcaPH297ogF/hczzb+Z5Ke8UmRccXss7ReahLWceeRccXso8r+adIvMCa7XP8472CPgf06dPl02bNklpaaltBO8yrbRpheXGG2+0V0XVJtBLliwR1+gBpbKy0h5gOnToYBc98dCm1Pp3rW65LDIyUhITE+XIkSPiGr0S46UncFqFc3Wqj/rhhx9k69attqm6y5588klbiR03bpy9WuuECRPkiSeesJ81F+mVT/Vzdf78eXsSvWfPHnuhDZ3+5aqYmBj789SpU83u19sNjyG4yLzA83LmuZx3iswLDq/lnSLz0JYzj7xrGS5nnhfzTpF5gXeNB/MukJnHoC0aae9kDXKdfrJt2zbp3bu3eI1W5Gpra8U1aWlpdpqPVrEaFq0c6hQE/btWjFymB8ijR4/a8HSNTu0qKytrdp/259GqsasKCwttbybtfeWympoaad++eUzoe1U/Zy7Tq3Lqe1WvOltcXGyvOOwqPc5qaGtfqQY6XUmvLupy77a2gMwLHi9nnst5p8i84PBq3ikyD37IPPLOf5nnxbxTZF7wdPFQ3gUy82iP0EIHw6bVK21IrAdxbfweHx8vLk2V0a/If/jhh7Z3SEOfDW2WrI2eXTNnzhw77UD34blz5+y2b9++3X6AXaP789KeUXrQiYqKcrKX1KxZs2TEiBE2FE+cOCF5eXn2QK7TEFyjVUFtpq5TZ8aOHWsrbytWrLCLizQMNcx16olW4F2m7wHtb6SfMZ06880330h+fr6dnuIi/ezrf0p0Sp0ec7WKrL2aJk2a5HQG6HSkefPmSd++fW245+bm2ulJo0aNEq/xSt4pMi94vJR5Xso7ReYFh9fyTpF5rY/MCw7yLni8lHleyztF5vkr71os8wyCrrS01OiuvnTJzMw0LrncNupSWFhoXJSVlWV69uxpQkNDTY8ePUxaWprZvHmz8YrU1FSTnZ1tXPTQQw+Z2NhYu2/j4uLs7SNHjhhXffTRR2bgwIEmLCzMJCUlmRUrVhhXFRcX289VWVmZcd3Zs2ftezQ+Pt6Eh4ebhIQEk5OTY2pra42L3nnnHbuN+r6NiYkx06ZNM9XV1c5nQH19vcnNzTXR0dH2PazHMi+8P7ycd4rMa1muZp7X8k6ReYHntbxTZF7rI/OCg7wLHq9lnpfyTpF5/sq7lsq8dvrH3x/iBQAAAAAAAAAEEz1tAQAAAAAAAMAhDNoCAAAAAAAAgEMYtAUAAAAAAAAAhzBoCwAAAAAAAAAOYdAWAAAAAAAAABzCoC0AAAAAAAAAOIRBWwAAAAAAAABwCIO2AAAAAAAAAOAQBm0B/F9WrVolkZGRjbefe+45ueGGGxpvT5w4UUaNGtVKWwcAQOCQeQAAvyDzgNbHoC3QRpw+fVoeffRRiY+Pl7CwMImJiZH09HT57LPP/lUoB8qSJUvsaze44447ZMaMGQFfDwDAP8g8AIBfkHmAf3Vo7Q0AEBgPPvig1NXVyRtvvCEJCQly6tQpKSkpkV9++aVVtysiIqJV1w8AaHvIPACAX5B5gH/xTVugDaiurpZPP/1UFi5cKHfeeaf07NlTbr75ZpkzZ47cf//99jn5+fly3XXXSZcuXeTqq6+Wxx57TM6fP28f2759u0yaNEnOnDkj7dq1s4tOf1G1tbUya9YsiYuLs/928ODB9vl/V9NpM/r3HTt22Kpsw3q+//57+9iBAwdk2LBh0rVrV4mOjpYJEybIzz//3Pg6GzZssNvfqVMniYqKkrvvvlt+++23gO5HAID7yDwAgF+QeYC/MWgLtAEagLp88MEHNnwvp3379rJ06VI5ePCgrdJu27ZNnnrqKfvYbbfdJi+99JJceeWVcvLkSbtogKvp06fLrl27ZN26dbJv3z4ZM2aM3HvvvfLdd9/94+3UEL/11lvlkUceaVyPnljoychdd90lgwYNki+//FI++eQTW0EeO3as/Xf6vPHjx0tWVpYcPnzYnkyMHj1ajDH/134DAHgPmQcA8AsyD/A32iMAbUCHDh1sPyENyeXLl0tKSoqkpqbKuHHj5Prrr7fPadpfqFevXjJv3jyZOnWqvPzyyxIaGmqnt2hFVHskNTh+/LgUFhban1dddZW9T0New1bvX7BgwT/aTl2Hrqtz587N1rNs2TIb5E1f7/XXX7dBX15ebivFFy9etAGu1WWl1VgAgP+QeQAAvyDzAH/jm7ZAG+p1dOLECdm4caOtkGqVUkO9oTn81q1bJS0tzU5/ueKKK+y0FO2DVFNT86evuX//fvnjjz8kMTGxscqri059OXr0aMC2fe/evVJaWtpsHUlJSfYxXU9ycrLddg1wrQCvXLlSqqqqArZ+AIC3kHkAAL8g8wD/4pu2QBsSHh4u99xzj11yc3NlypQpkpeXZ6/ked9999mrjs6fP1+6d+8uO3fulMmTJ9um9loRvRytfIaEhMhXX31lfzalgRsoup4RI0bYXk2Xio2NtevesmWLfP7557J582YpKCiQnJwc2b17t/Tu3Ttg2wEA8A4yDwDgF2Qe4E8M2gJt2IABA2z/Iw3j+vp6Wbx4se15pNavX9/suTqdRautTelUFr2vsrJShg4dGpBtutx6tFL83nvv2ek8OgXocnRKz5AhQ+wyd+5cO32mqKhIZs6cGZDtAgB4G5kHAPALMg/wB9ojAG2ATn/RBu9r1qyxTeQrKirk3XfflUWLFsnIkSOlT58+8vvvv9vK5bFjx2T16tW2J1JTGqRaCS0pKbFX89TpNDpdJiMjQx5++GF5//337evu2bNHXnjhBfn444//1bbqerRyqlcT1fXoSca0adPk119/tU3ov/jiCztVpri42F7pVINfn699kLR5vfZd0m05ffq09O/fP0B7EADgFWQeAMAvyDzA5wwAz7tw4YKZPXu2SUlJMREREaZz586mX79+5tlnnzU1NTX2Ofn5+SY2NtZ06tTJpKenmzfffFMvyWmqqqoaX2fq1KkmKirK3p+Xl2fvq6urM3PnzjW9evUyHTt2tK/xwAMPmH379tnHCwsL7Tob6L9LTk5uvJ2ZmWlGjhzZeLusrMzccsstdjt0PRUVFfb+8vJy+7qRkZH2saSkJDNjxgxTX19vDh06ZLe5R48eJiwszCQmJpqCgoIW2LMAANeQeQAAvyDzAH9rp3+09sAxAAAAAAAAAOC/aI8AAAAAAAAAAA5h0BYAAAAAAAAAHMKgLQAAAAAAAAA4hEFbAAAAAAAAAHAIg7YAAAAAAAAA4BAGbQEAAAAAAADAIQzaAgAAAAAAAIBDGLQFAAAAAAAAAIcwaAsAAAAAAAAADmHQFgAAAAAAAAAcwqAtAAAAAAAAADiEQVsAAAAAAAAAEHf8BzwTYNwbfQstAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -379,35 +412,27 @@ } ], "source": [ - "import numpy as np\n", - "\n", - "from tatc.tradespace import style_axes\n", - "from tatc.tradespace.plotting import COLORS, INK\n", + "from tatc.tradespace import plot_designs\n", "\n", - "satellites = summary.satellites + np.random.default_rng(0).uniform(-0.18, 0.18, len(summary)) # for legibility\n", "fig, axes = plt.subplots(1, 3, figsize=(14, 4), sharey=True)\n", "for ax, (name, search) in zip(axes, searches.items()):\n", - " evaluated = summary.design.isin(search.design).to_numpy()\n", - " ax.scatter(\n", - " satellites[~evaluated], summary.sufficient[~evaluated], s=10, color=GRAY, alpha=0.3, lw=0, label=\"not evaluated\"\n", - " )\n", - " ax.scatter(\n", - " satellites[evaluated], summary.sufficient[evaluated], s=14, color=COLORS[0], alpha=0.8, lw=0, label=\"evaluated\"\n", - " )\n", - " ax.scatter(\n", - " satellites[summary.pareto],\n", - " summary.sufficient[summary.pareto],\n", - " s=70,\n", - " facecolor=\"none\",\n", - " edgecolor=INK,\n", - " lw=1.5,\n", - " label=\"true front\",\n", + " evaluated = summary.design.isin(search.design)\n", + " plot_designs(\n", + " summary,\n", + " \"satellites\",\n", + " \"sufficient\",\n", + " highlight=evaluated, # the designs the search evaluated, over the others in gray\n", + " label=\"evaluated\",\n", + " others=\"not evaluated\",\n", + " front=\"pareto\",\n", + " front_label=\"true front\",\n", + " jitter=0.18, # spreads the designs of each number of satellites, for legibility\n", + " legend=\"upper left\" if ax is axes[0] else None,\n", + " ax=ax,\n", " )\n", - " ax.set(xlabel=\"Satellites\", xticks=range(1, MAX_SATELLITES + 1), ylim=(0, 105))\n", + " ax.set(xlabel=\"Satellites\", ylabel=\"\", xticks=range(1, MAX_SATELLITES + 1), ylim=(0, 105))\n", " ax.set_title(f\"{name}: {evaluated.sum()} designs\", fontsize=10)\n", - " style_axes(ax)\n", "axes[0].set_ylabel(\"Points sufficiently sampled (%)\")\n", - "axes[0].legend(loc=\"upper left\", fontsize=8, frameon=False, markerscale=1.4)\n", "fig.tight_layout()\n", "plt.show()" ] diff --git a/docs/examples/tradespace/TradeCostAndUtility.ipynb b/docs/examples/tradespace/TradeCostAndUtility.ipynb index a916a223..29dfef49 100644 --- a/docs/examples/tradespace/TradeCostAndUtility.ipynb +++ b/docs/examples/tradespace/TradeCostAndUtility.ipynb @@ -38,7 +38,14 @@ "cell_type": "code", "execution_count": 1, "id": "216ec565", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:42.888572Z", + "iopub.status.busy": "2026-11-14T06:30:42.887573Z", + "iopub.status.idle": "2026-11-14T06:30:45.508234Z", + "shell.execute_reply": "2026-11-14T06:30:45.507240Z" + } + }, "outputs": [ { "data": { @@ -187,7 +194,7 @@ " discount_rate=0.03,\n", ")\n", "PLAN = MissionPlan(SCHEDULE, COST_MODEL, kind=\"field_of_regard\", growth={\"development\": \"cost_growth\"})\n", - "cost_space = space.extend(cost_growth=Uncertain(lambda rng: float(rng.triangular(0.9, 1.0, 1.6))))\n", + "cost_space = space.extend(cost_growth=Uncertain.triangular(0.9, 1.0, 1.6))\n", "cost_study = accuracy_study.replace(space=cost_space, plan=PLAN)\n", "results = cost_study.run() # every design of the design space\n", "COSTS = [\"cost\", \"cost development\", \"cost production\", \"cost launch\", \"cost operations\"]\n", @@ -208,14 +215,21 @@ "* minimize the cost at 70% confidence, and maximize the share of points sufficiently sampled;\n", "* require the cost at 70% confidence to be within a budget of 150 million dollars (a `Requirement`).\n", "\n", - "`aggregate` gives the statistics of the criteria for each design, and `pareto_front` finds the efficient designs among those that meet the requirement." + "`aggregate` gives the statistics of the criteria for each design, and whether it is efficient among those that meet the requirement (`pareto`)." ] }, { "cell_type": "code", "execution_count": 2, "id": "80fc3006", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:45.509233Z", + "iopub.status.busy": "2026-11-14T06:30:45.509233Z", + "iopub.status.idle": "2026-11-14T06:30:46.006958Z", + "shell.execute_reply": "2026-11-14T06:30:46.006958Z" + } + }, "outputs": [ { "name": "stdout", @@ -238,8 +252,7 @@ "source": [ "import matplotlib.pyplot as plt\n", "\n", - "from tatc.tradespace import Criteria, Quantile, Requirement, aggregate, pareto_front, plot_designs\n", - "from tatc.tradespace.plotting import GRAY\n", + "from tatc.tradespace import GRAY, Criteria, Quantile, Requirement, aggregate, plot_designs\n", "\n", "BUDGET = 150 # millions of dollars, at 70% confidence\n", "COST = Criteria(\n", @@ -247,8 +260,7 @@ " statistics={\"cost p70\": Quantile(\"cost\", 0.7)},\n", " requirements=[Requirement(\"cost p70\", \"<=\", BUDGET)],\n", ")\n", - "costed = aggregate(results, COST)\n", - "costed[\"pareto\"] = pareto_front(costed, COST)\n", + "costed = aggregate(results, COST, statistics=[\"cost development\"]) # and whether each design is efficient\n", "costed[\"plane_group\"] = costed.planes.clip(upper=3) # 3 or 4 planes share a color\n", "print(f\"{costed.meets_requirements.sum()} of {len(costed)} designs cost at most {BUDGET} at 70% confidence\")\n", "\n", @@ -274,7 +286,14 @@ "cell_type": "code", "execution_count": 3, "id": "c732c5b8", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:46.008440Z", + "iopub.status.busy": "2026-11-14T06:30:46.008440Z", + "iopub.status.idle": "2026-11-14T06:30:46.037072Z", + "shell.execute_reply": "2026-11-14T06:30:46.037072Z" + } + }, "outputs": [ { "data": { @@ -320,7 +339,7 @@ " 1.0\n", " \n", " \n", - " 7\n", + " 1\n", " 800 km, 30 deg FOR, SSO: 2 at 06:00\n", " 2\n", " 1\n", @@ -342,7 +361,7 @@ " 6.2\n", " \n", " \n", - " 1\n", + " 3\n", " 800 km, 30 deg FOR, Walker 45 deg: 1 x 3 (spac...\n", " 3\n", " 1\n", @@ -364,7 +383,7 @@ " 11.2\n", " \n", " \n", - " 3\n", + " 5\n", " 800 km, 30 deg FOR, Walker 45 deg: 2 x 2 (spac...\n", " 4\n", " 2\n", @@ -375,7 +394,7 @@ " 22.2\n", " \n", " \n", - " 12\n", + " 6\n", " 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac...\n", " 2\n", " 2\n", @@ -386,7 +405,7 @@ " 30.2\n", " \n", " \n", - " 5\n", + " 7\n", " 800 km, 30 deg FOR, Walker 45 deg: 4 x 1 (spac...\n", " 4\n", " 4\n", @@ -397,7 +416,7 @@ " 31.0\n", " \n", " \n", - " 11\n", + " 8\n", " 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac...\n", " 3\n", " 1\n", @@ -412,27 +431,27 @@ "" ], "text/plain": [ - " description satellites planes \\\n", - "0 700 km, 30 deg FOR, SSO: 1 at 06:00 1 1 \n", - "7 800 km, 30 deg FOR, SSO: 2 at 06:00 2 1 \n", - "2 800 km, 30 deg FOR, Walker 45 deg: 2 x 1 (spac... 2 2 \n", - "1 800 km, 30 deg FOR, Walker 45 deg: 1 x 3 (spac... 3 1 \n", - "4 800 km, 30 deg FOR, Walker 45 deg: 3 x 1 (spac... 3 3 \n", - "3 800 km, 30 deg FOR, Walker 45 deg: 2 x 2 (spac... 4 2 \n", - "12 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2 2 \n", - "5 800 km, 30 deg FOR, Walker 45 deg: 4 x 1 (spac... 4 4 \n", - "11 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3 1 \n", + " description satellites planes \\\n", + "0 700 km, 30 deg FOR, SSO: 1 at 06:00 1 1 \n", + "1 800 km, 30 deg FOR, SSO: 2 at 06:00 2 1 \n", + "2 800 km, 30 deg FOR, Walker 45 deg: 2 x 1 (spac... 2 2 \n", + "3 800 km, 30 deg FOR, Walker 45 deg: 1 x 3 (spac... 3 1 \n", + "4 800 km, 30 deg FOR, Walker 45 deg: 3 x 1 (spac... 3 3 \n", + "5 800 km, 30 deg FOR, Walker 45 deg: 2 x 2 (spac... 4 2 \n", + "6 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2 2 \n", + "7 800 km, 30 deg FOR, Walker 45 deg: 4 x 1 (spac... 4 4 \n", + "8 800 km, 60 deg FOR, Walker 45 deg: 1 x 3 (spac... 3 1 \n", "\n", - " deployed cost development cost launch cost p70 sufficient \n", - "0 3.2 44.4 8.0 83.6 1.0 \n", - "7 3.5 44.4 8.0 96.9 2.6 \n", - "2 3.8 44.4 16.0 104.7 6.2 \n", - "1 3.8 44.4 8.0 109.6 7.8 \n", - "4 4.2 44.4 24.0 124.8 11.2 \n", - "3 4.0 44.4 16.0 129.3 22.2 \n", - "12 3.8 66.7 16.0 139.2 30.2 \n", - "5 4.8 44.4 32.0 144.3 31.0 \n", - "11 3.8 66.7 8.0 149.1 38.0 " + " deployed cost development cost launch cost p70 sufficient \n", + "0 3.2 44.4 8.0 83.6 1.0 \n", + "1 3.5 44.4 8.0 96.9 2.6 \n", + "2 3.8 44.4 16.0 104.7 6.2 \n", + "3 3.8 44.4 8.0 109.6 7.8 \n", + "4 4.2 44.4 24.0 124.8 11.2 \n", + "5 4.0 44.4 16.0 129.3 22.2 \n", + "6 3.8 66.7 16.0 139.2 30.2 \n", + "7 4.8 44.4 32.0 144.3 31.0 \n", + "8 3.8 66.7 8.0 149.1 38.0 " ] }, "execution_count": 3, @@ -441,10 +460,9 @@ } ], "source": [ - "development = aggregate(results, [\"cost development\"], design_columns=[]).drop(columns=\"replicates\")\n", - "front = costed[costed.pareto].merge(development, on=\"design\").sort_values(\"cost p70\")\n", - "front = front.drop_duplicates([\"cost p70\", \"sufficient\"]) # one of the designs that tie\n", - "front[\"description\"] = front.apply(describe, axis=1)\n", + "front = costed[costed.pareto].sort_values(\"cost p70\")\n", + "front = front.drop_duplicates([\"cost p70\", \"sufficient\"]).reset_index(drop=True) # one of the designs that tie\n", + "front[\"description\"] = [describe(d) for d in space.designs_of(front)]\n", "front[\n", " [\"description\", \"satellites\", \"planes\", \"deployed\", \"cost development\", \"cost launch\", \"cost p70\", \"sufficient\"]\n", "].round(1)" @@ -484,7 +502,14 @@ "cell_type": "code", "execution_count": 4, "id": "ae075375", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:46.039067Z", + "iopub.status.busy": "2026-11-14T06:30:46.039067Z", + "iopub.status.idle": "2026-11-14T06:30:46.345156Z", + "shell.execute_reply": "2026-11-14T06:30:46.344607Z" + } + }, "outputs": [ { "data": { @@ -498,24 +523,23 @@ } ], "source": [ - "from tatc.tradespace import ExponentialUtility, LinearUtility, Utility, style_axes\n", + "from tatc.tradespace import ExponentialUtility, LinearUtility, Utility, pareto_front, style_axes\n", "\n", "CURVES = {\"sufficient\": LinearUtility(0, 100), \"accurate\": ExponentialUtility(0, 100, risk=2)}\n", "STAKEHOLDERS = {\n", " \"sufficiency\": Utility(CURVES, weights={\"sufficient\": 0.7, \"accurate\": 0.3}),\n", " \"accuracy\": Utility(CURVES, weights={\"sufficient\": 0.3, \"accurate\": 0.7}),\n", "}\n", - "means = aggregate(\n", - " results, statistics={\"sufficient\": \"sufficient\", \"accurate\": \"accurate\", \"cost p70\": Quantile(\"cost\", 0.7)}\n", - ").set_index(\"design\")\n", - "means[\"description\"] = means.apply(describe, axis=1)\n", + "means = aggregate(results, [\"sufficient\", \"accurate\"], statistics={\"cost p70\": Quantile(\"cost\", 0.7)})\n", + "means[\"description\"] = [describe(d) for d in space.designs_of(means)]\n", + "means = means.set_index(\"design\")\n", "means[\"plane_group\"] = means.planes.clip(upper=3) # 3 or 4 planes share a color\n", "\n", "fig, axes = plt.subplots(1, 2, figsize=(11, 4.5), sharey=True)\n", "judged = {}\n", "for ax, (name, utility) in zip(axes, STAKEHOLDERS.items()):\n", " judged[name] = means.assign(utility=utility(means))\n", - " judged[name][\"pareto\"] = pareto_front(judged[name], {\"utility\": \"max\", \"cost p70\": \"min\"})\n", + " judged[name][\"pareto\"] = pareto_front(judged[name], {\"utility\": \"max\", \"cost p70\": \"min\"}) # of the utility\n", " legend = \"lower right\" if ax is axes[0] else None\n", " plot_designs(\n", " judged[name], \"cost p70\", \"utility\", by=\"plane_group\", front=\"pareto\", names=PLANE_GROUPS, legend=legend, ax=ax\n", @@ -540,7 +564,14 @@ "cell_type": "code", "execution_count": 5, "id": "ab147572", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-14T06:30:46.346185Z", + "iopub.status.busy": "2026-11-14T06:30:46.346185Z", + "iopub.status.idle": "2026-11-14T06:30:46.360659Z", + "shell.execute_reply": "2026-11-14T06:30:46.360659Z" + } + }, "outputs": [ { "name": "stdout", @@ -597,7 +628,7 @@ " \n", " \n", " \n", - " 828c0027d01f\n", + " d7161d3cbaa7\n", " 800 km, 60 deg FOR, SSO: 1 at 12:00, 2 at 18:00\n", " 3\n", " 2\n", @@ -610,7 +641,7 @@ " True\n", " \n", " \n", - " c576e2e2dbd1\n", + " d5bff0394d77\n", " 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00\n", " 3\n", " 2\n", @@ -636,7 +667,7 @@ " False\n", " \n", " \n", - " 3690f1194419\n", + " dfd5eb7d33d2\n", " 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00\n", " 4\n", " 2\n", @@ -681,37 +712,37 @@ "text/plain": [ " description satellites \\\n", "design \n", - "828c0027d01f 800 km, 60 deg FOR, SSO: 1 at 12:00, 2 at 18:00 3 \n", - "c576e2e2dbd1 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3 \n", + "d7161d3cbaa7 800 km, 60 deg FOR, SSO: 1 at 12:00, 2 at 18:00 3 \n", + "d5bff0394d77 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3 \n", "6ba50f2632cd 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4 \n", - "3690f1194419 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4 \n", + "dfd5eb7d33d2 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4 \n", "7d5b745cf8f6 800 km, 60 deg FOR, Walker 45 deg: 4 x 1 (spac... 4 \n", "64cf6542c326 800 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... 6 \n", "\n", " planes sufficient accurate cost p70 utility (sufficiency) \\\n", "design \n", - "828c0027d01f 2 29.2 57.0 156.65 0.44 \n", - "c576e2e2dbd1 2 28.8 60.6 156.90 0.45 \n", + "d7161d3cbaa7 2 29.2 57.0 156.65 0.44 \n", + "d5bff0394d77 2 28.8 60.6 156.90 0.45 \n", "6ba50f2632cd 2 69.6 65.4 173.73 0.74 \n", - "3690f1194419 2 57.6 85.4 173.73 0.69 \n", + "dfd5eb7d33d2 2 57.6 85.4 173.73 0.69 \n", "7d5b745cf8f6 4 68.6 71.2 188.73 0.74 \n", "64cf6542c326 3 90.2 95.8 213.53 0.93 \n", "\n", " efficient (sufficiency) utility (accuracy) \\\n", "design \n", - "828c0027d01f False 0.64 \n", - "c576e2e2dbd1 False 0.66 \n", + "d7161d3cbaa7 False 0.64 \n", + "d5bff0394d77 False 0.66 \n", "6ba50f2632cd True 0.80 \n", - "3690f1194419 False 0.84 \n", + "dfd5eb7d33d2 False 0.84 \n", "7d5b745cf8f6 True 0.82 \n", "64cf6542c326 False 0.96 \n", "\n", " efficient (accuracy) \n", "design \n", - "828c0027d01f True \n", - "c576e2e2dbd1 True \n", + "d7161d3cbaa7 True \n", + "d5bff0394d77 True \n", "6ba50f2632cd False \n", - "3690f1194419 True \n", + "dfd5eb7d33d2 True \n", "7d5b745cf8f6 False \n", "64cf6542c326 True " ] diff --git a/docs/examples/tradespace/trade_space_example.py b/docs/examples/tradespace/trade_space_example.py index 36f9df01..2e1f65b7 100644 --- a/docs/examples/tradespace/trade_space_example.py +++ b/docs/examples/tradespace/trade_space_example.py @@ -35,6 +35,7 @@ sso_planes_space, walker_space, ) +from tatc.tradespace.constellations import layout_of # EvaluateTradeSpace: the design space, and the study of sufficient sampling @@ -100,21 +101,8 @@ def count_samples(observations, duration=DURATION): def describe(d): - """A short description of a design (a row of its values).""" - if d.layout == "walker": - layout = ( - f"Walker {d['layout.walker.inclination']:.0f} deg: " - f"{d['layout.walker.planes']:.0f} x {d['layout.walker.per_plane']:.0f} " - f"(spacing {d['layout.walker.relative_spacing']:.0f})" - ) - else: - planes = [ - f"{d[f'layout.sso.planes[{k}].per_plane']:.0f} at " - f"{d[f'layout.sso.planes[{k}].crossing']:02.0f}:00" - for k in range(int(d["layout.sso.planes.count"])) - ] - layout = "SSO: " + ", ".join(planes) - return f"{d.altitude / 1e3:.0f} km, {d.field_of_regard} deg FOR, {layout}" + """A short description of a design: its altitude, field of regard, and layout.""" + return f"{d.altitude / 1e3:.0f} km, {d.field_of_regard} deg FOR, {layout_of(d.layout).describe()}" def planes_name(planes): @@ -185,7 +173,5 @@ def sample_field(observations, design): PLAN = MissionPlan( SCHEDULE, COST_MODEL, kind="field_of_regard", growth={"development": "cost_growth"} ) -cost_space = space.extend( - cost_growth=Uncertain(lambda rng: float(rng.triangular(0.9, 1.0, 1.6))) -) +cost_space = space.extend(cost_growth=Uncertain.triangular(0.9, 1.0, 1.6)) cost_study = accuracy_study.replace(space=cost_space, plan=PLAN) diff --git a/src/tatc/tradespace/__init__.py b/src/tatc/tradespace/__init__.py index 3b583664..9dd52234 100644 --- a/src/tatc/tradespace/__init__.py +++ b/src/tatc/tradespace/__init__.py @@ -86,6 +86,9 @@ pareto_ranks, ) from .plotting import ( + COLORS, + GRAY, + INK, plot_designs, plot_exceedance, plot_means, @@ -181,6 +184,9 @@ "refine", "screen", # plots + "COLORS", + "GRAY", + "INK", "plot_designs", "plot_exceedance", "plot_means", diff --git a/src/tatc/tradespace/attribution.py b/src/tatc/tradespace/attribution.py index 26247a8c..277833be 100644 --- a/src/tatc/tradespace/attribution.py +++ b/src/tatc/tradespace/attribution.py @@ -16,6 +16,7 @@ import numpy as np import pandas as pd +from .criteria import _resamples from .space import Design, DesignSpace, _check_uncertain, _designs, _generic from .study import Study @@ -60,8 +61,18 @@ class Attribution: """numpy.ndarray | None: The rows of A, B, and the mixed replicates in each resample of the bootstrap (a row per resample), which `differences` resamples too.""" - - def summary(self, share: str = "total") -> pd.DataFrame: + designs: list[Design] = field(default_factory=list) + """list[Design]: The designs attributed (of differences, those of the + pairs).""" + + @property + def summary(self) -> pd.DataFrame: + """pandas.DataFrame: The total shares of the variance of each metric + that each parameter causes, alone or with others, over every design + (see `summary_of`).""" + return self.summary_of("total") + + def summary_of(self, share: str = "total") -> pd.DataFrame: """ Gets the shares of the variance of each metric that each parameter explains over every design (and for each group of `by`): the @@ -172,7 +183,9 @@ def differences( raise ValueError("differences need an attribution of designs") designs = list(pd.unique(self.results["design"])) pairs = list(combinations(designs, 2)) if pairs is None else pairs - keyed = [(getattr(a, "key", a), getattr(b, "key", b)) for a, b in pairs] + keyed = [ + tuple(d.key if isinstance(d, Design) else d for d in pair) for pair in pairs + ] unknown = sorted({key for pair in keyed for key in pair} - set(designs)) if unknown: raise ValueError(f"designs that are not attributed: {unknown}") @@ -215,12 +228,14 @@ def differences( self.by, self.resamples, ) + paired = {key for pair in keyed for key in pair} return Attribution( results=differences, shares=shares, by=self.by, samples=samples, resamples=self.resamples, + designs=[design for design in self.designs if design.key in paired], ) @@ -466,7 +481,7 @@ def attribute_variance( designs: Sequence[Design] | pd.DataFrame, *, parameters: Sequence[str] | Mapping[str, Sequence[str]] | None = None, - replicates: int | None = None, + sample_size: int | None = None, by: Sequence[str] = (), n_resamples: int = 500, seed: int = 0, @@ -482,8 +497,8 @@ def attribute_variance( The effect of a parameter is measured by drawing it again while holding the others (a pick-freeze design, as of Sobol' indices), as its values need not relate to the outcomes in any order (as those of a seed do - not). The designs are evaluated in `2 n` plain replicates (`n` of - `replicates`): A, the first `n`, and B, the next `n` (those evaluated + not). The designs are evaluated in `2 n` plain replicates (`n` the + `sample_size`): A, the first `n`, and B, the next `n` (those evaluated before are taken from the study's store). For each parameter (or group of parameters), they are also evaluated in `n` mixed replicates: those of A, with the parameter drawn as in B (see `Study.run`'s `shift`), which @@ -531,8 +546,8 @@ def attribute_variance( see `DesignSpace.uncertain_paths`), groups of them (by name), or `None` for each of the design space's. Parameters not given vary between replicates, but are not attributed variance. - replicates (int | None): The replicates of A and of B (`n`), or - `None` for the study's. + sample_size (int | None): The replicates of each of A and B (`n`), + or `None` for the study's replicates. by (Sequence[str]): The columns that separate the records of an evaluation, if it has several (such as a sensor). n_resamples (int): The number of resamples of the bootstrap. @@ -542,15 +557,14 @@ def attribute_variance( Attribution: the results, and the shares of each design, metric, and parameter """ - n = study.replicates if replicates is None else int(replicates) + n = study.replicates if sample_size is None else int(sample_size) if n < 2: - raise ValueError("replicates must be at least 2") - if n_resamples < 2: - raise ValueError("n_resamples must be at least 2") + raise ValueError("sample_size must be at least 2") + resamples = _resamples(n, n_resamples, seed) groups = _groups_of(study.space, parameters) metrics, by = list(metrics), tuple(by) unique = _designs(study.space, designs) - plain = study.run(unique, replicates=range(2 * n)) + plain = study.run(unique, replicate_indices=range(2 * n)) missing = [column for column in (*metrics, *by) if column not in plain.columns] if missing and plain["feasible"].any(): raise ValueError(f"columns that are not in the results: {missing}") @@ -565,12 +579,11 @@ def attribute_variance( drawing = [design for design in unique if _draws(design, paths)] if drawing: mixed = study.run( - drawing, replicates=range(n), shift={path: n for path in paths} + drawing, replicate_indices=range(n), shift={path: n for path in paths} ) frames.append(mixed.assign(redrawn=name)) results = pd.concat(frames, ignore_index=True) - resamples = np.random.default_rng(seed).integers(n, size=(n_resamples, n)) shares, samples = _shares( results, ("design",), @@ -581,5 +594,10 @@ def attribute_variance( resamples, ) return Attribution( - results=results, shares=shares, by=by, samples=samples, resamples=resamples + results=results, + shares=shares, + by=by, + samples=samples, + resamples=resamples, + designs=unique, ) diff --git a/src/tatc/tradespace/cache.py b/src/tatc/tradespace/cache.py index f146170a..2b4a33ed 100644 --- a/src/tatc/tradespace/cache.py +++ b/src/tatc/tradespace/cache.py @@ -13,7 +13,6 @@ from __future__ import annotations -import hashlib import json import os import pickle @@ -28,7 +27,8 @@ import pandas as pd from ..schemas import Satellite -from .fingerprint import _fingerprint_of, compare_definitions, get_definition +from .fingerprint import _fingerprint_of, _with_other_code, get_definition +from .hashing import _canonical, _digest def _write(path: Path, data: bytes, replace: bool = False) -> None: @@ -52,6 +52,14 @@ def _write(path: Path, data: bytes, replace: bool = False) -> None: raise +def _read_definition(folder: Path) -> dict | None: + """Reads the definition of the results of a folder (`None` if unreadable).""" + try: + return json.loads((folder / "definition.json").read_text()) + except (OSError, ValueError): + return None + + def get_satellite_key(satellite: Satellite) -> str: """ Gets a key of a satellite's content: its orbit, instruments, and @@ -65,10 +73,7 @@ def get_satellite_key(satellite: Satellite) -> str: str: the key """ data = satellite.model_dump(mode="json", exclude={"name"}) - text = json.dumps( - {"type": type(satellite).__name__, **data}, sort_keys=True, default=str - ) - return hashlib.sha1(text.encode()).hexdigest() + return _digest(_canonical({"type": type(satellite).__name__, **data})) class SatelliteCache: @@ -95,10 +100,14 @@ class SatelliteCache: each namespace (by a hash of it, with the namespace in `namespace.txt`), and in it a folder of each fingerprint (with the definition in `definition.json`). A cache warns if its namespace has results only of - other definitions of its function, which it does not reuse, with the - differences from the latest (see `compare_definitions`), and removes - them with `prune`. A result that cannot be read (such as one written - with other versions of the libraries of its data) is computed again. + the same function with other code (of the function, of TAT-C, or of + Python: the same values but for code, as a study warns of its store, see + `Study`), which it does not reuse, with the differences from the latest + (see `compare_definitions`), and removes the results of other + definitions with `prune` (see `Observations.prune` for the caches of the + observations of a study). A result that cannot be read (such as one + written with other versions of the libraries of its data) is computed + again. Args: function (Callable): The analysis of one satellite. @@ -129,14 +138,19 @@ def __init__( if self.directory is not None: definition = get_definition(function=function) self.fingerprint = _fingerprint_of(definition) - space = hashlib.sha1(namespace.encode()).hexdigest()[:16] + space = _digest(namespace, 16) self._folder = self.directory / space / self.fingerprint self._folder.mkdir(parents=True, exist_ok=True) _write(self._folder.parent / "namespace.txt", namespace.encode()) - text = json.dumps(definition, sort_keys=True, default=str) - _write(self._folder / "definition.json", text.encode()) + _write(self._folder / "definition.json", _canonical(definition).encode()) self._warn_other_definitions(definition) + @property + def folder(self) -> Path | None: + """pathlib.Path | None: The folder of the results of the function's + definition on disk (in the folder of its namespace), if any.""" + return self._folder + def __getstate__(self) -> dict: # copies sent to parallel workers start with empty memories state = self.__dict__.copy() @@ -159,14 +173,20 @@ def _others(self) -> list[Path]: def _warn_other_definitions(self, definition: dict) -> None: """ - Warns if the namespace has results only of other definitions of the - function, with the differences from the latest, once (of the caches - of the definition, such as those of parallel workers). + Warns if the namespace has results only of the function with other + code (see `_with_other_code`), with the differences from the latest, + once (of the caches of the definition, such as those of parallel + workers). """ if next(self._folder.glob("*.pkl"), None) is not None: return others = self._others() - if not others: + stale = [ + folder + for folder in reversed(others) + if _with_other_code(definition, [_read_definition(folder)]) is not None + ] + if not stale: return try: # the first cache of the definition to warn marks its folder @@ -174,20 +194,16 @@ def _warn_other_definitions(self, definition: dict) -> None: pass except FileExistsError: return - count = sum(1 for folder in others for _ in folder.glob("*.pkl")) - message = ( - f"the cache has {count} results of namespace {self.namespace!r} by " - + "other definitions of its function, which are not reused (remove " - + "them with SatelliteCache.prune)" + count = sum(1 for folder in stale for _ in folder.glob("*.pkl")) + differences = _with_other_code(definition, [_read_definition(stale[0])]) + warnings.warn( + f"the cache in {self.directory} has {count} results of namespace " + + f"{self.namespace!r} by its function with other code, which are not " + + "reused (prune removes them: Observations.prune for the observations " + + "of a study); the latest differs in: " + + "; ".join(differences or []), + stacklevel=3, ) - try: - before = json.loads((others[-1] / "definition.json").read_text()) - except (OSError, ValueError): - before = None - if before is not None: - differences = compare_definitions(before, definition) - message += "; the latest differs in: " + "; ".join(differences) - warnings.warn(message, stacklevel=3) def prune(self) -> int: """ @@ -287,16 +303,17 @@ def __call__(self, satellites: Satellite | Iterable[Satellite]) -> Any: if not results: # no satellites (such as if all fail): an empty frame return pd.DataFrame() - if results and all(isinstance(result, pd.DataFrame) for result in results): + if all(isinstance(result, pd.DataFrame) for result in results): non_empty = [result for result in results if len(result) > 0] if not non_empty: return results[0] return pd.concat(non_empty, ignore_index=True) return results - def clear(self) -> None: + def clear_memory(self) -> None: """ - Clears the cache in memory (not on disk) and its statistics. + Clears the cache in memory and its statistics (not the results on + disk, which `prune` removes of other definitions). """ self._memory.clear() self.hits = self.misses = 0 diff --git a/src/tatc/tradespace/comparison.py b/src/tatc/tradespace/comparison.py index 80a3c97d..66da55a0 100644 --- a/src/tatc/tradespace/comparison.py +++ b/src/tatc/tradespace/comparison.py @@ -24,16 +24,7 @@ import pandas as pd from .criteria import _get_matrices, _groups -from .space import Design, _design_items - - -def _keys_of(designs: Iterable[Design | str] | pd.DataFrame) -> list[str]: - """ - Gets the keys of designs given as designs, keys, or a data frame of them - (with keys `design`, a column or the name of the index), each once. - """ - keys = [d.key if isinstance(d, Design) else d for d in _design_items(designs)] - return list(dict.fromkeys(keys)) +from .space import Design, _keys_of def exceedance( diff --git a/src/tatc/tradespace/confirmation.py b/src/tatc/tradespace/confirmation.py index 25d5489d..ed0c05e2 100644 --- a/src/tatc/tradespace/confirmation.py +++ b/src/tatc/tradespace/confirmation.py @@ -14,7 +14,6 @@ import pandas as pd from .criteria import Criteria, _as_criteria, aggregate -from .pareto import pareto_front from .space import Design, _designs from .study import Study @@ -36,33 +35,29 @@ class Confirmation: """pandas.DataFrame: A row per design (and group): the values of the design, the statistics of the criteria by the new replicates, those of the replicates that selected the design (` selected`), the - number of new `replicates`, and whether the design meets the - requirements (`meets_requirements`) and is efficient among the confirmed - designs that do (`pareto`), by the new replicates.""" + optimism of the selection in each objective (` optimism`: by + how much the selecting replicates made the design look better than the + new replicates do, in its units, positive if they did), the number of + new `replicates`, the `violation` of the requirements, and whether the + design meets them (`meets_requirements`) and is efficient among the + confirmed designs that do (`pareto`), by the new replicates.""" criteria: Criteria """Criteria: The criteria of the confirmation.""" designs: list[Design] = field(default_factory=list) """list[Design]: The confirmed designs.""" + @property def optimism(self) -> pd.Series: - """ - Gets the optimism of selection: the mean amount by which the selecting - replicates made the designs look better than the new replicates do, - in each objective of the criteria (positive if they looked better). - - Returns: - pandas.Series: the optimism of each objective, in its units - """ + """pandas.Series: The optimism of selection: the mean over the designs + of their optimism in each objective of the criteria (see + `summary`), in its units, positive if the selecting replicates made + them look better.""" return pd.Series( { - name: float( - np.nanmean( - (self.summary[f"{name} selected"] - self.summary[name]) - * (1.0 if direction == "max" else -1.0) - ) - ) - for name, direction in self.criteria.objectives.items() - } + name: float(np.nanmean(self.summary[f"{name} optimism"])) + for name in self.criteria.objectives + }, + dtype=float, ) @@ -115,41 +110,38 @@ def confirm( raise ValueError("replicates must be at least 1") if designs is None: summary = aggregate(results, criteria, design_columns=[]) - summary = summary.dropna(subset=list(criteria.objectives)) - designs = summary[pareto_front(summary, criteria)] + designs = summary[summary["pareto"]] designs = _designs(study.space, designs, results) keys = {design.key for design in designs} start = int(results["replicate"].max()) + 1 if len(results) > 0 else 0 - fresh = study.run(designs, replicates=range(start, start + count)) + fresh = study.run(designs, replicate_indices=range(start, start + count)) names = criteria.names columns = ["design", *criteria.by] + confirmed = aggregate(fresh, criteria) selected = aggregate( results[results["design"].isin(keys)], criteria, design_columns=[] - ) - confirmed = aggregate(fresh, criteria) - judged = {*columns, *names, "replicates", "violation", "meets_requirements"} - values = [column for column in confirmed.columns if column not in judged] - summary = confirmed[[*columns, *values, *names, "replicates", "meets_requirements"]] - summary = summary.merge( - selected[[*columns, *names]].rename( - columns={name: f"{name} selected" for name in names} - ), + )[[*columns, *names]] + summary = confirmed.merge( + selected.rename(columns={name: f"{name} selected" for name in names}), on=columns, how="left", ) + for name, direction in criteria.objectives.items(): + sign = 1.0 if direction == "max" else -1.0 + summary[f"{name} optimism"] = sign * ( + summary[f"{name} selected"] - summary[name] + ) + status = ["replicates", "violation", "meets_requirements", "pareto"] + values = [c for c in confirmed.columns if c not in {*columns, *names, *status}] summary = summary[ [ *columns, *values, *(c for name in names for c in (name, f"{name} selected")), - "replicates", - "meets_requirements", + *(f"{name} optimism" for name in criteria.objectives), + *status, ] ] - # the front of the designs whose objectives are known, by the new replicates - known = summary.dropna(subset=list(criteria.objectives)) - summary["pareto"] = False - summary.loc[known.index, "pareto"] = pareto_front(known, criteria).to_numpy() return Confirmation( results=fresh, summary=summary, criteria=criteria, designs=designs ) diff --git a/src/tatc/tradespace/constellations.py b/src/tatc/tradespace/constellations.py index 1c2553e2..ff2614b6 100644 --- a/src/tatc/tradespace/constellations.py +++ b/src/tatc/tradespace/constellations.py @@ -8,12 +8,15 @@ payload (instruments, or entries of the instrument catalog), and counts of satellites and planes for objectives and constraints. -The fragments share the names of their values: `planes` is the number of -planes, `per_plane` the number of satellites in each plane, and -`satellites` the number of satellites of a layout without planes (a mutual -orbiting group); `inclination` and `node` are in degrees, and -`phase_fraction` and `node_fraction` are fractions of the intervals over -which the phase and node give distinct layouts. +The fragments share the names of their values: `planes` is the planes, +their number (of Walker and streets-of-coverage constellations) or a +repetition of them (of planes of sun-synchronous or inclined orbits), whose +`count` is their number; `per_plane` is the number of satellites in each +plane, and `satellites` the number of satellites of a layout without planes +(a mutual orbiting group); `inclination`, `node` (the right ascension of the +ascending node), and `true_anomaly` are in degrees, and `phase_fraction` and +`node_fraction` are fractions of the intervals over which the phase and +node give distinct layouts. A fragment is a `DesignSpace` to place in a larger design space, for example as a branch of a `Choice` between layouts:: @@ -38,8 +41,9 @@ def build(d): satellites `build_constellation` builds together. The values of a fragment in a design are those of a `Layout` (see -`layout_of`), which gives its planes and the orbits of their satellites, and -which other layouts extend. +`layout_of`), which gives its planes and the orbits of their satellites, a +short description (such as `"Walker 60 deg: 3 x 4 (spacing 1)"`, see +`Layout.describe`), and which other layouts extend. @author: Paul T. Grogan """ @@ -66,7 +70,7 @@ def build(d): ) from .nodes import Derived, Fixed, Integer, Real, Repeat, Uncertain from .space import DesignSpace -from .values import ChoiceValues, RepeatValues, Scope +from .values import ChoiceValues, RepeatValues, Scope, Values WALKER = "walker" """The kind of the layouts of `walker_space`.""" @@ -110,8 +114,8 @@ def walker_space( phase by `360 / per_plane` degrees moves each onto the next in its plane, and shifting every plane's node by `360 / planes` degrees (of a delta configuration) moves each onto the next plane, which, with the shift of - phase between planes (`360 * relative_spacing / satellites`), gives the - same constellation. Fractions in [0, 1) of both therefore give every + phase between planes (`360 * relative_spacing / (planes * per_plane)`), + gives the same constellation. Fractions in [0, 1) of both therefore give every distinct constellation once, without searching the same constellation at several phases or nodes. A star configuration has no such symmetry of its nodes (its planes span 180 degrees, and the next plane after the @@ -119,8 +123,8 @@ def walker_space( node is of 360 degrees. The fractions may be design variables (such as `Real(0, 0.75, step=0.25)`, without 1, which is the same as 0) or uncertain parameters (such as `Uncertain.uniform(0, 1)`), and the - fragment derives the lead satellite's `true_anomaly` and `right_ascension` - (degrees) from them. + fragment derives the lead satellite's `true_anomaly` and `node` (degrees) + from them. Args: inclination (Any): The inclination, by default a variable from 30 to @@ -155,7 +159,7 @@ def walker_space( if altitude is not None: children["altitude"] = altitude children["true_anomaly"] = Derived(_lead_true_anomaly) - children["right_ascension"] = Derived(_lead_right_ascension) + children["node"] = Derived(_lead_node) return DesignSpace(constraints=constraints, **children) @@ -164,8 +168,8 @@ def _lead_true_anomaly(d: Scope) -> float: return float(d.phase_fraction) * 360 / d.per_plane % 360 -def _lead_right_ascension(d: Scope) -> float: - """The right ascension of the ascending node (degrees) of the lead +def _lead_node(d: Scope) -> float: + """The node (right ascension of the ascending node, degrees) of the lead satellite of a Walker layout.""" period = 360 if d.configuration == "star" else 360 / d.planes return float(d.node_fraction) * period % 360 @@ -266,7 +270,7 @@ def sso_planes_space( plane = DesignSpace( crossing=_node(crossing, Real(6, 18, step=1.5)), per_plane=_node(per_plane, Integer(1, 4)), - interval=Fixed(None) if interval is None else interval, + interval=interval, phase_fraction=phase_fraction, true_anomaly=Derived(_plane_true_anomaly), ) @@ -340,7 +344,7 @@ def planes_space( inclination=_node(inclination, Real(30, 90, step=15)), node=_node(node, Uncertain.uniform(0, 360)), per_plane=_node(per_plane, Integer(1, 4)), - interval=Fixed(None) if interval is None else interval, + interval=interval, phase_fraction=phase_fraction, true_anomaly=Derived(_plane_true_anomaly), ) @@ -361,7 +365,7 @@ def _soc_of(values: Any, altitude: float, epoch: datetime | None = None): "altitude": altitude, "inclination": values.inclination, "true_anomaly": getattr(values, "true_anomaly", 0.0), - "right_ascension_ascending_node": getattr(values, "right_ascension", 0.0), + "right_ascension_ascending_node": getattr(values, "node", 0.0), } return SOCConstellation( name="soc", @@ -383,8 +387,13 @@ def _soc_per_plane(d: Scope) -> int: return _soc_of(d, d.altitude).get_satellites_per_plane() -def _soc_right_ascension(d: Scope) -> float: - """The right ascension of the ascending node (degrees) of the lead +def _scope_altitude(d: Scope) -> float: + """The altitude decided before a fragment (outside it).""" + return d.altitude + + +def _soc_node(d: Scope) -> float: + """The node (right ascension of the ascending node, degrees) of the lead satellite of a streets-of-coverage layout.""" period = 360 if _soc_of(d, d.altitude).is_polar() else 360 / d.planes return float(d.node_fraction) * period % 360 @@ -415,15 +424,17 @@ def soc_space( The fragment derives its number of planes (`planes`) and of satellites in each plane (`per_plane`) from them and the altitude (meters), which therefore must be decided before them: a value of the fragment - (`altitude`), or of the design space outside it (declared before it), - the same as given to `build_constellation`. + (`altitude`), or by default the altitude of the design space outside it + (declared before it), which the fragment keeps as its own (so that + `build_constellation` builds the satellites at the altitude its planes + were derived at). The phase and node of the lead satellite are fractions, as those of a Walker constellation (see `walker_space`): of `360 / per_plane` degrees of phase, and of `360 / planes` degrees of node (inclined orbits) or 360 degrees (polar orbits, whose planes span 180 degrees). The fragment - derives the lead satellite's `true_anomaly` and `right_ascension` - (degrees) from them. + derives the lead satellite's `true_anomaly` and `node` (degrees) from + them. Args: swath_width (Any): The swath width (meters) of the footprints. @@ -435,7 +446,8 @@ def soc_space( polar (Any): `True` for the polar pattern, `False` for the Walker delta pattern, or `None` for the polar pattern of near-polar orbits. - altitude (Any): The altitude, if part of the layout. + altitude (Any): The altitude, or `None` for that of the design space + outside the fragment. phase_fraction (Any): The phase of the lead satellite, as a fraction of `360 / per_plane` degrees. node_fraction (Any): The node of the lead satellite, as a fraction of @@ -452,16 +464,15 @@ def soc_space( "inclination": _node(inclination, Real(30, 90, step=15)), "swath_width": swath_width, "packing_distance": packing_distance, - "polar": Fixed(None) if polar is None else polar, + "polar": polar, "phase_fraction": phase_fraction, "node_fraction": node_fraction, + "altitude": Derived(_scope_altitude) if altitude is None else altitude, } - if altitude is not None: - children["altitude"] = altitude children["planes"] = Derived(_soc_planes) children["per_plane"] = Derived(_soc_per_plane) children["true_anomaly"] = Derived(_lead_true_anomaly) - children["right_ascension"] = Derived(_soc_right_ascension) + children["node"] = Derived(_soc_node) return DesignSpace(constraints=constraints, **children) @@ -565,8 +576,12 @@ class Layout: `DeploymentSchedule.plan` and `MissionHistory.phases`). Other layouts subclass it, implementing `planes` and `orbits` (and - `names`, for names other than `"

-"`), so that they are - built, counted, deployed, and costed as the others. + `names`, for names other than `"

-"`, and `describe`), so + that they are built, counted, deployed, and costed as the others. + + A layout of its own altitude (such as a fragment with an `altitude`) + is built at that altitude; the altitude given to `build_constellation` + (or `orbits`) is that of layouts without their own. """ def planes(self) -> list[Plane]: @@ -585,17 +600,36 @@ def orbits(self, epoch: datetime, altitude: float | None = None) -> list[list[An Args: epoch (datetime.datetime): The epoch of the orbits. - altitude (float | None): The altitude (meters), or `None` for - that of the layout. + altitude (float | None): The altitude (meters) of a layout without + its own, if any. Returns: list[list]: the orbits of the satellites of each plane Raises: - ValueError: if no altitude is given and the layout has none. + ValueError: if the layout has no altitude of its own and none is + given. """ raise NotImplementedError + def describe(self) -> str: + """ + Gets a short description of the layout (such as `"Walker 60 deg: 3 x + 4 (spacing 1)"` or `"SSO: 2 at 06:00, 1 at 13:30"`), as for labels of + designs: by default, its numbers of planes and satellites. + + Returns: + str: the description + """ + planes = self.planes() + return f"{len(planes)} planes, {self.satellites} satellites" + + def __str__(self) -> str: + return self.describe() + + def __repr__(self) -> str: + return f"{type(self).__name__}({self.describe()!r})" + def names(self, name: str) -> list[list[str]]: """ Gets the names of the satellites of each plane: `"

-"` @@ -634,7 +668,7 @@ def build( payload (Payload): The payload of each satellite. epoch (datetime.datetime): The epoch of the orbits. altitude (float | None): The altitude (meters), if the layout does - not give it. + not give its own. name (str): The prefix of the names of the satellites. time_step (float | None): The analysis time step (seconds), for catalog configurations that tailor a field of view to it. @@ -644,8 +678,15 @@ def build( Raises: ValueError: if the orbits or names of the satellites do not match - the planes. + the planes, or the layout has values that are not realized. """ + values = getattr(self, "values", None) + if values is not None and _unrealized(values): + raise ValueError( + "the layout has values that are not realized (NaN, such as of " + + "uncertain parameters): build the satellites of a realized " + + "design (see Design.realize and Study.realize)" + ) counts = [plane.satellites for plane in self.planes()] orbits, names = self.orbits(epoch, altitude), self.names(name) if [len(o) for o in orbits] != counts or [len(n) for n in names] != counts: @@ -658,18 +699,35 @@ def build( def _get_altitude(values: Any, altitude: float | None) -> float: - """Gets the given altitude, or that of the values of a layout.""" - altitude = getattr(values, "altitude", None) if altitude is None else altitude + """Gets the altitude of the values of a layout, or else the given one.""" + own = getattr(values, "altitude", None) + altitude = altitude if own is None else own if altitude is None: raise ValueError("the layout has no altitude: give one") return altitude -class WalkerLayout(Layout): +def _unrealized(value: Any) -> bool: + """Whether values (of a layout) have a missing number (`NaN`).""" + if isinstance(value, float): + return value != value # pylint: disable=comparison-with-itself + if isinstance(value, ChoiceValues): + return _unrealized(value.value) + if isinstance(value, RepeatValues): + return any(_unrealized(item) for item in value) + if isinstance(value, Values): + return any(_unrealized(value[name]) for name in value) + return False + + +def _km(altitude: Any) -> str: + """The description of an altitude (meters) of a layout, if it has one.""" + return "" if altitude is None else f" at {float(altitude) / 1e3:g} km" + + +class _ValuesLayout(Layout): """ - A Walker constellation (see `tatc.schemas.WalkerConstellation`): the - values of `walker_space` in a design. Its satellites are named - `" "`, in order. + A layout of the values of a fragment of a design space in a design. Args: values (Values): The values of the layout. @@ -678,48 +736,106 @@ class WalkerLayout(Layout): def __init__(self, values: Any): self.values = values + def _altitude(self) -> str: + return _km(getattr(self.values, "altitude", None)) + + +class _MembersLayout(_ValuesLayout): + """ + A constellation whose members a schema of TAT-C generates (see + `_constellation`), plane by plane (the members of each plane following + each other), its satellites named `" "`, in order. + """ + + _MISMATCH = "the members of the constellation do not match its planes" + + def _constellation(self, epoch: datetime, altitude: float) -> Any: + """Gets the constellation (of `tatc.schemas`) at an epoch and altitude.""" + raise NotImplementedError + + def orbits(self, epoch: datetime, altitude: float | None = None) -> list[list[Any]]: + altitude = _get_altitude(self.values, altitude) + members = self._constellation(epoch, altitude).generate_members() + sizes = [plane.satellites for plane in self.planes()] + if len(members) != sum(sizes): + raise ValueError(self._MISMATCH) + starts = np.cumsum([0, *sizes]) + return [ + [member.orbit for member in members[start:stop]] + for start, stop in zip(starts[:-1], starts[1:]) + ] + + def names(self, name: str) -> list[list[str]]: + sizes = [plane.satellites for plane in self.planes()] + starts = np.cumsum([0, *sizes]) + return [ + [f"{name} {k + 1}" for k in range(start, start + size)] + for start, size in zip(starts[:-1], sizes) + ] + + +class WalkerLayout(_MembersLayout): + """ + A Walker constellation (see `tatc.schemas.WalkerConstellation`): the + values of `walker_space` in a design. Its satellites are named + `" "`, in order. + + Args: + values (Values): The values of the layout. + """ + def planes(self) -> list[Plane]: return [Plane(int(self.values.per_plane))] * int(self.values.planes) - def orbits(self, epoch: datetime, altitude: float | None = None) -> list[list[Any]]: + def _constellation(self, epoch: datetime, altitude: float) -> Any: values = self.values - members = WalkerConstellation( + return WalkerConstellation( name="walker", configuration=values.configuration, orbit=CircularOrbit( - altitude=_get_altitude(values, altitude), + altitude=altitude, inclination=values.inclination, true_anomaly=getattr(values, "true_anomaly", 0.0), - right_ascension_ascending_node=getattr(values, "right_ascension", 0.0), + right_ascension_ascending_node=getattr(values, "node", 0.0), epoch=epoch, ), number_planes=values.planes, number_satellites=values.planes * values.per_plane, relative_spacing=values.relative_spacing, - ).generate_members() - # the members of each plane follow each other - size = int(values.per_plane) - return [ - [member.orbit for member in members[p * size : (p + 1) * size]] - for p in range(int(values.planes)) - ] + ) - def names(self, name: str) -> list[list[str]]: - size = int(self.values.per_plane) - return [ - [f"{name} {p * size + s + 1}" for s in range(size)] - for p in range(int(self.values.planes)) - ] + def describe(self) -> str: + values = self.values + star = "star " if values.configuration == "star" else "" + return ( + f"Walker {star}{float(values.inclination):g} deg{self._altitude()}: " + + f"{int(values.planes)} x {int(values.per_plane)} " + + f"(spacing {int(values.relative_spacing)})" + ) -class _PlanesLayout(Layout): +class _PlanesLayout(_ValuesLayout): """ Planes of circular orbits, each with its own number of satellites, evenly spaced or in a train (see `sso_planes_space`). """ - def __init__(self, values: Any): - self.values = values + def _describe_plane(self, plane: Any) -> str: + """Gets a short description of a plane (its orbit).""" + raise NotImplementedError + + def _describe_planes(self) -> str: + """Gets a short description of the planes.""" + described = [] + for plane in self.values.planes: + text = f"{int(plane.per_plane)} at {self._describe_plane(plane)}" + interval = getattr(plane, "interval", None) + if interval is not None: + if isinstance(interval, timedelta): + interval = interval.total_seconds() / 60 + text += f" (train, {float(interval):g} min)" + described.append(text) + return ", ".join(described) def planes(self) -> list[Plane]: return [Plane(int(plane.per_plane), plane) for plane in self.values.planes] @@ -758,6 +874,13 @@ def _orbit(self, plane: Any, epoch: datetime, altitude: float, anomaly: float): true_anomaly=anomaly, ) + def _describe_plane(self, plane: Any) -> str: + return hours_to_time(plane.crossing).strftime("%H:%M") + + def describe(self) -> str: + descending = "" if getattr(self.values, "ascending", True) else " descending" + return f"SSO{descending}{self._altitude()}: {self._describe_planes()}" + class PlanesLayout(_PlanesLayout): """ @@ -778,49 +901,49 @@ def _orbit(self, plane: Any, epoch: datetime, altitude: float, anomaly: float): true_anomaly=anomaly, ) + def _describe_plane(self, plane: Any) -> str: + node = float(plane.node) + known = "" if node != node else f" (node {node % 360:g} deg)" + return f"{float(plane.inclination):g} deg{known}" + + def describe(self) -> str: + return f"Planes{self._altitude()}: {self._describe_planes()}" + -class SOCLayout(Layout): +class SOCLayout(_MembersLayout): """ A streets-of-coverage constellation (see `tatc.schemas.SOCConstellation`): the values of `soc_space` in a design, - whose planes and satellites in each plane it derived at the altitude of - the design. Its satellites are named `" "`, in order. + whose planes and satellites in each plane it derived at its altitude. + Its satellites are named `" "`, in order. Args: values (Values): The values of the layout. """ - def __init__(self, values: Any): - self.values = values + _MISMATCH = ( + "the altitude of a streets-of-coverage layout must be the one its " + + "planes were derived at" + ) def planes(self) -> list[Plane]: return [Plane(int(self.values.per_plane))] * int(self.values.planes) - def orbits(self, epoch: datetime, altitude: float | None = None) -> list[list[Any]]: - values = self.values - soc = _soc_of(values, _get_altitude(values, altitude), epoch) - members = soc.generate_members() - size, planes = int(values.per_plane), int(values.planes) - if len(members) != size * planes: - raise ValueError( - "the altitude of a streets-of-coverage layout must be the one " - + "its planes were derived at" - ) - # the members of each plane follow each other - return [ - [member.orbit for member in members[p * size : (p + 1) * size]] - for p in range(planes) - ] + def _constellation(self, epoch: datetime, altitude: float) -> Any: + return _soc_of(self.values, altitude, epoch) - def names(self, name: str) -> list[list[str]]: - size = int(self.values.per_plane) - return [ - [f"{name} {p * size + s + 1}" for s in range(size)] - for p in range(int(self.values.planes)) - ] + def describe(self) -> str: + values = self.values + polar = ( + "polar " if _soc_of(values, _get_altitude(values, None)).is_polar() else "" + ) + return ( + f"SOC {polar}{float(values.inclination):g} deg{self._altitude()}: " + + f"{int(values.planes)} x {int(values.per_plane)}" + ) -class MOGLayout(Layout): +class MOGLayout(_MembersLayout): """ A mutual orbiting group (see `tatc.schemas.MOGConstellation`): the values of `mog_space` in a design, a single plane (launched together). @@ -830,18 +953,15 @@ class MOGLayout(Layout): values (Values): The values of the layout. """ - def __init__(self, values: Any): - self.values = values - def planes(self) -> list[Plane]: return [Plane(int(self.values.satellites))] - def orbits(self, epoch: datetime, altitude: float | None = None) -> list[list[Any]]: + def _constellation(self, epoch: datetime, altitude: float) -> Any: values = self.values - members = MOGConstellation( + return MOGConstellation( name="mog", orbit=CircularOrbit( - altitude=_get_altitude(values, altitude), + altitude=altitude, inclination=values.inclination, right_ascension_ascending_node=float(values.node) % 360, true_anomaly=getattr(values, "true_anomaly", 0.0), @@ -851,11 +971,16 @@ def orbits(self, epoch: datetime, altitude: float | None = None) -> list[list[An transverse_axis=values.transverse_axis, clockwise=bool(values.clockwise), number_satellites=int(values.satellites), - ).generate_members() - return [[member.orbit for member in members]] + ) - def names(self, name: str) -> list[list[str]]: - return [[f"{name} {s + 1}" for s in range(int(self.values.satellites))]] + def describe(self) -> str: + values = self.values + return ( + f"MOG {float(values.inclination):g} deg{self._altitude()}: " + + f"{int(values.satellites)} satellites " + + f"({float(values.parallel_axis) / 1e3:g} x " + + f"{float(values.transverse_axis) / 1e3:g} km)" + ) class Layouts(Layout): @@ -889,6 +1014,9 @@ def names(self, name: str) -> list[list[str]]: for names in layout.names(f"{name} {chr(65 + k) if k < 26 else k + 1}") ] + def describe(self) -> str: + return "; ".join(layout.describe() for layout in self.layouts) + _KINDS = { WALKER: WalkerLayout, @@ -1076,8 +1204,8 @@ def build_constellation( """ Builds the satellites of a layout: the values of a fragment (such as `walker_space`) in a design (or of a choice of them), or a `Layout` (see - `layout_of`), at the layout's altitude (or the given one), each with a - payload: + `layout_of`), at the layout's own altitude (or else the given one), each + with a payload: * an `Instrument` (or a list of instruments); * the identifier of an entry of the instrument catalog (see @@ -1104,8 +1232,8 @@ def build_constellation( layout (Any): The values of the layout (or layouts), or a layout. payload (Payload): The payload of each satellite. epoch (datetime.datetime): The epoch of the orbits. - altitude (float | None): The altitude (meters), if the layout does - not give it. + altitude (float | None): The altitude (meters), of layouts that do + not give their own. name (str): The prefix of the names of the satellites. time_step (float | None): The analysis time step (seconds), for catalog configurations that tailor a field of view to it. diff --git a/src/tatc/tradespace/cost.py b/src/tatc/tradespace/cost.py index bdfbfb54..94cb6869 100644 --- a/src/tatc/tradespace/cost.py +++ b/src/tatc/tradespace/cost.py @@ -42,12 +42,13 @@ the present value of the cost at a discount rate, and the cost of each year (such as its peak, for annual budgets):: - def evaluate(built): - d, satellites = built - deployment = SCHEDULE.plan(d.layout, kind=d.payload) - cost = MODEL.estimate(deployment, growth={"development": d.growth}) + def evaluate(satellites, design): + deployment = SCHEDULE.plan(design.layout, kind=design.payload) + cost = MODEL.estimate(deployment, growth={"development": design.growth}) return cost.metrics() +(as an `ObservationStudy` with a `MissionPlan` does for each design). + @author: Paul T. Grogan """ @@ -64,6 +65,7 @@ def evaluate(built): import pandas as pd from .deployment import Deployment +from .events import _per_type from .mission import MissionHistory from .nodes import Uncertain from .space import _RESERVED_NAMES, DesignSpace @@ -367,16 +369,18 @@ def _spread( amount: float, begin: float, end: float, until: float = math.inf ) -> list[tuple[float, float]]: """ - Spreads an amount evenly from `begin` to `end` (years), dated at the - middle of each of its years (or at `begin`, if it has no duration), the - part before `until` (the end of a sustained mission). + Spreads an amount evenly from `begin` to `end` (years), in parts within + the years from the start of development (so that each falls in its year + of `CostEstimate.annual`), each dated at its middle (or at `begin`, if it + has no duration), the parts before `until` (the end of a sustained + mission). """ if end <= begin: return [(begin, amount)] if begin < until else [] flows = [] time, stop = begin, min(end, until) while time < stop - 1e-12: - step = min(1.0, stop - time) + step = min(math.floor(time + 1e-9) + 1 - time, stop - time) flows.append((time + step / 2, amount * step / (end - begin))) time += step return flows @@ -397,20 +401,21 @@ class CostEstimate: """float: The cost of launches.""" operations: float = 0.0 """float: The cost of operations.""" - units: dict[str, int] = field(default_factory=dict) - """dict: The units built of each type of satellite (including + units: dict[Any, int] = field(default_factory=dict) + """dict: The units built of each type of satellite, by kind (`None` for + the satellites of a deployment of one type without a kind), including replacements and spares, and those in production at the end of a - sustained mission).""" + sustained mission.""" launches: int = 0 - """int: The launches priced per launch.""" + """int: The launches (including those that fail).""" flows: list[tuple[float, str, float]] = field(default_factory=list) """list: The dated costs: the time (years from the start of development), element, and amount of each.""" present: dict[str, float] = field(default_factory=dict) """dict: The present value of each element.""" - blocks: dict[str, int] = field(default_factory=dict) - """dict: The blocks of production of each type of satellite (see - `SatelliteCost.block_size`).""" + blocks: dict[Any, int] = field(default_factory=dict) + """dict: The blocks of production of each type of satellite, by kind + (see `units` and `SatelliteCost.block_size`).""" @property def total(self) -> float: @@ -496,8 +501,8 @@ class CostModel: of different types of satellites, estimated alike). Args: - satellites (SatelliteCost | Mapping[str, SatelliteCost]): The cost of - the satellites, or of each type of satellite (by name). The + satellites (SatelliteCost | Mapping[Any, SatelliteCost]): The cost of + the satellites, or of each type of satellite (by kind). The components of the same name of different types must be the same (equal costs and growth). launch (LaunchCost): The cost of launches. @@ -509,7 +514,7 @@ class CostModel: (see `draw`), in [0, 1]. """ - satellites: SatelliteCost | Mapping[str, SatelliteCost] + satellites: SatelliteCost | Mapping[Any, SatelliteCost] launch: LaunchCost = LaunchCost() operations: OperationsCost = OperationsCost() discount_rate: float = 0.0 @@ -522,7 +527,7 @@ def __post_init__(self): if not 0 <= self.correlation <= 1: raise ValueError("correlation must be in [0, 1]") components: dict[str, Component] = {} - for _, _, cost in self._types(): + for _, cost in self._types(): for component in cost.components: if component.name == COMMON: raise ValueError( @@ -546,25 +551,28 @@ def discount(self, time: float) -> float: """ return float((1 + self.discount_rate) ** -(self.start + time)) - def _get_type(self, kind: Any) -> SatelliteCost: + def satellite_cost_of(self, kind: Any = None) -> SatelliteCost: + """ + Gets the cost of a type of satellite. + + Args: + kind (Any): The type (its kind), or `None` for a model of one + type. + + Returns: + SatelliteCost: the cost + """ if isinstance(self.satellites, SatelliteCost): return self.satellites if kind is None: raise ValueError("a model of several types of satellites needs a kind") - if kind not in self.satellites: - raise ValueError(f"no cost of satellites of kind {kind!r}") - return self.satellites[kind] + return _per_type(self.satellites, kind, "cost") - def _types(self) -> list[tuple[str, Any, SatelliteCost]]: - """ - Gets the types of satellites: the name of each (as of the units of - estimates), its kind, and its cost. - """ + def _types(self) -> list[tuple[Any, SatelliteCost]]: + """Gets the types of satellites: the kind of each, and its cost.""" if isinstance(self.satellites, SatelliteCost): - return [(_type_name(None), None, self.satellites)] - return [ - (_type_name(kind), kind, cost) for kind, cost in self.satellites.items() - ] + return [(None, self.satellites)] + return list(self.satellites.items()) def score_names(self) -> list[str]: """ @@ -578,7 +586,7 @@ def score_names(self) -> list[str]: names = list( dict.fromkeys( component.name - for _, _, cost in self._types() + for _, cost in self._types() for component in cost.components if component.uncertain ) @@ -631,7 +639,7 @@ def draw(self, scores: Mapping[str, float]) -> CostModel: ) * float(scores[name]) probabilities[name] = 0.5 * (1 + math.erf(score / math.sqrt(2))) drawn = {} - for _, kind, cost in self._types(): + for kind, cost in self._types(): components = tuple( ( dataclasses.replace( @@ -688,7 +696,7 @@ def estimate( Growth factors multiply the estimate, such as uncertain parameters of cost growth drawn for each replicate (for example, - `Uncertain(lambda rng: rng.triangular(0.9, 1.0, 1.5))`), whose + `Uncertain.triangular(0.9, 1.0, 1.5)`), whose statistics over the replicates give the cost at a confidence level (such as the 0.7 `Quantile`). Factors of each type of satellite (such as `{"development": {"narrow": "growth_narrow", "wide": @@ -717,7 +725,7 @@ def estimate( """ factors = _get_growth(growth) history = ( - deployment.simulate() if isinstance(deployment, Deployment) else deployment + deployment.planned() if isinstance(deployment, Deployment) else deployment ) estimate = CostEstimate() flows: list[tuple[float, str, float]] = [] @@ -729,7 +737,7 @@ def add( flows.extend((time, element, amount * factor) for time, amount in amounts) if self.launch.per_kg > 0 and any( - self._get_type(kind).mass is None for kind in history.development + self.satellite_cost_of(kind).mass is None for kind in history.development ): raise ValueError("launches priced by mass require masses") # the costs of a sustained constellation are those incurred by the end @@ -738,7 +746,7 @@ def add( for kind, developed in sorted( history.development.items(), key=lambda item: item[1] ): - cost = self._get_type(kind) + cost = self.satellite_cost_of(kind) amount = cost.development + sum( c.development * c.factor for c in cost.components @@ -749,7 +757,7 @@ def add( built: dict[Any, int] = {} begun: dict[Any, int] = {} for batch in history.production: - cost = self._get_type(batch.kind) + cost = self.satellite_cost_of(batch.kind) before = built.get(batch.kind, 0) amount = cost.production(before + batch.satellites) - cost.production( before @@ -784,15 +792,15 @@ def add( ), batch.kind, ) - estimate.units = {_type_name(kind): units for kind, units in begun.items()} + estimate.units = dict(begun) estimate.blocks = { - _type_name(kind): self._get_type(kind).blocks(units) + kind: self.satellite_cost_of(kind).blocks(units) for kind, units in begun.items() } begin, end = history.begin, history.end for launch in history.launches: - cost = self._get_type(launch.kind) - estimate.launches += int(self.launch.per_launch > 0) + cost = self.satellite_cost_of(launch.kind) + estimate.launches += 1 price = self.launch.per_launch + launch.satellites * ( self.launch.per_satellite + self.launch.per_kg * (cost.mass or 0.0) ) @@ -828,14 +836,6 @@ def add( return estimate -def _type_name(kind: Any) -> str: - """ - Gets the name of a type of satellite (as of the units of estimates): its - kind, or `"satellites"` without one. - """ - return "satellites" if kind is None else str(kind) - - def _get_growth(growth: Growth) -> dict[str, float | dict[Any, float]]: """ Gets the growth factor of each element of cost (or a mapping of each kind @@ -866,13 +866,9 @@ def _get_factor( (`None` for costs of no type). """ factor = factors[element] - if not isinstance(factor, Mapping): - return factor - if kind is None: + if isinstance(factor, Mapping) and kind is None: raise ValueError(f"growth of {element} by type of satellite needs kinds") - if kind not in factor: - raise ValueError(f"no growth of {element} of satellites of kind {kind!r}") - return factor[kind] + return _per_type(factor, kind, f"growth of {element}") def risk_space(*models: CostModel) -> DesignSpace: diff --git a/src/tatc/tradespace/criteria.py b/src/tatc/tradespace/criteria.py index a34068d3..087f1a2e 100644 --- a/src/tatc/tradespace/criteria.py +++ b/src/tatc/tradespace/criteria.py @@ -24,6 +24,7 @@ import numpy as np import pandas as pd +from .dominance import _efficient from .study import _STATUS_COLUMNS _OPERATORS = {">=": op.ge, ">": op.gt, "<=": op.le, "<": op.lt} @@ -31,6 +32,19 @@ _DIRECTIONS = ("min", "max") +def _as_statistic(name: str, value: Any) -> Statistic: + """ + Gets a statistic given by name: a statistic, or the mean of a metric + given as a string or a metric computed from others (such as a + `Utility`). + """ + if isinstance(value, str) or _is_derived(value): + return Mean(value) + if not isinstance(value, Statistic): + raise TypeError(f"statistic {name!r} is not a Statistic") + return value + + def _is_derived(metric: Any) -> bool: """ Whether a metric is computed from others in each replicate (such as a @@ -463,11 +477,12 @@ class Criteria: column, or once with criteria `across` it (see `Across`), which combine their statistics across the groups: their worst, or their mean. - The functions that judge designs (`aggregate`, `pareto_front`, - `pareto_ranks`, `hypervolume`, `pareto_probability`, `refine`, - `confirm`, `screen`, and the searches of `optimize_optuna` and - `optimize_pymoo`) take criteria, or a mapping of objectives to their - directions, which are criteria of the means of metrics alone. + The functions that judge designs (`aggregate`, `summarize`, + `pareto_front`, `pareto_ranks`, `hypervolume`, `hypervolume_progress`, + `pareto_probability`, `robustness`, `refine`, `confirm`, `screen`, and the + searches of `optimize_optuna` and `optimize_pymoo`) take criteria, or a + mapping of objectives to their directions, which are criteria of the + means of metrics alone. Args: objectives (Mapping[str, str]): The objectives: statistics (or @@ -507,12 +522,9 @@ def __post_init__(self): f"direction of {name!r} must be 'min' or 'max', not {direction!r}" ) statistics = { - name: Mean(value) if isinstance(value, str) or _is_derived(value) else value + name: _as_statistic(name, value) for name, value in dict(self.statistics).items() } - for name, statistic in statistics.items(): - if not isinstance(statistic, Statistic): - raise TypeError(f"statistic {name!r} is not a Statistic") requirements = tuple(self.requirements) for requirement in requirements: if not isinstance(requirement, Requirement): @@ -586,6 +598,40 @@ def _as_criteria(criteria: Criteria | Mapping[str, str]) -> Criteria: ) +def _resamples(count: int, n_resamples: int, seed: Any) -> np.ndarray: + """ + Gets the replicates of each resample of a bootstrap: a row per resample of + `count` replicates (their positions) drawn with replacement, from a seed + (or a random number generator, which draws them). + """ + if n_resamples < 2: + raise ValueError("n_resamples must be at least 2") + return np.random.default_rng(seed).integers(count, size=(n_resamples, count)) + + +def _bootstrap_error(sums: np.ndarray, squares: np.ndarray, n: int) -> np.ndarray: + """ + Gets the standard errors of statistics from the sums of their values (and + of their squares) over `n` resamples of a bootstrap: their standard + deviations over the resamples. + """ + mean = sums / n + return np.sqrt(np.maximum(squares - n * mean**2, 0.0) / max(n - 1, 1)) + + +def _costs_of(values: Mapping[str, np.ndarray], criteria: Criteria) -> np.ndarray: + """ + Gets the objectives of criteria as costs (to minimize), from the values of + their statistics: maximized objectives are negated. + """ + columns = [ + np.asarray(values[name], dtype=float) * sign + for name, sign in zip(criteria.objectives, _signs(criteria)) + ] + count = len(columns[0]) if columns else 0 + return np.column_stack(columns) if count else np.empty((0, len(columns))) + + def _resolve(criteria: Criteria) -> dict[str, Statistic]: """ Gets the statistic of each name of criteria. @@ -904,9 +950,37 @@ def _with_values( frame[column] = first.loc[designs, column].to_numpy() +def _summary_groups( + results: pd.DataFrame, + statistics: Mapping[str, Statistic], + by: Sequence[str], + requirements: Sequence[Requirement] = (), + across: Across | None = None, + combiners: Mapping[str, str] | None = None, + design_columns: Sequence[str] | None = None, +) -> Iterator[tuple[pd.DataFrame, _Statistics]]: + """ + Iterates over the groups (of the columns `by`) of the feasible results of + a study, for summaries of their designs: a data frame of the designs of + each group (`design`, the values of `by`, and the values of the designs, + see `aggregate`), and their statistics (see `_Statistics`). + """ + feasible = results[results["feasible"]] if "feasible" in results else results + groups = _across_groups(results, across) + columns = _value_columns(feasible, statistics, by, across, design_columns) + for key, positions in _groups(feasible, by): + group = feasible.iloc[positions] + table = _Statistics(group, statistics, requirements, across, combiners, groups) + frame = pd.DataFrame({"design": table.designs}) + for name, value in zip(by, key): + frame[name] = value + _with_values(frame, group, table.designs, columns) + yield frame, table + + def _criteria_of( criteria: Criteria | Mapping[str, str] | Sequence[str] | str, - statistics: Mapping[str, Statistic | str] | None, + statistics: Mapping[str, Statistic | str] | Sequence[str] | None, by: Sequence[str] | str, ) -> tuple[Criteria | None, dict[str, Statistic], tuple[str, ...]]: """ @@ -914,13 +988,14 @@ def _criteria_of( statistics to compute (by name), and the columns that group records. """ by = (by,) if isinstance(by, str) else tuple(by) + if isinstance(statistics, str): + statistics = [statistics] + if statistics is not None and not isinstance(statistics, Mapping): + statistics = {name: name for name in statistics} # their means extra = { - name: Mean(value) if isinstance(value, str) or _is_derived(value) else value + name: _as_statistic(name, value) for name, value in dict(statistics or {}).items() } - for name, statistic in extra.items(): - if not isinstance(statistic, Statistic): - raise TypeError(f"statistic {name!r} is not a Statistic") if isinstance(criteria, Mapping) and not set(criteria.values()) <= {"min", "max"}: raise ValueError( "a mapping of criteria gives the directions of objectives ('min' or " @@ -960,7 +1035,7 @@ def aggregate( results: pd.DataFrame, criteria: Criteria | Mapping[str, str] | Sequence[str] | str = (), *, - statistics: Mapping[str, Statistic | str] | None = None, + statistics: Mapping[str, Statistic | str] | Sequence[str] | None = None, by: Sequence[str] | str = (), design_columns: Sequence[str] | None = None, ) -> pd.DataFrame: @@ -976,18 +1051,21 @@ def aggregate( objectives to their directions, which are the means of the metrics of their names), or the means of metrics (a list of their names), and other `statistics`, by name (a statistic, or a metric given as a string, whose - mean it is):: + mean it is), or the means of other metrics (a list of their names):: aggregate(results, {"satellites": "min", "sufficient": "max"}) aggregate(results, ["sufficient", "accurate"]) aggregate(results, statistics={"cost p70": Quantile("cost", 0.7)}) + aggregate(results, COST, statistics=["cost development"]) With criteria, the summary also gives the `violation` of their requirements (the sum of the violations, see `Requirement`, 0 if the - design meets them all) and whether the design meets them - (`meets_requirements`). Criteria `across` a column combine the - statistics of each design across its groups (see `Across`), of which - `replicates` is the fewest of any group. + design meets them all), whether the design meets them + (`meets_requirements`), and whether it is efficient among the designs + that do (`pareto`, see `pareto_front`, in each group of the criteria's + `by`; a design with a missing objective, `NaN`, is not). Criteria + `across` a column combine the statistics of each design across its + groups (see `Across`), of which `replicates` is the fewest of any group. The results must have one record per evaluation (a design in a replicate) in each group (and in each group of the column of the @@ -998,8 +1076,9 @@ def aggregate( criteria (Criteria | Mapping[str, str] | Sequence[str] | str): The criteria (or objectives and their directions), or the metrics whose means to compute. - statistics (Mapping[str, Statistic | str] | None): Other statistics, - by name. + statistics (Mapping[str, Statistic | str] | Sequence[str] | None): + Other statistics, by name, or the metrics whose means to compute + as well. by (Sequence[str] | str): The columns that group records of an evaluation (those of the criteria, if they have any). design_columns (Sequence[str] | None): The columns of the values of @@ -1010,39 +1089,35 @@ def aggregate( pandas.DataFrame: a row per design (and group) """ judged, resolved, by = _criteria_of(criteria, statistics, by) - across, combiners, requirements = None, None, () + across, combiners, requirements, tolerances = None, None, (), None if judged is not None: requirements, across = judged.requirements, judged.across combiners = None if across is None else _combiners(judged) - feasible = results[results["feasible"]] if "feasible" in results else results - groups = _across_groups(results, across) - columns = _value_columns(feasible, resolved, by, across, design_columns) + tolerances = _get_tolerances(judged.objectives, judged.tolerance) frames = [] - for key, positions in _groups(feasible, by): - group = feasible.iloc[positions] - table = _Statistics(group, resolved, requirements, across, combiners, groups) - designs = table.designs + for frame, table in _summary_groups( + results, resolved, by, requirements, across, combiners, design_columns + ): values, violation = table.evaluate() - frame = pd.DataFrame({"design": designs}) - for name, value in zip(by, key): - frame[name] = value - _with_values(frame, group, designs, columns) for name, value in values.items(): frame[name] = value frame["replicates"] = table.counts if judged is not None: + meets = violation == 0 frame["violation"] = violation - frame["meets_requirements"] = violation == 0 + frame["meets_requirements"] = meets + frame["pareto"] = _efficient(_costs_of(values, judged), meets, tolerances) frames.append(frame) if not frames: - status = ["violation", "meets_requirements"] if judged is not None else [] + status = ["violation", "meets_requirements", "pareto"] if judged else [] return pd.DataFrame(columns=["design", *by, *resolved, "replicates", *status]) return pd.concat(frames, ignore_index=True) def summarize( results: pd.DataFrame, - metrics: Sequence[str], + metrics: Criteria | Mapping[str, str] | Sequence[str] | str, + *, by: Sequence[str] | str = (), design_columns: Sequence[str] | None = None, ) -> pd.DataFrame: @@ -1052,13 +1127,22 @@ def summarize( columns `by`, such as a sensor), the mean of each metric, its standard deviation (` std`) and standard error (` se`) between replicates, and the number of replicates (`replicates`), with the values - of the design. + of the design. Given criteria (or a mapping of objectives to their + directions), the summary is theirs (see `aggregate`: their statistics, + the violation of their requirements, and whether each design is + efficient, `pareto`), with the standard deviation and standard error of + each statistic that is the mean of a metric:: + + summary = summarize(results, {"satellites": "min", "sufficient": "max"}) + front = summary[summary.pareto] Args: results (pandas.DataFrame): The results (see `Study.run`). - metrics (Sequence[str]): The columns of the metrics. + metrics (Criteria | Mapping[str, str] | Sequence[str] | str): The + columns of the metrics, or criteria (or objectives and their + directions). by (Sequence[str] | str): Other columns that group records of an - evaluation. + evaluation (those of criteria, if they have any). design_columns (Sequence[str] | None): The columns of the values of designs, or `None` for those that are the same in every replicate of a design (except the metrics). @@ -1066,8 +1150,25 @@ def summarize( Returns: pandas.DataFrame: the summary, a row per design (and group) """ + if isinstance(metrics, (Criteria, Mapping)): + judged = _as_criteria(metrics) + if by: + if isinstance(metrics, Criteria): + raise ValueError( + "criteria group records by their own `by`: give it to the criteria" + ) + judged = replace(judged, by=(by,) if isinstance(by, str) else tuple(by)) + spread: dict[str, Statistic] = {} + for name in judged.names: + statistic = judged.statistic(name) + if type(statistic) is Mean and isinstance(statistic.column, str): + spread[f"{name} std"] = StandardDeviation(statistic.column) + spread[f"{name} se"] = StandardError(statistic.column) + return aggregate( + results, judged, statistics=spread, design_columns=design_columns + ) statistics: dict[str, Statistic] = {} - for metric in metrics: + for metric in [metrics] if isinstance(metrics, str) else metrics: statistics[metric] = Mean(metric) statistics[f"{metric} std"] = StandardDeviation(metric) statistics[f"{metric} se"] = StandardError(metric) diff --git a/src/tatc/tradespace/deployment.py b/src/tatc/tradespace/deployment.py index d5cd363c..aca9ac46 100644 --- a/src/tatc/tradespace/deployment.py +++ b/src/tatc/tradespace/deployment.py @@ -42,11 +42,11 @@ from ..schemas import Satellite from .constellations import layout_of -from .events import Launch, PerType, Production, _per_type +from .events import Launch, PerType, Production, _per_type, _per_type_values from .failures import FailureModel, RestorationPolicy -from .histories import _simulate_many -from .histories import expected_metrics as _expected_metrics -from .mission import Capability, Decision, MissionHistory, Phase, _Simulation +from .histories import _expected_metrics, _simulate_many +from .mission import Capability, Decision, MissionHistory, Phase +from .simulation import _Simulation from .values import Values @@ -235,9 +235,10 @@ def planned(self) -> MissionHistory: def simulate_many( self, failures: FailureModel, - policy: RestorationPolicy | None, - seed: int | None, - histories: int, + policy: RestorationPolicy | None = None, + seed: int | None = None, + histories: int = 1, + *, sampling: str = "stratified", stress: float = 1.0, launch_stress: float | None = None, @@ -279,8 +280,10 @@ def simulate_many( Args: failures (FailureModel): The failures. policy (RestorationPolicy | None): The policy for failed - satellites. - seed (int | None): The seed of the replicate. + satellites, or `None` to restore them by producing new ones + (as `simulate`). + seed (int | None): The seed of the replicate, or `None` for the + one history without failures. histories (int): The number of histories. sampling (str): `"stratified"` or `"random"`. stress (float): The factor of the hazards of stressed failures. @@ -302,27 +305,31 @@ def expected_metrics( self, failures: FailureModel, policy: RestorationPolicy | None = None, - histories: int = 1000, seed: int = 0, + histories: int = 1000, + *, sampling: str = "stratified", ) -> dict[str, float]: """ Estimates the expected measures of the mission (see `MissionHistory.metrics`, such as its `availability`) from many - simulated histories (see `expected_metrics`). + simulated histories (see `simulate_many`), without evaluating their + phases: precise and cheap, as the expected values of control + variates (see `summarize_missions`, and the `controls` of + `Failures`). Args: failures (FailureModel): The failures. policy (RestorationPolicy | None): The policy for failed - satellites. - histories (int): The number of histories. + satellites (see `simulate_many`). seed (int): The seed of the histories. + histories (int): The number of histories. sampling (str): The sampling of their failures. Returns: dict[str, float]: the mean of each measure """ - return _expected_metrics(self, failures, policy, histories, seed, sampling) + return _expected_metrics(self, failures, policy, seed, histories, sampling) def phases(self, satellites: Sequence[Satellite | str]) -> list[Phase]: """ @@ -360,7 +367,8 @@ class DeploymentSchedule: * The mission lasts `years` from the first launch. Satellites are replaced at the end of their `design_life` (one for every type, or one for each; if before the end of the mission), each replacement produced - at the production rate just before it is needed and launched then. A + at the production rate just before it is needed and launched then + (see `replacements`). A design life does not retire a satellite: one that is not replaced (as near the end of the mission, or if its replacement's launch fails) operates until it fails (by the wear-out of its life, see @@ -418,21 +426,21 @@ class DeploymentSchedule: def __post_init__(self): if self.years <= 0: raise ValueError("years must be positive") - lives = self.design_life - values = lives.values() if isinstance(lives, Mapping) else [lives] - if any(life is not None and life <= 0 for life in values): + if any( + life is not None and life <= 0 + for life in _per_type_values(self.design_life) + ): raise ValueError("design_life must be positive") if self.launch_interval < 0: raise ValueError("launch_interval must not be negative") if self.launch_capacity is not None and self.launch_capacity < 1: raise ValueError("launch_capacity must be at least 1") - rates = self.production_rate - values = rates.values() if isinstance(rates, Mapping) else [rates] - if any(rate is not None and rate <= 0 for rate in values): + if any( + rate is not None and rate <= 0 + for rate in _per_type_values(self.production_rate) + ): raise ValueError("production_rate must be positive") - years = self.development_years - values = years.values() if isinstance(years, Mapping) else [years] - if any(value < 0 for value in values): + if any(years < 0 for years in _per_type_values(self.development_years)): raise ValueError("development_years must not be negative") def design_life_of(self, kind: Any = None) -> float | None: @@ -448,30 +456,67 @@ def design_life_of(self, kind: Any = None) -> float | None: """ return _per_type(self.design_life, kind, "design life") - def _replacements( - self, kind: Any, time: float, satellites: int, end: float - ) -> list[tuple[float, float, int]]: + def production_years(self, kind: Any, satellites: int) -> float: + """ + Gets the time to produce satellites of a type on its line. + + Args: + kind (Any): The type of the satellites. + satellites (int): The number of satellites. + + Returns: + float: the years (0 for production that takes no time) + """ + rate = _per_type(self.production_rate, kind, "production rate") + return 0.0 if rate is None else satellites / rate + + def replacements( + self, launch: Launch, end: float + ) -> list[tuple[Production, Launch | None]]: """ - Gets the planned replacements of satellites launched at a time: the - start of the production and the launch of each, and its generation. - Replacements are launched before the end of the mission, or, for a - sustained constellation, produced after it from those whose - production begins within the development years of their type after - the end (whose later blocks of production may be developed before - it). + Gets the planned replacements of the satellites of a launch, at the + end of their design life: the production of each (just before it is + needed) and its launch. Replacements are launched before the end of + the mission, or, for a sustained constellation, produced after it + (without a launch, `None`) from those whose production begins within + the development years of their type after the end (whose later + blocks of production may be developed before it). + + Args: + launch (Launch): The launch. + end (float): The end of the mission. + + Returns: + list[tuple[Production, Launch | None]]: the production and the + launch of each replacement, in order """ - life = self.design_life_of(kind) + life = self.design_life_of(launch.kind) if life is None: return [] - rate = _per_type(self.production_rate, kind, "production rate") - producing = 0.0 if rate is None else satellites / rate + producing = self.production_years(launch.kind, launch.satellites) horizon = end if self.sustained: - horizon += float(_per_type(self.development_years, kind, "development")) - replacements = [] - need, generation = time + life, 1 + horizon += float( + _per_type(self.development_years, launch.kind, "development") + ) + replacements: list[tuple[Production, Launch | None]] = [] + need, generation = launch.time + life, 1 while (need - producing if self.sustained else need) < horizon - 1e-9: - replacements.append((need - producing, need, generation)) + production = Production( + launch.kind, need - producing, need, launch.satellites, "replacement" + ) + replacement = None + if need < end - 1e-9: # not those of a sustained constellation after it + replacement = Launch( + need, + launch.plane, + launch.kind, + launch.first, + launch.satellites, + generation, + "replacement", + ) + replacements.append((production, replacement)) need, generation = need + life, generation + 1 return replacements @@ -493,6 +538,62 @@ def mass_capacity_of(self, plane: tuple[int, Any] | None = None) -> float | None raise ValueError("a launch capacity of each plane needs the plane") return float(capacity(*plane)) + def per_launch( + self, mass: float | None = None, plane: tuple[int, Any] | None = None + ) -> float: + """ + Gets the most satellites of a launch (to a plane), by the capacity of + launches in number and in mass. + + Args: + mass (float | None): The mass (kg) of each satellite. + plane (tuple[int, Any] | None): The index and values of the plane, + for a capacity in mass that is a function of the plane. + + Returns: + float: the number of satellites (infinite if not limited) + + Raises: + ValueError: if a capacity in mass is not given the mass, or a + satellite exceeds it. + """ + capacity = math.inf if self.launch_capacity is None else self.launch_capacity + mass_capacity = self.mass_capacity_of(plane) + if mass_capacity is not None: + if mass is None: + raise ValueError("a launch capacity in mass requires masses") + fits = math.floor(mass_capacity / mass) + if fits < 1: + raise ValueError("a satellite exceeds the mass capacity of a launch") + capacity = min(capacity, fits) + return capacity + + def split( + self, + satellites: int, + mass: float | None = None, + plane: tuple[int, Any] | None = None, + ) -> list[int]: + """ + Gets the satellites of each launch of a plane: as few launches as + carry them (see `per_launch`, at least one), sharing them evenly. + + Args: + satellites (int): The number of satellites. + mass (float | None): The mass (kg) of each satellite. + plane (tuple[int, Any] | None): The index and values of the plane, + for a capacity in mass that is a function of the plane. + + Returns: + list[int]: the satellites of each launch + """ + capacity = self.per_launch(mass, plane) + count = max(1, math.ceil(satellites / capacity)) if capacity < math.inf else 1 + return [ + satellites // count + (1 if j < satellites % count else 0) + for j in range(count) + ] + def launches_of( self, satellites: int, @@ -500,7 +601,7 @@ def launches_of( plane: tuple[int, Any] | None = None, ) -> int: """ - Gets the launches of a plane of satellites. + Gets the launches of a plane of satellites (see `split`). Args: satellites (int): The number of satellites. @@ -511,18 +612,7 @@ def launches_of( Returns: int: the number of launches """ - count = 1 - if self.launch_capacity is not None: - count = max(count, math.ceil(satellites / self.launch_capacity)) - capacity = self.mass_capacity_of(plane) - if capacity is not None: - if mass is None: - raise ValueError("a launch capacity in mass requires masses") - per_launch = math.floor(capacity / mass) - if per_launch < 1: - raise ValueError("a satellite exceeds the mass capacity of a launch") - count = max(count, math.ceil(satellites / per_launch)) - return count + return len(self.split(satellites, mass, plane)) def plan( self, @@ -575,7 +665,6 @@ def plan( planes = [] # (ready, index, kind, satellites, mass) for name, item in fleets.items(): developed = float(_per_type(self.development_years, name, "development")) - rate = _per_type(self.production_rate, name, "production rate") mass = None if masses is None else _per_type(masses, name, "mass") deployment.development[name] = developed deployment.masses[name] = mass @@ -591,7 +680,7 @@ def plan( listed.sort(key=lambda plane: self.order(plane[0], plane[2])) line = developed for index, size, _ in listed: - ready = line + (0.0 if rate is None else size / rate) + ready = line + self.production_years(name, size) deployment.production.append(Production(name, line, ready, size)) planes.append((ready, index, name, size, mass)) line = ready @@ -604,43 +693,27 @@ def plan( raise ValueError("a deployment requires satellites (that are not staged)") cadence = -math.inf for ready, index, name, size, mass in sorted(planes, key=lambda p: p[0]): - count = self.launches_of( - size, mass, (index, deployment.plane_values[index]) - ) + carried = self.split(size, mass, (index, deployment.plane_values[index])) first = max(ready, cadence) position = 0 - for j in range(count): - carried = size // count + (1 if j < size % count else 0) + for j, satellites in enumerate(carried): deployment.launches.append( Launch( - first + j * self.launch_interval, index, name, position, carried + first + j * self.launch_interval, + index, + name, + position, + satellites, ) ) - position += carried - cadence = first + count * self.launch_interval + position += satellites + cadence = first + len(carried) * self.launch_interval end = deployment.end for launch in list(deployment.launches): - for produced, need, generation in self._replacements( - launch.kind, launch.time, launch.satellites, end - ): - deployment.production.append( - Production( - launch.kind, produced, need, launch.satellites, "replacement" - ) - ) - # not those of a sustained constellation after the end - if need < end - 1e-9: - deployment.launches.append( - Launch( - need, - launch.plane, - launch.kind, - launch.first, - launch.satellites, - generation, - "replacement", - ) - ) + for production, replacement in self.replacements(launch, end): + deployment.production.append(production) + if replacement is not None: + deployment.launches.append(replacement) deployment.production.sort(key=lambda batch: batch.begin) deployment.launches.sort(key=lambda launch: (launch.time, launch.plane)) return deployment diff --git a/src/tatc/tradespace/dominance.py b/src/tatc/tradespace/dominance.py new file mode 100644 index 00000000..f7e07b62 --- /dev/null +++ b/src/tatc/tradespace/dominance.py @@ -0,0 +1,109 @@ +""" +Dominance between points of several costs (objectives to minimize, such as +the objectives of designs, see `pareto_front`), with tolerances within +which differences do not matter. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +import numpy as np + +_BLOCK_ELEMENTS = 2_000_000 +"""The most elements of the temporary arrays of a block of comparisons.""" + +_CHUNK = 64 +"""The points of each chunk of a sweep (see `_dominated_plain`).""" + + +def _dominated_by( + points: np.ndarray, others: np.ndarray, tolerances: np.ndarray | None = None +) -> np.ndarray: + """ + Finds the points dominated by any of others, even if the other is + penalized by the tolerances (see `_dominated`), comparing them in blocks + whose temporary arrays are limited to a few million elements. + """ + dominated = np.zeros(len(points), dtype=bool) + if len(points) == 0 or len(others) == 0: + return dominated + if tolerances is None: + tolerances = np.zeros((2, points.shape[1])) + absolute, relative = tolerances + penalties = np.any(tolerances) + block = max(1, _BLOCK_ELEMENTS // max(len(others) * points.shape[1], 1)) + for start in range(0, len(points), block): + part = points[start : start + block] + # [i, j]: other j dominates point i of the block + penalized = others[None, :, :] + if penalties: + penalized = penalized + absolute + relative * np.abs(part[:, None, :]) + no_worse = np.all(penalized <= part[:, None, :], axis=2) + better = np.any(penalized < part[:, None, :], axis=2) + dominated[start : start + block] = np.any(no_worse & better, axis=1) + return dominated + + +def _dominated_plain(costs: np.ndarray) -> np.ndarray: + """ + Finds the points dominated by another (without tolerances) by a sweep in + lexicographic order, in which a point can only be dominated by points + before it, and is dominated by one if it is by any of the efficient + points before it (dominance is transitive). The sweep compares each + chunk of points with the efficient points before it, then those it does + not dominate with each other. + """ + n = len(costs) + order = np.lexsort(costs.T[::-1]) + ordered = costs[order] + dominated = np.zeros(n, dtype=bool) + efficient = np.empty((0, costs.shape[1])) + for start in range(0, n, _CHUNK): + part = ordered[start : start + _CHUNK] + beaten = _dominated_by(part, efficient) + # a point that an earlier efficient point dominates dominates nothing + # that it does not: compare only the others with each other + survivors = part[~beaten] + beaten[~beaten] = _dominated_by(survivors, survivors) + dominated[order[start : start + _CHUNK]] = beaten + efficient = np.vstack([efficient, part[~beaten]]) + return dominated + + +def _dominated(costs: np.ndarray, tolerances: np.ndarray | None = None) -> np.ndarray: + """ + Finds the points (rows of costs) dominated by another, even if the other + is penalized by the tolerances: no worse in every cost, and better in at + least one, by at least its tolerance (absolute, plus a share of the + magnitude of the cost of the point it would dominate, see + `_get_tolerances`). + + A point that is dominated with tolerances is also dominated by a point + that is efficient without them: the penalty depends only on the point + dominated, so any point no worse than its dominator in every cost (as + some efficient point is) dominates it too. Points are therefore compared + only with the efficient points (see `_dominated_plain`), which are few. + """ + plain = _dominated_plain(costs) + if tolerances is None or not np.any(tolerances): + return plain + return _dominated_by(costs, costs[~plain], tolerances) + + +def _efficient( + costs: np.ndarray, admissible: np.ndarray, tolerances: np.ndarray | None = None +) -> np.ndarray: + """ + Finds the efficient points (rows of costs) among the admissible ones + (such as the designs that meet requirements): those that no other + admissible point dominates (see `_dominated`). Points with a missing cost + (`NaN`) are neither efficient nor dominate others. + """ + known = np.asarray(admissible, dtype=bool) + if len(costs) > 0: + known = known & ~np.isnan(costs).any(axis=1) + efficient = np.zeros(len(costs), dtype=bool) + if known.any(): + efficient[known] = ~_dominated(costs[known], tolerances) + return efficient diff --git a/src/tatc/tradespace/events.py b/src/tatc/tradespace/events.py index 2f3e57ff..b3d27844 100644 --- a/src/tatc/tradespace/events.py +++ b/src/tatc/tradespace/events.py @@ -13,11 +13,15 @@ from typing import Any PerType = float | Mapping[Any, float] -"""A value for every type of satellite, or for each (by its name).""" +"""A value for every type of satellite, or for each (a mapping by kind).""" def _per_type(value: Any, kind: Any, name: str) -> Any: - """Gets the value of a type of satellite.""" + """ + Gets the value of a type of satellite (by its kind) of a value for every + type or a mapping of each, raising a `ValueError` (naming the value) if + the mapping lacks the kind. + """ if isinstance(value, Mapping): if kind not in value: raise ValueError(f"no {name} of satellites of kind {kind!r}") @@ -25,6 +29,11 @@ def _per_type(value: Any, kind: Any, name: str) -> Any: return value +def _per_type_values(value: Any) -> list: + """Gets the values of every type of satellite (of a mapping), or the value.""" + return list(value.values()) if isinstance(value, Mapping) else [value] + + @dataclass(frozen=True) class Launch: """ diff --git a/src/tatc/tradespace/failures.py b/src/tatc/tradespace/failures.py index d98dc024..f4ff89d7 100644 --- a/src/tatc/tradespace/failures.py +++ b/src/tatc/tradespace/failures.py @@ -26,6 +26,7 @@ import numpy as np +from .events import _per_type, _per_type_values from .nodes import Categorical from .space import DesignSpace from .values import Scope @@ -331,8 +332,8 @@ def _age_at(self, target: float) -> float: class FailureModel: """ The failures of a mission: the life of the satellites (of every type, or - of each, by name; `None` if they do not fail) and the probability that - a launch fails, losing its satellites. + of each, by kind; `None` if they do not fail) and the probability that a + launch fails, losing its satellites. Args: life (Lifetime | Mapping[Any, Lifetime] | None): The life of the @@ -357,11 +358,7 @@ def life_of(self, kind: Any) -> Lifetime | None: Returns: Lifetime | None: the life, or `None` if it does not fail """ - if isinstance(self.life, Mapping): - if kind not in self.life: - raise ValueError(f"no life of satellites of kind {kind!r}") - return self.life[kind] - return self.life + return _per_type(self.life, kind, "life") @dataclass(frozen=True) @@ -397,7 +394,8 @@ class RestorationPolicy: procurement_years (float): The time from ordering a satellite to the start of its production. ground_spares (int | Mapping[Any, int]): The spares on the ground of - each type of satellite. + every type of satellite, or of each (by kind, every kind of the + deployment). replenish (bool): `True` to replace the spares that are used. batch_years (float): The time that restorations of a plane wait to share a launch. @@ -420,12 +418,7 @@ def __post_init__(self): ): if getattr(self, name) < 0: raise ValueError(f"{name} must not be negative") - values = ( - self.ground_spares.values() - if isinstance(self.ground_spares, Mapping) - else [self.ground_spares] - ) - if any(value < 0 for value in values): + if any(value < 0 for value in _per_type_values(self.ground_spares)): raise ValueError("ground_spares must not be negative") def ground_spares_of(self, kind: Any) -> int: @@ -438,9 +431,7 @@ def ground_spares_of(self, kind: Any) -> int: Returns: int: the number of spares """ - if isinstance(self.ground_spares, Mapping): - return int(self.ground_spares.get(kind, 0)) - return int(self.ground_spares) + return int(_per_type(self.ground_spares, kind, "ground spares")) def _spares_restore(d: Scope) -> bool: diff --git a/src/tatc/tradespace/fingerprint.py b/src/tatc/tradespace/fingerprint.py index 7bc48d2c..caeff992 100644 --- a/src/tatc/tradespace/fingerprint.py +++ b/src/tatc/tradespace/fingerprint.py @@ -10,16 +10,21 @@ well-known binary), the nodes of design spaces, dataclasses (such as cost models) by their fields (but those whose metadata has `"fingerprint": False`, such as directories of caches, which do not change results), and -functions, by their compiled code (which ties a definition to the version of -Python, which it records), the values they close over and their defaults, -and the constants (numbers, strings, dates and times, and tuples of them), -data (arrays and data frames), dataclasses, and functions of the same module -that they refer to as globals (not mutable containers, which are often -state, such as caches). Functions and classes of other modules are described -by their names, and other objects by their type only. Data that functions -read (such as from files) and the code of other modules they call (other -than TAT-C's) are not described: identify them by a namespace (see -`ResultStore` and `SatelliteCache`). +geometries (by their well-known binary), and functions, by their compiled +code (which ties a definition to the version of Python, which it records, +but not their docstrings, which do not change results), the values they +close over and their defaults, and the constants (numbers, strings, dates +and times, and tuples of them), geometries, data (arrays and data frames), +dataclasses, and functions that they refer to as globals (not mutable +containers, which are often state, such as caches). Functions are described +so if they are of their own module or of another module of the study's own, +which is not installed (such as a module next to a notebook), so that a +notebook's function that calls a function it imports from such a module is +described as the module's copy of it is. Functions and classes of installed +modules are described by their names, and other objects by their type only. +Data that functions read (such as from files) and the code of installed +modules they call (other than TAT-C's) are not described: identify them by +a namespace (see `ResultStore` and `SatelliteCache`). TAT-C is described by the source of the modules that the values depend on: the modules that define the functions, classes, and objects of TAT-C they @@ -45,6 +50,7 @@ import hashlib import json import sys +import sysconfig import types from collections.abc import Iterable from datetime import date, datetime, time, timedelta @@ -53,8 +59,11 @@ import numpy as np import pandas as pd +import shapely from pydantic import BaseModel +from .hashing import _canonical, _digest + _MAX_DEPTH = 24 """The deepest nesting described, beyond which values are described by type.""" @@ -81,7 +90,7 @@ def _name(value: Any) -> str: def _sort_key(value: Any) -> str: - return json.dumps(value, sort_keys=True, default=str) + return _canonical(value) def _is_package_module(module: Any) -> bool: @@ -101,6 +110,33 @@ def _is_data(value: Any) -> bool: return isinstance(value, (np.ndarray, pd.DataFrame, pd.Series)) +@functools.lru_cache(maxsize=1) +def _installed_directories() -> tuple[Path, ...]: + """Gets the directories of installed modules (and the standard library).""" + paths = sysconfig.get_paths() + names = ("stdlib", "platstdlib", "purelib", "platlib") + found = {Path(paths[name]).resolve() for name in names if name in paths} + found.add(Path(sys.base_prefix).resolve()) + return tuple(sorted(found)) + + +def _is_own_module(module: Any) -> bool: + """ + Whether a module is of the study's own: neither of TAT-C nor installed + (such as `__main__`, or a module next to a notebook), so that its + functions are described by their code (see the module). + """ + if not isinstance(module, str) or _is_package_module(module): + return False + if module == "__main__": + return True + file = getattr(sys.modules.get(module), "__file__", None) + if file is None: + return False # built in, or not loaded + path = Path(file).resolve() + return not any(path.is_relative_to(d) for d in _installed_directories()) + + def _hash_column(column: pd.Series) -> bytes: """ Gets the hashes of the values of a column (geometries by their @@ -204,14 +240,20 @@ def note(self, module: Any) -> None: if _is_package_module(module): self.modules.add(module) - def code(self, code: types.CodeType, depth: int, seen: set) -> dict: + def code( + self, code: types.CodeType, depth: int, seen: set, doc: str | None = None + ) -> dict: """ Describes compiled code by its instructions, constants, and names (not - its file or line numbers, which change as code moves). + its file or line numbers, which change as code moves, nor the + docstring `doc` of its function, which does not change results). """ + constants = list(code.co_consts) + if doc is not None and constants and constants[0] == doc: + constants = constants[1:] return { "code": code.co_code.hex(), - "constants": [self.describe(c, depth + 1, seen) for c in code.co_consts], + "constants": [self.describe(c, depth + 1, seen) for c in constants], "names": list(code.co_names), } @@ -240,7 +282,7 @@ def function(self, function: types.FunctionType, depth: int, seen: set) -> dict: continue value = function.__globals__[name] if isinstance(value, types.FunctionType): - if value.__module__ == module: + if value.__module__ == module or _is_own_module(value.__module__): referenced[name] = self.function(value, depth + 1, seen) else: self.note(value.__module__) @@ -250,6 +292,7 @@ def function(self, function: types.FunctionType, depth: int, seen: set) -> dict: or _is_constant(value) or _is_data(value) or _is_dataclass(value) + or isinstance(value, shapely.Geometry) ): referenced[name] = self.describe(value, depth + 1, seen) else: @@ -257,7 +300,7 @@ def function(self, function: types.FunctionType, depth: int, seen: set) -> dict: self.note(type(value).__module__) return { "function": function.__qualname__, - **self.code(function.__code__, depth, seen), + **self.code(function.__code__, depth, seen, function.__doc__), "closure": closure, "defaults": self.describe(function.__defaults__, depth + 1, seen), "keyword defaults": self.describe(function.__kwdefaults__, depth + 1, seen), @@ -308,6 +351,8 @@ def describe(self, value: Any, depth: int = 0, seen: set | None = None) -> Any: } if isinstance(value, (pd.DataFrame, pd.Series)): return _frame(value) + if isinstance(value, shapely.Geometry): + return {**_type(value), "data": hashlib.sha1(value.wkb).hexdigest()} if isinstance(value, (list, tuple)): if len(value) > _MAX_ITEMS: return {**_type(value), "length": len(value)} @@ -562,7 +607,7 @@ def _get_dependencies(modules: Iterable[str]) -> tuple[list[str], list[str]]: @functools.lru_cache(maxsize=None) def _hash_file(path: Path, modified: int, size: int) -> str: del modified, size # keys of the cache, so that a changed file is hashed again - return hashlib.sha1(path.read_bytes()).hexdigest()[:16] + return _digest(path.read_bytes(), 16) def _hash(path: Path) -> str: @@ -603,8 +648,7 @@ def get_definition(*values: Any, **named: Any) -> dict: def _fingerprint_of(definition: dict) -> str: """Gets the fingerprint of a definition (see `get_definition`).""" - text = json.dumps(definition, sort_keys=True, default=str) - return hashlib.sha1(text.encode()).hexdigest()[:16] + return _digest(_canonical(definition), 16) def get_fingerprint(*values: Any, **named: Any) -> str: @@ -687,6 +731,24 @@ def _without_code(description: Any) -> Any: return description +def _with_other_code( + definition: dict, others: Iterable[dict | None] +) -> list[str] | None: + """ + Gets the differences (see `compare_definitions`) from the first of other + definitions that has the same values as a definition but other code (of + its functions, of TAT-C, or of Python, see `_without_code`), or `None` if + none does: results of the same study with other code, which are not + reused, as opposed to those of other studies (such as variants of other + settings), which share stores and caches freely. + """ + values = _without_code(definition.get("values", {})) + for other in others: + if other is not None and _without_code(other.get("values", {})) == values: + return compare_definitions(other, definition) + return None + + def compare_definitions(before: dict, after: dict, limit: int = 5) -> list[str]: """ Compares definitions (see `get_definition`), as to explain why results diff --git a/src/tatc/tradespace/hashing.py b/src/tatc/tradespace/hashing.py new file mode 100644 index 00000000..85b51360 --- /dev/null +++ b/src/tatc/tradespace/hashing.py @@ -0,0 +1,28 @@ +""" +Canonical text of plain values, and short hashes of it, which identify +designs (see `Design.key`), definitions (see `get_fingerprint`), and the +contents of caches and stores. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +import hashlib +import json +from typing import Any + + +def _canonical(value: Any) -> str: + """ + Gets the canonical text of a plain value: its JSON, with the keys of + mappings sorted (and other values as their strings). + """ + return json.dumps(value, sort_keys=True, default=str) + + +def _digest(data: str | bytes, length: int | None = None) -> str: + """Gets a hash of text (or bytes), as hexadecimal digits (the first `length`).""" + raw = data.encode() if isinstance(data, str) else data + text = hashlib.sha1(raw).hexdigest() + return text if length is None else text[:length] diff --git a/src/tatc/tradespace/histories.py b/src/tatc/tradespace/histories.py index 6070e51d..c54b98fc 100644 --- a/src/tatc/tradespace/histories.py +++ b/src/tatc/tradespace/histories.py @@ -20,18 +20,19 @@ import pandas as pd from ..schemas import Satellite -from .cache import get_satellite_key from .criteria import _OPERATORS, Requirement from .failures import FailureModel, RestorationPolicy from .mission import ( + PHASE_COLUMNS, MissionHistory, Phase, PhaseCache, - _Simulation, - _given_design, - evaluate_phases, + _as_cache, + _position_names, + _satellite_keys, summarize_phases, ) +from .simulation import _Simulation if TYPE_CHECKING: from .deployment import Deployment @@ -41,7 +42,8 @@ def evaluate_missions( histories: Sequence[MissionHistory], satellites: Sequence[Satellite], observations: pd.DataFrame, - metric: Callable[[pd.DataFrame], Mapping[str, float]] | PhaseCache, + metric: Callable[..., Mapping[str, float]] | PhaseCache, + *, context: Any = None, cost_model: Any = None, growth: Any = 1.0, @@ -53,8 +55,9 @@ def evaluate_missions( phases of the mission (` mission`, see `summarize_phases`), its measures (see `MissionHistory.metrics`), and its cost (see `CostEstimate.metrics`, with a cost model). The histories share the - observations of the replicate, so that a `PhaseCache` (as the metric) - evaluates each set of operating satellites once. + observations of the replicate, so that each set of operating satellites + is evaluated once (by a `PhaseCache` given as the metric, which keeps + them for other calls, or one of this call's own). Args: histories (Sequence[MissionHistory]): The histories. @@ -77,16 +80,13 @@ def evaluate_missions( """ rows = [] weighted = any(history.weight != 1.0 for history in histories) - keys = {s.name: get_satellite_key(s) for s in satellites} + keys = _satellite_keys(satellites) + cache = _as_cache(metric) for history in histories: - phases = history.phases(satellites) - if isinstance(metric, PhaseCache): - capability = metric.evaluate(phases, observations, keys, context, design) - else: - capability = evaluate_phases( - phases, observations, _given_design(metric, design) - ) - row = {**summarize_phases(capability), **history.metrics()} + phases = cache.evaluate( + history.phases(satellites), keys, observations, context, design + ) + row = {**summarize_phases(phases), **history.metrics()} if weighted: row["weight"] = history.weight if cost_model is not None: @@ -316,31 +316,17 @@ def _simulate_many( ] -def expected_metrics( +def _expected_metrics( deployment: Deployment, failures: FailureModel, - policy: RestorationPolicy | None = None, - histories: int = 1000, - seed: int = 0, - sampling: str = "stratified", + policy: RestorationPolicy | None, + seed: int, + histories: int, + sampling: str, ) -> dict[str, float]: """ - Estimates the expected measures of a mission (see - `MissionHistory.metrics`, such as its `availability`) from many - simulated histories, without evaluating their phases: precise and - cheap, as the expected values of control variates (see - `summarize_missions`). - - Args: - deployment (Deployment): The deployment. - failures (FailureModel): The failures. - policy (RestorationPolicy | None): The policy for failed satellites. - histories (int): The number of histories. - seed (int): The seed of the histories. - sampling (str): The sampling of their failures. - - Returns: - dict[str, float]: the mean of each measure + Estimates the expected measures of a mission from many simulated + histories (see `Deployment.expected_metrics`). """ rows = pd.DataFrame( [ @@ -528,12 +514,13 @@ def expected_missions( failures: FailureModel, satellites: Sequence[Satellite], observations: pd.DataFrame, - metric: Callable[[pd.DataFrame], Mapping[str, float]] | PhaseCache, + metric: Callable[..., Mapping[str, float]] | PhaseCache, + *, context: Any = None, + design: Any = None, tolerance: float = 1e-3, steps: int = 400, max_sets: int = 200_000, - design: Any = None, ) -> dict[str, float]: """ Computes the expected capability of a mission without restoration @@ -573,6 +560,8 @@ def expected_missions( set of satellites that gives its metrics, or a cache of one. context (Any): A hashable identifier of the observations, for a cache. + design (Design | None): The (realized) design of the mission, for a + metric with a parameter named `design` (see `PhaseCache`). tolerance (float): The share of the mission's time that the sets evaluated may leave out. steps (int): The times at which the probabilities are integrated. @@ -591,12 +580,7 @@ def expected_missions( "exact expectations need a deployment that is not staged: " + "simulate histories of a staged deployment instead" ) - names = [s.name for s in satellites] - built = sum(b for _, b, _ in deployment.planes) - if len(names) != built: - raise ValueError( - f"expected {built} satellites for the planes, not {len(names)}" - ) + names = list(_position_names(deployment.planes, satellites).values()) begin, end = deployment.begin, deployment.end times = begin + (np.arange(steps) + 0.5) * (end - begin) / steps count, groups = _launch_groups(deployment, failures, times) @@ -629,21 +613,15 @@ def expected_missions( if covered >= 1 - tolerance: break weights.sort(key=lambda item: -item[0]) - keys = {s.name: get_satellite_key(s) for s in satellites} + keys = _satellite_keys(satellites) + cache = _as_cache(metric) totals: dict[str, float] = {} evaluated, sets = 0.0, 0 for weight, members in weights: phase = Phase(begin, end, tuple(names[k] for k in members)) - if isinstance(metric, PhaseCache): - values = metric.evaluate([phase], observations, keys, context, design).iloc[ - 0 - ] - else: - values = evaluate_phases( - [phase], observations, _given_design(metric, design) - ).iloc[0] + values = cache.evaluate([phase], keys, observations, context, design).iloc[0] for name, value in values.items(): - if name in ("start", "end", "duration", "satellites"): + if name in PHASE_COLUMNS: continue totals[f"{name} mission"] = totals.get( f"{name} mission", 0.0 diff --git a/src/tatc/tradespace/mission.py b/src/tatc/tradespace/mission.py index f4049400..9c58e987 100644 --- a/src/tatc/tradespace/mission.py +++ b/src/tatc/tradespace/mission.py @@ -1,21 +1,20 @@ """ Simulated missions: the history of a deployment with failures and -restorations (see `Deployment.simulate`), the phases of a mission in which -constant sets of satellites operate, and their evaluation over the study's -representative period and combination over the mission. +restorations (see `Deployment.simulate`, whose simulation is in the module +`simulation`), the decisions of the rules of its stages, the phases of a +mission in which constant sets of satellites operate, and their evaluation +over the study's representative period and combination over the mission. @author: Paul T. Grogan """ from __future__ import annotations -import heapq -import itertools import math from collections.abc import Callable, Iterable, Mapping, Sequence -from dataclasses import dataclass, field, replace +from dataclasses import dataclass, field from functools import cached_property, partial -from typing import TYPE_CHECKING, Any +from typing import TYPE_CHECKING, Any, NamedTuple import numpy as np import pandas as pd @@ -23,8 +22,7 @@ from ..schemas import Satellite from .cache import get_satellite_key from .criteria import _OPERATORS, Requirement -from .events import Launch, Production, _per_type -from .failures import FailureModel, RestorationPolicy +from .events import Launch, Production from .study import _takes_design if TYPE_CHECKING: @@ -51,10 +49,82 @@ def duration(self) -> float: return self.end - self.start +PHASE_COLUMNS = ("start", "end", "duration", "satellites") +"""The columns of the evaluations of phases that are not metrics (see +`evaluate_phases`).""" + + def _names(satellites: Sequence[Satellite | str]) -> list[str]: return [s.name if isinstance(s, Satellite) else str(s) for s in satellites] +def _position_names( + planes: Sequence[tuple[Any, int, int]], satellites: Sequence[Satellite | str] +) -> dict[tuple[int, int], str]: + """ + Gets the name of the satellite at each position of each plane (by plane + and position) of satellites in the order of the planes, without spares + (see `MissionHistory.phases`), raising a `ValueError` if their numbers + differ. + """ + names = _names(satellites) + positions = [ + (plane, position) + for plane, (_, built, _) in enumerate(planes) + for position in range(built) + ] + if len(names) != len(positions): + raise ValueError( + f"expected {len(positions)} satellites for the planes, not {len(names)}" + ) + return dict(zip(positions, names)) + + +def _satellite_keys( + satellites: Sequence[Satellite | str] | Mapping[str, str], +) -> dict[str, str]: + """ + Gets the keys of satellites in a cache of their metrics (see + `PhaseCache`), by name: of their content (see `get_satellite_key`), or + their names, if given as names (or the keys given, by name). + """ + if isinstance(satellites, Mapping): + return dict(satellites) + return { + name: get_satellite_key(s) if isinstance(s, Satellite) else name + for name, s in zip(_names(satellites), satellites) + } + + +class Failure(NamedTuple): + """A failure of a satellite (see `MissionHistory.failures`).""" + + time: float + """float: The time of the failure (years from the start of development).""" + plane: int + """int: The plane (its index).""" + position: int + """int: The position in the plane.""" + cause: str + """str: `"life"`, or `"launch"` (lost in a launch).""" + + +class Restoration(NamedTuple): + """A restoration of a failed satellite (see `MissionHistory.restorations`).""" + + plane: int + """int: The plane (its index).""" + position: int + """int: The position in the plane.""" + failed: float + """float: The time of the failure (years from the start of development).""" + restored: float + """float: The time of the restoration.""" + source: str + """str: `"orbit"` (a spare in orbit), `"ground"` (a spare on the ground), + or `"production"` (a satellite produced when needed).""" + + @dataclass class MissionHistory: """ @@ -76,13 +146,13 @@ class MissionHistory: plane (by plane and position) operates.""" parked: list[tuple[float, float, int]] = field(default_factory=list) """list: The intervals in which spares wait in orbit, and their number.""" - failures: list[tuple[float, int, int, str]] = field(default_factory=list) - """list: The failures: their time, plane, position, and cause (`"life"` - or `"launch"`).""" - restorations: list[tuple[int, int, float, float, str]] = field(default_factory=list) - """list: The restorations: their plane, position, the time of the failure - and of the restoration, and the source (`"orbit"`, `"ground"`, or - `"production"`).""" + failures: list[Failure] = field(default_factory=list) + """list[Failure]: The failures: their time, plane, position, and cause + (`"life"` or `"launch"`).""" + restorations: list[Restoration] = field(default_factory=list) + """list[Restoration]: The restorations: their plane, position, the time + of the failure and of the restoration, and the source (`"orbit"`, + `"ground"`, or `"production"`).""" weight: float = 1.0 """float: The likelihood ratio of the history, drawn from stressed failures (see `Deployment.simulate_many`), or 1.""" @@ -153,16 +223,10 @@ def phases(self, satellites: Sequence[Satellite | str]) -> list[Phase]: Returns: list[Phase]: the phases, in order """ - names = _names(satellites) - expected = sum(built for _, built, _ in self.planes) - if len(names) != expected: - raise ValueError( - f"expected {expected} satellites for the planes, not {len(names)}" - ) - offsets = np.cumsum([0] + [built for _, built, _ in self.planes]) + named = _position_names(self.planes, satellites) + names = list(named.values()) intervals = { - names[offsets[plane] + position]: spans - for (plane, position), spans in self.operating.items() + named[position]: spans for position, spans in self.operating.items() } begin, end = self.begin, self.end events = {begin, end} @@ -194,22 +258,33 @@ def metrics(self) -> dict[str, float]: restorations (`restorations`), the spares used (`spares used`), the mean time from failure to restoration (`restoration years`, `NaN` without restorations), and the availability of the satellites - (`availability`: their years of operation, as a share of those of - the planned deployment). + (`availability`: their years of operation, as a share of those + possible from the launches that deployed them to the end of the + mission, whether these succeeded or not, and of the stages that this + history deployed). Returns: dict[str, float]: the metrics """ - planned = self.deployment.planned() operated = sum(b - a for spans in self.operating.values() for a, b in spans) - possible = sum(b - a for spans in planned.operating.values() for a, b in spans) - delays = [restored - failed for *_, failed, restored, _ in self.restorations] + built = [b for _, b, _ in self.planes] + possible = sum( + max(self.end - launch.time, 0.0) + * max( + min(launch.first + launch.satellites, built[launch.plane]) + - launch.first, + 0, + ) + for launch in self.launches + if launch.purpose == "deployment" + ) + delays = [r.restored - r.failed for r in self.restorations] metrics = { "failures": float(len(self.failures)), "launch failures": float(sum(launch.failed for launch in self.launches)), "restorations": float(len(self.restorations)), "spares used": float( - sum(source != "production" for *_, source in self.restorations) + sum(r.source != "production" for r in self.restorations) ), "restoration years": float(np.mean(delays)) if delays else math.nan, "availability": operated / possible if possible > 0 else math.nan, @@ -228,25 +303,34 @@ class Decision: deploy the stage (see `Stage`): the satellites operating and the history so far, and the capability of the satellites operating (see `capability`), such as for a stage deployed only if the satellites in - orbit fall short of a requirement. + orbit fall short of a requirement. Its time is from the start of + development, as every time of a mission (see `since_launch` for the + time after the first launch, as of the times of the stage). """ time: float - """float: The time of the decision, in years after the first launch.""" + """float: The time of the decision (years from the start of + development).""" stage: int """int: The stage (its index).""" - operating: int + satellites_operating: int """int: The number of satellites operating.""" history: MissionHistory """MissionHistory: The history of the mission so far: its production, launches, failures, restorations, and the periods of operation that have ended.""" - deployed: tuple[int, ...] - """tuple[int, ...]: The stages deployed so far.""" + stages_deployed: tuple[int, ...] + """tuple[int, ...]: The stages deployed so far (their indices).""" _measure: Callable[[], dict[str, float]] | None = field( default=None, repr=False, compare=False ) + @property + def since_launch(self) -> float: + """float: The time of the decision after the first launch (years), as + the times of stages are given (see `Stage`).""" + return self.time - self.history.begin + @cached_property def capability(self) -> dict[str, float]: """dict[str, float]: The metrics of the satellites operating at the @@ -271,448 +355,11 @@ def capability(self) -> dict[str, float]: return dict(self._measure()) -@dataclass -class _Booking: - """A launch of restorations or spares, open to more until it flies.""" - - time: float - plane: int - kind: Any - items: list = field(default_factory=list) - order: int = 0 - - -class _Simulation: - """ - A discrete-event simulation of a mission (see `Deployment.simulate`). - """ - - # pylint: disable=too-many-instance-attributes - - def __init__( - self, - deployment: Deployment, - failures: FailureModel, - policy: RestorationPolicy, - seed: int | Sequence[int] | None, - uniforms: Callable[[tuple, int], np.ndarray] | None = None, - stress: float = 1.0, - launch_stress: float = 1.0, - ): - self.deployment, self.failures, self.policy = deployment, failures, policy - self.seed, self.uniforms = seed, uniforms - self.stress, self.launch_stress = stress, launch_stress - self.log_weight = 0.0 - self.schedule = deployment.schedule - self.end = deployment.end - self.history = MissionHistory( - deployment, production=list(deployment.production) - ) - self.events: list = [] - self.counter = itertools.count() - # the state of each position: its generation, when it began to - # operate (or None), when it failed, and whether it awaits restoration - self.slots = { - (plane, position): { - "generation": -1, - "up": None, - "down": None, - "pending": False, - } - for plane, (_, built, _) in enumerate(deployment.planes) - for position in range(built) - } - self.spares = dict.fromkeys(range(len(deployment.planes)), 0) - self.spares_since: dict[int, float] = {} - self.ground: dict[Any, int] = {} - self.line = { - kind: max( - ( - b.end - for b in deployment.production - if b.kind == kind and b.purpose == "deployment" - ), - default=developed, - ) - for kind, developed in deployment.development.items() - } - self.booked = sorted(launch.time for launch in deployment.launches) - self.open: dict[int, list[_Booking]] = {} - self.launches_of_plane: dict[int, int] = {} - self.decided: dict[int, float] = {} - - # --- randomness - - def _rng(self, *key: int) -> np.random.Generator: - seed = list(self.seed) if isinstance(self.seed, Sequence) else [self.seed] - return np.random.default_rng([*seed, *key]) - - def _life( - self, plane: int, position: int, generation: int, start: float = 0.0 - ) -> float: - if self.seed is None: - return math.inf - life = self.failures.life_of(self.deployment.planes[plane][0]) - if life is None: - return math.inf - key = (0, plane, position, generation) - if self.stress != 1.0: - uniform = ( - self.uniforms(key, life.dimensions) - if self.uniforms is not None - else self._rng(*key).random(life.dimensions) - ) - value, log_ratio = life.stressed(uniform, self.stress, self.end - start) - self.log_weight += log_ratio - return value - if self.uniforms is not None: - return life.from_uniform(self.uniforms(key, life.dimensions)) - return life.sample(self._rng(*key)) - - def _launch_fails(self, *key: int) -> bool: - if self.seed is None or self.failures.launch == 0: - return False - uniform = ( - self.uniforms((1, *key), 1)[0] - if self.uniforms is not None - else self._rng(1, *key).random() - ) - p = self.failures.launch - if self.launch_stress == 1.0: - return bool(uniform < p) - stressed = min(p * self.launch_stress, 0.5) - failed = bool(uniform < stressed) - ratio = p / stressed if failed else (1 - p) / (1 - stressed) - self.log_weight += math.log(ratio) - return failed - - # --- events - - def _push(self, time: float, kind: str, *payload: Any) -> None: - heapq.heappush(self.events, (time, next(self.counter), kind, payload)) - - def run(self) -> MissionHistory: - """Runs the simulation, returning the history of the mission.""" - # pylint: disable=too-many-branches - for kind in self.deployment.development: - count = self.policy.ground_spares_of(kind) - if count > 0: - begin = self.line[kind] - ready = begin + self._producing(kind, count) - self.history.production.append( - Production(kind, begin, ready, count, "spare") - ) - self.line[kind] = ready - self.ground.setdefault(kind, 0) - self._push(ready, "stock", kind, count) - for launch in self.deployment.launches: - self._push(launch.time, "planned", launch) - for index, stage in enumerate(self.deployment.stages): - for time in stage.times: - self._push(self.deployment.begin + time, "decide", index) - steps = 0 - while self.events: - time, _, kind, payload = heapq.heappop(self.events) - if time >= self.end: - break - steps += 1 - if steps > 1_000_000: - raise RuntimeError("the simulation does not progress") - getattr(self, f"_on_{kind}")(time, *payload) - for (plane, position), slot in self.slots.items(): - if slot["up"] is not None: - self._close(plane, position, self.end) - for plane, since in self.spares_since.items(): - if self.spares[plane] > 0: - self.history.parked.append((since, self.end, self.spares[plane])) - self.history.weight = math.exp(self.log_weight) - self.history.stages = [ - self.decided.get(index) for index in range(len(self.deployment.stages)) - ] - self.history.production.sort(key=lambda batch: batch.begin) - self.history.launches.sort(key=lambda launch: (launch.time, launch.plane)) - return self.history - - def _on_stock(self, time: float, kind: Any, count: int) -> None: - del time - self.ground[kind] = self.ground.get(kind, 0) + count - - def _on_planned(self, time: float, launch: Launch) -> None: - failed = self._launch_fails(0, launch.plane, launch.first, launch.generation) - self.history.launches.append(replace(launch, failed=failed)) - built = self.deployment.planes[launch.plane][1] - positions = range(launch.first, launch.first + launch.satellites) - for position in positions: - if position >= built: - continue - slot = self.slots[launch.plane, position] - if launch.purpose == "deployment": - if failed: - self._fail(time, launch.plane, position, "launch") - else: - self._up(time, launch.plane, position) - elif not failed: - # a planned replacement takes the place of the satellite - if slot["up"] is not None: - self._close(launch.plane, position, time) - self._up(time, launch.plane, position) - spares = sum(position >= built for position in positions) - if spares and not failed: - level = self.deployment.planes[launch.plane][2] - if launch.purpose == "deployment": - self._park(time, launch.plane, spares) - else: - self._park( - time, - launch.plane, - max(0, min(spares, level - self.spares[launch.plane])), - ) - - def _on_decide(self, time: float, index: int) -> None: - if index in self.decided: - return # deployed at an earlier decision - stage = self.deployment.stages[index] - if stage.rule is not None: - operating = [ - position - for position, slot in self.slots.items() - if slot["up"] is not None - ] - capability = self.deployment.capability - decision = Decision( - time - self.deployment.begin, - index, - len(operating), - self.history, - tuple(sorted(self.decided)), - ( - None - if capability is None - else partial(capability.at, self.deployment.planes, operating) - ), - ) - if not stage.rule(decision): - return - self.decided[index] = time - self._deploy(time, stage) - - def _on_fail(self, time: float, plane: int, position: int, generation: int) -> None: - slot = self.slots[plane, position] - if slot["generation"] != generation or slot["up"] is None: - return # a satellite replaced before it failed - self._close(plane, position, time) - self._fail(time, plane, position, "life") - - def _fail(self, time: float, plane: int, position: int, cause: str) -> None: - slot = self.slots[plane, position] - slot["down"] = time - self.history.failures.append((time, plane, position, cause)) - if self.policy.restore and not slot["pending"]: - slot["pending"] = True - self._push(time + self.policy.detection_years, "request", plane, position) - - def _on_request(self, time: float, plane: int, position: int) -> None: - slot = self.slots[plane, position] - if slot["up"] is not None: # restored by a planned replacement - slot["pending"] = False - return - kind = self.deployment.planes[plane][0] - if self.spares[plane] > 0: - self._park(time, plane, -1) - self._push( - time + self.policy.drift_years, "activate", plane, position, "orbit" - ) - if self.policy.replenish: - ready = self._produce(time, kind, 1, "spare") - self._book(plane, kind, ready, ("spare",)) - elif self.ground.get(kind, 0) > 0: - self.ground[kind] -= 1 - self._book(plane, kind, time, ("slot", position, "ground")) - if self.policy.replenish: - ready = self._produce(time, kind, 1, "spare") - self._push(ready, "stock", kind, 1) - else: - ready = self._produce(time, kind, 1, "restoration") - self._book(plane, kind, ready, ("slot", position, "production")) - - def _on_activate(self, time: float, plane: int, position: int, source: str) -> None: - slot = self.slots[plane, position] - if slot["up"] is not None: - self._park(time, plane, 1) # not needed: back to waiting - return - self._restore(time, plane, position, source) - - def _on_booking(self, time: float, booking: _Booking) -> None: - self.open[booking.plane].remove(booking) - failed = self._launch_fails(1, booking.plane, booking.order) - spare = all(item[0] == "spare" for item in booking.items) - self.history.launches.append( - Launch( - time, - booking.plane, - booking.kind, - -1, - len(booking.items), - purpose="spare" if spare else "restoration", - failed=failed, - ) - ) - for item in booking.items: - if item[0] == "spare": - if not failed: - self._park(time, booking.plane, 1) - continue - _, position, source = item - slot = self.slots[booking.plane, position] - if failed: - slot["pending"] = False - self.history.failures.append((time, booking.plane, position, "launch")) - if self.policy.restore: - slot["pending"] = True - self._push( - time + max(self.policy.detection_years, 1e-6), - "request", - booking.plane, - position, - ) - elif slot["up"] is not None: - self._park(time, booking.plane, 1) # not needed: a spare in orbit - else: - self._restore(time, booking.plane, position, source) - - # --- actions - - def _up(self, time: float, plane: int, position: int) -> None: - slot = self.slots[plane, position] - slot["generation"] += 1 - slot["up"], slot["pending"] = time, False - life = self._life(plane, position, slot["generation"], time) - if time + life < self.end: - self._push(time + life, "fail", plane, position, slot["generation"]) - - def _close(self, plane: int, position: int, time: float) -> None: - slot = self.slots[plane, position] - if time > slot["up"]: - self.history.operating.setdefault((plane, position), []).append( - (slot["up"], time) - ) - slot["up"] = None - - def _restore(self, time: float, plane: int, position: int, source: str) -> None: - slot = self.slots[plane, position] - self.history.restorations.append((plane, position, slot["down"], time, source)) - self._up(time, plane, position) - - def _park(self, time: float, plane: int, change: int) -> None: - if change == 0: - return - if self.spares[plane] > 0: - since = self.spares_since[plane] - if time > since: - self.history.parked.append((since, time, self.spares[plane])) - self.spares[plane] += change - self.spares_since[plane] = time - - def _deploy(self, time: float, stage: Any) -> None: - """ - Deploys the planes of a stage: produced after its lead time (on their - type's line), launched at the next launch slots, and replaced at the - end of their design life. - """ - for plane in stage.planes: - kind, size, spares = self.deployment.planes[plane] - count = size + spares - if count == 0: - continue - begin = max(self.line[kind], time + stage.lead_years) - ready = begin + self._producing(kind, count) - self.line[kind] = ready - self.history.production.append(Production(kind, begin, ready, count)) - launches = self.schedule.launches_of( - count, - self.deployment.masses.get(kind), - self._plane(plane), - ) - position = 0 - for j in range(launches): - carried = count // launches + (1 if j < count % launches else 0) - at = self._slot(ready) - self.booked = sorted(self.booked + [at]) - self._push(at, "planned", Launch(at, plane, kind, position, carried)) - # pylint: disable-next=protected-access - for produced, need, generation in self.schedule._replacements( - kind, at, carried, self.end - ): - self.history.production.append( - Production(kind, produced, need, carried, "replacement") - ) - if need >= self.end - 1e-9: - continue # of a sustained constellation, after the end - replacement = Launch( - need, plane, kind, position, carried, generation, "replacement" - ) - self.booked = sorted(self.booked + [need]) - self._push(need, "planned", replacement) - position += carried - - def _producing(self, kind: Any, count: int) -> float: - rate = _per_type(self.schedule.production_rate, kind, "production rate") - return 0.0 if rate is None else count / rate - - def _produce(self, time: float, kind: Any, count: int, purpose: str) -> float: - begin = max(self.line[kind], time + self.policy.procurement_years) - ready = begin + self._producing(kind, count) - self.line[kind] = ready - self.history.production.append(Production(kind, begin, ready, count, purpose)) - return ready - - def _slot(self, ready: float) -> float: - """The earliest launch at or after a time, at the launch cadence.""" - interval = self.schedule.launch_interval - time = ready - if interval > 0: - for booked in self.booked: - if booked - interval < time < booked + interval: - time = booked + interval - return time - - def _plane(self, plane: int) -> tuple[int, Any]: - """The index and values of a plane (see `DeploymentSchedule`).""" - values = self.deployment.plane_values - return plane, values[plane] if plane < len(values) else None - - def _capacity(self, plane: int, kind: Any) -> float: - capacity = math.inf - if self.schedule.launch_capacity is not None: - capacity = self.schedule.launch_capacity - mass_capacity = self.schedule.mass_capacity_of(self._plane(plane)) - if mass_capacity is not None: - mass = self.deployment.masses.get(kind) - if mass is not None: - capacity = min(capacity, math.floor(mass_capacity / mass)) - return capacity - - def _book(self, plane: int, kind: Any, ready: float, item: tuple) -> None: - """Books an item on a launch of a plane: an open one, or a new one.""" - for booking in self.open.get(plane, []): - if booking.time >= ready and len(booking.items) < self._capacity( - plane, kind - ): - booking.items.append(item) - return - time = self._slot(ready + self.policy.batch_years) - order = self.launches_of_plane.get(plane, 0) - self.launches_of_plane[plane] = order + 1 - booking = _Booking(time, plane, kind, [item], order) - self.open.setdefault(plane, []).append(booking) - self.booked = sorted(self.booked + [time]) - self._push(time, "booking", booking) - - def evaluate_phases( phases: Sequence[Phase], observations: pd.DataFrame, - metric: Callable[[pd.DataFrame], Mapping[str, float]], + metric: Callable[..., Mapping[str, float]], + design: Any = None, ) -> pd.DataFrame: """ Evaluates the phases of a mission: a metric of the observations of the @@ -738,17 +385,21 @@ def evaluate_phases( observations (pandas.DataFrame): The observations of every satellite, with their names (`satellite`). metric (Callable): A function of the observations of a phase (which - may be empty) that gives its metrics. + may be empty) that gives its metrics (and of the design, if it + has a parameter named `design`, as the metrics of a study). + design (Design | None): The (realized) design of the mission, for a + metric with a parameter named `design`. Returns: pandas.DataFrame: a row per phase: its `start`, `end`, `duration`, number of `satellites`, and metrics """ - return _evaluate_phases(phases, observations, lambda subset, _: metric(subset())) + given = _given_design(metric, design) + return _evaluate_phases(phases, observations, lambda subset, _: given(subset())) def summarize_phases( - capability: pd.DataFrame, + phases: pd.DataFrame, metrics: Sequence[str] | None = None, requirements: Sequence[Requirement] = (), ) -> dict[str, float]: @@ -761,30 +412,27 @@ def summarize_phases( if none does). Args: - capability (pandas.DataFrame): The metrics of each phase. + phases (pandas.DataFrame): The metrics of each phase (see + `evaluate_phases`). metrics (Sequence[str] | None): The metrics, or `None` for every - column other than those of the phases. + column other than those of the phases (see `PHASE_COLUMNS`). requirements (Sequence[Requirement]): Requirements on metrics. Returns: dict[str, float]: the summary, as metrics of an evaluation """ if metrics is None: - metrics = [ - column - for column in capability.columns - if column not in ("start", "end", "duration", "satellites") - ] - weights = capability["duration"].to_numpy(dtype=float) + metrics = [column for column in phases.columns if column not in PHASE_COLUMNS] + weights = phases["duration"].to_numpy(dtype=float) summary = {} for name in metrics: - values = capability[name].to_numpy(dtype=float) + values = phases[name].to_numpy(dtype=float) summary[f"{name} mission"] = float(np.sum(values * weights) / np.sum(weights)) for requirement in requirements: met = _OPERATORS[requirement.operator]( - capability[requirement.name].to_numpy(dtype=float), requirement.value + phases[requirement.name].to_numpy(dtype=float), requirement.value ) - starts = capability["start"].to_numpy(dtype=float)[met] + starts = phases["start"].to_numpy(dtype=float)[met] summary[f"{requirement.name} time"] = ( float(starts[0]) if len(starts) > 0 else math.inf ) @@ -834,6 +482,11 @@ def _given_design(metric: Callable, design: Any) -> Callable: return partial(metric, design=design) if _takes_design(metric) else metric +def _as_cache(metric: Callable[..., Mapping[str, float]] | PhaseCache) -> PhaseCache: + """Gets a cache of a metric (see `PhaseCache`), or the cache given.""" + return metric if isinstance(metric, PhaseCache) else PhaseCache(metric) + + class PhaseCache: """ A cache of a metric of the phases of missions (see `evaluate_phases`), @@ -873,9 +526,9 @@ def __getstate__(self) -> dict: def evaluate( self, phases: Sequence[Phase], + satellites: Sequence[Satellite | str] | Mapping[str, str], observations: pd.DataFrame, - satellites: Sequence[Satellite] | Mapping[str, str], - context: Any, + context: Any = None, design: Any = None, ) -> pd.DataFrame: """ @@ -885,11 +538,12 @@ def evaluate( Args: phases (Sequence[Phase]): The phases. + satellites (Sequence[Satellite | str] | Mapping[str, str]): The + satellites, which key the cache by their content (or by + their names, if given as names, or by the keys given of their + names, see `get_satellite_key`). observations (pandas.DataFrame): The observations of every satellite, with their names (`satellite`). - satellites (Sequence[Satellite] | Mapping[str, str]): The - satellites, which key the cache by their content (or the keys - of their names, see `get_satellite_key`). context (Any): A hashable identifier of the observations (such as the seed of their targets and their period). design (Design | None): The (realized) design of the mission, @@ -899,12 +553,7 @@ def evaluate( pandas.DataFrame: a row per phase: its `start`, `end`, `duration`, number of `satellites`, and metrics """ - keys = ( - satellites - if isinstance(satellites, Mapping) - else {s.name: get_satellite_key(s) for s in satellites} - ) - + keys = _satellite_keys(satellites) metric = _given_design(self.metric, design) def cached(subset: Callable[[], pd.DataFrame], names: frozenset) -> dict: @@ -994,14 +643,12 @@ def __init__( @cached_property def _keys(self) -> dict[str, str]: """The keys of the satellites in a cache, by name.""" - return { - name: ( - get_satellite_key(satellite) - if isinstance(satellite, Satellite) - else name - ) - for name, satellite in zip(self._names, self.satellites) - } + return _satellite_keys(self.satellites) + + @cached_property + def _cache(self) -> PhaseCache: + """The cache of the metric (that given, or one of its own).""" + return _as_cache(self.metric) def __call__(self, names: Iterable[str]) -> dict[str, float]: """ @@ -1018,15 +665,10 @@ def __call__(self, names: Iterable[str]) -> dict[str, float]: if unknown: raise ValueError(f"satellites that are not given: {sorted(unknown)}") subset = partial(_subset, self.observations, names) - metric = ( - self.metric.metric if isinstance(self.metric, PhaseCache) else self.metric - ) - metric = _given_design(metric, self.design) - if isinstance(self.metric, PhaseCache): - key = (self.context, frozenset(self._keys[name] for name in names)) - # pylint: disable-next=protected-access - return dict(self.metric._metrics(key, subset, metric)) - return dict(metric(subset())) + metric = _given_design(self._cache.metric, self.design) + key = (self.context, frozenset(self._keys[name] for name in names)) + # pylint: disable-next=protected-access + return dict(self._cache._metrics(key, subset, metric)) def at( self, @@ -1046,12 +688,5 @@ def at( Returns: dict[str, float]: the metrics """ - offsets = np.cumsum([0] + [built for _, built, _ in planes]) - if len(self._names) != offsets[-1]: - raise ValueError( - f"expected {offsets[-1]} satellites for the planes, " - + f"not {len(self._names)}" - ) - return self( - self._names[offsets[plane] + position] for plane, position in positions - ) + named = _position_names(planes, self._names) + return self(named[plane, position] for plane, position in positions) diff --git a/src/tatc/tradespace/nodes.py b/src/tatc/tradespace/nodes.py index 38726c60..7664079d 100644 --- a/src/tatc/tradespace/nodes.py +++ b/src/tatc/tradespace/nodes.py @@ -7,15 +7,15 @@ from __future__ import annotations -import hashlib -import json import math +import numbers from collections.abc import Callable, Sequence from dataclasses import dataclass from typing import Any import numpy as np +from .hashing import _canonical, _digest from .values import Scope @@ -119,8 +119,7 @@ def suggest(self, trial: Any, name: str) -> Any: """ if self.kind == "categorical": if self.dynamic: - text = json.dumps(self.levels, sort_keys=True, default=str) - name = f"{name}#{hashlib.sha1(text.encode()).hexdigest()[:8]}" + name = f"{name}#{_digest(_canonical(self.levels), 8)}" return trial.suggest_categorical(name, self.levels) if self.kind == "integer": return trial.suggest_int( @@ -307,30 +306,65 @@ class Uncertain(Node): replicate of a design (see `Design.realize`), does not identify designs (see `Design.key`), and takes its nominal value until then. + The constructors of common distributions (`uniform`, `normal`, + `triangular`, `choice`, and `seed`) name their distributions in their + representations; their nominal values are `NaN` (or `None`), unless + given, so that what depends on them before a design is realized is + plainly unrealized. + Args: sampler (Callable): A function that draws a value from a `numpy.random.Generator`. nominal (Any): The value before a design is realized. + label (str | None): A description of the distribution, for the + representation (`None` for the sampler's). """ def __init__( - self, sampler: Callable[[np.random.Generator], Any], nominal: Any = math.nan + self, + sampler: Callable[[np.random.Generator], Any], + nominal: Any = math.nan, + label: str | None = None, ): - self.sampler, self.nominal = sampler, nominal + self.sampler, self.nominal, self.label = sampler, nominal, label @classmethod - def uniform(cls, low: float, high: float) -> Uncertain: + def uniform(cls, low: float, high: float, nominal: Any = math.nan) -> Uncertain: """ An uncertain parameter distributed uniformly on `[low, high)`. """ - return cls(lambda rng: float(rng.uniform(low, high))) + return cls( + lambda rng: float(rng.uniform(low, high)), + nominal, + f"uniform({low!r}, {high!r})", + ) @classmethod - def normal(cls, mean: float, std: float) -> Uncertain: + def normal(cls, mean: float, std: float, nominal: Any = math.nan) -> Uncertain: """ An uncertain parameter distributed normally. """ - return cls(lambda rng: float(rng.normal(mean, std))) + return cls( + lambda rng: float(rng.normal(mean, std)), + nominal, + f"normal({mean!r}, {std!r})", + ) + + @classmethod + def triangular( + cls, low: float, mode: float, high: float, nominal: Any = math.nan + ) -> Uncertain: + """ + An uncertain parameter with a triangular distribution from `low` to + `high`, most likely at `mode` (such as the growth of a cost). + """ + if not low <= mode <= high or low == high: + raise ValueError("a triangular distribution needs low <= mode <= high") + return cls( + lambda rng: float(rng.triangular(low, mode, high)), + nominal, + f"triangular({low!r}, {mode!r}, {high!r})", + ) @classmethod def seed(cls) -> Uncertain: @@ -341,19 +375,25 @@ def seed(cls) -> Uncertain: common random numbers, every design draws the same seed in the same replicate. """ - return cls(lambda rng: int(rng.integers(2**31)), None) + return cls(lambda rng: int(rng.integers(2**31)), None, "seed()") @classmethod - def choice(cls, options: Sequence, p: Sequence[float] | None = None) -> Uncertain: + def choice( + cls, options: Sequence, p: Sequence[float] | None = None, nominal: Any = None + ) -> Uncertain: """ An uncertain parameter that takes one of `options` (with probabilities `p`, or equally likely). """ options = list(options) - return cls(lambda rng: options[int(rng.choice(len(options), p=p))], None) + label = f"choice({options!r}" + ("" if p is None else f", p={list(p)!r}") + ")" + return cls( + lambda rng: options[int(rng.choice(len(options), p=p))], nominal, label + ) def __repr__(self) -> str: - return f"Uncertain({self.sampler!r})" + label = repr(self.sampler) if self.label is None else self.label + return f"Uncertain({label})" def _as_node(value: Any) -> Node: @@ -368,7 +408,9 @@ class Choice(Node): A choice of exactly one of several alternatives (branches), each a node (typically a `DesignSpace`). The nodes of the other branches are inactive. The value of a choice gives the name of the chosen branch as - `choice`, and the values of the branch as its attributes. + `choice` (and equals it), and the values of the branch as its attributes + (see `ChoiceValues`), so that its branches may not be named `choice` or + `value`. Args: **branches (Node): The alternatives, by name. @@ -377,6 +419,9 @@ class Choice(Node): def __init__(self, **branches: Any): if len(branches) == 0: raise ValueError("a choice requires at least one branch") + reserved = sorted({"choice", "value"}.intersection(branches)) + if reserved: + raise ValueError(f"reserved names of branches: {reserved}") self.branches = {name: _as_node(node) for name, node in branches.items()} def __repr__(self) -> str: @@ -397,15 +442,28 @@ class Repeat(Node): Args: item (Node): The repeated node. - count (int | Integer): The number of items, fixed or a design variable. + count (int | Integer | Categorical | Fixed | Derived): The number of + items: fixed (a number, or a `Fixed` one), a design variable of + integers (`Integer`, or `Categorical` of integers), or derived + from the values decided before (`Derived`, which a search that + encodes designs in a unit hypercube cannot encode). ordered (bool): `False` if designs that differ only in the order of their items are the same. """ - def __init__(self, item: Any, count: int | Integer, ordered: bool = True): + def __init__(self, item: Any, count: Any, ordered: bool = True): self.item = _as_node(item) - if isinstance(count, int) and count < 0: - raise ValueError("count must not be negative") + if isinstance(count, bool) or not isinstance( + count, (numbers.Integral, Integer, Categorical, Fixed, Derived) + ): + raise TypeError( + "the count of a repetition is a number, an Integer or Categorical " + + f"design variable, or a Fixed or Derived value, not {count!r}" + ) + if isinstance(count, numbers.Integral): + if count < 0: + raise ValueError("count must not be negative") + count = int(count) self.count, self.ordered = count, ordered def __repr__(self) -> str: diff --git a/src/tatc/tradespace/observations.py b/src/tatc/tradespace/observations.py index ae74a203..31e19061 100644 --- a/src/tatc/tradespace/observations.py +++ b/src/tatc/tradespace/observations.py @@ -20,28 +20,33 @@ from __future__ import annotations import dataclasses +import json import math import numbers import os +import warnings from collections.abc import Callable, Mapping, Sequence from datetime import datetime, timedelta from functools import partial +from pathlib import Path from typing import Any +import numpy as np import pandas as pd from ..analysis import collect_observations from ..schemas import Satellite from .cache import SatelliteCache from .constellations import count_planes -from .cost import CostModel +from .cost import CostEstimate, CostModel from .criteria import Requirement from .deployment import Deployment, DeploymentSchedule, Stage from .failures import FailureModel, RestorationPolicy from .histories import evaluate_missions, expected_missions, summarize_missions from .mission import Capability, PhaseCache, _given_design, summarize_phases from .space import Design, DesignSpace, _scenario_of -from .study import Study, _takes_design +from .store import _decode, _encode +from .study import Study, _Case, _takes_design from .values import configure _MAX_TARGETS = 32 @@ -55,9 +60,10 @@ def value_of(design: Design, reference: Reference | None) -> Any: """ Gets a value of a design that a reference names: a string names a value - (`d.`, or a path of `Design.flat`, such as `"layout.walker.planes"`, - or of a group of values, such as `"risk.cost_risk"`), - a function computes it from the design, and `None` is `None`. + by its name or path (`design[reference]`, see `Values`: such as + `"layout.walker.planes"`, the path of a column of results, see + `Design.flat`, or of a group of values, such as `"cost_risk"`), a + function computes it from the design, and `None` is `None`. Args: design (Design): The (realized) design. @@ -66,6 +72,9 @@ def value_of(design: Design, reference: Reference | None) -> Any: Returns: Any: the value + + Raises: + KeyError: if the design has no value of a name or path. """ if reference is None: return None @@ -73,22 +82,7 @@ def value_of(design: Design, reference: Reference | None) -> Any: return reference(design) if not isinstance(reference, str): raise TypeError(f"a reference to a value of a design, not {reference!r}") - if "." in reference or "[" in reference: - values = design.flat() - if reference in values: - return values[reference] - if "[" not in reference: - # a group of values (such as scores of `risk_space`), by its path - value: Any = design - try: - for name in reference.split("."): - value = value[name] - except (KeyError, TypeError, AttributeError): - pass - else: - return value - raise KeyError(f"no value {reference!r} of the design") - return getattr(design, reference) + return design[reference] @dataclasses.dataclass(frozen=True, eq=False, init=False) @@ -173,7 +167,12 @@ def of(self, design: Design | None = None) -> pd.DataFrame: """ if isinstance(self.source, pd.DataFrame): return self.source - seed = self.seed_of(design) + return self._of_seed(self.seed_of(design)) + + def _of_seed(self, seed: Any) -> pd.DataFrame: + """Gets the targets of a seed (generated, or kept in memory).""" + if isinstance(self.source, pd.DataFrame): + return self.source memory = self._memory if seed not in memory: if len(memory) >= _MAX_TARGETS: @@ -229,6 +228,10 @@ class Observations: disk, or `None` to cache in memory only. namespace (str): An identifier of what the fingerprint of the analysis cannot see. + + Results of the analysis with other code (such as of an earlier version of + TAT-C) are not reused, and a study warns of them (once, see + `SatelliteCache`); `prune` removes them. """ targets: Targets | pd.DataFrame @@ -318,26 +321,67 @@ def cache_of(self, design: Design | None = None) -> SatelliteCache: Returns: SatelliteCache: the cache """ - seed, start = self.targets.seed_of(design), self.start_of(design) + return self._cache(self.targets.seed_of(design), self.start_of(design)) + + def _namespace(self, seed: Any, start: datetime) -> str: + """Gets the namespace of the cache of the targets of a seed and a start.""" + context = ( + f"targets of seed {seed}, from {start.isoformat()} for {self.duration}" + ) + return f"{self.namespace}: {context}" if self.namespace else context + + def _cache(self, seed: Any, start: datetime) -> SatelliteCache: + """ + Gets the cache of the observations of the targets of a seed from a + start (see `cache_of`), with the seed and start in its namespace's + folder (`context.json`), from which `prune` finds it. + """ if (seed, start) not in self._caches: if len(self._caches) >= _MAX_TARGETS: self._caches.pop(next(iter(self._caches))) function = partial( _observe, self.analysis, - self.targets.of(design), + self.targets._of_seed(seed), # pylint: disable=protected-access start, start + self.duration, ) - context = ( - f"targets of seed {seed}, from {start.isoformat()} for {self.duration}" - ) - namespace = f"{self.namespace}: {context}" if self.namespace else context - self._caches[seed, start] = SatelliteCache( - function, self.directory, namespace + cache = SatelliteCache( + function, self.directory, self._namespace(seed, start) ) + if self.directory is not None: + context = cache.folder.parent / "context.json" + if not context.exists(): + context.write_text(json.dumps(_encode([seed, start]))) + self._caches[seed, start] = cache return self._caches[seed, start] + def prune(self) -> int: + """ + Removes the results on disk of the analysis with other code (or other + definitions, see `SatelliteCache.prune`) from the caches of every set + of targets (of each seed and start) of these observations in the + directory, such as after a study warns of them. + + Returns: + int: the number of results removed (0 without a directory) + """ + if self.directory is None or not Path(self.directory).is_dir(): + return 0 + removed = 0 + for folder in Path(self.directory).iterdir(): + try: + seed, start = _decode(json.loads((folder / "context.json").read_text())) + namespace = (folder / "namespace.txt").read_text(encoding="utf-8") + except (OSError, ValueError, TypeError): + continue + if namespace != self._namespace(seed, start): + continue # of other observations + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + removed += self._cache(seed, start).prune() + return removed + def __call__( self, satellites: Sequence[Satellite], design: Design | None = None ) -> pd.DataFrame: @@ -527,19 +571,32 @@ def _number(design: Design, value: Any) -> Any: class Failures: """ The failures of the satellites of each design: histories of its mission - (see `Deployment.simulate_many`), restored by a policy (or by the policy - of each design of a design space with a value `policy`, see - `policy_space`, which configures the policy, see `configure`, and the - spares in orbit), summarized over the histories (see - `summarize_missions`): the mean of each metric over the phases of the - mission and the histories, `quantiles` and `requirements` of them, and - their costs. Without restoration, the means of the metrics and the + (see `Deployment.simulate_many`), restored by a policy (by default by + producing new satellites; `RestorationPolicy(restore=False)` not to + restore them; or by the policy of each design of a design space with a + value `policy`, see `policy_space`, which configures the policy, see + `configure`, and the spares in orbit), summarized over the histories + (see `summarize_missions`): the mean of each metric over the phases of + the mission and the histories, `quantiles` and `requirements` of them, + and their costs. Without restoration, the means of the metrics and the availability are the exact expectations over the failures (see `expected_missions`) if `exact`. + With a `stress`, the failures are drawn from stressed distributions for + importance sampling (see `Deployment.simulate_many`), each history + weighted by its likelihood ratio. With `controls`, the means over the + histories are estimated with control variates (see + `summarize_missions`): measures of the missions (see + `MissionHistory.metrics`, such as `availability`) whose expected values + are estimated from `control_histories` other histories of the replicate, + simulated without evaluating their phases (see + `Deployment.expected_metrics`). With `spread`, the summaries add the + standard deviation of each column over the histories (` + histories std`), as `allocate_histories` needs of a pilot study. + Args: model (FailureModel): The failures. - policy (RestorationPolicy | None): The policy (`None` not to restore). + policy (RestorationPolicy): The policy. histories (int): The histories of each replicate. seed (Reference | None): The value of the design that seeds the failures (see `value_of`, such as of `Uncertain.seed`), or @@ -551,16 +608,40 @@ class Failures: requirements (Sequence[Requirement]): Requirements on the metrics of the histories (see `summarize_missions`). exact (bool): `True` for exact expectations without restoration. + stress (float): The factor of the hazards of stressed failures (1 + for none). + launch_stress (float | None): The factor of the probability that a + launch fails, or `None` for the stress. + controls (Sequence[str]): The measures of the missions that are + control variates, if any. + control_histories (int): The histories that estimate the expected + values of the controls. + spread (bool): `True` to add the standard deviations of the columns + over the histories. """ model: FailureModel - policy: RestorationPolicy | None = None + policy: RestorationPolicy = RestorationPolicy() histories: int = 1 seed: Reference | None = None sampling: str = "stratified" quantiles: Mapping[str, float | Sequence[float]] | None = None requirements: Sequence[Requirement] = () exact: bool = True + stress: float = 1.0 + launch_stress: float | None = None + controls: Sequence[str] = () + control_histories: int = 1000 + spread: bool = False + + def __post_init__(self): + if self.policy is None: # as `Deployment.simulate` takes it + object.__setattr__(self, "policy", RestorationPolicy()) + if isinstance(self.controls, str): + raise TypeError("controls are a sequence of names of measures") + object.__setattr__(self, "controls", tuple(self.controls)) + if self.histories < 1 or self.control_histories < 1: + raise ValueError("histories and control_histories must be at least 1") @dataclasses.dataclass(frozen=True) @@ -572,7 +653,7 @@ class _Mission: """ deployment: Deployment - policy: RestorationPolicy | None + policy: RestorationPolicy cost_model: CostModel | None growth: Any context: Any @@ -614,14 +695,14 @@ def __call__(self, satellites: Sequence[Satellite], design: Design) -> dict: record.update(self._phases(mission, satellites, observations, design)) return record - def _policy(self, design: Design) -> tuple[RestorationPolicy | None, Any]: + def _policy(self, design: Design) -> tuple[RestorationPolicy, Any]: """The policy of a design, and its spares in orbit in each plane.""" - base = None if self.failures is None else self.failures.policy + base = RestorationPolicy() if self.failures is None else self.failures.policy spares = _number(design, self.plan.spares) decided = design.values.get("policy") if decided is None: return base, spares - return configure(base or RestorationPolicy(), decided), decided.orbit_spares + return configure(base, decided), decided.orbit_spares def _mission( self, @@ -679,14 +760,24 @@ def _phases( design: Design, ) -> dict[str, float]: """Summarizes the metrics of the phases of a planned mission.""" - capability = self._phase_cache.evaluate( + phases = self._evaluate_phases(mission, satellites, observations, design) + return summarize_phases(phases, requirements=self.phases) + + def _evaluate_phases( + self, + mission: _Mission, + satellites: Sequence[Satellite], + observations: pd.DataFrame, + design: Design, + ) -> pd.DataFrame: + """Evaluates the phases of a planned mission (see `evaluate_phases`).""" + return self._phase_cache.evaluate( mission.deployment.phases(satellites), - observations, satellites, + observations, mission.context, design, ) - return summarize_phases(capability, requirements=self.phases) def _histories( self, @@ -701,12 +792,15 @@ def _histories( staged, if the failures are exact). """ failures = self.failures + seed = value_of(design, failures.seed) histories = mission.deployment.simulate_many( failures.model, mission.policy, - value_of(design, failures.seed), + seed, failures.histories, sampling=failures.sampling, + stress=failures.stress, + launch_stress=failures.launch_stress, ) missions = evaluate_missions( histories, @@ -718,12 +812,33 @@ def _histories( growth=mission.growth, design=design, ) + controls = None + if failures.controls and seed is not None: + # other histories of the replicate (by a seed of its seed) + other = int(np.random.default_rng([int(seed), 7]).integers(2**31)) + expected = mission.deployment.expected_metrics( + failures.model, + mission.policy, + other, + failures.control_histories, + sampling=failures.sampling, + ) + unknown = sorted(set(failures.controls) - set(expected)) + if unknown: + raise ValueError( + f"controls that are not measures of missions: {unknown} " + + f"(they are {sorted(expected)})" + ) + controls = {name: expected[name] for name in failures.controls} record = summarize_missions( - missions, quantiles=failures.quantiles, requirements=failures.requirements + missions, + quantiles=failures.quantiles, + requirements=failures.requirements, + controls=controls, + spread=failures.spread, ) if ( failures.exact - and mission.policy is not None and not mission.policy.restore and not mission.deployment.stages ): @@ -870,46 +985,159 @@ def _arguments(self) -> dict[str, Any]: **self._settings(), } - def satellites_of(self, design: Design, replicate: int = 0) -> list[Satellite]: + def _prepare( + self, + design: Design, + replicate: int, + shift: Mapping[str, int] | None, + case: _Case, + ) -> None: + # the cache of the observations of the first evaluation, in this + # process, so that it warns of results of other code here (once, see + # `SatelliteCache`), rather than in a worker process + realized = design.realize( + replicate, self.seed, self.common_random_numbers, shift, case.values + ) + self.observations.cache_of(realized) + + def satellites_of( + self, design: Design, replicate: int = 0, scenario: str | None = None + ) -> list[Satellite]: """ - Gets the satellites of a replicate of a design. + Gets the satellites of a replicate of a design (see `Study.realize`). Args: design (Design): The design. replicate (int): The replicate. + scenario (str | None): A scenario of the study (by name), if any. Returns: list[Satellite]: the satellites """ - return list(self.build(self._realize(design, replicate))) + return list(self.build(self.realize(design, replicate, scenario))) - def targets_of(self, design: Design, replicate: int = 0) -> pd.DataFrame: + def targets_of( + self, design: Design, replicate: int = 0, scenario: str | None = None + ) -> pd.DataFrame: """ - Gets the targets of a replicate of a design. + Gets the targets of a replicate of a design (see `Study.realize`). Args: design (Design): The design. replicate (int): The replicate. + scenario (str | None): A scenario of the study (by name), if any. Returns: pandas.DataFrame: the targets """ - return self.observations.targets.of(self._realize(design, replicate)) + return self.observations.targets.of(self.realize(design, replicate, scenario)) - def observations_of(self, design: Design, replicate: int = 0) -> pd.DataFrame: + def observations_of( + self, design: Design, replicate: int = 0, scenario: str | None = None + ) -> pd.DataFrame: """ - Gets the observations of a replicate of a design (such as for analyses - other than its metrics). + Gets the observations of a replicate of a design (see `Study.realize`), + such as for analyses other than its metrics. Args: design (Design): The design. replicate (int): The replicate. + scenario (str | None): A scenario of the study (by name), if any. Returns: pandas.DataFrame: the observations """ - realized = self._realize(design, replicate) + realized = self.realize(design, replicate, scenario) return self.observations(self.build(realized), realized) - def _realize(self, design: Design, replicate: int) -> Design: - return design.realize(replicate, self.seed, self.common_random_numbers) + def deployment_of( + self, design: Design, replicate: int = 0, scenario: str | None = None + ) -> Deployment: + """ + Gets the planned deployment of a replicate of a design, as its + evaluation plans it (see `MissionPlan`): with the plan's schedule, + kind, spares, masses, and stages, and the capability of its + satellites, which the rules of stages read (see `Deployment.capability`). + + Args: + design (Design): The design. + replicate (int): The replicate. + scenario (str | None): A scenario of the study (by name), if any. + + Returns: + Deployment: the deployment + + Raises: + ValueError: if the study has no mission plan. + """ + return self._mission_of(design, replicate, scenario)[3].deployment + + def phases_of( + self, design: Design, replicate: int = 0, scenario: str | None = None + ) -> pd.DataFrame: + """ + Gets the metrics of the phases of the planned deployment of a + replicate of a design (see `deployment_of` and `evaluate_phases`), + as its evaluation summarizes them (see `summarize_phases`). + + Args: + design (Design): The design. + replicate (int): The replicate. + scenario (str | None): A scenario of the study (by name), if any. + + Returns: + pandas.DataFrame: a row per phase: its `start`, `end`, + `duration`, number of `satellites`, and metrics + + Raises: + ValueError: if the study has no mission plan. + """ + realized, satellites, observations, mission = self._mission_of( + design, replicate, scenario + ) + # pylint: disable-next=protected-access + return self.evaluate._evaluate_phases( + mission, satellites, observations, realized + ) + + def estimate_of( + self, design: Design, replicate: int = 0, scenario: str | None = None + ) -> CostEstimate: + """ + Gets the cost estimate of the planned deployment of a replicate of a + design (see `deployment_of` and `CostModel.estimate`), with its + growth, as its evaluation estimates it. + + Args: + design (Design): The design. + replicate (int): The replicate. + scenario (str | None): A scenario of the study (by name), if any. + + Returns: + CostEstimate: the estimate + + Raises: + ValueError: if the study's plan has no cost model. + """ + mission = self._mission_of(design, replicate, scenario)[3] + if mission.cost_model is None: + raise ValueError("the study's mission plan has no cost model") + return mission.cost_model.estimate(mission.deployment, mission.growth) + + def _mission_of( + self, design: Design, replicate: int, scenario: str | None + ) -> tuple[Design, list[Satellite], pd.DataFrame, _Mission]: + """ + Plans the mission of a replicate of a design, as its evaluation does: + the realized design, its satellites, their observations, and the + mission. + """ + if self.plan is None: + raise ValueError("the study has no mission plan") + realized = self.realize(design, replicate, scenario) + satellites = list(self.build(realized)) + observations = self.observations(satellites, realized) + layout = value_of(realized, self.layout) + # pylint: disable-next=protected-access + mission = self.evaluate._mission(satellites, observations, realized, layout) + return realized, satellites, observations, mission diff --git a/src/tatc/tradespace/optimization.py b/src/tatc/tradespace/optimization.py index 5a860029..3f9cfd12 100644 --- a/src/tatc/tradespace/optimization.py +++ b/src/tatc/tradespace/optimization.py @@ -11,7 +11,8 @@ meeting a threshold. Requirements on statistics (see `Requirement`) are output constraints, whose violations the optimizers minimize along with those of the constraints of the design space. The tolerances of the -criteria do not apply to searches. +criteria do not apply to the optimizers' own ranking of designs, but they +do to the front of the designs they evaluate (see `Search`). A search of a study with several scenarios (see `Study`) evaluates each design in every scenario, and judges it by criteria `across` the scenarios @@ -48,7 +49,6 @@ _Statistics, aggregate, ) -from .pareto import pareto_front from .space import Design, Infeasible from .study import Study @@ -69,15 +69,17 @@ class Search: results: pd.DataFrame """pandas.DataFrame: The results of every evaluation (see `Study.run`).""" - designs: list[Design] + summary: pd.DataFrame = field(default_factory=pd.DataFrame) + """pandas.DataFrame: A row per design that the search found feasible + (feasible in every replicate, as the optimizers judge designs): the + summary of the criteria over its replicates (see `aggregate`), with + whether it is efficient among these designs (`pareto`, with the + tolerances of the criteria).""" + designs: list[Design] = field(default_factory=list) """list[Design]: The designs evaluated, in the order of their evaluation.""" - state: Any + state: Any = None """Any: The optimizer's own outcome: the Optuna study (`optuna.Study`) or the result of pymoo (`pymoo.core.result.Result`).""" - summary: pd.DataFrame = field(default_factory=pd.DataFrame) - """pandas.DataFrame: A row per feasible design: the statistics of the - criteria over its replicates (see `aggregate`), and whether it is - efficient by them (`pareto`, see `pareto_front`).""" class Evaluations: @@ -203,12 +205,17 @@ def search(self, state: Any) -> Search: """ results = self.results summary = pd.DataFrame() - if len(results) > 0 and results["feasible"].any(): - summary = aggregate(results, self.criteria) - summary = summary.dropna(subset=list(self.criteria.objectives)) - summary = summary.reset_index(drop=True) - summary["pareto"] = pareto_front(summary, self.criteria).to_numpy() - return Search(results, list(self.designs.values()), state, summary) + feasible = [key for key, value in self.values.items() if value is not None] + if feasible: + summary = aggregate( + results[results["design"].isin(feasible)], self.criteria + ) + return Search( + results=results, + summary=summary, + designs=list(self.designs.values()), + state=state, + ) def worst(self) -> list[float]: """ @@ -236,6 +243,7 @@ def optimize_optuna( study: Study, criteria: Criteria | Mapping[str, str], n_trials: int, + *, sampler: Any = None, optuna_study: Any = None, batch_size: int | None = None, @@ -513,7 +521,8 @@ def optimize_pymoo( criteria: Criteria | Mapping[str, str], algorithm: Any = None, termination: Any = ("n_gen", 10), - seed: int | None = None, + *, + seed: int | None = 0, distinct: bool = True, **kwargs: Any, ) -> Search: @@ -533,7 +542,8 @@ def optimize_pymoo( algorithm (pymoo.core.algorithm.Algorithm | None): The algorithm, or `None` for NSGA-II with populations of 20. termination (Any): The termination criterion of `pymoo.optimize.minimize`. - seed (int | None): The seed of the algorithm. + seed (int | None): The seed of the algorithm (`None` for one drawn + anew, as pymoo does). distinct (bool): `True` to eliminate the proposals of designs proposed or evaluated before, `False` for the algorithm's own elimination of duplicates (of equal points). diff --git a/src/tatc/tradespace/pareto.py b/src/tatc/tradespace/pareto.py index 57f912e8..90b4bc13 100644 --- a/src/tatc/tradespace/pareto.py +++ b/src/tatc/tradespace/pareto.py @@ -8,7 +8,9 @@ to minimize or maximize, requirements that efficient designs meet, the tolerances of the objectives, and the groups in which designs are judged separately. A mapping of objectives to their directions (`"min"` or -`"max"`) is the criteria of these objectives alone. +`"max"`) is the criteria of these objectives alone. A design with a missing +objective (`NaN`, such as a statistic of a metric that none of its feasible +replicates gives) is not efficient, and dominates no other. @author: Paul T. Grogan """ @@ -23,25 +25,26 @@ from .criteria import ( Criteria, Requirement, - _across_groups, _as_criteria, + _bootstrap_error, _check_summary, _combiners, + _costs_of, _get_tolerances, _groups, + _resamples, _resolve, _signs, - _Statistics, - _value_columns, - _with_values, + _summary_groups, aggregate, ) +from .dominance import _dominated, _efficient def _get_costs(frame: pd.DataFrame, objectives: Mapping[str, str]) -> np.ndarray: """ Gets the objectives of a data frame as costs (to minimize): maximized - objectives are negated. + objectives are negated (missing values are `NaN`). """ missing = [column for column in objectives if column not in frame.columns] if missing: @@ -50,10 +53,7 @@ def _get_costs(frame: pd.DataFrame, objectives: Mapping[str, str]) -> np.ndarray for column, direction in objectives.items(): values = frame[column].to_numpy(dtype=float) columns.append(values if direction == "min" else -values) - costs = np.column_stack(columns) if len(frame) > 0 else np.empty((0, len(columns))) - if np.isnan(costs).any(): - raise ValueError("objectives must not be NaN") - return costs + return np.column_stack(columns) if len(frame) > 0 else np.empty((0, len(columns))) def _get_violation( @@ -77,87 +77,6 @@ def _get_violation( return np.where(np.isnan(violation), np.inf, violation) -_BLOCK_ELEMENTS = 2_000_000 -"""The most elements of the temporary arrays of a block of comparisons.""" - -_CHUNK = 64 -"""The points of each chunk of a sweep (see `_dominated_plain`).""" - - -def _dominated_by( - points: np.ndarray, others: np.ndarray, tolerances: np.ndarray | None = None -) -> np.ndarray: - """ - Finds the points dominated by any of others, even if the other is - penalized by the tolerances (see `_dominated`), comparing them in blocks - whose temporary arrays are limited to a few million elements. - """ - dominated = np.zeros(len(points), dtype=bool) - if len(points) == 0 or len(others) == 0: - return dominated - if tolerances is None: - tolerances = np.zeros((2, points.shape[1])) - absolute, relative = tolerances - penalties = np.any(tolerances) - block = max(1, _BLOCK_ELEMENTS // max(len(others) * points.shape[1], 1)) - for start in range(0, len(points), block): - part = points[start : start + block] - # [i, j]: other j dominates point i of the block - penalized = others[None, :, :] - if penalties: - penalized = penalized + absolute + relative * np.abs(part[:, None, :]) - no_worse = np.all(penalized <= part[:, None, :], axis=2) - better = np.any(penalized < part[:, None, :], axis=2) - dominated[start : start + block] = np.any(no_worse & better, axis=1) - return dominated - - -def _dominated_plain(costs: np.ndarray) -> np.ndarray: - """ - Finds the points dominated by another (without tolerances) by a sweep in - lexicographic order, in which a point can only be dominated by points - before it, and is dominated by one if it is by any of the efficient - points before it (dominance is transitive). The sweep compares each - chunk of points with the efficient points before it, then those it does - not dominate with each other. - """ - n = len(costs) - order = np.lexsort(costs.T[::-1]) - ordered = costs[order] - dominated = np.zeros(n, dtype=bool) - efficient = np.empty((0, costs.shape[1])) - for start in range(0, n, _CHUNK): - part = ordered[start : start + _CHUNK] - beaten = _dominated_by(part, efficient) - # a point that an earlier efficient point dominates dominates nothing - # that it does not: compare only the others with each other - survivors = part[~beaten] - beaten[~beaten] = _dominated_by(survivors, survivors) - dominated[order[start : start + _CHUNK]] = beaten - efficient = np.vstack([efficient, part[~beaten]]) - return dominated - - -def _dominated(costs: np.ndarray, tolerances: np.ndarray | None = None) -> np.ndarray: - """ - Finds the points (rows of costs) dominated by another, even if the other - is penalized by the tolerances: no worse in every cost, and better in at - least one, by at least its tolerance (absolute, plus a share of the - magnitude of the cost of the point it would dominate, see - `_get_tolerances`). - - A point that is dominated with tolerances is also dominated by a point - that is efficient without them: the penalty depends only on the point - dominated, so any point no worse than its dominator in every cost (as - some efficient point is) dominates it too. Points are therefore compared - only with the efficient points (see `_dominated_plain`), which are few. - """ - plain = _dominated_plain(costs) - if tolerances is None or not np.any(tolerances): - return plain - return _dominated_by(costs, costs[~plain], tolerances) - - def pareto_front( summary: pd.DataFrame, criteria: Criteria | Mapping[str, str] ) -> pd.Series: @@ -168,7 +87,9 @@ def pareto_front( the requirements of the criteria (by the columns of their statistics) and that no other row that meets them dominates, being no worse in every objective and better in at least one, in each group of the criteria's - `by`. Rows with the same objectives are all efficient if any is. + `by`. Rows with the same objectives are all efficient if any is, and a + row with a missing objective (`NaN`) is not. Summaries of criteria give + whether each design is efficient already (`pareto`, see `aggregate`). With a tolerance of an objective (see `Criteria`), a row dominates another only if it would still dominate it if it were worse by the @@ -200,9 +121,8 @@ def pareto_front( for _, positions in _groups(summary, criteria.by): group = summary.iloc[positions] meets = _get_violation(group, criteria.requirements) == 0 - if meets.any(): - costs = _get_costs(group[meets], criteria.objectives) - efficient[positions[meets]] = ~_dominated(costs, tolerances) + costs = _get_costs(group, criteria.objectives) + efficient[positions] = _efficient(costs, meets, tolerances) return pd.Series(efficient, index=summary.index, name="pareto") @@ -216,7 +136,8 @@ def pareto_ranks( rank 1 the front of the others, and so on, with the tolerances of the criteria. Rows that miss the requirements of the criteria are ranked after those that meet them, in order of their violation (the sum of the - violations of the requirements, see `Requirement`). + violations of the requirements, see `Requirement`), and rows with a + missing objective (`NaN`) that meet them last. Args: summary (pandas.DataFrame): The rows (such as designs). @@ -237,18 +158,23 @@ def pareto_ranks( for _, positions in _groups(summary, criteria.by): group = summary.iloc[positions] violation = _get_violation(group, criteria.requirements) - meets = violation == 0 - costs = _get_costs(group[meets], criteria.objectives) - remaining = positions[meets] + costs = _get_costs(group, criteria.objectives) + known = ~np.isnan(costs).any(axis=1) + meets = (violation == 0) & known + remaining, costs = positions[meets], costs[meets] rank = 0 while len(remaining) > 0: front = ~_dominated(costs, tolerances) ranks[remaining[front]] = rank remaining, costs = remaining[~front], costs[~front] rank += 1 - if (~meets).any(): - order = pd.Series(violation[~meets]).rank(method="dense").to_numpy() - ranks[positions[~meets]] = rank + order.astype(int) - 1 + missing = violation != 0 + if missing.any(): + order = pd.Series(violation[missing]).rank(method="dense").to_numpy() + ranks[positions[missing]] = rank + order.astype(int) - 1 + rank = int(ranks[positions[missing]].max()) + 1 + unknown = (violation == 0) & ~known + ranks[positions[unknown]] = rank return pd.Series(ranks, index=summary.index, name="pareto_rank") @@ -289,9 +215,9 @@ def hypervolume( design, see `pareto_front`): the volume of the objective space that they dominate, up to a reference point that is worse than every row of interest in every objective. Rows that are not - better than the reference in every objective, or that miss the - requirements of the criteria, add nothing (the tolerances of the - criteria do not apply). A larger hypervolume is a better set of designs, + better than the reference in every objective, that miss the requirements + of the criteria, or that have a missing objective add nothing (the + tolerances of the criteria do not apply). A larger hypervolume is a better set of designs, which makes it a measure of the progress of a search, or of how close a search comes to the true Pareto front. @@ -338,6 +264,7 @@ def hypervolume_progress( results: pd.DataFrame, criteria: Criteria | Mapping[str, str], reference: Mapping[str, float] | Sequence[float], + *, step: int = 10, ) -> pd.Series: """ @@ -381,6 +308,7 @@ def hypervolume_progress( def pareto_probability( results: pd.DataFrame, criteria: Criteria | Mapping[str, str], + *, n_resamples: int = 500, seed: int = 0, design_columns: Sequence[str] | None = None, @@ -416,62 +344,46 @@ def pareto_probability( criteria (Criteria | Mapping[str, str]): The criteria, or the objectives (metrics whose means they are) and their directions (`"min"` or `"max"`). - n_resamples (int): The number of resamples. + n_resamples (int): The number of resamples (at least 2). seed (int): The seed of the resamples. design_columns (Sequence[str] | None): The columns of the values of designs, or `None` for those that are the same in every replicate of a design (see `aggregate`). Returns: - pandas.DataFrame: a row per design (and group): the values of the - design (see `aggregate`), the statistics of - the criteria over every replicate, the standard error of each - objective (` se`, its standard deviation over the - resamples), the number of `replicates`, - whether the design meets the requirements (`meets_requirements`) - and is efficient among those that do (`pareto`) by these - statistics, the probability that it is efficient - (`pareto_probability`), and the probability that it meets the - requirements (`requirements_probability`) + pandas.DataFrame: a row per design (and group): the summary of the + criteria over every replicate (see `aggregate`: the values of the + design, the statistics, the number of `replicates`, the + `violation` of the requirements, whether the design meets them, + `meets_requirements`, and whether it is efficient among those + that do, `pareto`), the standard error of each objective + (` se`, its standard deviation over the resamples), + the probability that it is efficient (`pareto_probability`), and + the probability that it meets the requirements + (`requirements_probability`) """ criteria = _as_criteria(criteria) resolved = _resolve(criteria) - requirements = criteria.requirements - signs = _signs(criteria) tolerances = _get_tolerances(criteria.objectives, criteria.tolerance) - feasible = results[results["feasible"]] if "feasible" in results else results combiners = None if criteria.across is None else _combiners(criteria) - groups = _across_groups(results, criteria.across) - columns = _value_columns( - feasible, resolved, criteria.by, criteria.across, design_columns - ) rng = np.random.default_rng(seed) frames = [] - for key, positions in _groups(feasible, criteria.by): - group = feasible.iloc[positions] - table = _Statistics( - group, resolved, requirements, criteria.across, combiners, groups - ) - designs, replicates = table.designs, table.replicates + for frame, table in _summary_groups( + results, + resolved, + criteria.by, + criteria.requirements, + criteria.across, + combiners, + design_columns, + ): values, violation = table.evaluate() - - def front(values, violation): - costs = np.column_stack( - [s * values[name] for s, name in zip(signs, criteria.objectives)] - ) - ok = (violation == 0) & ~np.isnan(costs).any(axis=1) - efficient = np.zeros(len(costs), dtype=bool) - efficient[ok] = ~_dominated(costs[ok], tolerances) - return efficient, ok - - efficient, meets = front(values, violation) - counts = np.zeros(len(designs)) - met = np.zeros(len(designs)) + counts = np.zeros(len(table.designs)) + met = np.zeros(len(table.designs)) # the sums of the objectives (and of their squares) over the resamples - sums = {name: np.zeros(len(designs)) for name in criteria.objectives} - squares = {name: np.zeros(len(designs)) for name in criteria.objectives} - for _ in range(n_resamples): - drawn = rng.integers(0, len(replicates), len(replicates)) + sums = {name: np.zeros(len(table.designs)) for name in criteria.objectives} + squares = {name: np.zeros(len(table.designs)) for name in criteria.objectives} + for drawn in _resamples(len(table.replicates), n_resamples, rng): sample, sample_violation = table.evaluate(drawn) # designs without a drawn replicate keep the statistics of all of theirs for name in sample: @@ -479,25 +391,23 @@ def front(values, violation): sample[name][missing] = values[name][missing] missing = np.isnan(sample_violation) sample_violation[missing] = violation[missing] - sample_front, sample_meets = front(sample, sample_violation) - counts += sample_front - met += sample_meets + meets = sample_violation == 0 + counts += _efficient(_costs_of(sample, criteria), meets, tolerances) + met += meets for name in criteria.objectives: sums[name] += sample[name] squares[name] += sample[name] ** 2 - frame = pd.DataFrame({"design": designs}) - for name, value in zip(criteria.by, key): - frame[name] = value - _with_values(frame, group, designs, columns) for name, value in values.items(): frame[name] = value for name in criteria.objectives: - mean = sums[name] / n_resamples - variance = np.maximum(squares[name] / n_resamples - mean**2, 0.0) - frame[f"{name} se"] = np.sqrt(variance) + frame[f"{name} se"] = _bootstrap_error( + sums[name], squares[name], n_resamples + ) + meets = violation == 0 frame["replicates"] = table.counts + frame["violation"] = violation frame["meets_requirements"] = meets - frame["pareto"] = efficient + frame["pareto"] = _efficient(_costs_of(values, criteria), meets, tolerances) frame["pareto_probability"] = counts / n_resamples frame["requirements_probability"] = met / n_resamples frames.append(frame) diff --git a/src/tatc/tradespace/plotting.py b/src/tatc/tradespace/plotting.py index 4fe66360..bf284850 100644 --- a/src/tatc/tradespace/plotting.py +++ b/src/tatc/tradespace/plotting.py @@ -83,10 +83,22 @@ def style_axes(ax: Any, grid: str | None = "y") -> Any: def _color(colors: Sequence[str] | Mapping[Any, str], value: Any, k: int) -> str: if isinstance(colors, Mapping): + if value is None and None not in colors: + return next(iter(colors.values())) # of rows without groups return colors[value] return colors[k % len(colors)] +def _mask(frame: pd.DataFrame, rows: str | Sequence[bool], name: str) -> np.ndarray: + """Gets the rows of a frame that a boolean column (or values) selects.""" + if isinstance(rows, str): + return frame[rows].to_numpy(dtype=bool) + mask = np.asarray(rows, dtype=bool) + if mask.shape != (len(frame),): + raise ValueError(f"{name} needs a value for each row ({len(frame)})") + return mask + + def _name(names: Mapping[Any, str] | Callable[[Any], str] | None, value: Any) -> str: if names is None: return str(value) @@ -108,10 +120,15 @@ def plot_designs( frame: pd.DataFrame, x: str, y: str, + *, by: str | None = None, - front: str | Criteria | Mapping[str, str] | None = None, + front: str | Sequence[bool] | Criteria | Mapping[str, str] | None = None, labels: str | Callable[[pd.Series], str] | None = None, names: Mapping[Any, str] | Callable[[Any], str] | None = None, + highlight: str | Sequence[bool] | None = None, + label: str | None = None, + others: str | None = None, + front_label: str = "Pareto-efficient", jitter: float = 0.0, colors: Sequence[str] | Mapping[Any, str] = COLORS, legend: str | None = "best", @@ -121,19 +138,36 @@ def plot_designs( """ Plots designs (such as a summary of a study, see `aggregate`) by two metrics: a point per row, colored by the value of a column `by` (if - any), with the efficient designs (`front`) ringed and labeled. + any), with the efficient designs (`front`) ringed and labeled. With + `highlight`, only some designs are colored, over the others in gray + (such as the designs a search evaluated, over every design):: + + plot_designs(summary, "satellites", "sufficient", front="pareto") + plot_designs( + summary, "cost", "accurate", highlight=summary.policy == "degrade", + label="degrade", others="other policies", front="pareto", + ) Args: frame (pandas.DataFrame): A row per design. x (str): The column of the horizontal axis. y (str): The column of the vertical axis. by (str | None): A column whose values color the designs, or `None`. - front (str | Criteria | Mapping | None): The efficient designs: a - boolean column, criteria (see `pareto_front`), or `None`. + front (str | Sequence[bool] | Criteria | Mapping | None): The + efficient designs: a boolean column (such as `"pareto"` of a + summary of criteria) or values (one per row), criteria (see + `pareto_front`), or `None`. labels (str | Callable | None): The labels of the efficient designs: a column, a function of a row, or `None`. names (Mapping | Callable | None): The names of the values of `by` in the legend (by default, the values). + highlight (str | Sequence[bool] | None): The designs to color (a + boolean column, or values), the others drawn in gray, or `None` + to color every design. + label (str | None): The name of the colored designs in the legend, + without `by`. + others (str | None): The name of the designs in gray in the legend. + front_label (str): The name of the efficient designs in the legend. jitter (float): The most that `x` is shifted at random (in its units), to separate designs of the same `x` (such as numbers of satellites). @@ -150,11 +184,25 @@ def plot_designs( shift = np.random.default_rng(seed).uniform(-jitter, jitter, len(frame)) xs = frame[x].to_numpy(dtype=float) + (shift if jitter else 0.0) ys = frame[y].to_numpy(dtype=float) + shown = np.ones(len(frame), dtype=bool) + if highlight is not None: + shown = _mask(frame, highlight, "highlight") + ax.scatter( + xs[~shown], ys[~shown], s=10, color=GRAY, alpha=0.3, lw=0, label=others + ) if by is None: - ax.scatter(xs, ys, s=14, color=_color(colors, None, 0), alpha=0.55, lw=0) + ax.scatter( + xs[shown], + ys[shown], + s=14, + color=_color(colors, None, 0), + alpha=0.55 if highlight is None else 0.8, + lw=0, + label=label, + ) else: for k, value in enumerate(_groups(frame, by)): - selected = (frame[by] == value).to_numpy() + selected = (frame[by] == value).to_numpy() & shown ax.scatter( xs[selected], ys[selected], @@ -165,10 +213,10 @@ def plot_designs( label=_name(names, value), ) if front is not None: - if isinstance(front, str): - efficient = frame[front].to_numpy(dtype=bool) - else: + if isinstance(front, (Criteria, Mapping)): efficient = np.asarray(pareto_front(frame, front), dtype=bool) + else: + efficient = _mask(frame, front, "front") ax.scatter( xs[efficient], ys[efficient], @@ -176,7 +224,7 @@ def plot_designs( facecolor="none", edgecolor=INK, lw=1.5, - label="Pareto-efficient", + label=front_label, ) if labels is not None: rows = frame[efficient] @@ -193,13 +241,15 @@ def plot_designs( ) ax.set(xlabel=x, ylabel=y) style_axes(ax) - if legend is not None and (by is not None or front is not None): + named = by is not None or front is not None or label is not None + if legend is not None and (named or others is not None): ax.legend(loc=legend, fontsize=8, frameon=False, markerscale=1.6) return ax def plot_progress( progress: Mapping[str, pd.Series], + *, colors: Sequence[str] | Mapping[str, str] = COLORS, legend: str | None = "lower right", ax: Any = None, @@ -246,6 +296,7 @@ def plot_means( results: pd.DataFrame, x: str, y: str, + *, by: str | None = None, names: Mapping[Any, str] | Callable[[Any], str] | None = None, colors: Sequence[str] | Mapping[Any, str] = COLORS, @@ -314,7 +365,8 @@ def plot_means( def plot_exceedance( frame: pd.DataFrame, - labels: Mapping[str, str] | Callable[[str], str] | None = None, + *, + names: Mapping[str, str] | Callable[[str], str] | None = None, colorbar: bool = True, ax: Any = None, ) -> Any: @@ -332,7 +384,7 @@ def plot_exceedance( Args: frame (pandas.DataFrame): The probabilities of a group (see `exceedance`). - labels (Mapping | Callable | None): The labels of the designs (by + names (Mapping | Callable | None): The names of the designs (by key), or `None` for their keys. colorbar (bool): `True` to draw a color bar. ax (matplotlib.axes.Axes | None): The axes, or `None` for a new figure. @@ -363,9 +415,9 @@ def plot_exceedance( matrix, cmap=scale, vmin=0, vmax=1, interpolation="nearest", aspect="equal" ) ax.set_xticks(range(len(columns))) - ax.set_xticklabels([_name(labels, key) for key in columns], rotation=90) + ax.set_xticklabels([_name(names, key) for key in columns], rotation=90) ax.set_yticks(range(len(rows))) - ax.set_yticklabels([_name(labels, key) for key in rows]) + ax.set_yticklabels([_name(names, key) for key in rows]) ax.tick_params(length=0, labelsize=8, colors=INK) ax.set(xlabel="Other design", ylabel="Design") for spine in ax.spines.values(): diff --git a/src/tatc/tradespace/refinement.py b/src/tatc/tradespace/refinement.py index 8c73c2c2..bcab27fb 100644 --- a/src/tatc/tradespace/refinement.py +++ b/src/tatc/tradespace/refinement.py @@ -43,10 +43,10 @@ class Refinement: its least replicates) and, if so, whether it is `indifferent` (its objectives are known to within the precision of their tolerances).""" history: pd.DataFrame = field(default_factory=pd.DataFrame) - """pandas.DataFrame: For each round, the number of designs whose - efficiency is uncertain (`uncertain`), of these, those that are - indifferent (`indifferent`), the number to which replicates were added - (`refined`), and the evaluations added (`evaluations`).""" + """pandas.DataFrame: For each round (`round`, from 0), the number of + designs whose efficiency is uncertain (`uncertain`), of these, those that + are indifferent (`indifferent`), the number to which replicates were + added (`refined`), and the evaluations added (`evaluations`).""" designs: list[Design] = field(default_factory=list) """list[Design]: The designs that could be refined.""" @@ -198,16 +198,11 @@ def refine( raise ValueError("budget must not be negative") refined = _designs(study.space, results if designs is None else designs, results) by_key = {design.key: design for design in refined} - frames = [results] - history = [] - spent = 0 + combined, history, spent = results, [], 0 def estimate(round_: int) -> pd.DataFrame: probability = pareto_probability( - pd.concat(frames, ignore_index=True), - criteria, - n_resamples=n_resamples, - seed=seed + round_, + combined, criteria, n_resamples=n_resamples, seed=seed + round_ ) few = probability["replicates"] < min_replicates probability["uncertain"] = ( @@ -221,49 +216,18 @@ def estimate(round_: int) -> pd.DataFrame: for round_ in range(max_rounds): probability = estimate(round_) - grouped = probability.groupby("design") - uncertain = grouped["uncertain"].any() - # a design is indifferent if it is in every group in which it is uncertain - settling = ( - (probability["uncertain"] & ~probability["indifferent"]) - .groupby(probability["design"]) - .any() - ) - indifferent = uncertain & ~settling - combined = pd.concat(frames, ignore_index=True) + uncertain, indifferent, settling = _settling(probability) following = combined.groupby("design")["replicate"].max() + 1 - # the designs to refine, the fewest replicates and the least settled first - distance = (probability["pareto_probability"] - 0.5).abs() - priority = pd.DataFrame( - { - "few": grouped["replicates"].min() < min_replicates, - "distance": distance.groupby(probability["design"]).min(), - "replicates": grouped["replicates"].min(), - } - ) - candidates = priority[settling.reindex(priority.index, fill_value=False)] - candidates = candidates.sort_values( - ["few", "distance", "replicates"], ascending=[False, True, True] + added_to = _allocate( + probability, + settling, + following, + list(by_key), + step=step, + min_replicates=min_replicates, + max_replicates=max_replicates, + budget=None if budget is None else budget - spent, ) - left = None if budget is None else budget - spent - added_to = {} - for key in candidates.index: - if key not in by_key: - continue - count = ( - step - if max_replicates is None - else min(step, max_replicates - int(following[key])) - ) - if left is not None: - count = min(count, left) - if count <= 0: - continue - added_to[key] = count - if left is not None: - left -= count - if left == 0: - break record = { "round": round_, "uncertain": int(uncertain.sum()), @@ -274,21 +238,11 @@ def estimate(round_: int) -> pd.DataFrame: if not added_to: history.append(record) break - # designs with the same next replicates are evaluated together - plan = pd.DataFrame( - { - "start": following[list(added_to)].astype(int), - "count": list(added_to.values()), - }, - index=list(added_to), + added = _evaluate_added(study, by_key, following, added_to) + combined = pd.concat([combined, *added], ignore_index=True) + record["evaluations"] = sum( + new.groupby(["design", "replicate"]).ngroups for new in added ) - for (start, count), keys in plan.groupby(["start", "count"]): - new = study.run( - [by_key[key] for key in keys.index], - replicates=range(int(start), int(start) + int(count)), - ) - frames.append(new) - record["evaluations"] += new.groupby(["design", "replicate"]).ngroups spent += record["evaluations"] history.append(record) else: @@ -304,8 +258,98 @@ def estimate(round_: int) -> pd.DataFrame: stacklevel=2, ) return Refinement( - results=pd.concat(frames, ignore_index=True), + results=combined, summary=probability, history=pd.DataFrame(history), designs=refined, ) + + +def _settling(probability: pd.DataFrame) -> tuple[pd.Series, pd.Series, pd.Series]: + """ + Gets, by design, whether its efficiency is uncertain (in any group of the + criteria's `by`), indifferent (uncertain only where its objectives are + known to within the precision of their tolerances), and settling (more + replicates would settle it), for a round of `refine`. + """ + uncertain = probability.groupby("design")["uncertain"].any() + settling = ( + (probability["uncertain"] & ~probability["indifferent"]) + .groupby(probability["design"]) + .any() + ) + return uncertain, uncertain & ~settling, settling + + +def _allocate( + probability: pd.DataFrame, + settling: pd.Series, + following: pd.Series, + refinable: list[str], + *, + step: int, + min_replicates: int, + max_replicates: int | None, + budget: int | None, +) -> dict[str, int]: + """ + Gets the replicates to add to designs whose efficiency more replicates + would settle (by key), for a round of `refine`: `step` each (up to + `max_replicates`), the fewest replicates and the least settled first + (nearest a probability of 0.5), within a budget (if any). + """ + grouped = probability.groupby("design") + distance = (probability["pareto_probability"] - 0.5).abs() + priority = pd.DataFrame( + { + "few": grouped["replicates"].min() < min_replicates, + "distance": distance.groupby(probability["design"]).min(), + "replicates": grouped["replicates"].min(), + } + ) + candidates = priority[settling.reindex(priority.index, fill_value=False)] + candidates = candidates.sort_values( + ["few", "distance", "replicates"], ascending=[False, True, True] + ) + left: int | None = budget + added: dict[str, int] = {} + allowed = set(refinable) + for key in candidates.index: + if key not in allowed: + continue + count = step + if max_replicates is not None: + count = min(count, max_replicates - int(following[key])) + if left is not None: + count = min(count, left) + if count <= 0: + continue + added[key] = count + if left is not None: + left -= count + if left == 0: + break + return added + + +def _evaluate_added( + study: Study, + designs: dict[str, Design], + following: pd.Series, + added: dict[str, int], +) -> list[pd.DataFrame]: + """ + Evaluates the replicates added to designs (by key, after the replicates + each has): designs with the same new replicates together. + """ + plan = pd.DataFrame( + {"start": following[list(added)].astype(int), "count": list(added.values())}, + index=list(added), + ) + return [ + study.run( + [designs[key] for key in keys.index], + replicate_indices=range(int(start), int(start) + int(count)), + ) + for (start, count), keys in plan.groupby(["start", "count"]) + ] diff --git a/src/tatc/tradespace/scenarios.py b/src/tatc/tradespace/scenarios.py index a809c378..3d3dd172 100644 --- a/src/tatc/tradespace/scenarios.py +++ b/src/tatc/tradespace/scenarios.py @@ -14,8 +14,7 @@ import numpy as np import pandas as pd -from .criteria import Criteria, _as_criteria, _get_tolerances, aggregate -from .pareto import pareto_front +from .criteria import Criteria, _as_criteria, _get_tolerances, _signs, aggregate def _scales(criteria: Criteria, scale: Mapping[str, float] | None) -> np.ndarray: @@ -43,6 +42,7 @@ def _scales(criteria: Criteria, scale: Mapping[str, float] | None) -> np.ndarray def robustness( results: pd.DataFrame, criteria: Criteria | Mapping[str, str], + *, scenario: str = "scenario", scale: Mapping[str, float] | None = None, ) -> pd.DataFrame: @@ -90,8 +90,10 @@ def robustness( objective (if it has one), or else 1 (its units). Returns: - pandas.DataFrame: a row per design (`design`): its `pareto_trace`, - `max_regret`, and regret in each scenario (` regret`) + pandas.DataFrame: a row per design (`design`): the values of the + design (as a summary keeps them, see `aggregate`), its + `pareto_trace`, `max_regret`, and regret in each scenario + (` regret`) Raises: ValueError: if the results have no scenarios, or the criteria group @@ -116,12 +118,9 @@ def robustness( judged = dataclasses.replace(criteria, by=(scenario,)) objectives = list(criteria.objectives) # each objective in units of its scale, larger being better - signs = np.array( - [1.0 if d == "max" else -1.0 for d in criteria.objectives.values()] - ) - units = signs / _scales(criteria, scale) + units = -_signs(criteria) / _scales(criteria, scale) summary = aggregate(results, judged) - efficient = pareto_front(summary, judged).to_numpy() + efficient = summary["pareto"].to_numpy(dtype=bool) scenarios = list(pd.unique(results[scenario])) designs = list(pd.unique(results["design"])) regret = pd.DataFrame(np.inf, index=designs, columns=scenarios) @@ -141,13 +140,23 @@ def robustness( meets = group["meets_requirements"].to_numpy(dtype=bool) regret.loc[keys, name] = np.where(front, 0.0, np.where(meets, needed, np.inf)) trace[keys[front]] += 1 - frame = pd.DataFrame( - { - "design": designs, - "pareto_trace": (trace / max(len(scenarios), 1)).to_numpy(), - "max_regret": regret.max(axis=1).to_numpy(), - } - ) + # the values of each design (of its first record, as of a summary) + judged_columns = { + "design", + scenario, + *judged.names, + "replicates", + "violation", + "meets_requirements", + "pareto", + } + values = [column for column in summary.columns if column not in judged_columns] + first = results.drop_duplicates("design").set_index("design") + frame = pd.DataFrame({"design": designs}) + for column in values: + frame[column] = first.loc[designs, column].to_numpy() + frame["pareto_trace"] = (trace / max(len(scenarios), 1)).to_numpy() + frame["max_regret"] = regret.max(axis=1).to_numpy() for name in scenarios: frame[f"{name} regret"] = regret[name].to_numpy() return frame diff --git a/src/tatc/tradespace/screening.py b/src/tatc/tradespace/screening.py index 3c4ca485..2f64b4a6 100644 --- a/src/tatc/tradespace/screening.py +++ b/src/tatc/tradespace/screening.py @@ -33,8 +33,10 @@ class Screening: the `stage` (0 for the first).""" summaries: list[pd.DataFrame] = field(default_factory=list) """list[pandas.DataFrame]: For each stage, the summary of its designs - (see `aggregate`), with their Pareto rank (`pareto_rank`, see - `pareto_ranks`) and whether they were `kept` for the next stage.""" + (see `aggregate`, with whether each is efficient by the stage's + analysis, `pareto`), with their Pareto rank (`pareto_rank`, see + `pareto_ranks`), whether they were `kept` for the next stage, and the + `stage`.""" designs: list[Design] = field(default_factory=list) """list[Design]: The designs analyzed in the last stage.""" @@ -72,8 +74,8 @@ def screen( designs). Designs that miss a requirement are ranked after those that meet them - all, in order of their violation (see `pareto_ranks`), rather than - dropped: + all, in order of their violation, and designs with a missing objective + last (see `pareto_ranks`), rather than dropped: a cheap analysis may miss a requirement that the full analysis meets, so designs that nearly meet the requirements are kept if `keep` reaches them. @@ -133,8 +135,6 @@ def screen( results = study.run(current).assign(stage=stage) frames.append(results) summary = aggregate(results, criteria) - summary = summary.dropna(subset=list(criteria.objectives)) - summary = summary.reset_index(drop=True) summary["pareto_rank"] = pareto_ranks(summary, criteria) if stage < transitions: amount = keeps[stage] diff --git a/src/tatc/tradespace/simulation.py b/src/tatc/tradespace/simulation.py new file mode 100644 index 00000000..32582837 --- /dev/null +++ b/src/tatc/tradespace/simulation.py @@ -0,0 +1,456 @@ +""" +The discrete-event simulation of missions (see `Deployment.simulate`): the +deployment of a constellation with the failures of its satellites and +launches, the restoration of failed satellites by a policy, and the +decisions of the rules of its stages, into the history of the mission (see +`MissionHistory`). + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +import bisect +import heapq +import itertools +import math +from collections.abc import Callable, Sequence +from dataclasses import dataclass, field, replace +from functools import partial +from typing import TYPE_CHECKING, Any + +import numpy as np + +from .events import Launch, Production +from .failures import FailureModel, RestorationPolicy +from .mission import Decision, Failure, MissionHistory, Restoration + +if TYPE_CHECKING: + from .deployment import Deployment + + +@dataclass +class _Slot: + """ + The state of a position of a plane: the generation of its satellite, + when it began to operate (or `None`), when it failed, and whether it + awaits restoration. + """ + + generation: int = -1 + up: float | None = None + down: float | None = None + pending: bool = False + + +@dataclass +class _Booking: + """A launch of restorations or spares, open to more until it flies.""" + + time: float + plane: int + kind: Any + items: list = field(default_factory=list) + order: int = 0 + + +class _Simulation: + """ + A discrete-event simulation of a mission (see `Deployment.simulate`). + """ + + # pylint: disable=too-many-instance-attributes + + def __init__( + self, + deployment: Deployment, + failures: FailureModel, + policy: RestorationPolicy, + seed: int | Sequence[int] | None, + uniforms: Callable[[tuple, int], np.ndarray] | None = None, + stress: float = 1.0, + launch_stress: float = 1.0, + ): + self.deployment, self.failures, self.policy = deployment, failures, policy + self.seed, self.uniforms = seed, uniforms + self.stress, self.launch_stress = stress, launch_stress + self.log_weight = 0.0 + self.schedule = deployment.schedule + self.end = deployment.end + self.history = MissionHistory( + deployment, production=list(deployment.production) + ) + self.events: list = [] + self.counter = itertools.count() + self.slots = { + (plane, position): _Slot() + for plane, (_, built, _) in enumerate(deployment.planes) + for position in range(built) + } + self.spares = dict.fromkeys(range(len(deployment.planes)), 0) + self.spares_since: dict[int, float] = {} + self.ground: dict[Any, int] = {} + self.line = { + kind: max( + ( + b.end + for b in deployment.production + if b.kind == kind and b.purpose == "deployment" + ), + default=developed, + ) + for kind, developed in deployment.development.items() + } + self.booked = sorted(launch.time for launch in deployment.launches) + self.open: dict[int, list[_Booking]] = {} + self.launches_of_plane: dict[int, int] = {} + self.decided: dict[int, float] = {} + + # --- randomness + + def _rng(self, *key: int) -> np.random.Generator: + seed = list(self.seed) if isinstance(self.seed, Sequence) else [self.seed] + return np.random.default_rng([*seed, *key]) + + def _life( + self, plane: int, position: int, generation: int, start: float = 0.0 + ) -> float: + if self.seed is None: + return math.inf + life = self.failures.life_of(self.deployment.planes[plane][0]) + if life is None: + return math.inf + key = (0, plane, position, generation) + if self.stress != 1.0: + uniform = ( + self.uniforms(key, life.dimensions) + if self.uniforms is not None + else self._rng(*key).random(life.dimensions) + ) + value, log_ratio = life.stressed(uniform, self.stress, self.end - start) + self.log_weight += log_ratio + return value + if self.uniforms is not None: + return life.from_uniform(self.uniforms(key, life.dimensions)) + return life.sample(self._rng(*key)) + + def _launch_fails(self, *key: int) -> bool: + if self.seed is None or self.failures.launch == 0: + return False + uniform = ( + self.uniforms((1, *key), 1)[0] + if self.uniforms is not None + else self._rng(1, *key).random() + ) + p = self.failures.launch + if self.launch_stress == 1.0: + return bool(uniform < p) + stressed = min(p * self.launch_stress, 0.5) + failed = bool(uniform < stressed) + ratio = p / stressed if failed else (1 - p) / (1 - stressed) + self.log_weight += math.log(ratio) + return failed + + # --- events + + def _push(self, time: float, kind: str, *payload: Any) -> None: + heapq.heappush(self.events, (time, next(self.counter), kind, payload)) + + def run(self) -> MissionHistory: + """Runs the simulation, returning the history of the mission.""" + # pylint: disable=too-many-branches + for kind in self.deployment.development: + count = self.policy.ground_spares_of(kind) + if count > 0: + begin = self.line[kind] + ready = begin + self.schedule.production_years(kind, count) + self.history.production.append( + Production(kind, begin, ready, count, "spare") + ) + self.line[kind] = ready + self.ground.setdefault(kind, 0) + self._push(ready, "stock", kind, count) + for launch in self.deployment.launches: + self._push(launch.time, "planned", launch) + for index, stage in enumerate(self.deployment.stages): + for time in stage.times: + self._push(self.deployment.begin + time, "decide", index) + steps = 0 + while self.events: + time, _, kind, payload = heapq.heappop(self.events) + if time >= self.end: + break + steps += 1 + if steps > 1_000_000: + raise RuntimeError("the simulation does not progress") + getattr(self, f"_on_{kind}")(time, *payload) + for (plane, position), slot in self.slots.items(): + if slot.up is not None: + self._close(plane, position, self.end) + for plane, since in self.spares_since.items(): + if self.spares[plane] > 0: + self.history.parked.append((since, self.end, self.spares[plane])) + self.history.weight = math.exp(self.log_weight) + self.history.stages = [ + self.decided.get(index) for index in range(len(self.deployment.stages)) + ] + self.history.production.sort(key=lambda batch: batch.begin) + self.history.launches.sort(key=lambda launch: (launch.time, launch.plane)) + return self.history + + def _on_stock(self, time: float, kind: Any, count: int) -> None: + del time + self.ground[kind] = self.ground.get(kind, 0) + count + + def _on_planned(self, time: float, launch: Launch) -> None: + failed = self._launch_fails(0, launch.plane, launch.first, launch.generation) + self.history.launches.append(replace(launch, failed=failed)) + built = self.deployment.planes[launch.plane][1] + positions = range(launch.first, launch.first + launch.satellites) + for position in positions: + if position >= built: + continue + slot = self.slots[launch.plane, position] + if launch.purpose == "deployment": + if failed: + self._fail(time, launch.plane, position, "launch") + else: + self._up(time, launch.plane, position) + elif not failed: + # a planned replacement takes the place of the satellite + if slot.up is not None: + self._close(launch.plane, position, time) + self._up(time, launch.plane, position) + spares = sum(position >= built for position in positions) + if spares and not failed: + level = self.deployment.planes[launch.plane][2] + if launch.purpose == "deployment": + self._park(time, launch.plane, spares) + else: + self._park( + time, + launch.plane, + max(0, min(spares, level - self.spares[launch.plane])), + ) + + def _on_decide(self, time: float, index: int) -> None: + if index in self.decided: + return # deployed at an earlier decision + stage = self.deployment.stages[index] + if stage.rule is not None: + operating = [ + position for position, slot in self.slots.items() if slot.up is not None + ] + capability = self.deployment.capability + decision = Decision( + time, + index, + len(operating), + self.history, + tuple(sorted(self.decided)), + ( + None + if capability is None + else partial(capability.at, self.deployment.planes, operating) + ), + ) + if not stage.rule(decision): + return + self.decided[index] = time + self._deploy(time, stage) + + def _on_fail(self, time: float, plane: int, position: int, generation: int) -> None: + slot = self.slots[plane, position] + if slot.generation != generation or slot.up is None: + return # a satellite replaced before it failed + self._close(plane, position, time) + self._fail(time, plane, position, "life") + + def _fail(self, time: float, plane: int, position: int, cause: str) -> None: + slot = self.slots[plane, position] + slot.down = time + self.history.failures.append(Failure(time, plane, position, cause)) + if self.policy.restore and not slot.pending: + slot.pending = True + self._push(time + self.policy.detection_years, "request", plane, position) + + def _on_request(self, time: float, plane: int, position: int) -> None: + slot = self.slots[plane, position] + if slot.up is not None: # restored by a planned replacement + slot.pending = False + return + kind = self.deployment.planes[plane][0] + if self.spares[plane] > 0: + self._park(time, plane, -1) + self._push( + time + self.policy.drift_years, "activate", plane, position, "orbit" + ) + if self.policy.replenish: + ready = self._produce(time, kind, 1, "spare") + self._book(plane, kind, ready, ("spare",)) + elif self.ground.get(kind, 0) > 0: + self.ground[kind] -= 1 + self._book(plane, kind, time, ("slot", position, "ground")) + if self.policy.replenish: + ready = self._produce(time, kind, 1, "spare") + self._push(ready, "stock", kind, 1) + else: + ready = self._produce(time, kind, 1, "restoration") + self._book(plane, kind, ready, ("slot", position, "production")) + + def _on_activate(self, time: float, plane: int, position: int, source: str) -> None: + slot = self.slots[plane, position] + if slot.up is not None: + self._park(time, plane, 1) # not needed: back to waiting + return + self._restore(time, plane, position, source) + + def _on_booking(self, time: float, booking: _Booking) -> None: + self.open[booking.plane].remove(booking) + failed = self._launch_fails(1, booking.plane, booking.order) + spare = all(item[0] == "spare" for item in booking.items) + self.history.launches.append( + Launch( + time, + booking.plane, + booking.kind, + -1, + len(booking.items), + purpose="spare" if spare else "restoration", + failed=failed, + ) + ) + for item in booking.items: + if item[0] == "spare": + if not failed: + self._park(time, booking.plane, 1) + continue + _, position, source = item + slot = self.slots[booking.plane, position] + if failed: + slot.pending = False + self.history.failures.append( + Failure(time, booking.plane, position, "launch") + ) + if self.policy.restore: + slot.pending = True + self._push( + time + max(self.policy.detection_years, 1e-6), + "request", + booking.plane, + position, + ) + elif slot.up is not None: + self._park(time, booking.plane, 1) # not needed: a spare in orbit + else: + self._restore(time, booking.plane, position, source) + + # --- actions + + def _up(self, time: float, plane: int, position: int) -> None: + slot = self.slots[plane, position] + slot.generation += 1 + slot.up, slot.pending = time, False + life = self._life(plane, position, slot.generation, time) + if time + life < self.end: + self._push(time + life, "fail", plane, position, slot.generation) + + def _close(self, plane: int, position: int, time: float) -> None: + slot = self.slots[plane, position] + if time > slot.up: + self.history.operating.setdefault((plane, position), []).append( + (slot.up, time) + ) + slot.up = None + + def _restore(self, time: float, plane: int, position: int, source: str) -> None: + slot = self.slots[plane, position] + self.history.restorations.append( + Restoration(plane, position, slot.down, time, source) + ) + self._up(time, plane, position) + + def _park(self, time: float, plane: int, change: int) -> None: + if change == 0: + return + if self.spares[plane] > 0: + since = self.spares_since[plane] + if time > since: + self.history.parked.append((since, time, self.spares[plane])) + self.spares[plane] += change + self.spares_since[plane] = time + + def _deploy(self, time: float, stage: Any) -> None: + """ + Deploys the planes of a stage: produced after its lead time (on their + type's line), launched at the next launch slots, and replaced at the + end of their design life. + """ + for plane in stage.planes: + kind, size, spares = self.deployment.planes[plane] + count = size + spares + if count == 0: + continue + begin = max(self.line[kind], time + stage.lead_years) + ready = begin + self.schedule.production_years(kind, count) + self.line[kind] = ready + self.history.production.append(Production(kind, begin, ready, count)) + position = 0 + for carried in self.schedule.split( + count, self.deployment.masses.get(kind), self._plane(plane) + ): + at = self._slot(ready) + bisect.insort(self.booked, at) + launch = Launch(at, plane, kind, position, carried) + self._push(at, "planned", launch) + for production, replacement in self.schedule.replacements( + launch, self.end + ): + self.history.production.append(production) + if replacement is not None: + bisect.insort(self.booked, replacement.time) + self._push(replacement.time, "planned", replacement) + position += carried + + def _produce(self, time: float, kind: Any, count: int, purpose: str) -> float: + begin = max(self.line[kind], time + self.policy.procurement_years) + ready = begin + self.schedule.production_years(kind, count) + self.line[kind] = ready + self.history.production.append(Production(kind, begin, ready, count, purpose)) + return ready + + def _slot(self, ready: float) -> float: + """The earliest launch at or after a time, at the launch cadence.""" + interval = self.schedule.launch_interval + time = ready + if interval > 0: + for booked in self.booked: + if booked - interval < time < booked + interval: + time = booked + interval + return time + + def _plane(self, plane: int) -> tuple[int, Any]: + """The index and values of a plane (see `DeploymentSchedule`).""" + values = self.deployment.plane_values + return plane, values[plane] if plane < len(values) else None + + def _capacity(self, plane: int, kind: Any) -> float: + return self.schedule.per_launch( + self.deployment.masses.get(kind), self._plane(plane) + ) + + def _book(self, plane: int, kind: Any, ready: float, item: tuple) -> None: + """Books an item on a launch of a plane: an open one, or a new one.""" + for booking in self.open.get(plane, []): + if booking.time >= ready and len(booking.items) < self._capacity( + plane, kind + ): + booking.items.append(item) + return + time = self._slot(ready + self.policy.batch_years) + order = self.launches_of_plane.get(plane, 0) + self.launches_of_plane[plane] = order + 1 + booking = _Booking(time, plane, kind, [item], order) + self.open.setdefault(plane, []).append(booking) + bisect.insort(self.booked, time) + self._push(time, "booking", booking) diff --git a/src/tatc/tradespace/space.py b/src/tatc/tradespace/space.py index 2b74ebf3..885e7e64 100644 --- a/src/tatc/tradespace/space.py +++ b/src/tatc/tradespace/space.py @@ -22,8 +22,6 @@ from __future__ import annotations -import hashlib -import json import math import re import zlib @@ -35,6 +33,7 @@ import pandas as pd from .fingerprint import _Describer +from .hashing import _canonical, _digest from .nodes import ( Choice, Derived, @@ -58,8 +57,25 @@ _ABSENT = object() """Marker of a node that records no decision (fixed, derived, or uncertain).""" -_RESERVED_NAMES = {"index", "count", "choice"} -"""Names that cannot be given to the children of a design space.""" +_RESERVED_NAMES = { + # names that the views of values give otherwise (see `Values`) + "index", + "count", + "choice", + "get", + "items", + "keys", + "values", + # attributes of designs (see `Design`) + "decisions", + "flat", + "key", + "realize", + "replicate", + "space", +} +"""Names that cannot be given to the children of a design space, as the views +of the values of designs (and designs) give them otherwise.""" # --------------------------------------------------------------------------- @@ -71,7 +87,7 @@ def _decision_key(decision: Any) -> str: """ Gets a canonical string of a decision. """ - return json.dumps(decision, sort_keys=True, default=str) + return _canonical(decision) def _plain(value: Any) -> Any: @@ -324,7 +340,7 @@ def _walk_repeat( their decisions and decided again in that order if they are unordered (see `_walk`). """ - if isinstance(node.count, Integer): + if isinstance(node.count, Variable): count = int( ctx.decide( _join(path, "count"), @@ -332,8 +348,14 @@ def _walk_repeat( _ABSENT if prescribed is _ABSENT else len(prescribed), ) ) + elif isinstance(node.count, Fixed): + count = int(node.count.value) + elif isinstance(node.count, Derived): + count = int(node.count.function(scope)) else: count = int(node.count) + if count < 0: + raise Infeasible(f"the count of {path} is negative ({count})") result, decisions = _walk_items(node, path, scope, ctx, count, prescribed, publish) if not node.ordered: canonical = sorted(decisions, key=_decision_key) @@ -388,13 +410,14 @@ def __init__( decisions: dict, values: dict, replicate: int | None = None, + scenario: str = "", ): self.space, self.decisions, self.replicate = space, decisions, replicate self._values = values - self._scenario = "" + self._scenario = scenario """str: A description of the values of the scenario of a realized design (see `realize`), `""` without one.""" - self.key = hashlib.sha1(_decision_key(decisions).encode()).hexdigest()[:12] + self.key = _digest(_decision_key(decisions), 12) """str: An identifier of the design, from its decisions only (not from its derived values or uncertain parameters).""" @@ -513,10 +536,13 @@ def fix(path: str, node: Fixed) -> Any: ctx = _Context(draw=draw, check=False, fix=fix if scenario else None) values, _ = _walk(self.space, "", Scope(), ctx, self.decisions) - realized = Design(self.space, self.decisions, values, replicate) - # pylint: disable-next=protected-access - realized._scenario = _describe_scenario(scenario) - return realized + return Design( + self.space, + self.decisions, + values, + replicate, + _describe_scenario(scenario), + ) def __repr__(self) -> str: replicate = "" if self.replicate is None else f", replicate={self.replicate}" @@ -650,7 +676,8 @@ def design( Raises: Infeasible: if the design violates a constraint. - ValueError: if an override names no child of the design space. + ValueError: if an override names no child of the design space, or + a decision is not a value of its variable's domain. """ if isinstance(decisions, Design): decisions = decisions.decisions @@ -662,7 +689,9 @@ def design( merged[name] = ( decision.decisions if isinstance(decision, Design) else decision ) - values, merged = _walk(self, "", Scope(), _Context(), merged) + values, merged = _walk( + self, "", Scope(), _Context(record=_check_domain), merged + ) return Design(self, merged, values) def extend( @@ -872,7 +901,7 @@ def uncertain_paths(self) -> list[str]: Returns: list[str]: the paths """ - return _uncertain_paths(self, "") + return _leaf_paths(self, "", Uncertain) def decode(self, unit: Sequence[float]) -> Design: """ @@ -962,41 +991,77 @@ def _unit_paths(node: Node, path: str) -> list[str]: for p in _unit_paths(branch, _join(path, name)) ] if isinstance(node, Repeat): - if isinstance(node.count, Integer): - if callable(node.count.high): - raise ValueError( - f"the count of {path} needs a fixed upper bound to be encoded" - ) - paths, largest = [_join(path, "count")], int(node.count.high) - else: - paths, largest = [], int(node.count) + paths, largest = [], _largest_count(node.count, path) + if isinstance(node.count, Variable): + paths = [_join(path, "count")] return paths + [ p for k in range(largest) for p in _unit_paths(node.item, f"{path}[{k}]") ] return [] -def _fixed_paths(node: Node, path: str) -> list[str]: +def _largest_count(count: Any, path: str) -> int: """ - Gets the paths of the fixed values of a node, with `[*]` for the index of - any item of a repetition (as `_uncertain_paths`). + Gets the largest count of a repetition (see `_unit_paths`), which must + not depend on other values. """ - if isinstance(node, Fixed): + if isinstance(count, Integer) and not callable(count.high): + return int(count.high) + if isinstance(count, Variable) and not isinstance(count, Integer): + options = getattr(count, "options", None) + if options is not None and not callable(options): + return int(max(options)) + elif isinstance(count, Fixed): + return int(count.value) + elif isinstance(count, int): + return count + raise ValueError(f"the count of {path} needs a fixed upper bound to be encoded") + + +def _check_domain(path: str, domain: _Domain, value: Any) -> None: + """ + Checks that a decision is a value of its domain (see `DesignSpace.design`), + raising a `ValueError` if not. + """ + if domain.levels is not None: + try: + if value in domain.levels: + return + except (TypeError, ValueError): + pass + raise ValueError(f"{value!r} is not a level of {path} ({domain.levels})") + try: + if domain.low <= float(value) <= domain.high: + return + except (TypeError, ValueError): + pass + raise ValueError( + f"{value!r} is not in the range of {path} ({domain.low}, {domain.high})" + ) + + +def _leaf_paths(node: Node, path: str, kind: type) -> list[str]: + """ + Gets the paths of the leaves of a kind of a node (such as its fixed + values), with `[*]` for the index of any item of a repetition, and with + the branches of choices, whether a design chooses them or not. + """ + if isinstance(node, kind): return [path] if isinstance(node, DesignSpace): return [ p for name, child in node.children.items() - for p in _fixed_paths(child, _join(path, name)) + for p in _leaf_paths(child, _join(path, name), kind) ] if isinstance(node, Choice): return [ p for name, branch in node.branches.items() - for p in _fixed_paths(branch, _join(path, name)) + for p in _leaf_paths(branch, _join(path, name), kind) ] if isinstance(node, Repeat): - return _fixed_paths(node.item, f"{path}[*]") + return _leaf_paths(node.item, f"{path}[*]", kind) return [] @@ -1058,6 +1123,15 @@ def _design_items(designs: Iterable[Design | str] | pd.DataFrame) -> list[Design return items +def _keys_of(designs: Iterable[Design | str] | pd.DataFrame) -> list[str]: + """ + Gets the keys of designs given as designs, keys, or a data frame of them + (with keys `design`, a column or the name of the index), each once. + """ + keys = [d.key if isinstance(d, Design) else d for d in _design_items(designs)] + return list(dict.fromkeys(keys)) + + def _designs( space: DesignSpace, designs: Iterable[Design | str] | pd.DataFrame, @@ -1107,7 +1181,7 @@ def _check_scenario(space: DesignSpace, values: Mapping[str, Any]) -> None: """ if not values: return - known = [*_fixed_paths(space, ""), *space.uncertain_paths()] + known = [*_leaf_paths(space, "", Fixed), *space.uncertain_paths()] unknown = sorted(set(values) - set(known)) if unknown: raise ValueError( @@ -1124,7 +1198,7 @@ def _describe_scenario(values: Mapping[str, Any]) -> str: if not values: return "" described = _Describer().describe(dict(values)) - return json.dumps(described, sort_keys=True, default=str) + return _canonical(described) def _scenario_of(design: Design) -> str: @@ -1146,27 +1220,3 @@ def _check_uncertain(space: DesignSpace, paths: Iterable[str]) -> None: raise ValueError( f"not uncertain parameters of the design space: {unknown} (it has {known})" ) - - -def _uncertain_paths(node: Node, path: str) -> list[str]: - """ - Gets the paths of the uncertain parameters of a node (see - `DesignSpace.uncertain_paths`). - """ - if isinstance(node, Uncertain): - return [path] - if isinstance(node, DesignSpace): - return [ - p - for name, child in node.children.items() - for p in _uncertain_paths(child, _join(path, name)) - ] - if isinstance(node, Choice): - return [ - p - for name, branch in node.branches.items() - for p in _uncertain_paths(branch, _join(path, name)) - ] - if isinstance(node, Repeat): - return _uncertain_paths(node.item, f"{path}[*]") - return [] diff --git a/src/tatc/tradespace/store.py b/src/tatc/tradespace/store.py index b2bd5ea8..6ef9a63a 100644 --- a/src/tatc/tradespace/store.py +++ b/src/tatc/tradespace/store.py @@ -22,6 +22,8 @@ import numpy as np +from .hashing import _canonical + _RESULTS_TABLE = ( "CREATE TABLE IF NOT EXISTS results (namespace TEXT, context TEXT, " + "design TEXT, replicate INTEGER, variant TEXT, records TEXT, " @@ -252,7 +254,7 @@ def define(self, context: str, definition: dict) -> None: [ self.namespace, context, - json.dumps(definition, sort_keys=True, default=str), + _canonical(definition), defined, ], ) @@ -295,28 +297,32 @@ def contexts(self) -> dict[str, int]: def __len__(self) -> int: return sum(self.contexts().values()) - def prune(self, keep: str) -> int: + def remove(self, contexts: str | Iterable[str]) -> int: """ - Removes the stored records (and definitions) of the namespace's other - contexts, such as those of earlier definitions of a study (keeping - those of its fingerprint, see `Study.fingerprint`). + Removes the stored records (and definitions) of contexts of the + namespace, such as those of earlier definitions of a study (see + `Study.prune`, which removes those of the study with other code, and + not those of other studies that share the namespace). Args: - keep (str): The context to keep. + contexts (str | Iterable[str]): The contexts. Returns: int: the number of evaluations removed """ + contexts = [contexts] if isinstance(contexts, str) else list(contexts) + removed = 0 with closing(self._connect()) as connection: with connection: - removed = connection.execute( - "DELETE FROM results WHERE namespace = ? AND context != ?", - [self.namespace, keep], - ).rowcount - connection.execute( - "DELETE FROM definitions WHERE namespace = ? AND context != ?", - [self.namespace, keep], - ) + for context in contexts: + removed += connection.execute( + "DELETE FROM results WHERE namespace = ? AND context = ?", + [self.namespace, context], + ).rowcount + connection.execute( + "DELETE FROM definitions WHERE namespace = ? AND context = ?", + [self.namespace, context], + ) return removed def clear(self) -> None: diff --git a/src/tatc/tradespace/study.py b/src/tatc/tradespace/study.py index 16470ff5..e5bad9ef 100644 --- a/src/tatc/tradespace/study.py +++ b/src/tatc/tradespace/study.py @@ -7,9 +7,7 @@ from __future__ import annotations -import hashlib import inspect -import json import math import os import time @@ -21,12 +19,8 @@ import pandas as pd from pydantic import ValidationError -from .fingerprint import ( - _fingerprint_of, - _without_code, - compare_definitions, - get_definition, -) +from .fingerprint import _fingerprint_of, _with_other_code, get_definition +from .hashing import _canonical, _digest from .nodes import Infeasible from .space import ( Design, @@ -409,6 +403,52 @@ def _settings(self) -> dict[str, Any]: "scenarios": self.scenarios, } + def realize( + self, design: Design, replicate: int = 0, scenario: str | None = None + ) -> Design: + """ + Realizes a replicate of a design as the study evaluates it (see + `Design.realize`): with the study's seed and common random numbers, + and in one of its scenarios (by name), if given, such as for analyses + of a design other than its metrics. + + Args: + design (Design): The design. + replicate (int): The replicate. + scenario (str | None): A scenario of the study (by name), or `None` + for the values of the design space. + + Returns: + Design: the realized design + + Raises: + KeyError: if the study has no scenario of the name. + """ + values = None + if scenario is not None: + if not self.scenarios or scenario not in self.scenarios: + raise KeyError( + f"no scenario {scenario!r} of the study " + + f"(it has {list(self.scenarios or {})})" + ) + values = self.scenarios[scenario] + return design.realize( + replicate, self.seed, self.common_random_numbers, None, values + ) + + def _prepare( + self, + design: Design, + replicate: int, + shift: Mapping[str, int] | None, + case: _Case, + ) -> None: + """ + Prepares to evaluate designs (in this process, before any worker + does), given the first evaluation of a run: nothing, unless a subclass + prepares something. + """ + @property def definition(self) -> dict: """dict: The definition of the study (see `get_definition`), which @@ -431,10 +471,29 @@ def definition(self) -> dict: def fingerprint(self) -> str: """str: A key of the definition of the study (see `definition`), which changes if it does. It keys the records of a store (see - `ResultStore`); data that it cannot describe (such as data frames) - must be identified by the store's namespace.""" + `ResultStore`); what it cannot describe (data that the functions read, + such as from files, and the code of installed modules other than + TAT-C's, see `get_definition`) must be identified by the store's + namespace.""" return _fingerprint_of(self.definition) + def prune(self) -> int: + """ + Removes the evaluations of the study's store (in its namespace) by + this study with other code (of its functions, of TAT-C, or of Python: + the same values but for code), which it does not reuse, and of which + it warns. The evaluations of other studies that share the namespace + (such as variants with other settings) are kept. + + Returns: + int: the number of evaluations removed (0 without a store) + """ + if self.store is None: + return 0 + definition = self.definition + context = _fingerprint_of(definition) + return self.store.remove(_other_code(self.store, context, definition)) + @property def workers(self) -> int: """int: The number of workers that evaluate designs (1 in this process).""" @@ -448,7 +507,8 @@ def run( self, designs: Iterable[Design] | pd.DataFrame | None = None, progress: Callable[[int, int], None] | None = None, - replicates: Iterable[int] | None = None, + *, + replicate_indices: Iterable[int] | None = None, shift: Mapping[str, int] | None = None, ) -> pd.DataFrame: """ @@ -475,7 +535,7 @@ def run( progress (Callable | None): A function called as evaluations complete with the number completed and the number of evaluations (not counting those taken from the store). - replicates (Iterable[int] | None): The replicates (their + replicate_indices (Iterable[int] | None): The replicates (their indices, which seed their uncertain parameters), or `None` for the study's (`range(replicates)`). shift (Mapping[str, int] | None): The offsets of the replicates as @@ -503,72 +563,17 @@ def run( (i, design, replicate, case) for replicate in ( range(self.replicates) - if replicates is None - else sorted(set(replicates)) + if replicate_indices is None + else sorted(set(replicate_indices)) ) for case in range(len(cases)) for i, design in enumerate(unique) ] - results: list[tuple[int, int, int, list[dict]]] = [] - context = "" - if self.store is not None: - # evaluations stored before (by an interrupted or earlier run) - definition = self.definition - context = _fingerprint_of(definition) - stored = {} - for k, case in enumerate(cases): - found = self.store.get( - ((d.key, r) for _, d, r, c in tasks if c == k), - context, - case.variant, - ) - stored.update( - {(key, r, k): records for (key, r), records in found.items()} - ) - if tasks and not stored: - _warn_other_definitions(self.store, context, definition) - self.store.define(context, definition) - results.extend( - (i, case, replicate, stored[design.key, replicate, case]) - for i, design, replicate, case in tasks - if (design.key, replicate, case) in stored - ) - tasks = [t for t in tasks if (t[1].key, t[2], t[3]) not in stored] - total = len(tasks) - if self.executor is None and self.n_jobs == 1: - for done, (i, design, replicate, case) in enumerate(tasks, 1): - records = self._evaluate_and_store( - design, replicate, context, shift, cases[case] - ) - results.append((i, case, replicate, records)) - if progress is not None: - progress(done, total) - elif tasks: - executor = self.executor or _get_executor(self.workers) - n_chunks = min(total, self.workers * self.chunks_per_job) - size = math.ceil(total / max(n_chunks, 1)) - chunks = [tasks[k : k + size] for k in range(0, total, size)] - futures = { - executor.submit(self._run_chunk, chunk, context, shift, cases): chunk - for chunk in chunks - } - done = 0 - try: - for future in as_completed(futures): - chunk = futures[future] - evaluated = future.result() - for (i, _, replicate, case), records in zip(chunk, evaluated): - results.append((i, case, replicate, records)) - done += len(chunk) - if progress is not None: - progress(done, total) - except BaseException: - # interrupted (or an error): chunks that have not begun are - # cancelled, and those in progress add their evaluations to - # the store as they complete - for future in futures: - future.cancel() - raise + context, results, tasks = self._stored(tasks, cases) + if tasks: + first = tasks[0] + self._prepare(first[1], first[2], shift, cases[first[3]]) + results.extend(self._execute(tasks, context, shift, cases, progress)) results.sort(key=lambda result: result[:3]) frame = pd.DataFrame.from_records( [ @@ -580,6 +585,98 @@ def run( _check_feasible(frame) return frame + def _stored( + self, tasks: list[_Task], cases: Sequence[_Case] + ) -> tuple[str, list[_Outcome], list[_Task]]: + """ + Takes the evaluations of tasks stored before (by an interrupted or + earlier run), if the study has a store: the context of its + evaluations in the store (its fingerprint, `""` without a store), the + outcomes of the stored tasks, and the tasks left to evaluate. Warns of + evaluations of the study with other code if none is stored. + """ + if self.store is None: + return "", [], tasks + definition = self.definition + context = _fingerprint_of(definition) + stored = {} + for k, case in enumerate(cases): + found = self.store.get( + ((d.key, r) for _, d, r, c in tasks if c == k), context, case.variant + ) + stored.update({(key, r, k): records for (key, r), records in found.items()}) + if tasks and not stored: + _warn_other_definitions(self.store, context, definition) + self.store.define(context, definition) + outcomes = [ + (i, case, replicate, stored[design.key, replicate, case]) + for i, design, replicate, case in tasks + if (design.key, replicate, case) in stored + ] + left = [t for t in tasks if (t[1].key, t[2], t[3]) not in stored] + return context, outcomes, left + + def _execute( + self, + tasks: list[_Task], + context: str, + shift: Mapping[str, int], + cases: Sequence[_Case], + progress: Callable[[int, int], None] | None, + ) -> list[_Outcome]: + """ + Evaluates tasks (in this process, or in chunks by workers), adding + each to the store (if any) in a context, and reporting progress. + """ + # pylint: disable=too-many-arguments,too-many-positional-arguments + outcomes: list[_Outcome] = [] + total = len(tasks) + if self.executor is None and self.n_jobs == 1: + for done, (i, design, replicate, case) in enumerate(tasks, 1): + records = self._evaluate_and_store( + design, replicate, context, shift, cases[case] + ) + outcomes.append((i, case, replicate, records)) + if progress is not None: + progress(done, total) + return outcomes + if not tasks: + return outcomes + executor = self.executor or _get_executor(self.workers) + n_chunks = min(total, self.workers * self.chunks_per_job) + size = math.ceil(total / max(n_chunks, 1)) + chunks = [tasks[k : k + size] for k in range(0, total, size)] + futures = { + executor.submit(self._run_chunk, chunk, context, shift, cases): chunk + for chunk in chunks + } + done = 0 + try: + for future in as_completed(futures): + chunk = futures[future] + for (i, _, replicate, case), records in zip(chunk, future.result()): + outcomes.append((i, case, replicate, records)) + done += len(chunk) + if progress is not None: + progress(done, total) + except BaseException: + # interrupted (or an error): chunks that have not begun are + # cancelled, and those in progress add their evaluations to the + # store as they complete + for future in futures: + future.cancel() + raise + return outcomes + + +_Task = tuple # (index of the design, design, replicate, index of the case) +"""A task of a run: the index of a design, the design, the replicate, and +the index of the case (scenario) in which to evaluate it.""" + +_Outcome = tuple # (index of the design, index of the case, replicate, records) +"""The outcome of a task: the index of the design, the index of the case, the +replicate, and the records of the evaluation.""" + def _in_scenario(record: dict, name: str | None) -> dict: """ @@ -642,10 +739,10 @@ def _variant_of(shift: Mapping[str, int] | None, scenario: str = "") -> str: shift = {name: int(offset) for name, offset in (shift or {}).items() if offset} parts: dict[str, Any] = {} if scenario: - parts["scenario"] = hashlib.sha1(scenario.encode()).hexdigest()[:16] + parts["scenario"] = _digest(scenario, 16) if shift: parts["shift"] = shift - return json.dumps(parts, sort_keys=True) if parts else "" + return _canonical(parts) if parts else "" def _takes_design(function: Callable) -> bool: @@ -663,34 +760,42 @@ def _takes_design(function: Callable) -> bool: ) +def _other_code(store: ResultStore, context: str, definition: dict) -> list[str]: + """ + Gets the contexts of a store's namespace whose evaluations are of the same + study with other code (its functions', TAT-C's, or Python's: the same + values but for the code of functions, see `_with_other_code`), the latest + first. + """ + others = [other for other in store.contexts() if other != context] + return [ + other + for other in reversed(others) + if _with_other_code(definition, [store.definition(other)]) is not None + ] + + def _warn_other_definitions(store: ResultStore, context: str, definition: dict) -> None: """ Warns if a store has evaluations of its namespace by the same study with - other code (its functions', TAT-C's, or Python's: the same values but for - the code of functions, see `_without_code`), which a study does not - reuse, with the differences (see `compare_definitions`). Studies of other + other code (see `_other_code`), which a study does not reuse, with the + differences from the latest (see `compare_definitions`). Studies of other values (such as other settings) share a namespace without a warning, as their fingerprints keep their evaluations apart. """ - contexts = store.contexts() - others = [other for other in contexts if other != context] - if not others: - return - values = _without_code(definition.get("values", {})) - for other in reversed(others): - before = store.definition(other) - if before is None or _without_code(before.get("values", {})) != values: - continue - differences = compare_definitions(before, definition) - warnings.warn( - f"the store has {contexts[other]} evaluations of namespace " - + f"{store.namespace!r} by this study with other code, which are not " - + "reused (see Study.fingerprint, and ResultStore.prune to remove " - + "them); it differs in: " - + "; ".join(differences), - stacklevel=3, - ) + stale = _other_code(store, context, definition) + if not stale: return + contexts = store.contexts() + count = sum(contexts.get(other, 0) for other in stale) + differences = _with_other_code(definition, [store.definition(stale[0])]) + warnings.warn( + f"the store has {count} evaluations of namespace {store.namespace!r} by " + + "this study with other code, which are not reused (see " + + "Study.fingerprint; Study.prune removes them); the latest differs in: " + + "; ".join(differences or []), + stacklevel=3, + ) def _unstored(records: list[dict]) -> bool: diff --git a/src/tatc/tradespace/values.py b/src/tatc/tradespace/values.py index 3fa7826a..08d036e2 100644 --- a/src/tatc/tradespace/values.py +++ b/src/tatc/tradespace/values.py @@ -8,6 +8,7 @@ from __future__ import annotations import dataclasses +import re from collections.abc import Iterator, Mapping from typing import Any @@ -43,17 +44,96 @@ def _view(value: Any) -> Any: return value +_SEGMENT = re.compile(r"\[(\d+)\]|([^.\[\]]+)") +"""A segment of a path: the index of an item (`[k]`) or a name.""" + + +def _segments(path: str) -> list[str | int]: + """ + Gets the segments of a path of values (see `Values`), such as + `["layout", "sso", "planes", 0, "crossing"]` of + `"layout.sso.planes[0].crossing"`. + """ + segments: list[str | int] = [] + for index, name in _SEGMENT.findall(path): + segments.append(int(index) if index else name) + rebuilt = "".join(f"[{s}]" if isinstance(s, int) else f".{s}" for s in segments) + if not segments or rebuilt.lstrip(".") != path.lstrip("."): + raise KeyError(f"{path!r} is not a path of values") + return segments + + +def _join(path: str, segment: str | int) -> str: + """Gets the path of a segment within a path (see `_segments`).""" + if isinstance(segment, int): + return f"{path}[{segment}]" + return f"{path}.{segment}" if path else segment + + +def _step(value: Any, segment: str | int, path: str) -> Any: + """ + Gets the value of a segment of a path within a value (see `Values`): a + child of a group, an item of a repetition (`[k]`) or its `count`, or, of + a choice, its chosen branch (by its name) or a value of that branch. + """ + where = path or "the design" + if isinstance(value, RepeatValues): + if isinstance(segment, int): + if not 0 <= segment < len(value): + raise KeyError(f"{where} has {len(value)} items, not an item {segment}") + return value[segment] + if segment == "count": + return value.count + raise KeyError(f"{where} is a repetition: give an item ([k]) or its count") + if isinstance(value, ChoiceValues): + if segment == value.choice: + return value.value + try: + return _step(value.value, segment, path) + except KeyError: + raise KeyError( + f"{where} chose {value.choice!r}, which has no value {segment!r}" + ) from None + if isinstance(value, Values) and isinstance(segment, str): + names = list(value) + if segment in names: + return value[segment] + raise KeyError(f"{where} has no value {segment!r} (it has {names})") + raise KeyError(f"{where} is a value ({value!r}), which has no {segment!r}") + + +def _resolve_path(value: Any, path: str) -> Any: + """Gets the value at a path within a value (see `Values`).""" + walked = "" + for segment in _segments(path): + value = _step(value, segment, walked) + walked = _join(walked, segment) + return value + + class Values(Mapping): """ A read-only view of the values of a design space (a group of nodes), by - attribute or by key. + attribute or by key. A key may also be a path of values, as the columns + of the results of a study name them (see `Design.flat`): `"a.b"` for the + value `b` of group `a`, `"c..d"` for the value `d` of the chosen + branch of choice `c` (an error if it chose another), `"e.count"` for the + count of repetition `e`, and `"e[k].f"` for the value `f` of its item + `k`. Fixed values, which the columns of results omit, are also given:: + + d["layout.walker.planes"] # d.layout.walker.planes, if it chose walker + d["layout.sso.planes[0].crossing"] """ def __init__(self, values: dict, index: int | None = None): self._values, self._index = values, index def __getitem__(self, name: str) -> Any: - return _view(self._values[name]) + if name in self._values: + return _view(self._values[name]) + if isinstance(name, str) and ("." in name or "[" in name): + return _resolve_path(self, name) + raise KeyError(name) def __getattr__(self, name: str) -> Any: if name.startswith("_"): @@ -78,7 +158,16 @@ def __repr__(self) -> str: class ChoiceValues: """ A read-only view of the value of a choice: the name of the chosen branch - (`choice`) and, as attributes, the values of the branch. + (`choice`), which the view equals (as the columns of the results of a + study give it, see `Design.flat`), and, as attributes (or keys), the + values of the branch, which are also those of the branch's name:: + + d.layout == "walker" # d.layout.choice == "walker" + d.layout.planes # d.layout.walker.planes, if it chose walker + + An attribute is a value of the branch if the branch has one of that + name, and otherwise the branch, if it is the branch's name; a path (see + `Values`) names the branch first, as the columns of results do. """ def __init__(self, value: _ChoiceValue): @@ -95,12 +184,38 @@ def value(self) -> Any: return _view(self._value.value) def __getattr__(self, name: str) -> Any: + # the values of the branch first (as before branches were attributes), + # then the branch by its name (which paths give first, see `Values`) if name.startswith("_"): raise AttributeError(name) - return getattr(self.value, name) + try: + return getattr(self.value, name) + except AttributeError: + if name == self._value.choice: + return self.value + raise AttributeError( + f"the choice chose {self.choice!r}, which has no value {name!r}" + ) from None def __getitem__(self, name: str) -> Any: - return self.value[name] + return _resolve_path(self, name) + + def __contains__(self, name: object) -> bool: + try: + self[name] # type: ignore[index] + except (KeyError, TypeError): + return False + return True + + def __eq__(self, other: object) -> bool: + if isinstance(other, str): + return self.choice == other + if isinstance(other, ChoiceValues): + return self.choice == other.choice and self.value == other.value + return NotImplemented + + def __hash__(self) -> int: + return hash(self.choice) def __repr__(self) -> str: return f"ChoiceValues({self.choice!r}, {self.value!r})" @@ -120,7 +235,11 @@ def count(self) -> int: """The number of items.""" return self._value.count - def __getitem__(self, index: int) -> Any: + def __getitem__(self, index: int | slice) -> Any: + if isinstance(index, slice): + return [self[k] for k in range(len(self))[index]] + if index < 0: + index += len(self) item = self._value.items[index] return Values(item, index) if isinstance(item, dict) else _view(item) @@ -130,6 +249,13 @@ def __len__(self) -> int: def __iter__(self) -> Iterator[Any]: return (self[k] for k in range(len(self))) + def __eq__(self, other: object) -> bool: + if isinstance(other, (RepeatValues, list, tuple)): + return list(self) == list(other) + return NotImplemented + + __hash__ = None # type: ignore[assignment] + def __repr__(self) -> str: return f"RepeatValues({list(self)!r})" @@ -163,7 +289,22 @@ def __getattr__(self, name: str) -> Any: raise AttributeError(f"{name!r} is not decided before it is used") def __getitem__(self, name: str) -> Any: - return getattr(self, name) + """ + Gets a value by its name, or by a path within it (see `Values`), such + as `"layout.walker.planes"`. + """ + segments = _segments(name) + if not isinstance(segments[0], str): + raise KeyError(f"{name!r} does not start with a name") + try: + value = getattr(self, segments[0]) + except AttributeError as error: + raise KeyError(str(error)) from None + walked = segments[0] + for segment in segments[1:]: + value = _step(value, segment, walked) + walked = _join(walked, segment) + return value def configure(base: Any, values: Any = None, **overrides: Any) -> Any: diff --git a/tests/tradespace/test_attribution.py b/tests/tradespace/test_attribution.py index 8a60bb6d..b3f168a3 100644 --- a/tests/tradespace/test_attribution.py +++ b/tests/tradespace/test_attribution.py @@ -63,7 +63,7 @@ def setUpClass(cls): cls.study, ["y", "z", "v", "w"], cls.designs, - replicates=300, + sample_size=300, n_resamples=200, ) @@ -128,13 +128,13 @@ def test_results(self): def test_designs_of_frame(self): """Designs may be given by a data frame of their values.""" frame = pd.DataFrame([{"design": d.key, **d.flat()} for d in self.designs]) - a = attribute_variance(self.study, ["y"], frame.iloc[:1], replicates=2) + a = attribute_variance(self.study, ["y"], frame.iloc[:1], sample_size=2) self.assertEqual(set(a.shares.design), {self.designs[0].key}) def test_summary(self): """The summary pools the designs' shares, weighted by their variances.""" a = self.attribution - summary = a.summary() + summary = a.summary metrics = ["y", "z", "v", "w"] self.assertEqual( list(summary.columns), [*metrics, *(f"{m} se" for m in metrics)] @@ -149,12 +149,12 @@ def test_summary(self): np.testing.assert_allclose(summary.loc["u2", "y se"], rows["total se"]) self.assertTrue((summary.loc[["u1", "u2"], ["y se", "z se"]] > 0).all().all()) np.testing.assert_array_equal(summary.loc["s", ["y se", "z se"]], 0.0) - first = a.summary("first") + first = a.summary_of("first") self.assertAlmostEqual(first.loc["s", "v"], 1.0) self.assertAlmostEqual(first.loc["s", "v se"], 0.0) self.assertEqual(a.samples["total"].shape, (len(a.shares), 200)) with self.assertRaises(ValueError): - a.summary("second") + a.summary_of("second") def test_groups(self): """Groups of parameters are redrawn together.""" @@ -163,7 +163,7 @@ def test_groups(self): ["y"], self.designs[:1], parameters={"normal": ["u1", "u2"], "seed": "s"}, - replicates=50, + sample_size=50, n_resamples=50, ) self.assertEqual(list(a.shares.parameter), ["normal", "seed"]) @@ -171,7 +171,7 @@ def test_groups(self): np.testing.assert_allclose(_share(a, "y", "normal", "total"), 1.0, atol=0.3) np.testing.assert_array_equal(_share(a, "y", "seed", "total"), 0.0) named = attribute_variance( - self.study, ["y"], self.designs[:1], parameters=["u2"], replicates=50 + self.study, ["y"], self.designs[:1], parameters=["u2"], sample_size=50 ) self.assertEqual(list(named.shares.parameter), ["u2"]) self.assertEqual(set(named.results.redrawn.dropna()), {"u2"}) @@ -186,12 +186,12 @@ def test_validation(self): ["y"], self.designs, parameters=parameters, - replicates=2, + sample_size=2, ) with self.assertRaises(ValueError): - attribute_variance(self.study, ["y"], self.designs, replicates=1) + attribute_variance(self.study, ["y"], self.designs, sample_size=1) with self.assertRaises(ValueError): - attribute_variance(self.study, ["q"], self.designs, replicates=2) + attribute_variance(self.study, ["q"], self.designs, sample_size=2) certain = Study(DesignSpace(x=Integer(1, 2)), lambda d: d, lambda d: {"y": d.x}) with self.assertRaises(ValueError): attribute_variance(certain, ["y"], certain.space.enumerate()) @@ -212,7 +212,7 @@ def evaluate(d): study = Study(space, lambda d: d, evaluate) designs = space.enumerate() - a = attribute_variance(study, ["y"], designs, replicates=20, n_resamples=20) + a = attribute_variance(study, ["y"], designs, sample_size=20, n_resamples=20) redrawn = a.results[a.results.redrawn == "layout.a.phase"] self.assertEqual(set(redrawn.design), {designs[0].key}) shares = a.shares.set_index(["design", "parameter"]) @@ -234,7 +234,7 @@ def build(d): study = Study(SPACE, build, _evaluate) a = attribute_variance( - study, ["y"], self.designs[:1], parameters=["u1", "u2"], replicates=100 + study, ["y"], self.designs[:1], parameters=["u1", "u2"], sample_size=100 ) self.assertFalse(a.results.feasible.all()) self.assertTrue(a.shares[["first", "total"]].notna().all().all()) @@ -244,12 +244,12 @@ def reject(d): never = Study(SPACE, reject, _evaluate) with self.assertWarns(UserWarning): - none = attribute_variance(never, ["y"], self.designs, replicates=2) + none = attribute_variance(never, ["y"], self.designs, sample_size=2) self.assertEqual(len(none.shares), 0) - self.assertEqual(len(none.summary()), 0) + self.assertEqual(len(none.summary), 0) with self.assertWarns(UserWarning): separated = attribute_variance( - never, ["y"], self.designs, replicates=2, by=["sensor"] + never, ["y"], self.designs, sample_size=2, by=["sensor"] ) self.assertEqual(len(separated.shares), 0) @@ -267,16 +267,16 @@ def evaluate(d): ["y"], self.designs[:1], parameters=["u1", "u2"], - replicates=20, + sample_size=20, by=["sensor"], ) shares = a.shares.set_index(["sensor", "parameter"])["total"] self.assertAlmostEqual(shares["one", "u1"], 1.0, delta=0.5) self.assertEqual(shares["one", "u2"], 0.0) self.assertEqual(shares["two", "u1"], 0.0) - self.assertEqual(list(a.summary().index.names), ["sensor", "parameter"]) + self.assertEqual(list(a.summary.index.names), ["sensor", "parameter"]) with self.assertRaises(ValueError): - attribute_variance(study, ["y"], self.designs[:1], replicates=2) + attribute_variance(study, ["y"], self.designs[:1], sample_size=2) def test_store(self): """The evaluations are stored, and taken from the store again.""" @@ -289,10 +289,10 @@ def evaluate(d): with tempfile.TemporaryDirectory() as directory: store = ResultStore(Path(directory) / "results.sqlite", "attribution") study = Study(SPACE, lambda d: d, evaluate, replicates=3, store=store) - first = attribute_variance(study, ["y"], self.designs, replicates=3) + first = attribute_variance(study, ["y"], self.designs, sample_size=3) self.assertEqual(len(self.calls), 2 * (2 * 3 + 3 * 3)) self.calls.clear() - again = attribute_variance(study, ["y"], self.designs, replicates=3) + again = attribute_variance(study, ["y"], self.designs, sample_size=3) self.assertEqual(self.calls, []) pd.testing.assert_frame_equal(first.shares, again.shares) @@ -318,7 +318,7 @@ def setUpClass(cls): ["y", "c"], cls.designs, parameters=["u1", "u2"], - replicates=200, + sample_size=200, n_resamples=200, ) cls.differences = cls.attribution.differences() @@ -336,7 +336,7 @@ def test_cancelled(self): np.testing.assert_allclose(_share(d, "c", "u1", "first"), 1.0) estimate, error = _share(d, "c", "u1"), _share(d, "c", "u1", "total se") self.assertTrue((np.abs(estimate - 1) <= 3 * error).all()) - self.assertAlmostEqual(d.summary().loc["u2", "c se"], 0.0) + self.assertAlmostEqual(d.summary.loc["u2", "c se"], 0.0) # u2 spreads c of both designs, but not their difference self.assertTrue((_share(self.attribution, "c", "u2") > 0.1).all()) @@ -394,7 +394,7 @@ def evaluate(d): study = Study(space, lambda d: d, evaluate) designs = space.enumerate() - a = attribute_variance(study, ["y"], designs, replicates=20, n_resamples=20) + a = attribute_variance(study, ["y"], designs, sample_size=20, n_resamples=20) d = a.differences().shares.set_index(["design", "other", "parameter"]) branch_a, b1, b2 = (design.key for design in designs) # a less b1 is the phase alone @@ -408,7 +408,7 @@ def test_independent_draws(self): """Without common random numbers, no parameter cancels.""" study = Study(SPACE, lambda d: d, _evaluate_pairs, common_random_numbers=False) a = attribute_variance( - study, ["c"], self.designs, parameters=["u1", "u2"], replicates=200 + study, ["c"], self.designs, parameters=["u1", "u2"], sample_size=200 ) d = a.differences() # c of the designs differs by u1 of both and u2 of both: 5 and 2 of 7 diff --git a/tests/tradespace/test_cache.py b/tests/tradespace/test_cache.py index 8cb781ef..7f416156 100644 --- a/tests/tradespace/test_cache.py +++ b/tests/tradespace/test_cache.py @@ -117,20 +117,21 @@ def test_disk_cache_of_other_functions(self): """Results on disk are not shared by functions of other definitions.""" def make(rows): - return SatelliteCache( - lambda satellite, rows=rows: pd.DataFrame( - {"satellite": [satellite.name] * rows} - ), - directory, - namespace="x", + # the same function, edited to give other rows + namespace = {"pd": pd} + exec( # pylint: disable=exec-used + "def analysis(satellite):\n" + + f" return pd.DataFrame({{'satellite': [satellite.name] * {rows}}})", + namespace, ) + return SatelliteCache(namespace["analysis"], directory, namespace="x") with tempfile.TemporaryDirectory() as directory: for rows in (1, 1): self.assertEqual(len(make(rows)(_satellite("a"))), rows) - # a namespace with results only of other definitions warns + # a namespace with results only of the function with other code warns with self.assertWarnsRegex( - UserWarning, r"1 results.*defaults\[0\]: 1 -> 2" + UserWarning, r"1 results.*with other code.*function.(code|constants)" ): cache = make(2) # once, of the caches of the definition (such as of parallel workers) @@ -163,7 +164,10 @@ def make(frame): same = make(pd.DataFrame({"value": [1.0]})) same(_satellite("b")) self.assertEqual((same.hits, same.misses), (1, 0)) - with self.assertWarns(UserWarning): + # results of other data are not reused, without a warning (as + # they are not of the same function with other code) + with warnings.catch_warnings(): + warnings.simplefilter("error") other = make(pd.DataFrame({"value": [2.0]})) self.assertEqual(list(other(_satellite("c")).value), [2.0]) self.assertEqual(other.misses, 1) @@ -207,7 +211,7 @@ def test_pickled_cache_is_empty(self): cache.get(_satellite("a")) copy = pickle.loads(pickle.dumps(cache)) self.assertEqual(copy._memory, {}) # pylint: disable=protected-access - cache.clear() + cache.clear_memory() self.assertEqual((cache.hits, cache.misses), (0, 0)) def test_no_satellites(self): diff --git a/tests/tradespace/test_confirmation.py b/tests/tradespace/test_confirmation.py index 91d11d4a..583398e5 100644 --- a/tests/tradespace/test_confirmation.py +++ b/tests/tradespace/test_confirmation.py @@ -65,8 +65,17 @@ def test_removes_optimism(self): self.assertTrue((confirmation.summary.replicates == 20).all()) # the new replicates follow every replicate of the results self.assertEqual(set(confirmation.results.replicate), set(range(3, 23))) - optimism = confirmation.optimism() + optimism = confirmation.optimism self.assertAlmostEqual(optimism["cost"], 0) + # the optimism of each design, signed by the direction of the objective + summary = confirmation.summary + np.testing.assert_allclose( + summary["value optimism"], summary["value selected"] - summary["value"] + ) + np.testing.assert_allclose( + summary["cost optimism"], summary["cost"] - summary["cost selected"] + ) + self.assertAlmostEqual(optimism["value"], summary["value optimism"].mean()) # the 5 best of 50 designs of 3 replicates look better by about a # standard deviation of their means (0.58), which the new ones remove self.assertGreater(optimism["value"], 0.6) diff --git a/tests/tradespace/test_constellations.py b/tests/tradespace/test_constellations.py index 66f82a10..67a506d5 100644 --- a/tests/tradespace/test_constellations.py +++ b/tests/tradespace/test_constellations.py @@ -300,7 +300,7 @@ def test_default(self): """The lead satellite is at the origin by default.""" design, satellites = _walker() self.assertEqual(design.layout.true_anomaly, 0) - self.assertEqual(design.layout.right_ascension, 0) + self.assertEqual(design.layout.node, 0) self.assertEqual(satellites[0].orbit.true_anomaly, 0) self.assertEqual(satellites[0].orbit.right_ascension_ascending_node, 0) @@ -308,11 +308,11 @@ def test_fractions(self): """Fractions give angles of the intervals of distinct constellations.""" design, satellites = _walker(phase_fraction=0.5, node_fraction=0.25) self.assertAlmostEqual(design.layout.true_anomaly, 0.5 * 360 / 4) - self.assertAlmostEqual(design.layout.right_ascension, 0.25 * 360 / 3) + self.assertAlmostEqual(design.layout.node, 0.25 * 360 / 3) self.assertAlmostEqual(satellites[0].orbit.true_anomaly, 45) self.assertAlmostEqual(satellites[0].orbit.right_ascension_ascending_node, 30) star, _ = _walker(configuration="star", node_fraction=0.25) - self.assertAlmostEqual(star.layout.right_ascension, 90) + self.assertAlmostEqual(star.layout.node, 90) def test_symmetries(self): """A whole interval of phase or node gives the same constellation.""" @@ -347,7 +347,7 @@ def test_uncertain_and_designed(self): fraction = realized.layout.phase_fraction self.assertTrue(0 <= fraction < 1) self.assertAlmostEqual(realized.layout.true_anomaly, fraction * 180) - self.assertAlmostEqual(realized.layout.right_ascension, 0.5 * 180) + self.assertAlmostEqual(realized.layout.node, 0.5 * 180) # the same draw in every design (common random numbers) self.assertEqual(designs[0].realize(0).layout.phase_fraction, fraction) @@ -524,9 +524,15 @@ def test_altitude_outside(self): high.layout, IMAGER, epoch=EPOCH, altitude=high.altitude ) self.assertEqual(len(satellites), count_satellites(high.layout)) - # the satellites of the planes derived at another altitude do not fit - with self.assertRaises(ValueError): - build_constellation(high.layout, IMAGER, epoch=EPOCH, altitude=500e3) + # the fragment keeps the altitude its planes were derived at, which + # builds its satellites whatever altitude is given + self.assertEqual(high.layout.altitude, high.altitude) + for given in (None, 500e3): + built = build_constellation( + high.layout, IMAGER, epoch=EPOCH, altitude=given + ) + self.assertEqual(len(built), count_satellites(high.layout)) + self.assertAlmostEqual(built[0].orbit.mean_altitude, 1000e3) def test_constraints(self): """Constraints of the fragment limit the satellites it derives.""" @@ -556,13 +562,11 @@ def test_fractions(self): (design,) = space.enumerate() layout = design.layout self.assertAlmostEqual(layout.true_anomaly, 180 / layout.per_plane) - self.assertAlmostEqual( - layout.right_ascension, 180 if polar else 180 / layout.planes - ) + self.assertAlmostEqual(layout.node, 180 if polar else 180 / layout.planes) satellites = build_constellation(layout, IMAGER, epoch=EPOCH) self.assertAlmostEqual( satellites[0].orbit.right_ascension_ascending_node, - layout.right_ascension, + layout.node, ) @@ -771,3 +775,87 @@ def orbits(self, epoch, altitude=None): with self.assertRaises(ValueError): Short([0, 90], altitude=600e3).build(IMAGER, epoch=EPOCH) + + +class TestDescriptions(unittest.TestCase): + """ + Unit tests for the descriptions of layouts, and their altitudes. + """ + + def test_describe(self): + """Layouts describe themselves briefly.""" + from tatc.tradespace.constellations import ( + layout_of, + ) # pylint: disable=import-outside-toplevel + + walker = _single( + DesignSpace( + layout=walker_space( + inclination=60, planes=3, per_plane=4, relative_spacing=1 + ) + ) + ).layout + self.assertEqual( + layout_of(walker).describe(), "Walker 60 deg: 3 x 4 (spacing 1)" + ) + self.assertIn("Walker 60 deg", repr(layout_of(walker))) + sso = _single( + DesignSpace( + layout=sso_planes_space( + crossing=Derived(lambda d: [6, 13.5][d.index]), + planes=2, + per_plane=Integer(1, 1), + ordered=True, + ) + ) + ).layout + self.assertEqual(str(layout_of(sso)), "SSO: 1 at 06:00, 1 at 13:30") + mixed = layout_of([walker, sso]) + self.assertEqual( + mixed.describe(), + "Walker 60 deg: 3 x 4 (spacing 1); SSO: 1 at 06:00, 1 at 13:30", + ) + mog = _single( + DesignSpace( + layout=mog_space( + parallel_axis=10e3, + transverse_axis=5e3, + inclination=45, + satellites=3, + altitude=500e3, + ) + ) + ).layout + self.assertEqual( + layout_of(mog).describe(), "MOG 45 deg at 500 km: 3 satellites (10 x 5 km)" + ) + + def test_own_altitude(self): + """A layout's own altitude is built, rather than the one given.""" + layout = _single( + DesignSpace( + layout=walker_space( + inclination=60, planes=1, per_plane=1, altitude=700e3 + ) + ) + ).layout + satellites = build_constellation(layout, IMAGER, epoch=EPOCH, altitude=500e3) + self.assertAlmostEqual(satellites[0].orbit.mean_altitude, 700e3) + + def test_unrealized(self): + """A layout of unrealized values (NaN) is not built.""" + space = DesignSpace( + layout=walker_space( + inclination=60, + planes=1, + per_plane=2, + phase_fraction=Uncertain.uniform(0, 1), + ) + ) + design = space.enumerate()[0] + with self.assertRaisesRegex(ValueError, "realize"): + build_constellation(design.layout, IMAGER, epoch=EPOCH, altitude=500e3) + built = build_constellation( + design.realize(0).layout, IMAGER, epoch=EPOCH, altitude=500e3 + ) + self.assertEqual(len(built), 2) diff --git a/tests/tradespace/test_cost.py b/tests/tradespace/test_cost.py index 580a8fbe..435fd64d 100644 --- a/tests/tradespace/test_cost.py +++ b/tests/tradespace/test_cost.py @@ -120,7 +120,7 @@ def test_elements(self): schedule = DeploymentSchedule(years=6, design_life=3, launch_capacity=3) estimate = model.estimate(schedule.plan(_walker(planes=3, per_plane=4))) # two generations of 3 planes of 4 satellites, 2 launches each - self.assertEqual(estimate.units, {"satellites": 24}) + self.assertEqual(estimate.units, {None: 24}) self.assertEqual(estimate.launches, 12) self.assertEqual(estimate.development, 100) self.assertAlmostEqual(estimate.production, self.satellite.production(24)) @@ -152,7 +152,7 @@ def test_rideshare(self): self.satellite, launch=LaunchCost(per_satellite=2, per_kg=0.1) ) estimate = model.estimate(DeploymentSchedule().plan(_walker(1, 4))) - self.assertEqual(estimate.launches, 0) + self.assertEqual(estimate.launches, 1) # counted, though not priced per launch self.assertAlmostEqual(estimate.launch, 4 * (2 + 0.1 * 50)) with self.assertRaises(ValueError): CostModel(SatelliteCost(), launch=LaunchCost(per_kg=1)).estimate( @@ -168,7 +168,7 @@ def test_spares(self): ) schedule = DeploymentSchedule(launch_capacity=4) estimate = model.estimate(schedule.plan(_walker(2, 4), spares=1)) - self.assertEqual(estimate.units["satellites"], 10) + self.assertEqual(estimate.units[None], 10) self.assertEqual(estimate.launches, 4) self.assertEqual(estimate.operations, 10) @@ -306,8 +306,8 @@ def test_blocks(self): self.terms["satellites"], block_size=4, redevelopment=0.5 ) dated = self._estimate(development_years=2, production_rate=8) - self.assertEqual(dated.units, {"satellites": 24}) - self.assertEqual(dated.blocks, {"satellites": 6}) + self.assertEqual(dated.units, {None: 24}) + self.assertEqual(dated.blocks, {None: 6}) self.assertAlmostEqual(dated.development, 90 + 5 * 45) learning = SatelliteCost(first_unit=10, learning_rate=0.9) self.assertAlmostEqual(dated.production, 6 * learning.production(4)) @@ -316,17 +316,18 @@ def test_blocks(self): ] # the second block (the second plane of the first generation, produced # from 2.5) is developed over the two years before - self.assertIn((1.0, 22.5), development) - self.assertIn((2.0, 22.5), development) + # (in parts within the years from the start of development) + for flow in [(0.75, 11.25), (1.5, 22.5), (2.25, 11.25)]: + self.assertIn(flow, development) # the fourth (the first replacements, produced from 5.25) - self.assertIn((3.75, 22.5), development) - self.assertIn((4.75, 22.5), development) + for flow in [(3.625, 16.875), (4.5, 22.5), (5.125, 5.625)]: + self.assertIn(flow, development) # without blocks, one self.assertEqual( CostModel(SatelliteCost(development=90)) .estimate(DeploymentSchedule(years=6, design_life=3).plan(self.layout)) .blocks, - {"satellites": 1}, + {None: 1}, ) def test_sustained(self): @@ -349,11 +350,11 @@ def test_sustained(self): sustained = model.estimate( DeploymentSchedule(**terms, sustained=True).plan(_walker(1, 1)) ) - self.assertEqual(ending.units, {"satellites": 3}) + self.assertEqual(ending.units, {None: 3}) self.assertEqual(ending.development, 90 + 90) self.assertEqual(ending.production, 30) - self.assertEqual(sustained.units, {"satellites": 4}) - self.assertEqual(sustained.blocks, {"satellites": 2}) + self.assertEqual(sustained.units, {None: 4}) + self.assertEqual(sustained.blocks, {None: 2}) # the third block is developed over [8, 11], two thirds by the end self.assertAlmostEqual(sustained.development, 90 + 90 + 60) # half of the fourth unit, and none of the fifth @@ -751,3 +752,21 @@ def test_invalid(self): ) with self.assertRaises(ValueError): risk_space(dotted) + + +class TestSpread(unittest.TestCase): + """ + Unit tests for amounts spread over durations. + """ + + def test_years(self): + """Amounts are spread in parts within years, for the annual costs.""" + from tatc.tradespace.cost import ( + _spread, + ) # pylint: disable=import-outside-toplevel + + flows = _spread(10.0, 3.5, 6.0) + self.assertEqual(flows, [(3.75, 2.0), (4.5, 4.0), (5.5, 4.0)]) + self.assertEqual(_spread(10.0, 0.0, 2.0), [(0.5, 5.0), (1.5, 5.0)]) + # the part before the end of a sustained mission + self.assertEqual(_spread(10.0, 3.5, 6.0, until=5.0), [(3.75, 2.0), (4.5, 4.0)]) diff --git a/tests/tradespace/test_criteria.py b/tests/tradespace/test_criteria.py index 04252766..fc7e2fbb 100644 --- a/tests/tradespace/test_criteria.py +++ b/tests/tradespace/test_criteria.py @@ -203,11 +203,22 @@ def test_criteria(self): ) frame = aggregate(_results(), criteria).set_index("design") self.assertEqual( - list(frame.columns[-6:-2]), ["cost", "value", "value p25", "replicates"] + list(frame.columns[-7:]), + [ + "cost", + "value", + "value p25", + "replicates", + "violation", + "meets_requirements", + "pareto", + ], ) self.assertAlmostEqual(frame.loc["a", "violation"], 0.5 / 1.5) self.assertAlmostEqual(frame.loc["c", "violation"], 4 / 5) self.assertEqual(list(frame.meets_requirements), [False, False, False]) + # none meets the requirements, so that none is efficient + self.assertEqual(list(frame.pareto), [False, False, False]) with self.assertRaises(ValueError): aggregate(_results(), criteria, by=["size"]) @@ -365,3 +376,43 @@ def test_misses_ranked_last(self): self.assertGreater(misses.pareto_rank.min(), meets.pareto_rank.max()) # the nearest miss (cost 4) is kept to fill four designs self.assertEqual(sorted(first[first.kept].cost), [1, 2, 3, 4]) + + +class TestSummaries(unittest.TestCase): + """ + Unit tests for summaries of criteria. + """ + + def test_pareto(self): + """Summaries of criteria give the efficient designs, in each group.""" + criteria = Criteria({"cost": "min", "value": "max"}, by="size") + summary = aggregate(_results(), criteria) + self.assertEqual( + list(summary.pareto), + list(pareto_front(summary.drop(columns="pareto"), criteria)), + ) + # designs a (a mean of 13) and b (17.5) of the same cost, and c alone + self.assertEqual( + dict(zip(summary.design, summary.pareto)), + {"a": False, "b": True, "c": True}, + ) + + def test_summarize_criteria(self): + """Summaries of criteria add the spread of their means of metrics.""" + criteria = Criteria( + {"cost": "min", "value": "max"}, + statistics={"value p25": Quantile("value", 0.25)}, + ) + summary = summarize(_results(), criteria) + for column in ("cost std", "cost se", "value std", "value se", "pareto"): + self.assertIn(column, summary.columns) + self.assertNotIn("value p25 se", summary.columns) + grouped = summarize(_results(), {"value": "max"}, by="size") + self.assertEqual(len(grouped), 3) + with self.assertRaises(ValueError): + summarize(_results(), Criteria({"value": "max"}), by="size") + + def test_statistics_of_names(self): + """Statistics given by names are the means of the metrics.""" + summary = aggregate(_results(), {"value": "max"}, statistics=["cost"]) + self.assertEqual(list(summary.cost), [2.0, 2.0, 1.0]) diff --git a/tests/tradespace/test_failures.py b/tests/tradespace/test_failures.py index f7531a59..d3f0c03a 100644 --- a/tests/tradespace/test_failures.py +++ b/tests/tradespace/test_failures.py @@ -368,9 +368,8 @@ def test_policy_validation(self): ): with self.assertRaises(ValueError): RestorationPolicy(**invalid) - self.assertEqual( - RestorationPolicy(ground_spares={"a": 2}).ground_spares_of("b"), 0 - ) + with self.assertRaisesRegex(ValueError, "ground spares"): + RestorationPolicy(ground_spares={"a": 2}).ground_spares_of("b") class TestPolicySpace(unittest.TestCase): @@ -530,7 +529,7 @@ def test_phase_cache(self): cache = PhaseCache(self._metric) for history in histories: phases = history.phases(self.satellites) - cached = cache.evaluate(phases, self.observations, self.satellites, "r0") + cached = cache.evaluate(phases, self.satellites, self.observations, "r0") direct = evaluate_phases(phases, self.observations, self._metric) pd.testing.assert_frame_equal(cached, direct) self.assertGreater(cache.hits, cache.misses) @@ -543,13 +542,13 @@ def test_phase_cache(self): {s.name: r.name for s, r in zip(self.satellites, renamed)} ) misses = cache.misses - cache.evaluate(histories[0].phases(renamed), observations, renamed, "r0") + cache.evaluate(histories[0].phases(renamed), renamed, observations, "r0") self.assertEqual(cache.misses, misses) # other observations (another context) are evaluated again cache.evaluate( histories[0].phases(self.satellites), - self.observations, self.satellites, + self.observations, "r1", ) self.assertGreater(cache.misses, misses) @@ -662,7 +661,7 @@ def test_stratified_histories(self): RestorationPolicy(restore=False), seed, 20, - sampling, + sampling=sampling, ) ] ) diff --git a/tests/tradespace/test_fingerprint.py b/tests/tradespace/test_fingerprint.py index 227f2342..7bdaadd2 100644 --- a/tests/tradespace/test_fingerprint.py +++ b/tests/tradespace/test_fingerprint.py @@ -5,18 +5,21 @@ """ import ast +import importlib import os +import tempfile import subprocess import sys import unittest from unittest import mock from datetime import datetime, timedelta, timezone from functools import partial +from pathlib import Path import numpy as np import pandas as pd -from shapely.geometry import Point +from shapely.geometry import Point, box from tatc.analysis import collect_observations from tatc.generation import generate_points_rotated_lattice @@ -348,3 +351,70 @@ def test_stable_between_sessions(self): ) prints.add(output.stdout.strip()) self.assertEqual(len(prints), 1) + + +_BOX = box(0, 0, 1, 1) + + +def _uses_box(d): + return {"area": _BOX.area * d.a} + + +def _function(source, **names): + """A function `f` of source code, with globals.""" + namespace = dict(names) + exec(source, namespace) # pylint: disable=exec-used + return namespace["f"] + + +class TestDescriptions(unittest.TestCase): + """ + Unit tests for the descriptions of values that fingerprints hash. + """ + + def test_geometries(self): + """Geometries are described by their content, also as globals.""" + + def closing(geometry): + return lambda d: geometry.area * d.a + + self.assertNotEqual( + get_fingerprint(f=closing(box(0, 0, 1, 1))), + get_fingerprint(f=closing(box(0, 0, 2, 2))), + ) + self.assertEqual( + get_fingerprint(f=closing(box(0, 0, 1, 1))), + get_fingerprint(f=closing(box(0, 0, 1, 1))), + ) + described = get_definition(f=_uses_box)["values"]["f"]["globals"]["_BOX"] + self.assertIn("data", described) + + def test_docstrings(self): + """The docstrings of functions do not change fingerprints.""" + one = _function('def f(x):\n """One."""\n return x\n') + other = _function('def f(x):\n """Another."""\n return x\n') + changed = _function('def f(x):\n """One."""\n return x + 1\n') + self.assertEqual(get_fingerprint(f=one), get_fingerprint(f=other)) + self.assertNotEqual(get_fingerprint(f=one), get_fingerprint(f=changed)) + + def test_own_modules(self): + """Functions of modules that are not installed are described by code.""" + with tempfile.TemporaryDirectory() as directory: + Path(directory, "tatc_own_helpers.py").write_text( + "def helper(x):\n return x + 1\n", encoding="utf-8" + ) + sys.path.insert(0, directory) + try: + module = importlib.import_module("tatc_own_helpers") + calling = _function( + "def f(x):\n return helper(x)\n", helper=module.helper + ) + described = get_definition(f=calling)["values"]["f"]["globals"] + self.assertIn("code", described["helper"]) + # functions of installed modules by their names + installed = _function("def f(x):\n return isna(x)\n", isna=pd.isna) + described = get_definition(f=installed)["values"]["f"]["globals"] + self.assertEqual(set(described["isna"]), {"name"}) + finally: + sys.path.remove(directory) + sys.modules.pop("tatc_own_helpers", None) diff --git a/tests/tradespace/test_layering.py b/tests/tradespace/test_layering.py index 06fb1c76..cb42fe47 100644 --- a/tests/tradespace/test_layering.py +++ b/tests/tradespace/test_layering.py @@ -19,7 +19,9 @@ "comparison", "confirmation", "criteria", + "dominance", "fingerprint", + "hashing", "nodes", "optimization", "pareto", diff --git a/tests/tradespace/test_observations.py b/tests/tradespace/test_observations.py index cb9d7178..23a3c331 100644 --- a/tests/tradespace/test_observations.py +++ b/tests/tradespace/test_observations.py @@ -10,6 +10,7 @@ import pickle import tempfile import unittest +import warnings from datetime import datetime, timedelta, timezone from functools import partial from pathlib import Path @@ -50,6 +51,7 @@ risk_space, walker_space, ) +from tatc.tradespace.mission import summarize_phases from tatc.tradespace.observations import value_of HAS_JOBLIB = importlib.util.find_spec("joblib") is not None @@ -578,3 +580,108 @@ def test_parallel(self): parallel = study(n_jobs=2).run(designs) columns = [c for c in serial.columns if c != "seconds"] pd.testing.assert_frame_equal(serial[columns], parallel[columns]) + + +class TestOneDesign(unittest.TestCase): + """ + Unit tests for the parts of the evaluations of one design. + """ + + def setUp(self): + self.study = ObservationStudy( + SPACE, + _build, + _observations(), + _metrics, + layout="layout", + plan=PLAN, + phases=True, + replicates=2, + ) + self.design = SPACE.enumerate()[3] + + def test_mission(self): + """The deployment, phases, and costs of a design are its evaluation's.""" + result = self.study.run([self.design]).iloc[1] + realized = self.study.realize(self.design, 1) + deployment = self.study.deployment_of(self.design, 1) + self.assertEqual(deployment.planes, SCHEDULE.plan(realized.layout).planes) + self.assertIsNotNone(deployment.capability) + phases = self.study.phases_of(self.design, 1) + self.assertAlmostEqual( + summarize_phases(phases)["observed mission"], result["observed mission"] + ) + self.assertAlmostEqual( + self.study.estimate_of(self.design, 1).total, result["cost"] + ) + unplanned = self.study.replace(plan=None, phases=None) + with self.assertRaisesRegex(ValueError, "plan"): + unplanned.deployment_of(self.design) + + def test_realize(self): + """A study realizes designs with its seed, and in its scenarios.""" + self.assertEqual( + self.study.realize(self.design, 1).growth, self.design.realize(1).growth + ) + self.assertNotEqual( + self.study.replace(seed=3).realize(self.design, 1).growth, + self.design.realize(1).growth, + ) + slow = self.study.replace(scenarios={"slow": {"growth": 1.2}}) + self.assertEqual(slow.realize(self.design, 1, "slow").growth, 1.2) + self.assertEqual( + slow.satellites_of(self.design, 1, "slow"), + slow.satellites_of(self.design, 1), + ) + with self.assertRaises(KeyError): + slow.realize(self.design, 1, "fast") + + def test_prune(self): + """Observations remove their caches' results of other definitions.""" + with tempfile.TemporaryDirectory() as directory: + first = _observations(directory) + other = Observations( + TARGETS, + START, + HOURS, + analysis=partial(collect_observations), + directory=directory, + ) + realized = self.design.realize(0) + satellites = _build(realized) + first(satellites, realized) + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + other(satellites, realized) + self.assertEqual(other.prune(), len(satellites)) + self.assertEqual(other.prune(), 0) + self.assertEqual(Observations(TARGETS, START, HOURS).prune(), 0) + + def test_failure_options(self): + """Failures sample stressed histories, with controls and spreads.""" + self.assertTrue(Failures(FAILURES).policy.restore) + study = ObservationStudy( + SPACE, + _build, + _observations(), + _metrics, + layout="layout", + plan=PLAN, + failures=Failures( + FAILURES, + histories=6, + seed="failure_seed", + stress=2.0, + controls=["availability"], + control_histories=50, + spread=True, + ), + ) + result = study.run([self.design]).iloc[0] + self.assertIn("observed mission histories std", result.index) + self.assertLess(result["effective histories"], 6) + self.assertTrue(math.isfinite(result["observed mission"])) + with self.assertRaisesRegex(ValueError, "controls"): + study.replace( + failures=Failures(FAILURES, seed="failure_seed", controls=["other"]) + ).run([self.design]) diff --git a/tests/tradespace/test_optimization.py b/tests/tradespace/test_optimization.py index e83a10b0..08fc5567 100644 --- a/tests/tradespace/test_optimization.py +++ b/tests/tradespace/test_optimization.py @@ -121,7 +121,7 @@ def test_dynamic_count_bound(self): """Counts need fixed upper bounds to be encoded.""" space = DesignSpace( n=Integer(1, 3), - items=Repeat(Integer(0, 1), count=Integer(1, lambda d: d.n)), + parts=Repeat(Integer(0, 1), count=Integer(1, lambda d: d.n)), ) with self.assertRaises(ValueError): space.unit_paths() @@ -482,6 +482,9 @@ def build(d): share = evaluations.infeasibility[space.enumerate()[1].key] self.assertGreater(share, 0) self.assertLess(share, 1) + # the summary of a search is of the designs it found feasible + summary = evaluations.search(None).summary + self.assertEqual(list(summary.design), [space.enumerate()[0].key]) optuna_study = optimize_optuna(study, {"f": "max"}, n_trials=6).state for trial in optuna_study.trials: if trial.params.get("x") == 1: diff --git a/tests/tradespace/test_pareto.py b/tests/tradespace/test_pareto.py index dc20ea4b..b6c10e27 100644 --- a/tests/tradespace/test_pareto.py +++ b/tests/tradespace/test_pareto.py @@ -383,3 +383,19 @@ def test_standard_errors(self): np.testing.assert_allclose( probability.set_index("design")["y se"], expected, rtol=0.15 ) + + +class TestMissingObjectives(unittest.TestCase): + """ + Unit tests for designs with missing objectives. + """ + + def test_not_efficient(self): + """A design with a missing objective is not efficient, and dominates none.""" + summary = pd.DataFrame( + {"design": list("abc"), "x": [1.0, np.nan, 2.0], "y": [1.0, 0.0, 0.0]} + ) + objectives = {"x": "min", "y": "min"} + self.assertEqual(list(pareto_front(summary, objectives)), [True, False, True]) + self.assertEqual(list(pareto_ranks(summary, objectives)), [0, 1, 0]) + self.assertAlmostEqual(hypervolume(summary, objectives, {"x": 3, "y": 2}), 3.0) diff --git a/tests/tradespace/test_plotting.py b/tests/tradespace/test_plotting.py index 0afea236..5eada6d0 100644 --- a/tests/tradespace/test_plotting.py +++ b/tests/tradespace/test_plotting.py @@ -123,7 +123,7 @@ def test_exceedance(self): } ) compared = exceedance(results, "cost") - ax = plot_exceedance(compared, labels={"a": "first"}) + ax = plot_exceedance(compared, names={"a": "first"}) matrix = ax.images[0].get_array() self.assertEqual(matrix.shape, (3, 3)) self.assertEqual(matrix[2, 0], 1.0) # c costs more than a @@ -135,3 +135,38 @@ def test_exceedance(self): twice = pd.concat([compared, compared.assign(scenario="other")]) with self.assertRaises(ValueError): plot_exceedance(twice) + + +class TestHighlights(unittest.TestCase): + """ + Unit tests for plots of some designs over others. + """ + + def tearDown(self): + plt.close("all") + + def test_highlight(self): + """Highlighted designs are colored over the others, in gray.""" + summary = pd.DataFrame( + { + "x": [1.0, 2.0, 3.0, 4.0], + "y": [1.0, 2.0, 2.5, 4.0], + "pareto": [True, True, False, True], + } + ) + ax = plot_designs( + summary, + "x", + "y", + highlight=[True, False, True, False], + label="chosen", + others="the rest", + front=summary.pareto.to_numpy(), + front_label="true front", + colors={"a": "#123456"}, + ) + labels = [text.get_text() for text in ax.get_legend().get_texts()] + self.assertEqual(labels, ["the rest", "chosen", "true front"]) + self.assertEqual(len(ax.collections[1].get_offsets()), 2) + with self.assertRaises(ValueError): + plot_designs(summary, "x", "y", highlight=[True]) diff --git a/tests/tradespace/test_scenarios.py b/tests/tradespace/test_scenarios.py index c8b32905..4776ccb7 100644 --- a/tests/tradespace/test_scenarios.py +++ b/tests/tradespace/test_scenarios.py @@ -136,7 +136,7 @@ def test_attribution(self): store = ResultStore(self.path, "scenarios") study = self._study(SCENARIOS, store=store) a = attribute_variance( - study, ["y"], SPACE.enumerate(), replicates=20, by=["scenario"] + study, ["y"], SPACE.enumerate(), sample_size=20, by=["scenario"] ) shares = a.shares.set_index(["design", "scenario"])["total"] key = SPACE.enumerate()[0].key @@ -146,7 +146,7 @@ def test_attribution(self): self.assertTrue(np.isnan(shares[key, "pinned"])) self.calls.clear() attribute_variance( - study, ["y"], SPACE.enumerate(), replicates=20, by=["scenario"] + study, ["y"], SPACE.enumerate(), sample_size=20, by=["scenario"] ) self.assertEqual(self.calls, []) @@ -271,6 +271,8 @@ def test_study(self): # every design trades y against cost, in every scenario np.testing.assert_allclose(r["pareto_trace"], 1.0) self.assertEqual(len(r), 3) + # with the values of the designs, from which they are rebuilt + self.assertEqual(len(SPACE.designs_of(r)), 3) class TestAcross(unittest.TestCase): diff --git a/tests/tradespace/test_space.py b/tests/tradespace/test_space.py index 1d7539a1..730d9734 100644 --- a/tests/tradespace/test_space.py +++ b/tests/tradespace/test_space.py @@ -330,7 +330,7 @@ def test_same_designs(self): """Walking one order of unordered items gives the same designs.""" spaces = [ DesignSpace( - items=Repeat( + parts=Repeat( DesignSpace( kind=Choice( a=DesignSpace(x=Integer(0, 2)), @@ -424,3 +424,165 @@ def test_extend(self): extended.design(design, z=1) with self.assertRaises(Infeasible): extended.design({"a": 3, "b": 0, "c": "x"}) + + +def _layouts_space(): + """A choice of a group of planes (a number) or a repetition of planes.""" + return DesignSpace( + altitude=Real(500e3, 600e3, step=100e3), + layout=Choice( + walker=DesignSpace(planes=Integer(1, 2), per_plane=Fixed(2)), + sso=DesignSpace( + planes=Repeat( + DesignSpace(crossing=Real(6, 9, step=3)), count=Categorical([1, 2]) + ) + ), + ), + ) + + +class TestValuesByPath(unittest.TestCase): + """ + Unit tests for the values of designs by their paths. + """ + + def setUp(self): + self.designs = _layouts_space().enumerate() + self.walker = next(d for d in self.designs if d.layout == "walker") + self.sso = [d for d in self.designs if d.layout == "sso"][-1] + + def test_paths(self): + """Paths of the columns of results (and of fixed values) give values.""" + self.assertEqual(self.walker["layout.walker.planes"], self.walker.layout.planes) + self.assertEqual(self.walker["layout.walker.per_plane"], 2) # fixed + self.assertEqual(self.walker["layout.walker"], self.walker.layout.value) + self.assertEqual(self.sso["layout.sso.planes.count"], 2) + self.assertEqual( + self.sso["layout.sso.planes[1].crossing"], + self.sso.layout.planes[1].crossing, + ) + for design in (self.walker, self.sso): + for path, value in design.flat().items(): + self.assertEqual(design[path], value, path) + with self.assertRaisesRegex(KeyError, "chose 'sso'"): + self.sso["layout.walker.planes"] # pylint: disable=pointless-statement + with self.assertRaisesRegex(KeyError, "2 items"): + self.sso[ + "layout.sso.planes[2].crossing" + ] # pylint: disable=pointless-statement + + def test_choices(self): + """A choice equals the name of its branch, and steps into it.""" + layout = self.walker.layout + self.assertTrue(layout == "walker") + self.assertFalse(layout == "sso") + self.assertIn("planes", layout) + self.assertNotIn("crossing", layout) + self.assertEqual(layout.walker.planes, layout.planes) + with self.assertRaisesRegex(AttributeError, "chose 'walker'"): + layout.sso # pylint: disable=pointless-statement + + def test_items(self): + """Repetitions give views of their items, also of slices.""" + planes = self.sso.layout.planes + self.assertEqual(planes[-1].crossing, planes[1].crossing) + self.assertEqual([plane.crossing for plane in planes[:1]], [planes[0].crossing]) + self.assertEqual(planes, list(planes)) + + def test_constraints(self): + """The callables of a design space read values by paths too.""" + space = DesignSpace( + layout=Choice(walker=DesignSpace(planes=Integer(1, 3))), + constraints=[lambda d: d["layout.walker.planes"] <= 2], + ) + self.assertEqual(len(space.enumerate()), 2) + + +class TestReservedNames(unittest.TestCase): + """ + Unit tests for names that the views of values give otherwise. + """ + + def test_reserved(self): + """Children and branches may not be named as attributes of views.""" + for name in ("values", "items", "keys", "get", "key", "flat", "space"): + with self.assertRaisesRegex(ValueError, "reserved"): + DesignSpace(**{name: 1}) + for name in ("choice", "value"): + with self.assertRaisesRegex(ValueError, "reserved"): + Choice(**{name: DesignSpace()}) + + +class TestCounts(unittest.TestCase): + """ + Unit tests for the counts of repetitions. + """ + + def test_kinds(self): + """Counts may be categorical, fixed, or derived.""" + categorical = DesignSpace( + parts=Repeat(Integer(0, 1), count=Categorical([1, 3])) + ) + designs = categorical.enumerate() + self.assertEqual(len(designs), 2 + 8) + self.assertEqual( + categorical.unit_paths(), + ["parts.count", "parts[0]", "parts[1]", "parts[2]"], + ) + rebuilt = categorical.designs_of( + pd.DataFrame([{"design": d.key, **d.flat()} for d in designs]) + ) + self.assertEqual([d.key for d in rebuilt], [d.key for d in designs]) + fixed = DesignSpace(parts=Repeat(Integer(0, 1), count=Fixed(2))) + self.assertEqual(len(fixed.enumerate()), 4) + derived = DesignSpace( + n=Integer(1, 2), parts=Repeat(Integer(0, 1), count=Derived(lambda d: d.n)) + ) + self.assertEqual(len(derived.enumerate()), 2 + 4) + with self.assertRaisesRegex(ValueError, "upper bound"): + derived.unit_paths() + + def test_invalid(self): + """Counts of other nodes, or negative, are rejected at once.""" + with self.assertRaisesRegex(TypeError, "count"): + Repeat(Integer(0, 1), count=Real(1, 2)) + with self.assertRaises(ValueError): + Repeat(Integer(0, 1), count=-1) + + +class TestDomains(unittest.TestCase): + """ + Unit tests for the decisions of designs given by their values. + """ + + def test_checked(self): + """Decisions outside their variables' domains are rejected.""" + space = DesignSpace(a=Integer(1, 6), b=Categorical(["x", "y"]), c=Real(0, 1)) + self.assertEqual(space.design({"a": 2, "b": "x", "c": 0.5}).a, 2) + for decisions in ({"a": 99}, {"b": "z"}, {"c": 2.0}): + with self.assertRaises(ValueError): + space.design({"a": 2, "b": "x", "c": 0.5, **decisions}) + + +class TestUncertainConstructors(unittest.TestCase): + """ + Unit tests for the constructors of uncertain parameters. + """ + + def test_triangular(self): + """A triangular parameter draws in its range, and names it.""" + growth = Uncertain.triangular(0.9, 1.0, 1.6) + self.assertEqual(repr(growth), "Uncertain(triangular(0.9, 1.0, 1.6))") + self.assertTrue(math.isnan(growth.nominal)) + space = DesignSpace(growth=growth) + draws = [space.enumerate()[0].realize(r).growth for r in range(50)] + self.assertTrue(all(0.9 <= draw <= 1.6 for draw in draws)) + with self.assertRaises(ValueError): + Uncertain.triangular(1.0, 0.5, 2.0) + + def test_nominal(self): + """The constructors take nominal values.""" + space = DesignSpace(x=Uncertain.uniform(0, 1, nominal=0.5)) + self.assertEqual(space.enumerate()[0].x, 0.5) + self.assertEqual(Uncertain.normal(0, 1, nominal=0.0).nominal, 0.0) + self.assertIn("seed()", repr(Uncertain.seed())) diff --git a/tests/tradespace/test_stages.py b/tests/tradespace/test_stages.py index a2d330d0..04a96794 100644 --- a/tests/tradespace/test_stages.py +++ b/tests/tradespace/test_stages.py @@ -110,24 +110,26 @@ def test_decisions(self): def rule(decision): seen.append(decision) - return decision.time >= 1.0 + return decision.since_launch >= 1.0 stages = [Stage(1, 0.25), Stage(2, [0.5, 1.0, 1.5], rule)] history = SCHEDULE.plan(_layout(), stages=stages).simulate() - self.assertEqual([d.time for d in seen], [0.5, 1.0]) + self.assertEqual([d.since_launch for d in seen], [0.5, 1.0]) self.assertEqual({d.stage for d in seen}, {1}) - self.assertEqual(seen[0].deployed, (0,)) + self.assertEqual(seen[0].stages_deployed, (0,)) # the satellites of the first plane operate (those of the second are # still being produced) - self.assertEqual(seen[0].operating, 2) + self.assertEqual(seen[0].satellites_operating, 2) begin = min(launch.time for launch in history.launches) + # times are from the start of development, as every time of a mission + self.assertEqual([d.time for d in seen], [begin + 0.5, begin + 1.0]) self.assertEqual(history.stages, [begin + 0.25, begin + 1.0]) def test_contingency(self): """A rule on failures deploys a stage in the histories that need it.""" failures = FailureModel(life=Exponential(0.1)) policy = RestorationPolicy(restore=False) - stage = Stage(2, [0.5, 1.0, 1.5, 2.0], lambda d: d.operating < 4) + stage = Stage(2, [0.5, 1.0, 1.5, 2.0], lambda d: d.satellites_operating < 4) deployment = SCHEDULE.plan(_layout(), stages=[stage]) self.assertEqual(deployment.simulate().stages, [None]) histories = deployment.simulate_many(failures, policy, seed=1, histories=20) @@ -137,6 +139,9 @@ def test_contingency(self): failed = [t for t, *_ in history.failures] if history.stages[0] is not None: self.assertLess(min(failed), history.stages[0]) + # the satellites of a stage count in the availability of the + # histories that deploy it (and only of those) + self.assertLessEqual(history.metrics()["availability"], 1.0) # the same history draws the same failures again again = deployment.simulate_many(failures, policy, seed=1, histories=20) self.assertEqual([h.stages for h in again], [h.stages for h in histories]) @@ -146,7 +151,13 @@ def test_capability(self): seen = [] def rule(decision): - seen.append((decision.time, decision.operating, decision.capability)) + seen.append( + ( + decision.since_launch, + decision.satellites_operating, + decision.capability, + ) + ) return decision.capability["observing"] < 4 deployment = SCHEDULE.plan(_layout(), stages=[Stage(2, [0.0, 0.5], rule)]) @@ -155,7 +166,7 @@ def rule(decision): # the first plane alone at the first launch (the second is launched later) self.assertEqual(seen, [(0.0, 2, {"observing": 2.0})]) self.assertEqual(history.stages, [deployment.begin]) - # the planned history (of the availability) reads it too + # the planned history reads it too self.assertEqual(history.metrics()["stages deployed"], 1.0) self.assertEqual(deployment.planned().stages, [deployment.begin]) later = SCHEDULE.plan(_layout(), stages=[Stage(2, 0.5, rule)]) @@ -172,7 +183,9 @@ def test_capability_of_failures(self): policy = RestorationPolicy(restore=False) by_count = SCHEDULE.plan( _layout(), - stages=[Stage(2, [0.5, 1.0, 1.5, 2.0], lambda d: d.operating < 4)], + stages=[ + Stage(2, [0.5, 1.0, 1.5, 2.0], lambda d: d.satellites_operating < 4) + ], ) measured = SCHEDULE.plan( _layout(), diff --git a/tests/tradespace/test_store.py b/tests/tradespace/test_store.py index 20ce7e1d..d5f3690e 100644 --- a/tests/tradespace/test_store.py +++ b/tests/tradespace/test_store.py @@ -108,7 +108,7 @@ def test_more_replicates(self): store = ResultStore(self.path, "study") self._study(store).run() self.calls.clear() - results = self._study(store).run(replicates=range(5)) + results = self._study(store).run(replicate_indices=range(5)) self.assertEqual(len(self.calls), 4 * 2) self.assertEqual(len(results), 4 * 5) @@ -180,6 +180,16 @@ def study(evaluate): with self.assertWarnsRegex(UserWarning, "other code.*evaluate.code"): edited = study(lambda d: {"value": d.a + 1}).run() self.assertEqual(list(edited.value[:2]), [2, 2]) + # another study (of other settings) shares the namespace + other = study(lambda d: {"value": d.a + 1}).replace(seed=1) + other.run() + # pruning removes the study's evaluations with other code, only + current = study(lambda d: {"value": d.a + 1}) + self.assertEqual(current.prune(), 8) + self.assertEqual( + store.contexts(), {current.fingerprint: 8, other.fingerprint: 8} + ) + self.assertEqual(current.prune(), 0) def test_records_as_json(self): """Records are kept as JSON, and read as they were written.""" @@ -240,8 +250,8 @@ def test_definitions(self): self.assertEqual( list(store.contexts()), [study.fingerprint, reseeded.fingerprint] ) - # the records of other definitions are removed - self.assertEqual(store.prune(reseeded.fingerprint), 12) + # the records of a context are removed + self.assertEqual(store.remove(study.fingerprint), 12) self.assertEqual(store.contexts(), {reseeded.fingerprint: 12}) self.assertIsNone(store.definition(study.fingerprint)) store.clear() @@ -288,7 +298,7 @@ def test_shifted_runs(self): shifted = self._study(store).run(shift={"noise": 3}) self.assertEqual(len(self.calls), 2 * 4 * 3) self.assertEqual(list(shifted.replicate), list(plain.replicate)) - later = self._study(store).run(replicates=range(3, 6)) + later = self._study(store).run(replicate_indices=range(3, 6)) np.testing.assert_array_equal(shifted.noise, later.noise) self.calls.clear() again = self._study(store).run(shift={"noise": 3}) From d89e9135b02f1f1c07c9926d99f3d27aa9c1fb1d Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Sat, 14 Nov 2026 07:00:50 -0700 Subject: [PATCH 46/52] review the trade space a third time: prune only evaluations and observations of the same study with other code (keeping those of studies that differ in constants or analyses), key designs given by value as their levels, fingerprint the classes and objects of a study's own modules by their attributes and code, summarize criteria across scenarios, name statistics by convention, color designs by values, plot shares of variance, apply a style to the plots of trade studies, refer to a design's restoration policy, give the histories of a design's failures, and seed searches with Optuna by default --- CHANGELOG.md | 1 + docs/api_reference/tradespace/evaluate.rst | 2 +- docs/api_reference/tradespace/index.rst | 13 +- docs/api_reference/tradespace/judge.rst | 11 +- docs/api_reference/tradespace/missions.rst | 6 +- .../tradespace/CompareScenarios.ipynb | 124 +++---- .../tradespace/EvaluateTradeSpace.ipynb | 81 +++-- .../tradespace/ExplainTradeSpace.ipynb | 97 +++--- docs/examples/tradespace/PlanDeployment.ipynb | 55 ++-- .../examples/tradespace/PlanForFailures.ipynb | 130 ++++---- .../tradespace/RankUncertainDesigns.ipynb | 107 +++--- .../tradespace/SearchTradeSpace.ipynb | 54 ++-- .../tradespace/TradeCostAndUtility.ipynb | 72 ++--- .../tradespace/trade_space_example.py | 1 - src/tatc/tradespace/__init__.py | 4 + src/tatc/tradespace/attribution.py | 13 +- src/tatc/tradespace/cache.py | 23 +- src/tatc/tradespace/constellations.py | 19 +- src/tatc/tradespace/cost.py | 166 ++++++---- src/tatc/tradespace/criteria.py | 277 +++++++++++----- src/tatc/tradespace/deployment.py | 63 ++-- src/tatc/tradespace/events.py | 13 +- src/tatc/tradespace/failures.py | 23 +- src/tatc/tradespace/fingerprint.py | 98 +++++- src/tatc/tradespace/hashing.py | 16 +- src/tatc/tradespace/histories.py | 87 ++--- src/tatc/tradespace/mission.py | 28 +- src/tatc/tradespace/nodes.py | 11 +- src/tatc/tradespace/observations.py | 306 +++++++++--------- src/tatc/tradespace/optimization.py | 14 +- src/tatc/tradespace/pareto.py | 42 +-- src/tatc/tradespace/plotting.py | 188 ++++++++++- src/tatc/tradespace/scenarios.py | 39 ++- src/tatc/tradespace/sensitivity.py | 15 +- src/tatc/tradespace/simulation.py | 153 +++++---- src/tatc/tradespace/space.py | 174 +++++----- src/tatc/tradespace/study.py | 84 +++-- src/tatc/tradespace/values.py | 37 ++- tests/tradespace/test_cache.py | 3 +- tests/tradespace/test_criteria.py | 40 +++ tests/tradespace/test_failures.py | 57 ++-- tests/tradespace/test_fingerprint.py | 48 ++- tests/tradespace/test_observations.py | 101 ++++-- tests/tradespace/test_plotting.py | 48 +++ tests/tradespace/test_scenarios.py | 32 +- tests/tradespace/test_sensitivity.py | 5 + tests/tradespace/test_space.py | 63 +++- tests/tradespace/test_stages.py | 4 +- tests/tradespace/test_store.py | 32 +- tests/tradespace/test_study.py | 9 +- 50 files changed, 1948 insertions(+), 1141 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 93d88c98..82808502 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -38,6 +38,7 @@ Added: - Studies of the observations of constellations (`tradespace.ObservationStudy`): the targets of each replicate (`Targets`, fixed or generated from a seed of the design), the observations of each satellite, cached on disk (`Observations`), the metrics of the observations, and, with a `MissionPlan`, the costs of the deployment and the summaries of its phases or of the histories of its `Failures`. Plots of the results of studies (`plot_designs`, `plot_progress`, and `plot_means`, with matplotlib, in the `tradespace` extra), and the hypervolume of a search as it proceeds (`hypervolume_progress`). - The steps of trade studies share their arguments and outcomes: `tradespace.refine(study, criteria, results)`, `confirm(study, criteria, results)` (by default, the front of the results), `screen(studies, criteria, designs)` (with criteria for each stage), and `attribute_variance(study, metrics, designs)` take designs as `Design` objects, their keys, or rows of a summary or of results, and `Refinement`, `Confirmation`, `Screening`, and `Search` give their `results`, the `summary` of their designs, and the `designs`. `DesignSpace.designs_of` rebuilds designs from rows of their values, which summaries keep (also those of `pareto_probability`, `confirm`, and `screen`), and `DesignSpace.extend`, `DesignSpace.design(design, **overrides)`, and `Study.replace` make variants of design spaces, designs, and studies. `aggregate` takes criteria, a mapping of objectives, or metrics (as the other functions do), and other `statistics` by name; `pareto_front`, `pareto_ranks`, `hypervolume`, `sensitivity`, and `main_effects` raise an error given the results of a study (a row per replicate) instead of a summary. Studies with a mission plan record the years by which it is `deployed`, and the parts of observation studies that refer to values of designs are typed as a `Reference`. Columns: ` se`, ` mission` for the mean over the phases of a mission, ` histories p` and ` histories std` for statistics over the histories of failures, and `pareto_trace` and `max_regret`. Package `tradespace` exports the functions and classes of trade studies; the parts from which they are made (such as `PhaseCache`, `Layout`, `configure`, and the fingerprints) are imported from its modules. - Values of `tradespace` designs by the paths of the columns of results (`d["layout.walker.planes"]`, also in the callables of design spaces and in references), choices equal to the names of their branches, and reserved names of children that views and designs give otherwise (such as `values` and `key`). `Repeat` counts may be `Integer`, `Categorical`, `Fixed`, or `Derived`; `DesignSpace.design` checks decisions against their domains; and the constructors of uncertain parameters (with `Uncertain.triangular`) take nominal values and name their distributions. Summaries of criteria give whether each design is efficient (`pareto`, also of `summarize`, which takes criteria, and of `confirm`, `screen`, and searches), designs with a missing objective are not efficient, and `aggregate` takes `statistics` by name. `Study.realize` realizes a design as a study does (in a scenario), and an `ObservationStudy` gives the `deployment_of`, `phases_of`, and `estimate_of` a design as its evaluation plans them. `Study.prune` removes a study's evaluations with other code (and not those of other studies that share its store, `ResultStore.remove`), `Observations.prune` removes the results of its caches with other code, and caches warn of results of other code once, in the main process. Fingerprints describe geometries by their content, ignore docstrings, and describe the functions of a study's own modules (such as one next to a notebook) by their code. `Failures` restore by default, with importance sampling (`stress`), control variates (`controls`), and spreads over the histories. Layouts describe themselves (`Layout.describe`) and are built at their own altitude (the given one is for layouts without one; `soc_space` keeps the altitude its planes are derived at). `plot_designs` colors some designs over the others (`highlight`, `label`, `others`, `front_label`), and `COLORS`, `INK`, and `GRAY` name the colors of plots. Each design confirmed gives its ` optimism`, `robustness` keeps the values of designs, and `Search.summary` keeps the designs the search found feasible. The simulation of missions is in module `simulation`. + - Decisions given to `tradespace.DesignSpace.design` by value are levels of their domains (`2.0` or `numpy.int64(2)` give the key of the enumerated design), designs and scopes tell whether they have a value (`"layout.walker.planes" in design`), and the items of a `Repeat` take slices. `DesignSpace.designs_of` gives a series of designs aligned to the rows of a data frame (`space.designs_of(summary).map(describe)`). Statistics given without names are named by convention (`Statistic.name`, such as `"cost p70"` for `Quantile("cost", 0.7)` and `"P(cost <= 150)"`), so that `statistics` may be a list, `summarize(results, criteria, statistics=...)` adds the means and spreads of other metrics to a summary of criteria, criteria `across` scenarios are summarized and aggregated as others, and `Requirement.met` tells which values meet a requirement. An `ObservationStudy` counts the satellites and planes of a design's `layout` by default, gives the histories of a design's failures (`missions_of`) and its satellites, targets, and observations (`satellites_of`, `targets_of`, `observations_of`) as its evaluation realizes them, and `MissionPlan.policy` refers to each design's restoration policy (such as of `policy_space`). Fingerprints describe the classes and callable objects of a study's own modules by their attributes and the code of their methods, and tell studies that differ in constants apart from the same study with other code; `Observations.prune` removes only the results of its own analyses with other code. `plot_designs` colors designs by a column or by values of their rows (`by`), `plot_shares` plots shares of variance (of `sensitivity` or `attribute_variance`) as grouped bars with their standard errors, and `use_style` applies the style of the plots of trade studies (with constrained layouts) to the figures of a session. `robustness` gives each objective of a design in each scenario (` `). `Deployment.planes` are `PlannedPlane`s (type, satellites, and spares in orbit), `DeploymentSchedule.next_slot` gives the next launch slot that keeps the launch interval, and `Capability.evaluate` evaluates phases with a deployment's cached observations. Searches with Optuna are seeded by default (`seed=0`), and lives of satellites are drawn from uniform numbers (`Lifetime.from_uniform`, which subclasses implement). - Trade space tutorial (`docs/examples/tradespace`): eight notebooks that follow one trade of constellations, each adding one idea to those before it: `EvaluateTradeSpace` (design space, study, and Pareto front), `ExplainTradeSpace` (sampling error, revisits, and sensitivity), `SearchTradeSpace` (hypervolume, screening, and optimizers), `RankUncertainDesigns` (probability of efficiency, refinement, confirmation, and requirements on statistics), `CompareScenarios` (scenarios, regret, and searches across scenarios), `TradeCostAndUtility` (costs with uncertain growth, budgets, and utility), `PlanDeployment` (phases and staging), and `PlanForFailures` (failures, restoration policies, and the attribution of variance). Each notebook defines what it introduces, and imports what earlier notebooks defined from `trade_space_example.py`. - The `RunOSSEMonsoon` example declares its constellation trade as a design space, caches the looks of each satellite, evaluates its replicates in parallel, and finds its Pareto-efficient designs. diff --git a/docs/api_reference/tradespace/evaluate.rst b/docs/api_reference/tradespace/evaluate.rst index d7d9cfcb..4f545428 100644 --- a/docs/api_reference/tradespace/evaluate.rst +++ b/docs/api_reference/tradespace/evaluate.rst @@ -15,7 +15,7 @@ Observation Studies :no-members: .. autoclass:: tatc.tradespace.ObservationStudy - :members: satellites_of, targets_of, observations_of, deployment_of, phases_of, estimate_of + :members: satellites_of, targets_of, observations_of, deployment_of, phases_of, estimate_of, missions_of, prune .. autoclass:: tatc.tradespace.Observations :members: end, start_of, end_of, cache_of, context_of, prune, __call__ diff --git a/docs/api_reference/tradespace/index.rst b/docs/api_reference/tradespace/index.rst index 3a93e855..2a6e38d3 100644 --- a/docs/api_reference/tradespace/index.rst +++ b/docs/api_reference/tradespace/index.rst @@ -65,13 +65,15 @@ take one or the other: * - Take results (a row per replicate) - Take summaries (a row per design) * - `aggregate`, `summarize`, `pareto_probability`, - `hypervolume_progress`, `robustness`, `refine`, `confirm`, - `attribute_variance`, `plot_means` + `hypervolume_progress`, `robustness`, `exceedance`, `refine`, + `confirm`, `plot_means` - `pareto_front`, `pareto_ranks`, `hypervolume`, `sensitivity`, `main_effects`, `plot_designs` The functions of summaries raise an error if a design has several rows, as -in the results of a study: summarize them first. +in the results of a study: summarize them first. The steps that evaluate +designs (such as `confirm` and `attribute_variance`) take designs, their +keys, or rows of either (see `DesignSpace.designs_of`). Columns ------- @@ -79,8 +81,9 @@ Columns Columns named after a metric or a statistic take a suffix after a space, and columns that TAT-C defines are named in snake case: -* statistics over the replicates of a design: named by the criteria (such - as `"cost p70"` for `Quantile("cost", 0.7)`), the means of metrics by +* statistics over the replicates of a design: named by the criteria, or by + convention if given without names (see `Statistic.name`, such as + `"cost p70"` for `Quantile("cost", 0.7)`), the means of metrics by their names, and ` std` and ` se` (by `summarize`, and the standard error of each objective by `pareto_probability`), and of confirmed designs, ` selected` (by the replicates that selected diff --git a/docs/api_reference/tradespace/judge.rst b/docs/api_reference/tradespace/judge.rst index 458ff504..3fc007ad 100644 --- a/docs/api_reference/tradespace/judge.rst +++ b/docs/api_reference/tradespace/judge.rst @@ -30,10 +30,10 @@ Criteria, Statistics, and Requirements .. autoclass:: tatc.tradespace.Probability .. autoclass:: tatc.tradespace.criteria.Statistic - :members: reduce, columns, values_of + :members: name, metric, reduce, columns, values_of .. autoclass:: tatc.tradespace.Requirement - :members: violation + :members: met, violation .. autoclass:: tatc.tradespace.Across :members: weights_of @@ -106,8 +106,15 @@ Plots .. autofunction:: tatc.tradespace.plot_progress +.. autofunction:: tatc.tradespace.plot_shares + .. autofunction:: tatc.tradespace.style_axes +.. autofunction:: tatc.tradespace.use_style + +.. autodata:: tatc.tradespace.plotting.STYLE + :annotation: + .. autodata:: tatc.tradespace.plotting.COLORS :annotation: diff --git a/docs/api_reference/tradespace/missions.rst b/docs/api_reference/tradespace/missions.rst index 2f16d22e..9865dcc8 100644 --- a/docs/api_reference/tradespace/missions.rst +++ b/docs/api_reference/tradespace/missions.rst @@ -46,13 +46,15 @@ Deployment :no-members: .. autoclass:: tatc.tradespace.DeploymentSchedule - :members: plan, production_years, replacements, per_launch, split, launches_of, mass_capacity_of, design_life_of + :members: plan, production_years, replacements, next_slot, per_launch, split, launches_of, mass_capacity_of, design_life_of .. autoclass:: tatc.tradespace.Stage .. autoclass:: tatc.tradespace.deployment.Deployment :members: simulate, simulate_many, expected_metrics, planned, phases, begin, end, deployed, units, stages, capability +.. autoclass:: tatc.tradespace.events.PlannedPlane + .. autoclass:: tatc.tradespace.deployment.Launch .. autoclass:: tatc.tradespace.deployment.Production @@ -110,7 +112,7 @@ Missions :members: evaluate, clear .. autoclass:: tatc.tradespace.mission.Capability - :members: at + :members: evaluate, at :special-members: __call__ .. automodule:: tatc.tradespace.simulation diff --git a/docs/examples/tradespace/CompareScenarios.ipynb b/docs/examples/tradespace/CompareScenarios.ipynb index b8e3eafd..f108db49 100644 --- a/docs/examples/tradespace/CompareScenarios.ipynb +++ b/docs/examples/tradespace/CompareScenarios.ipynb @@ -41,10 +41,10 @@ "id": "4c97b966", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:35.251601Z", - "iopub.status.busy": "2026-11-14T06:30:35.251601Z", - "iopub.status.idle": "2026-11-14T06:30:38.321469Z", - "shell.execute_reply": "2026-11-14T06:30:38.320469Z" + "iopub.execute_input": "2026-11-14T08:06:00.886245Z", + "iopub.status.busy": "2026-11-14T08:06:00.886245Z", + "iopub.status.idle": "2026-11-14T08:06:03.887357Z", + "shell.execute_reply": "2026-11-14T08:06:03.887357Z" } }, "outputs": [ @@ -100,10 +100,10 @@ "id": "8e021fe5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:38.322469Z", - "iopub.status.busy": "2026-11-14T06:30:38.322469Z", - "iopub.status.idle": "2026-11-14T06:30:38.563207Z", - "shell.execute_reply": "2026-11-14T06:30:38.563207Z" + "iopub.execute_input": "2026-11-14T08:06:03.887357Z", + "iopub.status.busy": "2026-11-14T08:06:03.887357Z", + "iopub.status.idle": "2026-11-14T08:06:04.128039Z", + "shell.execute_reply": "2026-11-14T08:06:04.127036Z" } }, "outputs": [ @@ -138,9 +138,9 @@ " description\n", " satellites\n", " planes\n", - " 1 hour\n", - " 3 hours\n", - " 12 hours\n", + " 1 hour accurate\n", + " 3 hours accurate\n", + " 12 hours accurate\n", " pareto_trace\n", " \n", " \n", @@ -251,16 +251,27 @@ "de505bc89299 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", "679ca275c8fc 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", "\n", - " planes 1 hour 3 hours 12 hours pareto_trace \n", - "design \n", - "33b006848799 2.0 26.2 34.2 60.4 0.67 \n", - "b85daf65c3a4 1.0 8.0 17.0 95.6 0.67 \n", - "d5bff0394d77 2.0 40.8 60.6 85.8 0.67 \n", - "dfd5eb7d33d2 2.0 69.0 85.4 93.0 0.67 \n", - "cb6bd361b577 4.0 96.6 96.6 97.8 0.67 \n", - "5529c21520be 3.0 97.8 97.8 97.8 0.67 \n", - "de505bc89299 3.0 97.8 97.8 97.8 0.67 \n", - "679ca275c8fc 3.0 97.8 97.8 97.8 0.67 " + " planes 1 hour accurate 3 hours accurate 12 hours accurate \\\n", + "design \n", + "33b006848799 2.0 26.2 34.2 60.4 \n", + "b85daf65c3a4 1.0 8.0 17.0 95.6 \n", + "d5bff0394d77 2.0 40.8 60.6 85.8 \n", + "dfd5eb7d33d2 2.0 69.0 85.4 93.0 \n", + "cb6bd361b577 4.0 96.6 96.6 97.8 \n", + "5529c21520be 3.0 97.8 97.8 97.8 \n", + "de505bc89299 3.0 97.8 97.8 97.8 \n", + "679ca275c8fc 3.0 97.8 97.8 97.8 \n", + "\n", + " pareto_trace \n", + "design \n", + "33b006848799 0.67 \n", + "b85daf65c3a4 0.67 \n", + "d5bff0394d77 0.67 \n", + "dfd5eb7d33d2 0.67 \n", + "cb6bd361b577 0.67 \n", + "5529c21520be 0.67 \n", + "de505bc89299 0.67 \n", + "679ca275c8fc 0.67 " ] }, "execution_count": 2, @@ -276,17 +287,12 @@ "print(\"efficient designs:\", by_field[by_field.pareto].scenario.value_counts()[list(FIELDS)].to_dict())\n", "\n", "# a row per design: its share accurately sampled in each field, and the share of the fields in which it is efficient\n", - "values = by_field.drop_duplicates(\"design\").set_index(\"design\") # the values of each design\n", - "traced = pd.DataFrame(\n", - " {\n", - " \"description\": [describe(d) for d in space.designs_of(values)],\n", - " \"satellites\": values.satellites,\n", - " \"planes\": values.planes,\n", - " }\n", - ")\n", - "traced = traced.join(by_field.pivot(index=\"design\", columns=\"scenario\", values=\"accurate\")[list(FIELDS)])\n", - "traced[\"pareto_trace\"] = robustness(fields, ACCURACY).set_index(\"design\")[\"pareto_trace\"]\n", - "traced[traced.pareto_trace > 0.5].sort_values([\"satellites\", \"planes\"]).round(2)" + "traced = robustness(fields, ACCURACY).set_index(\"design\")\n", + "traced[\"description\"] = space.designs_of(traced).map(describe)\n", + "ACCURATE = [f\"{field} accurate\" for field in FIELDS]\n", + "traced[traced.pareto_trace > 0.5].sort_values([\"satellites\", \"planes\"])[\n", + " [\"description\", \"satellites\", \"planes\", *ACCURATE, \"pareto_trace\"]\n", + "].round(2)" ] }, { @@ -303,16 +309,16 @@ "id": "8b9e713f", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:38.565404Z", - "iopub.status.busy": "2026-11-14T06:30:38.564395Z", - "iopub.status.idle": "2026-11-14T06:30:39.171554Z", - "shell.execute_reply": "2026-11-14T06:30:39.171554Z" + "iopub.execute_input": "2026-11-14T08:06:04.128039Z", + "iopub.status.busy": "2026-11-14T08:06:04.128039Z", + "iopub.status.idle": "2026-11-14T08:06:04.761224Z", + "shell.execute_reply": "2026-11-14T08:06:04.761224Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "

" ] @@ -324,7 +330,9 @@ "source": [ "import matplotlib.pyplot as plt\n", "\n", - "from tatc.tradespace import plot_designs\n", + "from tatc.tradespace import plot_designs, use_style\n", + "\n", + "use_style() # the style of the plots of trade studies\n", "\n", "LAYOUTS = {\"walker\": \"Walker\", \"sso\": \"Sun-synchronous\"}\n", "fig, axes = plt.subplots(1, 3, figsize=(14, 4.2), sharey=True)\n", @@ -341,9 +349,8 @@ " ax=ax,\n", " )\n", " ax.set(xlabel=\"Satellites\", ylabel=\"\", xticks=range(1, MAX_SATELLITES + 1), ylim=(0, 105))\n", - " ax.set_title(f\"A field that decorrelates in {field}\", fontsize=10)\n", + " ax.set_title(f\"A field that decorrelates in {field}\")\n", "axes[0].set_ylabel(\"Points accurately sampled (%)\")\n", - "fig.tight_layout()\n", "plt.show()" ] }, @@ -373,10 +380,10 @@ "id": "acf5055d", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:39.173555Z", - "iopub.status.busy": "2026-11-14T06:30:39.172556Z", - "iopub.status.idle": "2026-11-14T06:30:39.421539Z", - "shell.execute_reply": "2026-11-14T06:30:39.421539Z" + "iopub.execute_input": "2026-11-14T08:06:04.762881Z", + "iopub.status.busy": "2026-11-14T08:06:04.762881Z", + "iopub.status.idle": "2026-11-14T08:06:05.030698Z", + "shell.execute_reply": "2026-11-14T08:06:05.030698Z" } }, "outputs": [ @@ -518,16 +525,16 @@ "id": "ae6ac96b", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:39.423540Z", - "iopub.status.busy": "2026-11-14T06:30:39.423540Z", - "iopub.status.idle": "2026-11-14T06:30:39.609483Z", - "shell.execute_reply": "2026-11-14T06:30:39.608489Z" + "iopub.execute_input": "2026-11-14T08:06:05.030698Z", + "iopub.status.busy": "2026-11-14T08:06:05.030698Z", + "iopub.status.idle": "2026-11-14T08:06:05.220711Z", + "shell.execute_reply": "2026-11-14T08:06:05.220711Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -537,7 +544,7 @@ } ], "source": [ - "from tatc.tradespace import COLORS, GRAY, style_axes\n", + "from tatc.tradespace import COLORS, GRAY\n", "\n", "fig, axes = plt.subplots(1, len(robust_design), figsize=(14, 3.6), sharey=True)\n", "for ax, (limit, best) in zip(axes, robust_design.items()):\n", @@ -546,7 +553,7 @@ " ax.plot(range(len(FIELDS)), ceiling, color=GRAY, lw=2, ls=\"--\", marker=\"o\", ms=5, label=\"best of the field\")\n", " ax.plot(\n", " range(len(FIELDS)),\n", - " traced.loc[best, list(FIELDS)],\n", + " traced.loc[best, ACCURATE],\n", " color=COLORS[0],\n", " lw=2,\n", " marker=\"o\",\n", @@ -558,10 +565,8 @@ " ax.set_title(\n", " f\"At most {limit} satellites\\n{traced.loc[best, 'description'].replace(', 60 deg FOR', '')}\", fontsize=8\n", " )\n", - " style_axes(ax)\n", "axes[0].set_ylabel(\"Points accurately sampled (%)\")\n", - "axes[0].legend(loc=\"lower right\", fontsize=8, frameon=False)\n", - "fig.tight_layout()\n", + "axes[0].legend(loc=\"lower right\")\n", "plt.show()" ] }, @@ -591,10 +596,10 @@ "id": "2050e0b0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:39.610483Z", - "iopub.status.busy": "2026-11-14T06:30:39.610483Z", - "iopub.status.idle": "2026-11-14T06:30:40.566392Z", - "shell.execute_reply": "2026-11-14T06:30:40.566392Z" + "iopub.execute_input": "2026-11-14T08:06:05.220711Z", + "iopub.status.busy": "2026-11-14T08:06:05.220711Z", + "iopub.status.idle": "2026-11-14T08:06:06.221219Z", + "shell.execute_reply": "2026-11-14T08:06:06.221219Z" } }, "outputs": [ @@ -625,7 +630,8 @@ " f\"{len(evaluated)} designs evaluated (in {len(FIELDS)} fields each): {found:.1f}% of the hypervolume of the true \"\n", " f\"front, and {len(evaluated & true_front)} of its {len(true_front)} designs\"\n", ")\n", - "print(\"the field in which each design is least accurate:\", traced[list(FIELDS)].idxmin(axis=1).value_counts().to_dict())" + "least = traced[ACCURATE].idxmin(axis=1).str.removesuffix(\" accurate\")\n", + "print(\"the field in which each design is least accurate:\", least.value_counts().to_dict())" ] }, { diff --git a/docs/examples/tradespace/EvaluateTradeSpace.ipynb b/docs/examples/tradespace/EvaluateTradeSpace.ipynb index f0bd5266..07b7933f 100644 --- a/docs/examples/tradespace/EvaluateTradeSpace.ipynb +++ b/docs/examples/tradespace/EvaluateTradeSpace.ipynb @@ -35,10 +35,10 @@ "id": "bc7b296c", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:29:55.928171Z", - "iopub.status.busy": "2026-11-14T06:29:55.928171Z", - "iopub.status.idle": "2026-11-14T06:29:56.411760Z", - "shell.execute_reply": "2026-11-14T06:29:56.411760Z" + "iopub.execute_input": "2026-11-14T08:05:20.754477Z", + "iopub.status.busy": "2026-11-14T08:05:20.754477Z", + "iopub.status.idle": "2026-11-14T08:05:22.879382Z", + "shell.execute_reply": "2026-11-14T08:05:22.879382Z" } }, "outputs": [], @@ -46,6 +46,9 @@ "from datetime import datetime, timedelta, timezone\n", "\n", "import matplotlib.pyplot as plt\n", + "from tatc.tradespace import use_style\n", + "\n", + "use_style() # the style of the plots of trade studies\n", "\n", "START = datetime(2026, 7, 1, tzinfo=timezone.utc)\n", "DURATION = timedelta(days=1) # the period of the analysis\n", @@ -81,10 +84,10 @@ "id": "c05d366a", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:29:56.413752Z", - "iopub.status.busy": "2026-11-14T06:29:56.413752Z", - "iopub.status.idle": "2026-11-14T06:29:58.161052Z", - "shell.execute_reply": "2026-11-14T06:29:58.160059Z" + "iopub.execute_input": "2026-11-14T08:05:22.879382Z", + "iopub.status.busy": "2026-11-14T08:05:22.879382Z", + "iopub.status.idle": "2026-11-14T08:05:22.990678Z", + "shell.execute_reply": "2026-11-14T08:05:22.990678Z" } }, "outputs": [ @@ -160,10 +163,10 @@ "id": "374124d4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:29:58.162053Z", - "iopub.status.busy": "2026-11-14T06:29:58.162053Z", - "iopub.status.idle": "2026-11-14T06:29:58.175867Z", - "shell.execute_reply": "2026-11-14T06:29:58.175867Z" + "iopub.execute_input": "2026-11-14T08:05:22.990678Z", + "iopub.status.busy": "2026-11-14T08:05:22.990678Z", + "iopub.status.idle": "2026-11-14T08:05:23.006799Z", + "shell.execute_reply": "2026-11-14T08:05:23.006799Z" } }, "outputs": [], @@ -201,7 +204,6 @@ " build,\n", " OBSERVATIONS,\n", " count_samples,\n", - " layout=\"layout\",\n", " replicates=N_REPLICATES,\n", " n_jobs=-1,\n", " store=ResultStore(CACHE_DIRECTORY / \"results.sqlite\"),\n", @@ -224,10 +226,10 @@ "id": "8967e528", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:29:58.176870Z", - "iopub.status.busy": "2026-11-14T06:29:58.176870Z", - "iopub.status.idle": "2026-11-14T06:29:58.784905Z", - "shell.execute_reply": "2026-11-14T06:29:58.783911Z" + "iopub.execute_input": "2026-11-14T08:05:23.006799Z", + "iopub.status.busy": "2026-11-14T08:05:23.006799Z", + "iopub.status.idle": "2026-11-14T08:05:23.612875Z", + "shell.execute_reply": "2026-11-14T08:05:23.612875Z" } }, "outputs": [ @@ -374,10 +376,10 @@ "id": "9e23a64a", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:29:58.785905Z", - "iopub.status.busy": "2026-11-14T06:29:58.785905Z", - "iopub.status.idle": "2026-11-14T06:29:59.048683Z", - "shell.execute_reply": "2026-11-14T06:29:59.048683Z" + "iopub.execute_input": "2026-11-14T08:05:23.612875Z", + "iopub.status.busy": "2026-11-14T08:05:23.612875Z", + "iopub.status.idle": "2026-11-14T08:05:23.888781Z", + "shell.execute_reply": "2026-11-14T08:05:23.888781Z" } }, "outputs": [ @@ -501,7 +503,7 @@ "\n", "OBJECTIVES = {\"satellites\": \"min\", \"planes\": \"min\", \"sufficient\": \"max\"}\n", "summary = summarize(results, OBJECTIVES) # a row per design, and whether it is efficient\n", - "summary[\"description\"] = [describe(d) for d in space.designs_of(summary)]\n", + "summary[\"description\"] = space.designs_of(summary).map(describe)\n", "front = summary[summary.pareto].sort_values([\"satellites\", \"planes\"])\n", "front[[\"description\", \"satellites\", \"planes\", \"sufficient\", \"sufficient se\"]].round(1)" ] @@ -520,16 +522,16 @@ "id": "6f877e2d", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:29:59.050685Z", - "iopub.status.busy": "2026-11-14T06:29:59.050685Z", - "iopub.status.idle": "2026-11-14T06:29:59.179938Z", - "shell.execute_reply": "2026-11-14T06:29:59.179938Z" + "iopub.execute_input": "2026-11-14T08:05:23.890781Z", + "iopub.status.busy": "2026-11-14T08:05:23.889781Z", + "iopub.status.idle": "2026-11-14T08:05:24.035704Z", + "shell.execute_reply": "2026-11-14T08:05:24.034695Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -541,7 +543,7 @@ "source": [ "import numpy as np\n", "\n", - "from tatc.tradespace import COLORS, INK, style_axes\n", + "from tatc.tradespace import COLORS, INK\n", "\n", "fig, ax = plt.subplots(figsize=(8, 3.8))\n", "for k, row in enumerate(front.itertuples()):\n", @@ -551,10 +553,8 @@ " ax.hlines(row.sufficient, k - 0.28, k + 0.28, color=INK, lw=2, label=\"mean\" if k == 0 else None)\n", "ax.set_xticks(range(len(front)), [f\"{row.satellites:.0f} sat., {row.planes:.0f} pl.\" for row in front.itertuples()])\n", "ax.set(ylabel=\"Points sufficiently sampled (%)\", ylim=(0, 105))\n", - "ax.set_title(\"The replicates of the efficient designs\", fontsize=10)\n", - "ax.legend(loc=\"upper left\", fontsize=8, frameon=False)\n", - "style_axes(ax)\n", - "fig.tight_layout()\n", + "ax.set_title(\"The replicates of the efficient designs\")\n", + "ax.legend(loc=\"upper left\")\n", "plt.show()" ] }, @@ -582,16 +582,16 @@ "id": "523cddaa", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:29:59.181946Z", - "iopub.status.busy": "2026-11-14T06:29:59.181946Z", - "iopub.status.idle": "2026-11-14T06:29:59.316707Z", - "shell.execute_reply": "2026-11-14T06:29:59.316707Z" + "iopub.execute_input": "2026-11-14T08:05:24.036707Z", + "iopub.status.busy": "2026-11-14T08:05:24.036707Z", + "iopub.status.idle": "2026-11-14T08:05:24.190048Z", + "shell.execute_reply": "2026-11-14T08:05:24.190048Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -605,10 +605,10 @@ "from tatc.tradespace import plot_designs\n", "\n", "ax = plot_designs(\n", - " summary.assign(plane_group=summary.planes.clip(upper=3)), # 3 or 4 planes share a color\n", + " summary,\n", " \"satellites\",\n", " \"sufficient\",\n", - " by=\"plane_group\",\n", + " by=summary.planes.clip(upper=3), # 3 or 4 planes share a color\n", " front=\"pareto\",\n", " labels=lambda row: f\"{row.satellites:.0f} sat., {row.planes:.0f} pl.\",\n", " names=PLANE_GROUPS,\n", @@ -618,8 +618,7 @@ "ax.set(\n", " xlabel=\"Satellites\", ylabel=\"Points sufficiently sampled (%)\", xticks=range(1, MAX_SATELLITES + 1), ylim=(0, 105)\n", ")\n", - "ax.set_title(\"Every design: mean over 5 replicates\", fontsize=10)\n", - "ax.figure.tight_layout()\n", + "ax.set_title(\"Every design: mean over 5 replicates\")\n", "plt.show()" ] }, diff --git a/docs/examples/tradespace/ExplainTradeSpace.ipynb b/docs/examples/tradespace/ExplainTradeSpace.ipynb index 24dc08ab..e94e69a8 100644 --- a/docs/examples/tradespace/ExplainTradeSpace.ipynb +++ b/docs/examples/tradespace/ExplainTradeSpace.ipynb @@ -36,10 +36,10 @@ "id": "99a62858", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:01.484827Z", - "iopub.status.busy": "2026-11-14T06:30:01.483826Z", - "iopub.status.idle": "2026-11-14T06:30:04.485515Z", - "shell.execute_reply": "2026-11-14T06:30:04.485515Z" + "iopub.execute_input": "2026-11-14T08:05:26.361507Z", + "iopub.status.busy": "2026-11-14T08:05:26.361507Z", + "iopub.status.idle": "2026-11-14T08:05:29.440369Z", + "shell.execute_reply": "2026-11-14T08:05:29.439834Z" } }, "outputs": [], @@ -61,7 +61,9 @@ " study,\n", ")\n", "from tatc.analysis import estimate_sampling_error\n", - "from tatc.tradespace import summarize\n", + "from tatc.tradespace import summarize, use_style\n", + "\n", + "use_style() # the style of the plots of trade studies\n", "\n", "DECORRELATION_TIME = timedelta(hours=3) # of the field whose daily mean is estimated\n", "MAX_RELATIVE_ERROR = 0.5 # of an accurate sample, in standard deviations of the field\n", @@ -83,7 +85,7 @@ "accuracy_study = study.replace(metrics=sample)\n", "results = accuracy_study.run(designs)\n", "summary = summarize(results, [\"satellites\", \"planes\", \"sufficient\", \"accurate\"])\n", - "summary[\"description\"] = [describe(d) for d in space.designs_of(summary)]" + "summary[\"description\"] = space.designs_of(summary).map(describe)" ] }, { @@ -100,16 +102,16 @@ "id": "7326121b", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:04.487524Z", - "iopub.status.busy": "2026-11-14T06:30:04.487524Z", - "iopub.status.idle": "2026-11-14T06:30:04.626821Z", - "shell.execute_reply": "2026-11-14T06:30:04.625814Z" + "iopub.execute_input": "2026-11-14T08:05:29.442416Z", + "iopub.status.busy": "2026-11-14T08:05:29.441905Z", + "iopub.status.idle": "2026-11-14T08:05:29.581444Z", + "shell.execute_reply": "2026-11-14T08:05:29.581444Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -122,13 +124,12 @@ "from tatc.tradespace import GRAY, plot_designs, style_axes\n", "\n", "fig, ax = plt.subplots(figsize=(6.5, 5))\n", - "grouped = summary.assign(plane_group=summary.planes.clip(upper=3)) # 3 or 4 planes share a color\n", - "plot_designs(grouped, \"sufficient\", \"accurate\", by=\"plane_group\", names=PLANE_GROUPS, legend=\"upper left\", ax=ax)\n", + "groups = summary.planes.clip(upper=3) # 3 or 4 planes share a color\n", + "plot_designs(summary, \"sufficient\", \"accurate\", by=groups, names=PLANE_GROUPS, legend=\"upper left\", ax=ax)\n", "ax.plot([0, 100], [0, 100], color=GRAY, lw=1, ls=\"--\")\n", "ax.set(xlabel=\"Points sufficiently sampled (%)\", ylabel=\"Points accurately sampled (%)\", xlim=(0, 102), ylim=(0, 102))\n", "style_axes(ax, grid=\"both\")\n", - "ax.set_title(\"Two measures of sampling, for every design\", fontsize=10)\n", - "fig.tight_layout()\n", + "ax.set_title(\"Two measures of sampling, for every design\")\n", "plt.show()" ] }, @@ -156,10 +157,10 @@ "id": "715976e0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:04.627821Z", - "iopub.status.busy": "2026-11-14T06:30:04.627821Z", - "iopub.status.idle": "2026-11-14T06:30:04.656132Z", - "shell.execute_reply": "2026-11-14T06:30:04.656132Z" + "iopub.execute_input": "2026-11-14T08:05:29.581444Z", + "iopub.status.busy": "2026-11-14T08:05:29.581444Z", + "iopub.status.idle": "2026-11-14T08:05:29.613359Z", + "shell.execute_reply": "2026-11-14T08:05:29.613359Z" } }, "outputs": [ @@ -393,10 +394,10 @@ "id": "92827f66", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:04.658636Z", - "iopub.status.busy": "2026-11-14T06:30:04.657133Z", - "iopub.status.idle": "2026-11-14T06:30:04.732051Z", - "shell.execute_reply": "2026-11-14T06:30:04.732051Z" + "iopub.execute_input": "2026-11-14T08:05:29.615364Z", + "iopub.status.busy": "2026-11-14T08:05:29.615364Z", + "iopub.status.idle": "2026-11-14T08:05:29.708263Z", + "shell.execute_reply": "2026-11-14T08:05:29.708263Z" } }, "outputs": [ @@ -530,16 +531,16 @@ "id": "5555b886", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:04.734047Z", - "iopub.status.busy": "2026-11-14T06:30:04.734047Z", - "iopub.status.idle": "2026-11-14T06:30:04.886501Z", - "shell.execute_reply": "2026-11-14T06:30:04.886501Z" + "iopub.execute_input": "2026-11-14T08:05:29.708263Z", + "iopub.status.busy": "2026-11-14T08:05:29.708263Z", + "iopub.status.idle": "2026-11-14T08:05:29.866894Z", + "shell.execute_reply": "2026-11-14T08:05:29.866894Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -570,7 +571,6 @@ " style_axes(ax, grid=\"x\")\n", "axes[0].set_yticks(range(len(shown)), [f\"{latitude:.0f} deg\" for latitude in shown.latitude])\n", "axes[0].set_ylabel(\"Latitude of the point\")\n", - "fig.tight_layout()\n", "plt.show()" ] }, @@ -598,10 +598,10 @@ "id": "40126ee8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:04.888488Z", - "iopub.status.busy": "2026-11-14T06:30:04.888488Z", - "iopub.status.idle": "2026-11-14T06:30:04.917370Z", - "shell.execute_reply": "2026-11-14T06:30:04.917370Z" + "iopub.execute_input": "2026-11-14T08:05:29.866894Z", + "iopub.status.busy": "2026-11-14T08:05:29.866894Z", + "iopub.status.idle": "2026-11-14T08:05:29.899159Z", + "shell.execute_reply": "2026-11-14T08:05:29.899159Z" } }, "outputs": [ @@ -731,16 +731,16 @@ "id": "b1adf213", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:04.919363Z", - "iopub.status.busy": "2026-11-14T06:30:04.919363Z", - "iopub.status.idle": "2026-11-14T06:30:04.992910Z", - "shell.execute_reply": "2026-11-14T06:30:04.992910Z" + "iopub.execute_input": "2026-11-14T08:05:29.899159Z", + "iopub.status.busy": "2026-11-14T08:05:29.899159Z", + "iopub.status.idle": "2026-11-14T08:05:29.994743Z", + "shell.execute_reply": "2026-11-14T08:05:29.994743Z" } }, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAuQAAAGGCAYAAAAzcJSpAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAcKtJREFUeJzt3QmcTfX/P/D3LHZjZ8Y6yC5biS8KhZAsWYtE9qUiJMoaIZQtqRQisoVIWZIt2bNly743xjbGEmbm/B+v9+9x7v/eO3dm7mzOnTuv5+Nxjbud8zmfu70/7/M+n+NjGIYhRERERERkCV9rVktERERERMCAnIiIiIjIQgzIiYiIiIgsxICciIiIiMhCDMiJiIiIiCzEgJyIiIiIyEIMyImIiIiILMSAnIiIiIjIQgzIiTwMztV1+/Zt/UtERETejwE5kYcJDw+XrFmzSlhYmNVNSbGioqLkypWL+pcShn2YOOy/xGMfJh77MOX0IQNyIiIiIiILMSAnIiIiIrIQA3IiIiIiIgsxICciIiIishADciIiIiIiCzEgJyIiIiKyEANyIiIiIiILMSAnIiIiIrIQA3IiIiIiIgsxICciIiIishADciIiIiIiCzEgJyIiIiKyEANyIiIiIiILMSAnIq/k75/G6iakeOzDxGH/JR77kFILf6sbQESu+fpyvJyYvsudO9DqZqRo7MPEYf8lHvswcSKjDPGxuhHkNgbkRB5q6I+X5dKd61Y3g4iIUpiiedLK+Db5JSrKsLop5CYG5EQe6mzoQzl5k1+mRERE3o77xImIiIiILMSAnIiIiIjIQgzIiYiIiIgsxICciIiIiMhCDMiJiIiIiCzEgJyIiIiIyEIMyL2UYRjSrVs3yZEjh/j4+Ei2bNmkb9++bj9/zpw5+pzYjBgxQipWrChJ5dixY/K///1P0qdPn6TLtdLZs2e1//fv3291U4iIiMhDcR5yL7VmzRoNqjdt2iRFixbVM55lyJBBPNnw4cMlU6ZMcvz4ccmcObPVzSEiIiJ6LBiQe6lTp05J3rx5pXr16pKS2tyoUSMJDg5O0PMfPXokadKkESs8fPhQ0qZNa8m6iYiIKGVjyYoX6tixo7z99tty/vx5LZcoXLiw1K5d26Fk5cGDBzJgwADJnz+/ZqWrVq2q2fTYjBs3TgIDAyUgIEA6d+4s//33n9ttioqKko8++kgKFCgg6dKl05IUZPFNaOfevXv1Mfg/ymHcKQVZtGiR1KpVS8tc5s+fr/d98803Urp0ab2tVKlS8sUXXzg8988//9T14/7KlSvLihUrHMpKIiMjdfuKFCmiexVKliwpU6ZMidbHzZo1k48//ljy5cunj4Fdu3ZJpUqVbMvet2+f231EREREqRMz5F4IweMTTzwhX3/9tezevVv8/PykVatWDo9566235MiRI7Jw4UINKJcvXy4NGjSQQ4cOSfHixaMtc/HixRokT58+XZ599lmZN2+eTJ06Vcth3G3Tp59+Kl999ZUGrLNmzZImTZrI4cOHdX1XrlyRunXrahswUHC3ZGXQoEG6XDMIRlA+bNgw+fzzz/U2BMRdu3bVQUeHDh3k9u3b0rhxY3nppZdkwYIFcu7cuWi19Rg8YOCwZMkSyZkzpwbwqMfHHofWrVvbHrdhwwbJkiWLrF+/Xq/fuXNHXn75ZalXr558//33cubMGenTp0+c24DBES4mtBGqF88kJR6kd6sfiIiIwu9HyrU7kVI0D/fYpjgGeaVJkyYZwcHBtuu1atUy+vTpo/8/d+6c4efnZ1y6dMnhOXXq1DEGDx6s/589e7aRNWtW233VqlUzevXq5fD4qlWrGhUqVHCrPfny5TM+/vhjh9ueeeYZh2ViWcOHD3dreWfOnDHw9p08ebLD7U888YSxYMECh9tGjRql7YcZM2YYOXPmNO7fv2+7f+bMmbqsffv2xbi+3r17Gy1atLBd79ChgxEYGGg8ePDAdttXX30VbdlYX1zLxjbjMc6XsLAwt/qCiIgIoiIjbP+PiIwyIiMjjcuXL+hfSpjH1YfMkKdCyIKjLKNEiRIOtyNLi4ywK0ePHpUePXo43FatWjXZuHFjnOtDxvfy5ctSo0YNh9tx/cCBA5IYKAsx3b17V+vQUW6CrLgpIiJCsmbNqv/HAaPly5fXbLqpSpUq0ZaLPQHI4qPs5/79+1oj7jzzS7ly5RzqxtFHzstGH8Vl8ODB0q9fP4f+KliwoITPGy2RYZfd7AkiIkrN/IOKSECnUbbrfr4+EhWF/A6lBAzIUyGUVqCMBTXb+Gsvpc1uglIU++2CmTNnak28PeftjA3KeFA2g1IYBNSomZ8wYYLs3LkzxnUnBmrqcXEWEXJOIkNPJ8k6iIiIyHPxoM5UCLXVyJBfvXpVihUr5nAJCgpy+RwcJOkckO7YscOt9aHOGnXq27Ztc7gd18uUKSNJBQecYj2nT5+Otl04QBNw8CX2ENjXbKPO3rldmJ2mV69e2ld4PjLvcUEfHTx40OFgV3f7iIiIiFIvBuSpEEpV2rVrJ2+88YYsW7ZMDz7E7CBjx46V1atXu3wODk5ECcfs2bPln3/+0TnDcUCmu9577z355JNPdFYUlI3gYEzMauLOQY/xMXLkSN0OHHCKdiL4Rps/++wzvb9t27Z60CYO0kSJydq1a2XixIl6H2ZaARxkumfPHr0Pyxg6dGi0oN0VLBvLQLkMDpj95ZdfbMsmIiIiigkD8lQKQSoC8v79+2vWGFP4IegsVKiQy8e3adNGA9OBAwfK008/rbOT9OzZ0+31vfPOO1onjfWh9hpTHq5cudLljC6J0aVLF532ENuH9WBKRJwgycyQI1u/atUqHQygJvzDDz/UWVnArP3u3r27NG/eXLcZpS/Xr1/XbHlcUO6DZWMQgMw6lo1BCBEREVFsfHBkZ6yPIPJymCrxzTfflLCwMI84mykO6sRBqGeHtpZMrCEnIiI3+BUsKdk/+N7hNuwRDgm5LIGB+fSM3RR/j6sPeVAnpTpz587V+dNxUiTM8vL+++/r/OKeEIwTERFR6sPhEiUJlGvEdNm6dWu8lzdmzJgYl9ewYcNEtfXff/+V119/XQ/CfPfdd/WkSTiJEhEREZEVWLJCSeLkyZMx3odMdHyzzzdu3NCLK1gWlumtWLJCRETxxZKV5MGSFUpRMDVgUsqRI4deiIiIiLwdh0tERERERBZiQE5EREREZCEG5EREREREFmINOZGH8g8MFr/0aaxuBhERpQD+Qf93AjxKmRiQE3mogPZD9MyiRERE7jCiIsXH18/qZlACsGSFyIOnWqKE911oaAj7MBHYh4nD/ks89mH8MRhPuRiQE5FXioh4ZHUTUjz2YeKw/xKPfUipBQNyIiIiIiILMSAnIiIiIrIQA3IiIiIiIgsxICciIiIishADciIiIiIiCzEgJyKv5O/PkyolFvswcdh/icc+pNSCJwYi8lC+vhwvJ6bvcucOtLoZKRr7MHHYf6mjDyOjDPHz9bG6GeQFGJATeaihP16WS3euW90MIiJyoWietDK+TX6rm0FeggE5kYc6G/pQTt40rG4GERERJTPuEyciIiIishADciIiIiIiCzEgJyIiIiKyEANyIiIiIiILMSAnIiIiIrIQA3IiIiIiIgt5fUBeu3Zt6du3r9XN8AiFCxeWyZMn2677+PjIihUrJLVK7dtPREREnsHrA3JPxEECEREREZkYkFOSefjwoVeth4iIiOhxSFUB+bx586Ry5coSEBAgQUFB0rZtW7l69areZxiGFCtWTCZOnOjwnP3792tpw8mTJ/X6+fPnpWnTppI5c2bJkiWLtG7dWkJCQmyP79ixozRr1sxhGciGIytu3r9582aZMmWKLheXs2fPRmvr559/Lk8++aTtOkor8Ngvv/zSdlvdunVlyJAh+v9Tp05puwIDA7VtzzzzjPz222/x6p/hw4dL3rx55eDBg3r9jz/+kOeee04yZMggBQsWlHfeeUfu3r3rUAIzatQoeeONN7QvunXrFm2ZaPOMGTOkYcOGupyiRYvK0qVLHR5z4cIF7cds2bJJjhw5dDvs+8Ts048//ljy5csnJUuWjHNbzLa99tprkilTJsmfP79Mnz491ue8//77UqJECcmYMaO2c+jQofLo0SPb/SNGjJCKFSvq+wjLz5o1q7z66qsSHh5ue0xUVJSMHTtWihQpottboUKFaNtLRERElGoDcgRXCNIOHDigAS6CPgR7ZuDYqVMnmT17tsNzcL1mzZoarCPYQrB448YNDarXr18vp0+fljZt2rjdBgTi1apVk65du8qVK1f0gmDXWa1ateTIkSMSGhqq17G+XLlyyaZNm2zbsn37dlugf+fOHXnppZdkw4YNsm/fPmnQoIE0btxYBxBxwWDk7bfflrlz58rWrVulfPnyGuBjGS1atNAAfdGiRRqgv/XWWw7PxQAGQSfWiQDWFdyO5aDf27Vrp0Hs0aNHbdtRv359HSRh3du2bdMBBdZtnwnHdh0/flz7/Oeff3arrydMmGBr26BBg6RPnz76/JigDXPmzNF+x+s0c+ZMmTRpksNj0C9476ANuOB1GTdunO1+BOPoRwycDh8+LO+++668/vrr+jgiIiIiV/wlFUHAbUIGdOrUqZpJRjCLIBDB+bBhw2TXrl1SpUoVDRYXLFhgy5ojKDx06JCcOXPGFkQj+Cpbtqzs3r1blxUXZFXTpk2rWVhk6WOC7DiyxQjkWrZsqYF4//79NVAEtBHtq169ul5H4ImLCQOP5cuXy8qVK6MF0fYiIiI0YETQioAbmWQzsETwbNa6Fy9eXPsLAwVkvNOnT6+3v/DCC9qu2LRq1Uq6dOliaxeC4mnTpskXX3yhgT4GOt98840OisxBELLl2OYXX3xRb0OWG49B37mrRo0aGogDMt8I9hFg16tXz+Xjzb0NgAz4gAEDZOHChTJw4EDb7WgrgnYE79C+fXt9XyB7/+DBAxkzZozumcCgy3yfoV+/+uor7TtX8DxcTLdv39a/1YtnkhIP/q+fiYgel/D7kXLtTqTVzfB4RfO4/3tEFJdUFZDv3btXyw6Qqb1586YGV4AscpkyZbQcolGjRjJr1iwNyFetWqWBEgJKQFYXgbh9RhvPQ/CI+9wJyN2F4BSZeQSlKE1B1rZXr14yfvx4OXbsmAbqWB8Ce8CgAtu2evVqzboj0L5//36cGXJkcNOlSyc7duzQDLwJfYTM+Pz58x0y6egzDEhKly6tt6EEKC5mcGp/HaVA5npQDmQGuKb//vtPs9GmcuXKxSsYj2m99rPMOMPgAIMOrBf9iT5EKY49BOr2bUWJj1n2hO24d+9etIAfmf5KlSrFuF4MfkaOHBnt9p51ckdbPxFRcjOiIsXH18/qZqQIkVGG+Pn+XzKJKDFSTUCO2meURuCCIDN37twarOK6fWkEMrnIeiKTikwtylHMoNcdvr6+Grjas69Djg+Uo3z99ddayoGADsGZGaQjILfPuCKbi8wzsvkor0H9MjLrcR0AieDxhx9+kLVr12pG3ISAtHv37lo37qxQoUK2/yNznRhYz9NPP+0Q+JvwGiXVeuKC8h9sPwJjvCewJwPZ8U8//dThcWnSpIk2cDIHdtgWwKDI3NNgwqAnJoMHD5Z+/fo5ZMgx6AufN1oiwy4nyfYREbnDP6iIBHQaJZ4A363Xr4dKzpy59bfVEzEYp6SSagJyZJWvX7+u9b5mhnvPnj3RHoc6bAR/KMtYs2aNbNmyxXYfssI4ABEXcxnIXN+6dUsz5WYQ+ffffzssE9lg+0AOmd7IyLh3ByLgRsnIkiVLbLXi+IuSCJRf2JeK4DpKbl555RVbcOjqYFFnTZo00VpzHODq5+en9d3w1FNP6bYhuE8sZN9x4Kf9dTNjjPUgM50nT54kzwZjPc7Xzcy+sz///FOCg4Plww8/tN127ty5eK0P7wEE3hjoxVSe4gqe4ypgjwg5J5Ghp+PVBiIibxIRkbCEFlFK45lDzmSArC4CYdQu40BM1FajntkZglIEtshaom7avuwBpSMonUAm9a+//tI6bgSaCL7M0g3UVCPQR235iRMndOYS5wAdZQ87d+7UgPnatWu2DGupUqW07tuEgyuzZ8+udez2ATkOKkQpDWqkTWjrsmXLNPhHGQgCbHO5cUEQj5lD3nzzTduMIJhxBEEq6s+xTGzLTz/9FGs9+qVLl3Qb0C/2MKBAGdA///yj/YH7zeWgL1Eqg4NlsScA5TDYA4DM/MWLFyUxMEhBiQ/WixlW0A4c2OkK+g+BNLLiKFlB6Yr9a+EOlLJgTwXKgL777jtdDt4neM/hOhEREVGqDsiRucbBeAjKkMlEptx5ikNT586dtdQDAapzeQKCUgTJKB1BgI6D9pDhNaHcAbOK4EBA1HhjSjz77DAgaEPgj3aYpTOAWUTCwsIc1odpB/H32WeftQXpyCRjAGBfxvHZZ59pu3CQJzLeaAeyz+5CeQuCRpTrILDHelAWg2AWbUBGGwe8os4+JijNwTagjtoeykAQ6GKZGKigRMbco4ByIOyFwICpefPmmsFG/6OGPLEZc+xBwOAIbR89erT2Efolpj0FCKQxUMDUhhiMxDRrTGwwyMPzUBeObcFsMShhwTSIRERERK74GM4Fz6SZ2jp16mhpCub1poTDYAKZZue52ZMb9kKg3CclnhEVNeSoYT87tLVkYskKET1GfgVLSvYPvhdPgL28ISGXJTAwn8fWkHs69mHK6cNUU0PuDpSBYN5vzFaCmVUYjBMRERFRcuNwyQ5KKXBgHw7SRO0xee4eDMwbH9OFiIiIKCVhhtwODuY0z9xJSSM5KqJQP2/OYx4Td2aYISIiIvIEDMgpxcEc60kxHSMRERGRJ2DJChERERGRhRiQExERERFZiAE5EREREZGFWENO5KH8A4PFL30aq5tBRKmIfxBPYkZkBQbkRB4qoP2QRJ+tlIgovoyoSPHx9bO6GUSpCktWiDz47GCU8L4LDQ1hHyYC+zD19h+DcaLHjwE5EXmliIhHVjchxWMfJg77j4jcxYCciIiIiMhCDMiJiIiIiCzEgJyIiIiIyEIMyImIiIiILMSAnIiIiIjIQgzIicgr+fvzpEqJxT5MHPYfEbmLJwYi8lC+vhwvJ6bvcucOtLoZKRr7MHHYf65FRhni5+tjdTOIPA4DciIPNfTHy3LpznWrm0FElCSK5kkr49vkt7oZRB6JATmRhzob+lBO3jSsbgYRERElM+4TJyIiIiKyEANyIiIiIiILMSAnIiIiIrIQA3IiIiIiIgsxICciIiIishADciIiIiIiCzEgJ69Qu3Zt6du3r9XNICIiIoo3BuREyYSDBCIiInIHA3IiIiIiIgsxICevM2/ePKlcubIEBARIUFCQtG3bVq5evar3GYYhxYoVk4kTJzo8Z//+/eLj4yMnT57U6+fPn5emTZtK5syZJUuWLNK6dWsJCQmxPb5jx47SrFkzh2UgG46suHn/5s2bZcqUKbpcXM6ePfsYtp6IiIhSGgbk5HUePXoko0aNkgMHDsiKFSs0EEaADAiMO3XqJLNnz3Z4Dq7XrFlTg/WoqCgNxm/cuKFB9fr16+X06dPSpk0bt9uAQLxatWrStWtXuXLlil4KFiyY5NtKREREKZ+/1Q0gSmoIuE1FixaVqVOnyjPPPCN37tzRjDeC82HDhsmuXbukSpUqGsAvWLDAljXfsGGDHDp0SM6cOWMLoufOnStly5aV3bt367LikjVrVkmbNq1kzJhRs/SxefDggV5Mt2/f1r/Vi2eSEg/SJ7gfiLxZ+P1IuXYn0upmUDwUzZPW6iYQeSwG5OR19u7dKyNGjNAM+c2bNzXjbZahlClTRvLlyyeNGjWSWbNmaUC+atUqDYhbtWqljzt69KgG4vYZbTwvW7Zsep87AXl8jB07VkaOHBnt9p51cmu5DBFFZ0RFio+vn9XNoHiKjDLEz9fH6mYQeRwG5ORV7t69K/Xr19fL/PnzJXfu3BqI4/rDhw9tj+vSpYu0b99eJk2apOUqKEdBNttdvr6+Wo9uD5n2hBg8eLD069fPIUOOwUD4vNESGXY5Qcsk8mb+QUUkoNMo8WRIBFy/Hio5c+bW7wv6PwzGiVxjQE5e5dixY3L9+nUZN26cLcO9Z8+eaI976aWXJFOmTDJjxgxZs2aNbNmyxXZf6dKl5cKFC3oxl3HkyBG5deuWZsoBgf7ff/8d7cDQNGnS2K6jZCUyMu5d6unSpdOLs4iQcxIZejpe209EniMiImGDdCJKfThsJ69SqFAhDYSnTZumB2KuXLlSD/B05ufnp7XkyE4XL15cD8A01a1bV8qVKyft2rWTv/76S2vN33jjDalVq5bO3gIvvPCCBvqoLT9x4oQMHz48WoBeuHBh2blzpx5Ueu3aNVvpDBEREZE9BuTkVZC5njNnjixZskSz2ciUO09xaOrcubOWsbz55psOt2Mmlp9++kmyZ8+uM68gQMfBoYsWLbI9BiUwQ4cOlYEDB2pNeXh4uAbt9gYMGKCBP9phls4QEREROfMxnAthiVKJrVu3Sp06dbQ0JTAwUDwFasgxS8vZoa0lE0tWiKLxK1hSsn/wvXgy7BELCbksgYH5WEOeQOzDxGMfppw+ZA05pTqYUSU0NFRnYsHMKp4UjBMREVHqw+ESpTo//PCDBAcH60Ga48ePt7o5RERElMoxIKdUBwdzYvYTzFeeP39+q5tDREREqRwDciIiIiIiCzEgJyIiIiKyEANyIiIiIiILMSAnIiIiIrIQpz0k8lD+gcHilz6N1c0g8jj+QUWsbgIRUZJiQE7koQLaD5EsWbJY3Qwij2RERYqPr5/VzSAiShIsWSHy4LODUcL7LjQ0hH3oxX3IYJyIvAkDciLyShERj6xuQorHPiQiejwYkBMRERERWYgBORERERGRhRiQExERERFZiAE5EREREZGFGJATEREREVmIATkRERERkYUYkBORV/L351lOE4t9SET0ePBMnUQeyteX4+XE9F3u3IFWNyNF87Q+jIwyxM/Xx+pmEBElCwbkRB5q6I+X5dKd61Y3g8hyRfOklfFt8lvdDCKiZMOAnMhDnQ19KCdvGlY3g4iIiJIZ94kTEREREVmIATkRERERkYUYkBMRERERWYgBORERERGRhRiQExERERFZiAE5EREREZGFGJAnQu3ataVv375WN8MjFC5cWCZPnmy77uPjIytWrLC0TWfPntV27N+/39J2EBEREcWGAbmX4SCBiIiIKGVhQE4pwsOHD61uAhEREVGyYECeRObNmyeVK1eWgIAACQoKkrZt28rVq1f1PsMwpFixYjJx4kSH56CUAiUVJ0+e1Ovnz5+Xpk2bSubMmSVLlizSunVrCQkJsT2+Y8eO0qxZM4dlIBuOrLh5/+bNm2XKlCm6XFxQtuHs888/lyeffNJ2HaUleOyXX35pu61u3boyZMgQ/f+pU6e0XYGBgdq2Z555Rn777bd49c/w4cMlb968cvDgQb3+xx9/yHPPPScZMmSQggULyjvvvCN37951KIEZNWqUvPHGG9oX3bp1i7ZMtHnGjBnSsGFDXU7RokVl6dKlMbYhMjJSOnfuLEWKFNHHlyxZUvvKntnHeK3Q3pw5c0rv3r3l0aNHtsc8ePBABgwYIPnz55dMmTJJ1apVZdOmTbb7z507J40bN5bs2bPr/WXLlpVffvklXv1FREREqYe/1Q3wFgjYEEAiyEMg3q9fPw3uEIghcOzUqZPMnj1bAzkTrtesWVOD9aioKFswjqA6IiJCA8E2bdo4BHuxQXD5zz//aLD90Ucf6W25c+eO9rhatWppABwaGqr3Y325cuXS9fTo0UO3Zfv27TJo0CB9/J07d+Sll16Sjz/+WNKlSydz587VgPP48eNSqFChWNuEwQjW9fPPP8vWrVt1WxHgN2jQQEaPHi2zZs3Sdrz11lt6QZ+YEBQPGzZMg/mYDB06VMaNG6fbjkHRq6++KocOHZLSpUtHeyz6uECBArJkyRINtP/8808N9BF4Y/Bj2rhxo96Gvxgs4TWoWLGidO3aVe9HO48cOSILFy6UfPnyyfLly3V7sN7ixYvr64aM/pYtWzQgx2PxusYEAT4uptu3b+vf6sUzSYkH6WPtX6LUoECONJIS+funzHZ7EvZh4rEPUwiDEqxWrVpGnz59XN63e/duA90bHh6u1y9dumT4+fkZO3fu1OsPHz40cuXKZcyZM0evr1u3Tu8/f/68bRmHDx/WZezatUuvd+jQwWjatKnDerB+tMOdNpmioqKMnDlzGkuWLNHrFStWNMaOHWsEBQXp9T/++MNIkyaNcffu3RiXUbZsWWPatGm268HBwcakSZNs19FuLL9t27ZG6dKljYsXL9ru69y5s9GtWzeH5W3dutXw9fU17t+/b1tes2bNYt0OrKNHjx4Ot1WtWtXo2bOn/v/MmTP6mH379sW4jN69exstWrSwXUcfY90RERG221q1amW0adNG/3/u3Dl9nfB62qtTp44xePBg/X+5cuWMESNGGO4aPny4ttP5EhYW5vYyiIiIKP6iIv//770rkZGRxuXLF/RvcmKGPIns3btXRowYIQcOHJCbN29qNtYsQylTpoxmUhs1aqQZ4SpVqsiqVas0K9qqVSt93NGjR7V0AxcTnpctWza9D2UiSQUZe2TmkRFHaQoyuL169ZLx48fLsWPHNGOO9WXMmNGWIce2rV69Wq5cuaLZ+/v37+u2xebdd9/VjPqOHTs0A29CH6F0Zf78+bbbEF+jz86cOWPLbqMEKC7VqlWLdj22WVWmT5+urwHajm1AJhvZb3soMfHz87NdR7Yc2W/AX5S+lChRwuE5eC2RdQfsEejZs6esW7dO+7dFixZSvnz5GNs0ePBg3aNinyHH+yB83miJDLscZx8QERFR/PkHFZGATqPEEzAgTwKofa5fv75eEGSiDAQBH67bH4zYpUsXad++vUyaNElLM1AKYQa97vD19dXA1Z59bXN8oO7866+/1jKSSpUqaZ22GaQjIEdZiwllNuvXr9cSEpScoP66ZcuWcR5oWa9ePfnhhx9k7dq10q5dO9vtCPC7d++ugasz+xIYlHskJZSYYFs+/fRTDdxR7z9hwgTZuXOnw+PSpEkTbQBjDrDQdgTrGIDZB+1glqXgdcZrjwEMgvKxY8fqOt9++22X7cKgBRdnESHnJDL0dKK3m4iIiDwbA/IkgKzy9evXtZbZzHDv2bMn2uNQh40gEwcirlmzRmuMTcgKX7hwQS/mMpC5vnXrlmbKAYH+33//7bBMZIPtA8i0adNqBjcuCLhxQCjqqc2DQvEXB2tu27ZN+vfvb3ssrqMe/pVXXrEFpa4OFnXWpEkTrTXHAa4IXlHfDU899ZRuG4L7xEL2HQd+2l/HAMMVbEf16tV1b4AJ9ezxgWWjf3GcAA5KjQleQ9Tj44IM+MyZM2MMyImIiCh14ywrSQBZXQTC06ZNk9OnT8vKlSv1AE9nCEoR2CJAw8F/9uUWKG0oV66cZpL/+usv2bVrlwaaCJzN0o0XXnhBA30cVHnixAk92NE5QMfsJMj4ImC+du2aLbNbqlQpPfjQhBIKzAKyYMECh4AcM66g/KJGjRq2x6Kty5Yt0+Af5SYIsM3lxgVBPA62fPPNN20zoLz//vt6QCUOjsQysS0//fSTXo/JpUuXdBvQL/YwoEAJCg5mRX/g/piWg+1A/yFjj8fjgNDdu3dLfKBUBa8RXhv0CUpssE5kwZERBwx0sA7ch9cSB4e6OsiUiIiICBiQJwFkrufMmaPBIbLZyJQ7T3FowrR7KPVAgOpcFoGgFEEySkcQoGMav0WLFtkegzIIBJEDBw7UGu/w8HCH7DCgJAOBP9phls4AZkQJCwtzWB8yvPj77LPP2oJ0lK5gAGBfLvLZZ59pu5BdRsYb7UCW210ob/nuu++0XAdBLNaDshgExWgDss6YTQV19jFBaQ624d69ew63jxw5UktRsEwMVFAiY+5RcIYymebNm2upEKYqxF4N+2y5u1BuhH7HXgTMqoNpEhHYm+U2yKBjphUE4Zh9BUH8F198Ee/1EBERUerggyM7rW5EaoKa7Tp16mhpCub1poTDYAJZf+e52VM6HNSZNWtWOTu0tWRiDTkREVGy8CtYUrJ/8H2sj0FFQEjIZQkMzKfH8iUX1pA/JigDwXzbmK0EM6swGCciIiIiYMnKY4JSiuDgYD1IE9MLEhEREREBM+SPCQ7mxIWSDqutiIiIyBswQ05EREREZCEG5EREREREFmJATkRERERkIQbkREREREQW4kGdRB7KPzBY/NKnsboZREREXsk/qIh4CgbkRB4qoP0QPXMqERERJQ8jKlJ8fP3EaixZIfJQODsYJbzvQkND2IeJwD5MHPZf4rEPE499GDdPCMaBATkReaWIiEdWNyHFYx8mDvsv8diHicc+TBkYkBMRERERWYgBORERERGRhRiQExERERFZiAE5EREREZGFGJATEREREVmIATkReSV/f55UKbHYh0REjwdPDETkoXx9OV5OTN/lzh1odTO8tg8jowzx8/V57G0iIvJWDMiJPNTQHy/LpTvXrW4GkYOiedLK+Db5rW4GEZFXYUBO5KHOhj6UkzcNq5tBREREyYz7xImIiIiILMSAnIiIiIjIQgzIiYiIiIgsxICciIiIiMhCDMiJiIiIiCzEgJyIiIiIyEKpIiCvXbu29O3b1+pmpHhnz54VHx8f2b9/v9VNISIiIvIaqSIg90QcJHi3TZs26eDl1q1bVjeFiIiIPBwDciIiIiIiC6W6gHzevHlSuXJlCQgIkKCgIGnbtq1cvXpV7zMMQ4oVKyYTJ050eA5KNJDtPHnypF4/f/68NG3aVDJnzixZsmSR1q1bS0hIiO3xHTt2lGbNmjksA9lwZMXN+zdv3ixTpkzR5eKCchBXvvjiCylevLikT59eAgMDpWXLlrb7li5dKuXKlZMMGTJIzpw5pW7dunL37l29LyoqSj766CMpUKCApEuXTipWrChr1qyJtW/QjhkzZkjDhg11mUWLFtV1xCQyMlI6d+4sRYoU0ceXLFlSt8me2Rfo07x582o7e/fuLY8ePbI95sGDBzJgwADJnz+/ZMqUSapWraoZZtO5c+ekcePGkj17dr2/bNmy8ssvv8TYLizv/fffl4IFC+q24zX99ttvbfej76tUqaL3oU2DBg2SiIgI2/2FCxeWyZMnOywT/TdixAiHvvrmm2/klVdekYwZM+prtHLlSr0Pr+Xzzz+v/0eb8Vj0AxEREZEr/pLKIBAcNWqUBo8IxPv166fBEgI8BE6dOnWS2bNna4BowvWaNWtqYIdA1wzGEdghkEOA2aZNG4cgMjYIWv/55x958sknNWiG3LlzR3vcnj175J133tFBRPXq1eXGjRuydetWve/KlSvy2muvyfjx4zUoDA8P1/swqDDX8emnn8pXX30llSpVklmzZkmTJk3k8OHDGjzGZOjQoTJu3Dh9Ptb76quvyqFDh6R06dLRHou+QMC/ZMkSDbT//PNP6datmwa5GKSYNm7cqLfhLwY16CsEuF27dtX733rrLTly5IgsXLhQ8uXLJ8uXL5cGDRroetFW9O/Dhw9ly5YtGpDjsej/mLzxxhuyfft2mTp1qlSoUEHOnDkj165d0/suXbokL730kr7mc+fOlWPHjmk7MOCxD7jdMXLkSO3/CRMmyLRp06Rdu3Y6eMBA4Mcff5QWLVrI8ePHddCGAUtsAwhcTLdv39a/1YtnkhIP0serTUTJrUCONFY3IcXw92dfEZGbjFSgVq1aRp8+fVzet3v3bkSwRnh4uF6/dOmS4efnZ+zcuVOvP3z40MiVK5cxZ84cvb5u3Tq9//z587ZlHD58WJexa9cuvd6hQwejadOmDuvB+tEOd9pk+vHHH40sWbIYt2/fjnbf3r17dZ1nz551+dx8+fIZH3/8scNtzzzzjNGrV68Y14fl9ejRw+G2qlWrGj179tT/nzlzRh+zb9++GJfRu3dvo0WLFrbr6Ivg4GAjIiLCdlurVq2MNm3a6P/PnTun/Yl+t1enTh1j8ODB+v9y5coZI0aMMNxx/PhxbeP69etd3v/BBx8YJUuWNKKiomy3TZ8+3cicObMRGRmp19HeSZMmOTyvQoUKxvDhw23XsY4hQ4bYrt+5c0dv+/XXX/X6xo0b9frNmzfjbDOWi8c6X8LCwtzaZiIiTxAV+f+/55MCvpMvX75g+26m+GMfppw+THUZ8r1792om9MCBA3Lz5k3N8pplKGXKlNEMbaNGjTSjjLKGVatWafayVatW+rijR49qBhQXE56XLVs2ve+ZZ55JsrbWq1dPgoODtXQEGWNczBIJZH7r1KmjJSv169eXF198UctZUCKBDOvly5elRo0aDsvDdWx3bKpVqxbtemyzqkyfPl37Cv13//59zWQj+20PJSZ+fn6268iWI/sN+IvSlxIlSjg8B32OrDtgL0HPnj1l3bp1WpaDzHP58uVdtgdtxbpq1arl8n68Rtgm7A2x75c7d+7IxYsXpVChQuIu+zYgc49MuFn+FB+DBw/WPTUmvH54f4XPGy2RYZfjvTwiosfNP6iIBHQaZXUziFKsVBWQo74awSsu8+fP1zIRBJK4jkDS1KVLF2nfvr1MmjRJy1VQYoEg2F2+vr620hGTfc20u1Dn/tdff2kpDILRYcOG6WBi9+7dOgBYv369longPpRMfPjhh7Jz505bIJvcUGKC0h6UxiDIRXtRvoE22EuTxnG3LYJhcyCEQBgBNAZK9kE7mGUpeD3wGq1evVq3dezYsbrOt99+O1qbYisNSerXL7btig/UsuPiLCLknESGno738oiIiChlSVUHdaJe+Pr161oj/dxzz0mpUqVcZjRRY4yMJw5wxIGQqCs3oZb6woULejGhphnT2yFTDgj0UeNtzznLnDZtWs0Mx8Xf31+zwqhVPnjwoB4w+Pvvv9sCQGR3Ucu8b98+XSbqr5GpRaZ/27ZtDsvCdbONMdmxY0e0667qx83loba9V69eWqeOGvtTp05JfOB56Ae8Dni+/QUH3ZqQMe7Ro4csW7ZM+vfvLzNnznS5POwxQFCM+n5XsC2oL7cPuLEdGEygHt7V64eMNerQ4wOvBbjzGhMREVHqlqoCcpQjIFBCNvn06dM6KwYO8HSGTC0O+kMpAQ4qtC/jQHCMoA8H8CF7vWvXLj2IECUSmL0FXnjhBT0gEwcNnjhxQoYPHy5///23wzowkwcyyQiwccChmVnFIAFBNfz88896YCKCeRwsiOXhcTggFc8dM2aMrgdZfgSqoaGhtuD5vffek08++UQWLVqkBxZiJhEsp0+fPraDG7EutN8eDtBECQoOOkW7cT8OunQFfYP1r127Vh+PA0KRvY8PlKqgL9GH2AYEvlgnsuDIiJsz1GAduA99joND7QcJ9n2Gfu3QoYMOolasWKHPwR6GxYsX6/0YPGAwhew6Bmg//fSTbidKRpAZN18/HNCKg2RRUoPlOWfv44JSIwyY8BridcGeACIiIiJJ7QE5Mp9z5szRoBOZYmTKnac4NGE6P5SxvPnmmw63I8hCEIdabcy8ggAdNd4IfE0or0BwOnDgQK0pxwwoCDjtodQDQR7aYZbOAILnsLAw/T/KUhCkIkBEAPrll1/KDz/8oDXZyIJj1hFk8xHUDhkyRMs4MGWhWXeNIBPZZAwgkOnHAMScYQUlGFjXvXv3HNqFbDtKUVAfjQEA1hdTVr179+7SvHlzLenBVIXY+4CAN75QFoT+QVsx2MA0iQjszXpuZJkx0wr6AHX02F5MB2my7zPAng3U06MtCNYxi4o5HSSmVsSMOgj6UYePrDtea/SfCQMxDLBefvllPZ4A7XniiSfitU1YD/oSAyFMVxnToIaIiIjIB0d2Wt0IT4TsKA6aRDYVAVVqgMEGMs3Oc6jT44USmaxZs8rZoa0lE2vIiSgF8CtYUrJ/8H2SLhN7hENCLktgYD7bHkyKH/ZhyunDVHVQpzswuwdKDHDwJGZWSS3BOBERERFZg8MlJyjRQP0vDtLEgZRERERERMmJGXInOJgztZ7mnNVLRERERI8fM+RERERERBZiQE5EREREZCEG5EREREREFmJATkRERERkIR7USeSh/AODxS99GqubQUQUJ/+gIlY3gShFY0BO5KEC2g/RM7ISEaUERlSk+Pj6Wd0MohSJJStEHnx2MEp434WGhrAPE4F9mDipsf8YjBMlHANyIvJKERGPrG5Cisc+TBz2HxG5iwE5EREREZGFGJATEREREVmIATkRERERkYUYkBMRERERWYgBORERERGRhRiQExERERFZiAE5kYfy9U1ZH8/IKMPqJhAREaVIPFMnkYca+uNluXTnuqQERfOklfFt8lvdDCIiohSJATmRhzob+lBO3mTWmYiIyNulrH3iRERERERehgE5EREREZGFGJATEREREVmIATkRERERkYUYkBMRERERWYgBORERERGRhRiQU4p29uxZ8fHxkf3798f6uNq1a0vfvn2TpQ0dO3aUZs2aJcuyiYiIyPsxICevsmnTJg3Qb9265XD7smXLZNSoUbbrhQsXlsmTJ1vQQiIiIiJHPDEQpQo5cuSwuglERERELjFDTh5vzZo18uyzz0q2bNkkZ86c8vLLL8upU6dclq88//zz+v/s2bNrphzlJM4lK/j/uXPn5N1339XH4AIjRoyQihUrOiwTWXRk002RkZHSr18/W1sGDhwohuF4Ns2oqCgZO3asFClSRDJkyCAVKlSQpUuXJkPPEBERkTdgQE4e7+7duxoE79mzRzZs2CC+vr7yyiuvaOBrr2DBgvLjjz/q/48fPy5XrlyRKVOmRFseylcKFCggH330kT4GF3d9+umnMmfOHJk1a5b88ccfcuPGDVm+fLnDYxCMz507V7788ks5fPiwBv6vv/66bN68OcF9QERERN6LJSvk8Vq0aOFwHcFw7ty55ciRI5I5c2bb7X5+frbSlDx58mgW2xU8Bo8NCAiQoKCgeLUFGfPBgwdL8+bN9TqC7rVr19ruf/DggYwZM0Z+++03qVatmt5WtGhRDd6/+uorqVWrVrRl4jm4mG7fvq1/qxfPJCUepJeUoECONFY3gYiIKMViQE4e78SJEzJs2DDZuXOnXLt2zZYZP3/+vJQpU+axtSMsLEyz6VWrVrXd5u/vL5UrV7aVrZw8eVLu3bsn9erVc3juw4cPpVKlSi6Xi4z6yJEjo93es05uyZIli3gLIypSfHz9rG4GERGRx2FATh6vcePGEhwcLDNnzpR8+fJpQP7kk09qkJuUUArjXA/+6NGjeC3jzp07+nf16tWSP39+h/vSpUvn8jnIuKMkx4QMOcpvwueNlsiwy+IN/IOKSECn/z/LDREREf1/DMjJo12/fl3rwRGMP/fcc3obyj9ikjZtWtvBl7HB45wfgzKYf//9V4Ny80BP+/nNs2bNKnnz5tVMfc2aNfW2iIgI2bt3rzz11FN6HRl7BN7I3rsqT3EFj3cVrEeEnJPI0NNuLYOIiIhSLgbk5NEwWwpmM/n66681GEagO2jQoBgfj0w6gumff/5ZXnrpJZ3lxL7O3ISZU7Zs2SKvvvqqBsO5cuXS2VdCQ0Nl/Pjx0rJlS53d5ddff3UoG+nTp4+MGzdOihcvLqVKlZLPPvvMYc5z1KUPGDBAD+REJh+zw6DUZdu2bbqcDh06JEMvERERUUrGWVbIo6GMZOHChZqFRpkKAt0JEybE+HiUiaAeG0F7YGCgvPXWWy4fhxlWME3iE088oZlxKF26tHzxxRcyffp0napw165dGlzb69+/v7Rv314Daxy0iQAcM77YwwmIhg4dqrXhWGaDBg20hAXTIBIRERE58zGci2aJyFKoIUd5zNmhrSWTl5Ss+BUsKdk/+P6xrQ97J0JCLktgYD4d1FH8sQ8Th/2XeOzDxGMfppw+5KtDRERERGQhBuRERERERBZiQE5EREREZCEG5EREREREFmJATkRERERkIQbkREREREQWYkBORERERGQhnqmTyEP5BwaLX/o04g38g3hSJCIiopgwICfyUAHth0iWLFnEWxhRkeLj62d1M4iIiDwOS1aIPPjsYN6EwTgREZFrDMiJiIiIiCzEgJyIiIiIyEIMyImIiIiILMSAnIiIiIjIQgzIiYiIiIgsxICciIiIiMhCDMiJiIiIiCzEgJyIiIiIyEIMyIk8lK9vyvh4RkYZVjeBiIgoRfO3ugFE5NrQHy/LpTvXxZMVzZNWxrfJb3UziIiIUjQG5EQe6mzoQzl5k9lnIiIib5cy9okTEREREXkpBuRERERERBZiQE5EREREZCEG5EREREREFmJATkRERERkIQbkREREREQpJSCvXbu29O3bN/lak4IULlxYJk+ebLvu4+MjK1asEE+UVG3z5G1MamfPntXt3b9/v9VNISIiIi+X4jPkHCQkvREjRkjFihWj3X7lyhVp2LChpAYFCxbU7X3yySetbgoRERF5uRQfkHurhw8fxvmYR48eyeMUFBQk6dKlk9TAz89Pt9ffn+fOIiIiIg8NyOfNmyeVK1eWgIAADVzatm0rV69e1fsMw5BixYrJxIkTHZ6D3f8oAzh58qReP3/+vDRt2lQyZ84sWbJkkdatW0tISIjt8R07dpRmzZo5LAPZcGTFzfs3b94sU6ZM0eXiglIDZ59//rlDphNlF3jsl19+abutbt26MmTIEP3/qVOntF2BgYHatmeeeUZ+++23ePXP8OHDJW/evHLw4EG9/scff8hzzz0nGTJk0OzrO++8I3fv3nUogRk1apS88cYb2hfdunWLtky0ecaMGdKkSRPJlCmTfPzxx3r7Tz/9JE899ZSkT59eihYtKiNHjpSIiIgY2/b+++9LiRIlJGPGjPr4oUOH2oL7OXPm6PMPHDhg61Pc5lyyUr16dV2OvdDQUEmTJo1s2bJFrz948EAGDBgg+fPn1/ZWrVpVNm3a5Fb/nTt3Tho3bizZs2fX55YtW1Z++eUXvQ/LQFtWr14t5cuX1+3+3//+J3///bft+devX5fXXntN143tLFeunPzwww8O64iKipLx48frexUDjUKFCtn61LlkxVznhg0b9H2PZaIPjh8/7rDM0aNHS548efRz0aVLFxk0aJDLvQ1EREREpgSn/xDAIYAsWbKkBuL9+vXTABlBEwKXTp06yezZszUgM+F6zZo1NQBCMGQG4wiqEUD27t1b2rRp43bQhkD8n3/+0WD7o48+0tty584d7XG1atXSABgBI+7H+nLlyqXr6dGjh27L9u3bNXiCO3fuyEsvvaTBGQK1uXPnanCI4AtBW2wwGMG6fv75Z9m6datuKwL8Bg0aaLA2a9Ysbcdbb72lF/SJCQOYYcOGaTAfWznJuHHjtH4d2VusA0H81KlTNeDHusxgPqblIFhEkJ0vXz45dOiQdO3aVW8bOHCg9j8C2zVr1tgGIVmzZo22jHbt2mkwi7bg9YZFixbpMtEOwPYdOXJEFi5cqLcvX75c+wHrLF68eKz9iPcC9hIguEdAjuXgvWLvvffe0/cABoQffPCBvkZ4P2BQ8N9//8nTTz+tgwYMcBC8t2/fXp544gmpUqWKPn/w4MEyc+ZMmTRpkjz77LNaonLs2LFY2/Xhhx/Kp59+qu8jvHfwPt+2bZveN3/+fH3PfPHFF1KjRg3dbjy2SJEisS4TAxdcTLdv39a/1YtnkhIP0osnK5AjjXgqf3/PbRsREZEDIx5q1apl9OnTx+V9u3fvNrC48PBwvX7p0iXDz8/P2Llzp15/+PChkStXLmPOnDl6fd26dXr/+fPnbcs4fPiwLmPXrl16vUOHDkbTpk0d1oP1ox3utMkUFRVl5MyZ01iyZIler1ixojF27FgjKChIr//xxx9GmjRpjLt378a4jLJlyxrTpk2zXQ8ODjYmTZpku452Y/lt27Y1SpcubVy8eNF2X+fOnY1u3bo5LG/r1q2Gr6+vcf/+fdvymjVrFut2YB19+/Z1uK1OnTrGmDFjHG6bN2+ekTdvXofnLV++PMblTpgwwXj66adt14cPH25UqFDB5frN5Vy9etXw9/c3tmzZYru/WrVqxvvvv6//P3funL6+eB84t3fw4MFGXMqVK2eMGDHC5X0bN27UtixcuNB22/Xr140MGTIYixYtinGZjRo1Mvr376//v337tpEuXTpj5syZLh975swZXce+ffsc1vnbb7/ZHrN69Wq9zXwNq1atavTu3dthOTVq1HDZl/bQ31iO8yUsLCzW59HjExUZYaQ2kZGRxuXLF/QvxR/7L/HYh4nHPkw5fZjgDPnevXs1W4vShps3b2rG2yxDKVOmjGZEGzVqpBlhZCRXrVqlWcBWrVrp444ePaqlG7iY8Lxs2bLpfSgTSSrI4CIzj4w4SlOQbe3Vq5dmeJERRcYc60MZgpkhx7Yhq4qsKbL39+/f122LzbvvvqsZ9R07dmgG3oQ+QukKMqgmxLfoszNnzkjp0qX1NpRCxMX5MVg2MrRmqQVERkZqhvjevXu2bbKHTDYy6simY1uxfcgixwcyxC+++KJuEzLi2A7sZfjqq6/0fmTB0Q6UxtjDeyBnzpxxLh97GXr27Cnr1q3T16xFixZanmKvWrVqtv/nyJFD99bgvWP2wZgxY2Tx4sVy6dIlzbZj3WZ/4HG4XqdOnXhtt30bUJIE2EOEPSfYg4L3lT2893///fdYl4lMPfYw2WfI8bkInzdaIsMux6t9lPT8g4pIQKdRVjeDiIi8WIICctQ+169fXy8IyBCcIVjFdfuDEVFDizIBlASgNAPlEK4CxJj4+vpq4JoUBzKi7vzrr7/WEo9KlSppAGoG6QjIUdZiQpnN+vXrtYQEJSeo+27ZsmWcB1rWq1dP65TXrl2rJR0mBL3du3fXINOZfQkMSjPi4vwYLBs1382bN4/2WNRWO0PQjLbhOXi9UI5illbEF5aDbZo2bZosWLBA67RxMduFAyMxcMNfe86lJ67gvYP2YVCEoHzs2LHaxrffftuttk2YMEHLWVDagzah33D8gfka4jVNCJTDmMxSHXMwmlAYxLk6WDYi5JxEhp5O1LKJiIjISwNyZJVx0Bzqh80M9549e6I9DnXYCIRwICJqks2D/QBZ4QsXLujFXAYy17du3dJMOSDQtz9QD3CQnX1QlDZtWs2GxgUBNwKyJUuW2A4KxV/USSPD3L9/f9tjcR318K+88ootuHR1sKgzHGyJOmYc4Iog9NVXX9XbccAltg3BfVLDspGZdXfZf/75pwQHB2sttP0BlPbc7VMcA4B6dby2CMhRy27CoAfLQPbYrCmPL7wvUKeNi1nvbR+QY0+EOaDBXhrUj5t7G/Aaon2vv/66LWjG/eZ7CzXsCMpxkCaC/6SADP3u3bsd+gHXiYiIiJJ8lhUEQQjakBk9ffq0rFy5Ug/wdIagFIEtgikEQPYlBihDQOYSWda//vpLdu3apYEMAmezLOOFF17QQB8HVZ44cUIPUnQO0DE7yc6dOzVgvnbtmi1bWapUKT2I0L7UADN2IHC0D8gxawhKF3AQngltXbZsmQb/KAlBgO1uFhRBPGagefPNN2Xp0qV6Gw4sRCCMgxyxTGwLZkbB9ZigzALbgH6JDQ4CRf8g43348GEtxUDG25wxxhm2DXsz8BiUrKB0xb6fzD5FCQraij61P+DQHgZbmAUHs7RgvZjVxIRSFby2eE3Rl1getgWZbmS944LBE/Y04Hl4f2zcuNEWbJtwIC8Carwn8D5DmZA5Kw+2E3s50O9oG/ZQ2M/gg70HeF1wICv6D32BAP/bb7+VhMJgAc//7rvv9DXGQbwoVTIz6URERERJFpAjc41ZOpBtRsYRmXLnKQ5NnTt31jIBBKj2EKQgKEWQjNIRBOiYgg/1zSaULCDYQ9CEGu/w8HCH7KNZXoLAH+0wS2cAWeOwsDCH9SFTi7+YUcMM0lG6ggGAfSnIZ599pu3CtHbIeKMdyES7C+UtCMpQroNgFOtBWQwytGgDsscIpFFnHxOU5mAbUAceG7QNM7qgrAN9hOn/UCKELHhMWXzUumMwgOn4ELCij+2hXhuzoTz//PPap87TBdpD0I1BC7bLeQYalCnh9cLeB2SPESwjYxzXTDWA7DpmWkEQjrYgwMfsJfbwvuvTp4/OpvLvv//qcQoYKAIGJHjN0D8YeGEmFucpNLHdaBteC6wHJVXm1J0Jgb7A4BPvSawbgwkMFFyVDhERERGZfHBkpyQj1GzjwDmUpmBeb6LEQt0/BgsoU8FBwJ4MxxVgMIC9Ju7CQZ2o7T87tLVkYg255fwKlpTsH3wvqQ32CoaEXJbAwHx6PA/FD/sv8diHicc+TDl9mGynIUSZA+bbxmwlmFmFwTh5O+zNwMmmkJXHXhvsWcAxCiidISIiIopJsoX6CEZQNoGDNDG9IJG9hg0b6mwrri6YrjAlQjkUToyFEiyU0aCE5scff9RyLCIiIqLHniFH7SwuRK588803Ore7K5hTPDaoCU/mSqsEwawt5tlNiYiIiCwPyIlikz9/fqubQEREROQRWOFPRERERGQhBuRERERERBZiQE5EREREZCHWkBN5KP/AYPFLn8bqZqR6/kFFrG4CERF5OQbkRB4qoP0QPZMsWc+IihQfXz+rm0FERF6KJStEHnx2MEp434WGhiRZHzIYJyKi5MSAnIi8UkTEI6ubQERE5BYG5EREREREFmJATkRERERkIQbkREREREQWYkBORERERGQhBuRERERERBZiQE5EREREZCEG5EREREREFmJATkRERERkIQbkREREREQWYkBORERERGQhBuRERERERBZiQE5EREREZCEG5EREREREFmJATkRERB7J3z+N1U0geiwYkBMREVGyiowy4v0cX19fyZ07UP8mdtmFCxeWkiVLSsWKFaVMmTIyffr0OJ/z0ksvyfHjx+N83IoVK2THjh3yOHz11VdSqlQp3Y7r1687XL906ZI899xzSbZdsZkzZ44cO3bM4XqzZs0kpejYsaNMnjw53s8bMGCAjBgxIlna5C9eqHbt2vrmTEhnext8CfXt21cv4OPjI8uXL0/WD05Sr8P59XTepuRy9uxZKVKkiOzbt0/XT0RECePn6yMDF12S01cfJulyi+ZJK+Pb5HfrsYsWLdLv8nPnzkn58uU1eMXfmPzyyy9uLRcBOZb7v//9T5Ibfgdnz54t1apVc3l969atcS7D3e2KDQLwbNmy6WCAkgYz5I8JgsrkDiA9xZUrV6Rhw4bJtvzdu3dLt27dkny07DyAKFiwoG7Lk08+maTrIiJKjRCMH738X5JeEhLgBwcHa7b8n3/+katXr0rz5s2lXLly+l2PjLMJyZ/9+/fbfsORHUUQ/8QTT0iPHj1swe3KlStlwoQJGpR/8803cuLECalRo4ZUqFBBlztkyJBobbh//760adNGs/V43Isvvqi3b9q0ySEB9Pfff2s7oGXLlnLq1Cn9vcL/na8jiYQg2bR9+3apWbOm1K37oi7zp59+irZd//77r7Ru3VqqVKkSra143LBhwzTYR3Jq9OjReju2cc+ePfLuu+/qcp0D/JdfflkWLFhgu75u3TqpWrVqtD4IDQ3V7cZ6y5cvL2+++abefujQIXn22Wflqaee0v4x1wvITqO9jRs3lhIlSui60Ef169fX66+99ppERUXpY9EvnTp1kurVq+t9HTp00H539ujRIxk0aJD2AbYHy79586behxigQYMGUqvWC9rWixcvSnLxygw5PT4PHz6UtGnTOtwWFBSUrOvMnTu3PA5+fn7Jvi1ERPR4IeBDuQUC4bfffluD82XLlmlw/vTTT+vtrrLdCH43btyoARwCRQS8KP9o0qSJBnJm0q1Pnz4aKA4ePFiv37hxI9qy1qxZI7du3ZIjR47E+BhnS5cu1SDZzPSD/XUE5CYsD0mmxYsXS4kST0ju3EFy+/btaMtEkPrBBx9IrVq1JCIiQtu9ZMkSadWqld6PNmI7r127pgMRBM1dunSR77//XrfXTGQhY27C9g8fPlzatm2r11Ee9NZbb0VbN5aBQB8Bu30fYJs2bNgg6dKl0wAaAXXdunVtrwkGA3v37tXBBwZKaM/69eslQ4YMUrlyZfn111+lUaNG+tidO3dqOVHGjBm1rZMmTdLttYfBVKZMmWTXrl16fdSoUTowQbvfeecdDdS/+26WREQYOkhIrr0CXp8hnzdvnr5AAQEBGlzhDYIPHRiGIcWKFZOJEyc6PAcjR5RdnDx5Uq+fP39emjZtKpkzZ5YsWbLo6CkkJCTW7CreqHijmPdv3rxZpkyZosvFxf6DY/r8888dsrHYDYbHfvnll7bb8KY0R7D4ckC7AgMDtW3PPPOM/Pbbb/HqH3xo8ubNKwcPHtTrf/zxh2YA8MZGhhhvxrt379oejw8K3qxvvPGG9oWrTDXajLYDthPX8WX3/PPP64cCX3b4gNvbtm2b9hfuz549u452zRGqM7TBvhwJy8eI/ZVXXtHnFy9eXDMWpsjISOncubN+8LFd+PLFa2E/4v7uu+80e2C+PshSmG03MwmA1xEfTnxRoN8wqsaXmAnbgD4bOHCg5MiRQ99zyVVvRkRE7kNGGoFr9+7dZdasWfpbgd9MXIc8efJotjym31E839/fX39HsBz8BruCrPTMmTPlww8/1GDTPmttwu/g0aNHpVevXhpQp0mTtAev4jcWv3VmTTnq8PGbZA+/7Qh8EUBjexArIe6xry83g+pcuXJJ0aJF5cyZM3Guu169ehIWFqblnigPQqCLuMkZAmwEz/3799ffXwTFgCAcQTYy53gMlmH/O4xMNeIE/D4jQMbvLmI8vDaVKlXSPRQmrBf3IcGGOMDVa4t4BYMD9AEuP/zwg2070T94HuTPn18HX8nF6wNyjGQRQB44cEA7HUEWAmTAi4ndGai/sofr+EAhWMeuDwS9GLkhGMMo7PTp0/rBdBeCP+zy6dq1q+7+wAXBrjOMUDFaxm4cwPrwIUBwaG4LPmRmoH/nzh0dneMNgzc+dqtgNw4GEHHBYASZgblz52rNGXYX4csFy2jRooUG6PiSQIDuPLLFAAZfJljn0KFD3eoDfDFhdx8+VOZuJTOQxW116tSxZRywTmwHAml3jRw5Uj94aDf6pF27drbRNl7DAgUK6Kgf/YtdcBghI3MAaBeei203Xx+MyJ3hgBksGwMfvJ9mzJgh3377rcPuNEBwjy8WjMzHjx8vH330kb5vYvLgwQPNXNhfiIgoaeE3Db83f/75p5Z4uIK4ICbp06e3/R8Bnn0yxh5+Q5FkQkCMRBuyzs4Q3OL3CL87eCyScUhCIai0/+3777//JLkgDgBkkNEvuCAgty9bcXebnSExNW3aNE0oIs5CEssZ4iKsE+Usy5Yt099WbDt+nxH7IMbAby1iHvt+cG5TfNro6vVFP6CtZh/gdYmpzj6290dieX1AjjcC6pnx5sdIa+rUqToiQzALCM4xGjR3VSDoRe0TngcIdrF7C7dhVxbeOAhiESyjltkdWbNm1bIOZG+RMcUFbxpn+EBiBItlAwJxjBzN62gj2mcGiwiKMbLH8zDSx8ADu5Tss8Ou4M36+uuv67Yh+MXAA8aOHauBLLL7WB7Wg/7C9tp/GF544QVtF9aFizsQ9GIXEoJxBM8Y8Zp7IBC0YmT+xRdf6DaVLVtWBwH4QLoLryOCfGzLmDFj9PU1X1NkHrBOrANZcmwjdruZATn2LiDjgS8M8/VxLsMBtA8DKXzBYpcV9opguZ9++qmtZg0wuMGeB/Qh9iRgvejrmKDf8R4xL64Ga0RElPSw1xnZbEAyDIEhMrzxgb3FyAibkKHFnmt8/+P3zdUMLKhFRnCHjCuSXAgKL1y4oLEKfh/NxBz28icEfr/RDvMgT/xGOZfF4LcPe67HjRtnu+3y5ctu1Uk7b7Oz9u3by9q1azXBadbbO0MWGm1AQmzatGla04/fbgxMkETD4ATxWWwJLXfKfLBMBPpoC15vZ2Ypy7179/Q6/h4+fFj/j8ebSVsk6+KKrxLD62vIUWeEkgGMsvAim4ETssjIyObLl08DRey+QinCqlWrNGNp1k9hlxICJPsgCc/DLijchxFdUsGHE5l5BOJ4E2CUht1Z+ECj3g2BOdaHwB7wJsO2rV69Wt8oCLSxqyeuDDkOxEDwiS8J+6AXfYQM8/z582234UsCfYYPTunSpfU2BJjxZX8kO0o9AKVDCGwxIjX7O6Hsl4/sNL4szNIkQC0YXmP0DfoIte/xnTkFrzdG9PYjZBy4g9cBX2CFChWK1hZze+3b4gx1hv369bNdR4acQTkReRvMiOJpy0TSqWfPnloegd877M11dQBibBB8IimEvfC9e/fWYBolEEjs4PfTvuzUhEQfvvuxTvx2YxnmbwdKHhGPIKhP6AQJKOnAbGdInt28eUPSpk2nSTvsfbaH33v8/iCxh982/H7iwFYExLFBuSqWjUAWSTBniFNQ/oMAP6bfM8Q6n332mS2rPWHCBE1KIUOP/sDeZiT9kARMKMRMKIHFa4Lfb1eTa7z//vsa9+F1N3/fcRuSg6hwQJ39woUL9Tc+MW1J1QE56qPwQuCCNx0OBkRAhusIyEyoVcKLjzcWRkIoRzGDXnegNsvc9WNCJjshsGvm66+/1lEtaqEQWJpBOgJylLXYZ50xcsToGplhZHmxG85+21zB6B81Uhi9IltsQmCJjDt2NTkzg00w67ziw74+znzDm4MjtDuxnOvvsA5z+fggoa+QycYHEvVk+OCjpCQ5xNYWVzA4crU7j4jIW2CucHenJ0zIsjGtYmxcHbcFCHqRFY/rOWbpqH3m1T7oMzOqJvOAzpgg0I4p2EZAal82gj2uMW2H/XUcX4WDME2oCkAsERJyWQID89nmc7d/DurmMXhwxXldOJjShDIc51IcsxwYkJHGupH5jgn2VJszq9hD7IOZU1xxPibL+RhAHE9mD4McJOOc2R+Eikw8SktxcYaEGg7Ade7D5ODVJSvIKmPifOyOwYENyMa6ylSiLhhBJmqC0fFmuQogK4zdSLiYkLnGmx6ZckCgjwy1PfsDEAAjZXdqos06ctQ7m7Xi+IsDEcwDH024jg8ADmbE6B6lFjF96djDLjKU4GAggmDVhIMjsG4E984XVyUcSQUfmNhKOhIL/YTdd9jbgA86tsf5YBx3Xh+8F1Djbj/4wrIR4MeVTSAiSs3iCphdQSIjNDQk1oRGQpdNyQdlHchsIwHmzomKKBUE5MjqItDCCA0HYuJNgl02zrC7BIEtRrSo+zUn2AeUjiDYRSb5r7/+0rpk1IUhcDZLN7ALAyNH1FqjZgujWefRHUauyMgiYMb0QeYXDAYJ2K1kH5xiVxMCZvuAHLvCsEsFJRImtBUjewT/KDfB0dBxfXGZEMSjNg2jU3Okj100ONgF9dtYJrYFRz67mq7I/kBHbINZr50Q6HfU4yNgRskMBlIYHKGfkgL6Ca8P9gigRg0HojrX/+P1wbpRr4b1utrDgfZhYIaDYdFG9A1ea+zuS85RMxFRahURkbC9zWQdJP0Q6+B33Epz5sxJUed/8eooAplrvCDINiObjUy58+4NE6a1QamH8+4TlBsg8EKQ/H8T7NfVgy5wtLYJJTAI8lD3hV1X4eHhGrTbQ8kEAn+0wyydAQSA9gdGYH0YUeIvJsY3g3SUrmAAYF8ugtortAvZX9SFoR3IcrsL5S2o0UK5DgJ7rAdlMQha0QZkkzEjCersY4LAFdtgHgyREDjQE1NDYVCBujkMiNDn2I2UFFCGg1o2lCKhRgx7TRBc28MMODgiHn2M1weZb2eY8ghHXmPwgYNPcaAK3jeuTvpARERE5C4fw7n4OZVCrROm3kMGFDVlRFbBQZ04sAUHIbuav5bihj1Fj6Pmz5uxDxOH/Zd47MPEYx+mnD706oM63YEyEBx9iwMFMNMHg3EiIiIiepxS/XAJs40EBwfrQZqYXpCIiIiI6HFK9QE5DubE7BqYrxw1wkREROQZ/P2T9pTyRJ4q1QfkRERElLyMqLin/XWGet3cuQPjrNt1Z9mYSQsH7uOEcJhcASeLiwumRMakBXHBLGiuzsaZEmF2FFcnMooJJqCwn/vck23atCneJwQEzJpXpcr/n30vuaT6GnIiIiJKXj6+fhI+a6hE/HsmSZfrH1REAjpFn87YFcyOhoAMp6bHrGKYTcz5zMr2MKuWOxCQY7k4EY+nwxkxY5vBzAzIYzrdPSUfZsiJiIgo2SEYj7xwPEkvCQnwcdwYsuWY4hcnC8S0uDjfCE4fj9PG22fVzZP84XwgmL4YQTxOemMGrAjacY4TnP0ZQTnOFIlzeOCcIZgeF8uNaWpcnN8EU+1iUNCoUSP5999/bfetXr1ap1HGMrBc88zSODkdpkTG7Xgepgh2bitguebZRVu0aCV9+vTRKYVffPFFDcoxTTIeg9PD4xwmOLM5YLuwVwDrxHzigO1B+9AerPPzzz+Pti04nwmWbUIpMPoZJxt0Nnr0aD3RHtZhDpBi6w8MEjDjGKaXxtTOOLcIpiZ+99139fl43cxzv2CbcR1TT+Pv008/He1EjSacmwR9icdgyuWNGzfa7sNEH1gP7rOf5jo5MUNOREREqcahQ4f05G4IanGiNwTnOBcHgnMEYLjdVbYbZ3hG0Ibzb6DsBcExyloQuCIwNE9Cg+AXp5XHSe/gxo0bLtsxefJkPe8F4DwpCAKRncZAAedE2bJli554D+vDuT6wnGbNmmnwi4EBpuNzt1wEy8Ty0qRJo2ebxskHc+bMqf/HeTlwAsVBgwbp+rEdZhCLwPq1116T77//XtuCdqBvcE4PBOj2JxvEgAXBPPoTgxScFds8o7kJ0/nifDA4u3mGDBl0eWZJ0uQY+gNwvha8Nji547fffqsDilWrVsmkSZN0MDRy5Eg95wwcPnxYpkyZoidrXLx4sbz66qty9OhRh3bgZJFYPoJynOfl5MmT2qcI/nFmdCwLxxbiTNyvv/66PA4MyImIiMjr4eRwCAIzZswos2bN0gwogi8EXpAnTx7NluM2VwE5no9yD1wQgCNAtz+ztwknEXzvvffkzp07elZvnFDQFQTFOGP2f//9p5dcuXLp7evXr5cGDRpoAAwIonFuCmTNEeyap6NHIJsjRw63th3ZZywHEIQjkMXykC1HsIsTDLqCABsBLoJaE05+iMy3fUCOEx8isEdt/tSpU/Wvq7N8I/hFvyPIRUYdmfACBQrE2h+QPn16HYwAsuiZM2eW559/Xq8juz1//nzbY7G3AOeVgdatW0u3bt30HDP21qxZo0E4XisT+hMnbdywYYM+D20FPB+DmeTGgJyIiIi8nllDHtdBijFBUGgfgCKYdaVFixYa4CKwRnkHMr/O9eh//PGHBq7IsmMggIwyzoydUBgkIJttQkBrDwGsCYHv77//rmfmRtCJduC6KwjeEfTHVPbhfMZrZMRRLoJg1yx5sYd+wwGwf/75p5aXYOCD6ad9fHxi7Y906dI5LMPd1wKwbOfXFdtVr1497Yu4xPaeSEqsISciIqJUCdnrmTNn6v9xkkCUriBQiw8Etcgym1BzjZMMIjDF+U1czcCC0g2UQ6Bs5OHDhw616yjHQCkFymoAJStmFhvLxpnFASUrZjkMykPMOvNdu3bFOjsM1o3sM9qNbPecOXNi3BZk5HHb7Nmzbbch2HZVhpM9e3Zp2rSplq90795dA2VnWF9ISIhm+VETjhruffv2xdof8YWyE7MeHOU9eC3MLLx9H2NPyMGDB223od/M9wRKVtBWBO7m+yO5MUNOREREyQ4zonjaMpGV7dmzpx58ieDrww8/1Pro+Gjfvr2e0wSzrfTu3VsDe9Rcp02bVoNmV9MIoiQFj0HAiyAUQeClS5dswTUCYJR1IBhHYItloDRj+fLl0r9/fw0WUWKBmurGjRvrgZIdOnTQQBZlNDhYMyYYKOBgUKwbNdsIjs0DK3FAJZ6LAyKLFi2qmeqff/5Z68pR5oIsPIL5mDLLyJIjwMdfVxDst2zZUg8iReYZ5Stod8aMGWPsj/hC+9GGd955R18DMwNvD32MbcDAAXXsGARUqlRJb8NxAQjOcQApBiN4rR4HHwPvQCLyGLdv39Z6QWQMcGQ5xR9+BENCLktgYL445zAm19iHicP+iz5XOKY+TGnLTuke9/sQB2ziAEoceGmFTZs2ORyUmpL6kBlyIiIiSlYJCZgRCF2/Hio5c+aONRBiMO4ZkJlGJhoHTFL8MSAnIiIijxQR8cjqJpCbMBuL1WrXrp2k2fHHifvRiIiIiIgsxICciIiIiMhCDMiJiIiIiCzEgJyIiIiIyEIMyImIiIiILMSAnIiIiIjIQgzIiYiIiIgsxICciIiIiMhCPDEQkYcxDEP/3r59m6fcTiCc4S88PFwyZGAfJhT7MHHYf4nHPkw89qFn9GFAQICexTQ2DMiJPMz169f1b3BwsNVNISIiokQKCwuTLFmyxPoYBuREHiZHjhz69/z585I1a1arm5MiYe9CwYIF5cKFC3F+CZJr7MPEYf8lHvsw8diHntGHyJDHhQE5kYcxd4khGOcXaOKg/9iHicM+TBz2X+KxDxOPfej5fciCIiIiIiIiCzEgJyIiIiKyEANyIg+TLl06GT58uP6lhGEfJh77MHHYf4nHPkw89mHK6UMfw5xjjYiIiIiIHjtmyImIiIiILMSAnIiIiIjIQgzIiYiIiIgsxICcKJlNnz5dChcuLOnTp5eqVavKrl27Yn38kiVLpFSpUvr4cuXKyS+//OJwPw77GDZsmOTNm1cyZMggdevWlRMnTog3S+o+7Nixo57G2P7SoEED8Wbx6cPDhw9LixYt9PHom8mTJyd6md4gqftwxIgR0d6HeN96s/j04cyZM+W5556T7Nmz6wXfdc6P5/dh4vuQ34dVY+3DZcuWSeXKlSVbtmySKVMmqVixosybNy/p34c4qJOIksfChQuNtGnTGrNmzTIOHz5sdO3a1ciWLZsREhLi8vHbtm0z/Pz8jPHjxxtHjhwxhgwZYqRJk8Y4dOiQ7THjxo0zsmbNaqxYscI4cOCA0aRJE6NIkSLG/fv3DW+UHH3YoUMHo0GDBsaVK1dslxs3bhjeKr59uGvXLmPAgAHGDz/8YAQFBRmTJk1K9DJTuuTow+HDhxtly5Z1eB+GhoYa3iq+fdi2bVtj+vTpxr59+4yjR48aHTt21O++ixcv2h7D78PE9yG/D7vG2ocbN240li1bpr8nJ0+eNCZPnqy/MWvWrEnS9yEDcqJkVKVKFaN3796265GRkUa+fPmMsWPHunx869atjUaNGjncVrVqVaN79+76/6ioKP1xnzBhgu3+W7duGenSpdMffm+U1H1o/gA1bdrUSC3i24f2goODXQaTiVlmSpQcfYiAvEKFCkZqkdj3TEREhBEQEGB89913ep3fh4nvQ+D3YWS8v7sqVaqkyZ6kfB+yZIUomTx8+FD27t2ru65Mvr6+en379u0un4Pb7R8P9evXtz3+zJkz8u+//zo8JmvWrLrLLaZlpmTJ0YemTZs2SZ48eaRkyZLSs2dPuX79unijhPShFcv0ZMm5vditnS9fPilatKi0a9dOzp8/L94oKfrw3r178ujRI8mRI4de5/dh4vvQxO/Dum71IRLZGzZskOPHj0vNmjWT9H3IgJwomVy7dk0iIyMlMDDQ4XZcx4fXFdwe2+PNv/FZZkqWHH0IqI+cO3eufrF+8sknsnnzZmnYsKGuy9skpA+tWKYnS67txQ/2nDlzZM2aNTJjxgz9YUe9b3h4uHibpOjD999/XwcvZuDD78PE9yHw+1Di7MOwsDDJnDmzpE2bVho1aiTTpk2TevXqJen70D+e20JElOK9+uqrtv/joM/y5cvLE088oVmiOnXqWNo2Sj0Q9JjwHkSAHhwcLIsXL5bOnTtb2jZPM27cOFm4cKF+RnEgHiVdH/L7MG4BAQGyf/9+uXPnjg5c+vXrp3u1ateuLUmFGXKiZJIrVy7x8/OTkJAQh9txPSgoyOVzcHtsjzf/xmeZKVly9KEr+GLFuk6ePCneJiF9aMUyPdnj2l7M4lCiRAm+D51MnDhRg8l169ZpsGji92Hi+9AVfh9Gh7KWYsWK6Qwr/fv3l5YtW8rYsWOT9H3IgJwomWDX1tNPP62jaVNUVJRer1atmsvn4Hb7x8P69ettjy9SpIh+wO0fc/v2bdm5c2eMy0zJkqMPXbl48aLWTGLKKm+TkD60Ypme7HFtL7Jvp06d4vvQzvjx42XUqFFa1oOp5+zx+zDxfegKvw/jhuc8ePAgad+Hbh/+SUQJml4JR1rPmTNHp0zq1q2bTq/077//6v3t27c3Bg0a5DBln7+/vzFx4kSdogqzMLia9hDL+Omnn4yDBw/q0fHePs1XUvZheHi4Tke3fft248yZM8Zvv/1mPPXUU0bx4sWN//77z/BG8e3DBw8e6DRpuOTNm1f7C/8/ceKE28v0NsnRh/379zc2bdqk70O8b+vWrWvkypXLuHr1quGN4tuH+K7D9HRLly51mJIPn2H7x/D7MOF9yO/DI3H24ZgxY4x169YZp06d0sfjtwW/MTNnzkzS9yEDcqJkNm3aNKNQoUL6pYjplnbs2GG7r1atWjrllL3FixcbJUqU0MdjjuLVq1c73I8ploYOHWoEBgbql0qdOnWM48ePG94sKfvw3r17xosvvmjkzp1bA3VMSYd5aL01kExIH+KHGfka5wse5+4yvVFS92GbNm00WMfy8ufPr9cxz7E3i08f4rPpqg8xyDbx+zBxfcjvw7Rx9uGHH35oFCtWzEifPr2RPXt2o1q1ahrU20uK96EP/nE/n05EREREREmJNeRERERERBZiQE5EREREZCEG5EREREREFmJATkRERERkIQbkREREREQWYkBORERERGQhBuRERERERBZiQE5EREREZCEG5ESUYvj4+MiKFSskpcB517p16yY5cuTQtu/fv9/t5xYuXFgmT54sKUXHjh2lWbNm4g3wHitWrJj4+flJ37593X7eiBEjpGLFivI4JOX7Y86cOZItW7YkWRZZY9OmTfodc+vWLbefU7t27Xi9vxPKm74bkhMDciLyCKGhodKzZ08pVKiQpEuXToKCgqR+/fqybds2SanWrFmjwc7PP/8sV65ckSeffNJrg6EpU6botniD7t27S8uWLeXChQsyatQorxgcxqZNmzbyzz//PNZ1IkjDAIass2zZshjf3/T4+VuwTiKiaFq0aCEPHz6U7777TooWLSohISGyYcMGuX79erKuF+tMmzZtsiz71KlTkjdvXqlevbp4q8jISA1Os2bNKt7gzp07cvXqVR0M5suXT1KDDBky6IVSF+y5I8/BDDkRWQ67Wbdu3SqffPKJPP/88xIcHCxVqlSRwYMHS5MmTRwee+3aNXnllVckY8aMUrx4cVm5cqVDcNi5c2cpUqSIBhglS5bUzK2r3acff/yxBlx4DCAb2rp1a81W44eqadOmcvbs2VjbvXnzZm0nMvoIvAcNGiQRERG29bz99tty/vx5DVhRYuBqN/Obb74pYWFh+hhc7LOG9+7dk06dOklAQIDuOfj6668dnh+fNkdFRUmBAgVkxowZDrfv27dPfH195dy5c3r9s88+k3LlykmmTJmkYMGC0qtXLw1SnTP66PcyZcrotmMbnXdLY+/As88+q4/NmTOnvPzyyzpAMaGd2F5k6fCa4/WsUKGCbN++3aF92EOCXeu4P3v27Boo37x507ZNY8eOtb3eeP7SpUtjfc3w3DfeeEOXhWU2bNhQTpw4YXs90NfwwgsvaPtwmzPztcT70NVrO2/ePL0Ng5RXX31VwsPDHV6H+LYZA4TGjRvr4/G8+fPnu/wMdenSRXLnzi1ZsmTR9h84cMB2P/6Pfsb24f6nn35a9uzZE+NemtGjR0uePHn08Vgu3tv25Tjm6z1x4kR97+M17t27tzx69Mj2mC+++EI/o+nTp5fAwEDd6xDf8p9Zs2bpez9z5sz6XsRnfPz48boHDe3D5zg+/YD3ID4naA+W+cwzz8hvv/3msAy8dmPGjInxs4dB/FtvvaXbjW3D9xVe09h88803Urp0aX18qVKltG9MWE/58uXlwYMHtuVXqlRJ36f2n5WFCxfq4B7LwN42fP/EBImM1157TfLnz6/vc3ymf/jhh1hLVuLabne+c/D69OvXz/a5HzhwoJbukRsMIiKLPXr0yMicObPRt29f47///ovxcfjKKlCggLFgwQLjxIkTxjvvvKPPu379ut7/8OFDY9iwYcbu3buN06dPG99//72RMWNGY9GiRbZldOjQQZ/Tvn174++//9YLnle6dGmjU6dOxsGDB40jR44Ybdu2NUqWLGk8ePDAZVsuXryoy+7Vq5dx9OhRY/ny5UauXLmM4cOH6/23bt0yPvroI23vlStXjKtXr0ZbBpY9efJkI0uWLPoYXMLDw/W+4OBgI0eOHMb06dN1W8eOHWv4+voax44ds21rfNs8YMAA49lnn3W4rX///g63TZo0yfj999+NM2fOGBs2bNDl9ezZ03b/7NmzjTRp0hjVq1c3tm3bpu25e/eu9mvTpk1tj1u6dKnx448/atv37dtnNG7c2ChXrpwRGRmp92P5eD1LlSpl/Pzzz8bx48eNli1b6nbj/QB4Xrp06XT9+/fv19dq2rRpRmhoqN4/evRoff6aNWuMU6dOadvw+E2bNsX4HmrSpIn225YtW3SZ9evXN4oVK6b9iX5DO9AutB2vh6u+xGuJx2B99q8tXnu8t5o3b24cOnRI1xEUFGR88MEHtucmpM0NGzY0KlSoYGzfvt3Ys2eP9n2GDBn0tTLVrVtX+xjv/X/++Udf15w5c9o+G2XLljVef/11fa/i/sWLF+v2m69p1qxZbcvC5yZ9+vTGrFmztD9Gjhyp71G0wYTXG7f16NFDl7lq1Sr9PHz99dd6P9rh5+enn9WzZ88af/31lzFlyhSH55ufFVfMvsR74vDhw8bKlSuNtGnT6uv19ttv6/sO7cPrsGPHDrf7Adv85Zdf6uuD+4cMGaLbeu7cOdsy4vrsTZgwwShYsKC+vti2rVu36nbGBP2ZN29efU/hewl/sfw5c+bo/fjMFy1aVL//zM9p4cKFjbCwMIfPCr5L8LnCZ71Lly5GQECAce3aNX3Mxo0b9TE3b960fT+hnfgM4X02depUfT127txpa1etWrWMPn36uL3d7nznfPLJJ0b27Nl1G3F/586dtZ323w3kGgNyIvII+KHBFzl+HBFwDB482Dhw4IDDY/CDgx9Q0507d/S2X3/9Ncbl9u7d22jRooVDIBAYGOgQaM2bN09/VKKiomy34X4EPWvXrnW5XARZzs/BDxmCCDPoRMCEH7nYOAdDJjwPAZQJ68mTJ48xY8aMBLcZP84+Pj624APtzJ8/v22ZrixZskQDGvv2os/NYM7kHJA7QxCN5yEQsg8yvvnmG9tjEHjhNgR48Nprrxk1atRwuTwM3BAA/vnnnw63IwDA81xBAIblYyBhQkCDPkOACgho8BgEOLHBYzAIcw4i0abbt2/bbnvvvfeMqlWrJrjN5gBh165dttvQP7jNDMgRECI4dh7MPvHEE8ZXX32l/0dQZAaAcb0H0V58buzhdXAOyPEejYiIsN3WqlUro02bNvp/BGRok31fxIervkQwjkDV/HwBPgMIHN3tB1cwWMFAz93PHgYEL7zwgsNnLzZYv3PAPmrUKKNatWq263hPYKA7dOhQw9/fX7fFZH5Wxo0bZ7sNg1YE6AiAXQXkrjRq1EgHKLEF5In9zsHAY/z48dHayYA8bixZISKPqSG/fPmylkI0aNBASwWeeuqpaAcKYteuCWUV2C2NXfqm6dOn6+547LLGLmnsckVJhT3svrWvG8cu7ZMnT+puWjwHF+yO/e+//xzKLOwdPXpUqlWrpruSTTVq1NDyjosXLyZJn9hvK9aD3fTmtiakzSgBwG7zBQsW6HXs8sbyWrVqZXsMdt/XqVNHd3Vj2e3bt9fd3yifMaHv7NvmCspAsMscxwPgNTLLOpxfC/vloAQAzG3ErDRoiyvYdrSpXr16tu3HZe7cubG+Zv7+/lK1alXbbditjrIl3JcUsJ1m2Yu5Teb2JKbNeE+bUPJgX2KC9wLed9gW++WeOXPGtlyUEaCUo27dujJu3LgY1wfHjx/XUix7ztehbNmyOhONq23FNqKUA68/3kMos7F/DyWkL1FmgjIplFjZ32b/mYirH3D/gAED9HOAPsT96OPY3pfOnz2U6+C9iffNO++8I+vWrYtxG+7evavrRimdfZtQEmT/GuC7BO3CQZb9+/fXci9neIwJ74nKlSvH+L5F6QiWhe86fC9gnWvXro22nUn5nYPSOxy8bv/5MttJceNBnUTkMVAbiR9yXIYOHaoBxPDhw/UH0JQmTRqH5+BHA3W5gBpL/Kh9+umn+uOFH44JEybIzp07HZ6DQN4efqQR8LiqzUVgb5XYtjWhbW7Xrp0G5KgJxl8MfhDAAGpBUeuN2W5Qm4sf2z/++EODCdS1ohYVUMtsPxBxBTXPCMhmzpyptfpoN+pesZyYttFcprmNsR1oaNa1r169WgcP9lDX7qmvWXK0GctFMOyq3t0M3FGT3bZtW133r7/+qp8rfF5QB58c24rP3l9//aVtQsA6bNgwbcPu3bvdnlXI1fLj6t+4+gHfD+vXr9fad0xtifcYattje186rweJAgT56EcMYFFTjYGOq2MBzNccnwP7QBXsBzNYNo6XwG0IehML33s4fgZTY5rHhKBe3Hk7H8d3DrmHATkReSxkw+IztRx+0HDQEw7+MsWWCTThB3bRokV6kBiyue5Ahu3HH3/UA5bMQBLrRyCCgyfdhWwzslnxlZA2A4KyIUOGyN69ezWA+PLLL2334Tb8+GJAY2YhFy9eHO+2IaOOLCuCkOeee05vQ2AfX8jWYaadkSNHRrvP/oDSWrVquf2a4aBbDNDMmW/MtmJ58YHAJb6vW0LajGw42ozXBgcgAtprP9803gv//vuvZiNdHTxsKlGihF7effdd3Xsxe/ZslwE5Mr8InM2DCgHX4wvtQaCKCwYACIp///13ad68uSQHd/oBn1EM8M3tRpAZ18HbruAzh+kicUFAj4HtjRs3os1cggw+BqSnT5/WwXBsAfSxY8d0rxUOXMZrgwO+7e3YsUNq1qyp/zffEzi4NKbtxAGXr7/+ul7H5xpTW8b3fR7f7xwMiPD5cm4nnkuxY8kKEVkOQRFmQ/j+++/l4MGDmn1asmSJzqaAHxV3YUYHzByBXbP48UGW3Z1AAj+UuXLl0nVhthesH1k27I6OqfwEQT9mHMBMKvgh/emnnzToQGmA/S71uCBwQFCAwBMzyLi7Wz8hbTbXh2AUWW8ElPaz2CBjiFkypk2bpgEEZguxD9jdhRlMkHVHuRCyfQjC0C/xhVl28Pqhr/G+QD9jlhj0EwY+yHYiuMRUmRh4ISOLtuN6TO8P9FfXrl11gIBd8AhYkK2Oz/vM7Ee8ZggAzVlf4pKQNiM4RrCHudER6CC4wZ4j+70HCHixRwizniAbjQDzzz//lA8//FA/D/fv39fADe8PzKaDYA39igGKK3hPf/vtt9omlB6hvAL9H9deEXuYe3/q1Kla2oF1oiwHQaE5q1FyiKsfzPcAZvZBu/D6Y4BqZoDdhZmIMGMJ3o/4nsF3FUo7Ysr8Y0CJWVjQH3j8oUOHNODGcsyZjrAHATOxoOwNt/fp00c/g/ZQjrd8+XJdL2a0wfsOM6K4gu3EngBsP8pa8P7BVLKJ4c53DtqNkigkUtBOfHbjc7Ki1IwBORFZDrWI2J07adIkzaygtAHBNAKnzz//3O3l4EcH2TdkrbA8BPr22fKYoBRjy5YtOs0Xno9ABQEraiNjygQhiPvll19k165dOnVdjx499DnIPscHgmM8F23Gbl8MQtyRkDbb/7AiGEGW0D6ww3YgGMD0k3gNsGs6runcXMGABOUQCB6xHASgyADGF7K5CKzQVtQwI9jCwAcZUECNLN4naCO2H4ErSjIwNWBMEAhhtztKc7A87OHA6+i8qz4u2IuAgAdTQ2KKOncltM3IsiKrjtcaZ39FltKEQBnbgM8OsqroN0y3iEAYGVqUQeCzgIw37kOJBaZ7dLXnwXx/YDCEwYNZnoGsMkrK3IXgFIEvBtrYTgzsEMSi7jy5xNUPgPc3Boz43KGsCtno+GZvMbDC5xS10dhrgcAf641pII4BFIJtvI4oH8HriGNj8Jrj84pBIfoX7QG8vpiiErX39nthEOjigs8pBpQ43gYBsiv4HsJ2YfswvSEGDIk9W6Y73zmof0e7O3ToYCsbTExZVGrigyM7rW4EEREReS4c14GgDntN6PFCwI/gHZl0+7ngybuwhpyIiIhsUDaFjDayq8iuI7ONgxexR4CIkgcDciIiIopW+oGZdlCOgLpvHMCMGm0iSh4sWSEiIiIishAP6iQiIiIishADciIiIiIiCzEgJyIiIiKyEANyIiIiIiILMSAnIiIiIrIQA3IiIiIiIgsxICciIiIishADciIiIiIiCzEgJyIiIiIS6/w/q5VeumBf4wgAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -750,24 +750,11 @@ } ], "source": [ - "fig, ax = plt.subplots(figsize=(7.5, 4))\n", - "rows = np.arange(len(shares))\n", - "for k, (metric, name) in enumerate([(\"sufficient\", \"sufficiently\"), (\"accurate\", \"accurately\")]):\n", - " ax.barh(\n", - " rows + (k - 0.5) * 0.38,\n", - " shares[metric],\n", - " height=0.38,\n", - " color=COLORS[k],\n", - " edgecolor=\"white\",\n", - " lw=1,\n", - " label=f\"Points {name} sampled\",\n", - " )\n", - "ax.set_yticks(rows, shares.index)\n", - "ax.invert_yaxis()\n", + "from tatc.tradespace import plot_shares\n", + "\n", + "LABELS = {\"sufficient\": \"Points sufficiently sampled\", \"accurate\": \"Points accurately sampled\"}\n", + "ax = plot_shares(shares, list(LABELS), labels=LABELS, horizontal=True, legend=\"lower right\")\n", "ax.set(xlabel=\"Share of the variance of the designs' means explained\")\n", - "ax.legend(loc=\"lower right\", fontsize=8, frameon=False)\n", - "style_axes(ax, grid=\"x\")\n", - "fig.tight_layout()\n", "plt.show()" ] }, diff --git a/docs/examples/tradespace/PlanDeployment.ipynb b/docs/examples/tradespace/PlanDeployment.ipynb index b601c86e..1ab78d9a 100644 --- a/docs/examples/tradespace/PlanDeployment.ipynb +++ b/docs/examples/tradespace/PlanDeployment.ipynb @@ -38,10 +38,10 @@ "id": "6bc87f54", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:48.525293Z", - "iopub.status.busy": "2026-11-14T06:30:48.525293Z", - "iopub.status.idle": "2026-11-14T06:30:51.349054Z", - "shell.execute_reply": "2026-11-14T06:30:51.349054Z" + "iopub.execute_input": "2026-11-14T08:06:13.952822Z", + "iopub.status.busy": "2026-11-14T08:06:13.952822Z", + "iopub.status.idle": "2026-11-14T08:06:16.845691Z", + "shell.execute_reply": "2026-11-14T08:06:16.845691Z" } }, "outputs": [ @@ -208,11 +208,11 @@ ], "source": [ "from trade_space_example import OBJECTIVES, cost_study, describe, space\n", - "from tatc.tradespace import Requirement, aggregate, pareto_front, summarize\n", + "from tatc.tradespace import Requirement, aggregate, summarize\n", "\n", - "summary = summarize(cost_study.run(), [\"satellites\", \"planes\", \"sufficient\", \"accurate\"])\n", - "summary[\"description\"] = [describe(d) for d in space.designs_of(summary)]\n", - "front = summary[pareto_front(summary, OBJECTIVES)]\n", + "summary = summarize(cost_study.run(), OBJECTIVES, statistics=[\"accurate\"])\n", + "summary[\"description\"] = space.designs_of(summary).map(describe)\n", + "front = summary[summary.pareto]\n", "leaders = front.sort_values(\"sufficient\", ascending=False).drop_duplicates([\"satellites\", \"planes\"])\n", "\n", "phased_study = cost_study.replace(phases=[Requirement(\"sufficient\", \">=\", 50)])\n", @@ -238,16 +238,16 @@ "id": "c7af361b", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:51.351053Z", - "iopub.status.busy": "2026-11-14T06:30:51.351053Z", - "iopub.status.idle": "2026-11-14T06:30:51.846335Z", - "shell.execute_reply": "2026-11-14T06:30:51.846335Z" + "iopub.execute_input": "2026-11-14T08:06:16.845691Z", + "iopub.status.busy": "2026-11-14T08:06:16.845691Z", + "iopub.status.idle": "2026-11-14T08:06:17.352993Z", + "shell.execute_reply": "2026-11-14T08:06:17.352993Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -260,7 +260,9 @@ "import matplotlib.pyplot as plt\n", "\n", "from trade_space_example import SCHEDULE, cost_space, planes_name\n", - "from tatc.tradespace import COLORS, GRAY, style_axes\n", + "from tatc.tradespace import COLORS, GRAY, style_axes, use_style\n", + "\n", + "use_style() # the style of the plots of trade studies\n", "\n", "fig, ax = plt.subplots(figsize=(8, 4))\n", "for color, (satellites, planes) in zip(COLORS, [(4, 1), (4, 2), (6, 2)]):\n", @@ -292,9 +294,7 @@ " xlim=(0, None),\n", " ylim=(0, 105),\n", ")\n", - "ax.legend(loc=\"center right\", fontsize=8, frameon=False)\n", - "style_axes(ax)\n", - "fig.tight_layout()\n", + "ax.legend(loc=\"center right\")\n", "plt.show()" ] }, @@ -334,10 +334,10 @@ "id": "eec3e4ab", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:51.848441Z", - "iopub.status.busy": "2026-11-14T06:30:51.848441Z", - "iopub.status.idle": "2026-11-14T06:30:51.891798Z", - "shell.execute_reply": "2026-11-14T06:30:51.891798Z" + "iopub.execute_input": "2026-11-14T08:06:17.352993Z", + "iopub.status.busy": "2026-11-14T08:06:17.352993Z", + "iopub.status.idle": "2026-11-14T08:06:17.449071Z", + "shell.execute_reply": "2026-11-14T08:06:17.449071Z" } }, "outputs": [ @@ -510,16 +510,16 @@ "id": "37d6f8ba", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:51.893799Z", - "iopub.status.busy": "2026-11-14T06:30:51.893799Z", - "iopub.status.idle": "2026-11-14T06:30:52.078716Z", - "shell.execute_reply": "2026-11-14T06:30:52.078716Z" + "iopub.execute_input": "2026-11-14T08:06:17.449071Z", + "iopub.status.busy": "2026-11-14T08:06:17.449071Z", + "iopub.status.idle": "2026-11-14T08:06:17.607637Z", + "shell.execute_reply": "2026-11-14T08:06:17.607637Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -542,10 +542,9 @@ "axes[0].invert_yaxis()\n", "axes[0].set(xlabel=\"Points accurately sampled over the mission (%)\", xlim=(0, 100))\n", "axes[1].set(xlabel=\"Present cost (millions of dollars)\")\n", - "axes[0].legend(loc=\"lower left\", fontsize=8, frameon=False)\n", + "axes[0].legend(loc=\"lower left\")\n", "for ax in axes:\n", " style_axes(ax, grid=\"x\")\n", - "fig.tight_layout()\n", "plt.show()" ] }, diff --git a/docs/examples/tradespace/PlanForFailures.ipynb b/docs/examples/tradespace/PlanForFailures.ipynb index 27d1bfd0..37a6f37c 100644 --- a/docs/examples/tradespace/PlanForFailures.ipynb +++ b/docs/examples/tradespace/PlanForFailures.ipynb @@ -35,10 +35,10 @@ "id": "e20ee309", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:54.256305Z", - "iopub.status.busy": "2026-11-14T06:30:54.256305Z", - "iopub.status.idle": "2026-11-14T06:30:56.079832Z", - "shell.execute_reply": "2026-11-14T06:30:56.078839Z" + "iopub.execute_input": "2026-11-14T08:06:19.762215Z", + "iopub.status.busy": "2026-11-14T08:06:19.762215Z", + "iopub.status.idle": "2026-11-14T08:06:21.582005Z", + "shell.execute_reply": "2026-11-14T08:06:21.582005Z" } }, "outputs": [ @@ -74,16 +74,16 @@ "id": "7c437e44", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:56.080832Z", - "iopub.status.busy": "2026-11-14T06:30:56.080832Z", - "iopub.status.idle": "2026-11-14T06:30:56.544061Z", - "shell.execute_reply": "2026-11-14T06:30:56.544061Z" + "iopub.execute_input": "2026-11-14T08:06:21.582005Z", + "iopub.status.busy": "2026-11-14T08:06:21.582005Z", + "iopub.status.idle": "2026-11-14T08:06:22.072799Z", + "shell.execute_reply": "2026-11-14T08:06:22.072799Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -96,7 +96,9 @@ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", - "from tatc.tradespace import COLORS, GRAY, INK, style_axes\n", + "from tatc.tradespace import COLORS, GRAY, INK, style_axes, use_style\n", + "\n", + "use_style() # the style of the plots of trade studies\n", "\n", "age = np.linspace(0.02, 10, 500) # years since launch\n", "fig, axes = plt.subplots(1, 2, figsize=(11, 3.6))\n", @@ -110,7 +112,6 @@ " style_axes(ax, grid=\"both\")\n", "axes[1].annotate(\"infant mortality\", (0.3, 0.2), xytext=(8, 14), textcoords=\"offset points\", fontsize=8, color=INK)\n", "axes[1].annotate(\"wear-out\", (8.5, 0.5), xytext=(-60, 10), textcoords=\"offset points\", fontsize=8, color=INK)\n", - "fig.tight_layout()\n", "plt.show()" ] }, @@ -140,10 +141,10 @@ "id": "35efa3e2", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:56.546058Z", - "iopub.status.busy": "2026-11-14T06:30:56.546058Z", - "iopub.status.idle": "2026-11-14T06:30:57.552578Z", - "shell.execute_reply": "2026-11-14T06:30:57.552578Z" + "iopub.execute_input": "2026-11-14T08:06:22.072799Z", + "iopub.status.busy": "2026-11-14T08:06:22.072799Z", + "iopub.status.idle": "2026-11-14T08:06:23.178781Z", + "shell.execute_reply": "2026-11-14T08:06:23.178781Z" } }, "outputs": [ @@ -156,7 +157,9 @@ } ], "source": [ - "from trade_space_example import ACCURACY, cost_space, cost_study, describe, space\n", + "import dataclasses\n", + "\n", + "from trade_space_example import ACCURACY, PLAN, cost_space, cost_study, describe, space\n", "from tatc.tradespace import (\n", " Failures,\n", " Integer,\n", @@ -168,8 +171,8 @@ " summarize,\n", ")\n", "\n", - "summary = summarize(cost_study.run(), [\"satellites\", \"planes\", \"accurate\"])\n", - "efficient = summary[pareto_front(summary, ACCURACY)]\n", + "summary = summarize(cost_study.run(), ACCURACY)\n", + "efficient = summary[summary.pareto]\n", "\n", "POLICY = policy_space(orbit_spares=Integer(0, 1), ground_spares=Integer(0, 1), replenish=True)\n", "failure_space = cost_space.extend(failure_seed=Uncertain.seed(), policy=POLICY)\n", @@ -180,7 +183,10 @@ " seed=\"failure_seed\",\n", " quantiles={\"accurate mission\": 0.1, \"cost\": 0.7},\n", ")\n", - "failure_study = cost_study.replace(space=failure_space, failures=FAILURES)\n", + "# the plan configures the policy (and spares in orbit) of each design from its values `policy`\n", + "failure_study = cost_study.replace(\n", + " space=failure_space, plan=dataclasses.replace(PLAN, policy=\"policy\"), failures=FAILURES\n", + ")\n", "\n", "# the efficient designs, each with each policy\n", "with_policies, base_of = [], {}\n", @@ -207,10 +213,10 @@ "id": "4c9a47e8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:57.554592Z", - "iopub.status.busy": "2026-11-14T06:30:57.554592Z", - "iopub.status.idle": "2026-11-14T06:30:57.600152Z", - "shell.execute_reply": "2026-11-14T06:30:57.600152Z" + "iopub.execute_input": "2026-11-14T08:06:23.178781Z", + "iopub.status.busy": "2026-11-14T08:06:23.178781Z", + "iopub.status.idle": "2026-11-14T08:06:23.226105Z", + "shell.execute_reply": "2026-11-14T08:06:23.226105Z" } }, "outputs": [ @@ -487,10 +493,9 @@ "traded = aggregate(trades, statistics=ROBUST).set_index(\"design\")\n", "traded[\"policy\"] = pd.Categorical(traded.apply(describe_policy, axis=1), POLICIES)\n", "traded[\"base\"] = [base_of[key] for key in traded.index]\n", - "bases = efficient.set_index(\"design\")\n", - "described = {d.key: describe(d) for d in space.designs_of(efficient)}\n", - "traded[\"description\"] = traded.base.map(described)\n", - "traded[\"full constellation\"] = bases.loc[traded.base, \"accurate\"].to_numpy()\n", + "bases = efficient.set_index(\"design\").loc[traded.base] # the base design of each row\n", + "traded[\"description\"] = space.designs_of(bases).map(describe).to_numpy()\n", + "traded[\"full constellation\"] = bases.accurate.to_numpy()\n", "\n", "# four of the designs, with each policy: two satellites in two planes, four in two, six in three, and nine in three\n", "shown = efficient.drop_duplicates([\"satellites\", \"planes\"]).set_index([\"satellites\", \"planes\"])\n", @@ -528,10 +533,10 @@ "id": "a41c39e2", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:57.602146Z", - "iopub.status.busy": "2026-11-14T06:30:57.602146Z", - "iopub.status.idle": "2026-11-14T06:30:57.616209Z", - "shell.execute_reply": "2026-11-14T06:30:57.616209Z" + "iopub.execute_input": "2026-11-14T08:06:23.227869Z", + "iopub.status.busy": "2026-11-14T08:06:23.227869Z", + "iopub.status.idle": "2026-11-14T08:06:23.241957Z", + "shell.execute_reply": "2026-11-14T08:06:23.241957Z" } }, "outputs": [ @@ -778,16 +783,16 @@ "id": "58d5e989", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:57.618218Z", - "iopub.status.busy": "2026-11-14T06:30:57.618218Z", - "iopub.status.idle": "2026-11-14T06:30:57.910722Z", - "shell.execute_reply": "2026-11-14T06:30:57.910722Z" + "iopub.execute_input": "2026-11-14T08:06:23.241957Z", + "iopub.status.busy": "2026-11-14T08:06:23.241957Z", + "iopub.status.idle": "2026-11-14T08:06:23.605760Z", + "shell.execute_reply": "2026-11-14T08:06:23.605760Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -809,7 +814,6 @@ " ax.set(xlabel=\"Cost at 70% confidence\", ylabel=\"\")\n", " style_axes(ax, grid=\"both\")\n", "axes[0].set_ylabel(\"Accurately sampled (%), worst 10%\")\n", - "fig.tight_layout()\n", "plt.show()" ] }, @@ -839,10 +843,10 @@ "id": "c687c0ed", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:57.912730Z", - "iopub.status.busy": "2026-11-14T06:30:57.912730Z", - "iopub.status.idle": "2026-11-14T06:30:58.160645Z", - "shell.execute_reply": "2026-11-14T06:30:58.159467Z" + "iopub.execute_input": "2026-11-14T08:06:23.605760Z", + "iopub.status.busy": "2026-11-14T08:06:23.605760Z", + "iopub.status.idle": "2026-11-14T08:06:23.874510Z", + "shell.execute_reply": "2026-11-14T08:06:23.874510Z" } }, "outputs": [ @@ -975,18 +979,18 @@ "id": "608307dd", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:58.162816Z", - "iopub.status.busy": "2026-11-14T06:30:58.162816Z", - "iopub.status.idle": "2026-11-14T06:30:58.244015Z", - "shell.execute_reply": "2026-11-14T06:30:58.242980Z" + "iopub.execute_input": "2026-11-14T08:06:23.874510Z", + "iopub.status.busy": "2026-11-14T08:06:23.874510Z", + "iopub.status.idle": "2026-11-14T08:06:23.953804Z", + "shell.execute_reply": "2026-11-14T08:06:23.953804Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1004,26 +1008,12 @@ " \"accurate mission histories p10\": \"Accurately sampled,\\nworst 10% of the histories\",\n", " \"cost histories p70\": \"Cost at\\n70% confidence\",\n", "}\n", - "shares = attribution.summary.mul(100)\n", - "fig, ax = plt.subplots(figsize=(8, 3.8))\n", - "x = np.arange(len(LABELS))\n", - "for k, (parameter, name) in enumerate(PARAMETERS.items()):\n", - " ax.bar(\n", - " x + (k - 1) * 0.27,\n", - " shares.loc[parameter, list(LABELS)],\n", - " width=0.27,\n", - " yerr=shares.loc[parameter, [f\"{column} se\" for column in LABELS]],\n", - " color=COLORS[k],\n", - " edgecolor=\"white\",\n", - " lw=1,\n", - " error_kw={\"ecolor\": INK, \"lw\": 1},\n", - " label=name,\n", - " )\n", - "ax.set_xticks(x, list(LABELS.values()))\n", + "from tatc.tradespace import plot_shares\n", + "\n", + "shares = attribution.summary.mul(100).loc[list(PARAMETERS)]\n", + "# a group of bars of each column, one of each parameter, with error bars of their standard errors\n", + "ax = plot_shares(shares, list(LABELS), groups=\"metrics\", names=PARAMETERS, labels=LABELS, legend=\"upper center\")\n", "ax.set(ylabel=\"Total share of the variance (%)\", ylim=(0, None))\n", - "ax.legend(loc=\"upper center\", fontsize=8, frameon=False)\n", - "style_axes(ax)\n", - "fig.tight_layout()\n", "plt.show()" ] }, @@ -1051,10 +1041,10 @@ "id": "d53fe0cc", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:58.245020Z", - "iopub.status.busy": "2026-11-14T06:30:58.245020Z", - "iopub.status.idle": "2026-11-14T06:30:58.507210Z", - "shell.execute_reply": "2026-11-14T06:30:58.506311Z" + "iopub.execute_input": "2026-11-14T08:06:23.953804Z", + "iopub.status.busy": "2026-11-14T08:06:23.953804Z", + "iopub.status.idle": "2026-11-14T08:06:24.207649Z", + "shell.execute_reply": "2026-11-14T08:06:24.207649Z" } }, "outputs": [ diff --git a/docs/examples/tradespace/RankUncertainDesigns.ipynb b/docs/examples/tradespace/RankUncertainDesigns.ipynb index 8ef7169c..80885c28 100644 --- a/docs/examples/tradespace/RankUncertainDesigns.ipynb +++ b/docs/examples/tradespace/RankUncertainDesigns.ipynb @@ -25,10 +25,10 @@ "id": "cc653395", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:14.647890Z", - "iopub.status.busy": "2026-11-14T06:30:14.647890Z", - "iopub.status.idle": "2026-11-14T06:30:17.133649Z", - "shell.execute_reply": "2026-11-14T06:30:17.133649Z" + "iopub.execute_input": "2026-11-14T08:05:39.675555Z", + "iopub.status.busy": "2026-11-14T08:05:39.673497Z", + "iopub.status.idle": "2026-11-14T08:05:42.202106Z", + "shell.execute_reply": "2026-11-14T08:05:42.202106Z" } }, "outputs": [ @@ -63,10 +63,10 @@ "id": "4aef9718", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:17.135652Z", - "iopub.status.busy": "2026-11-14T06:30:17.135652Z", - "iopub.status.idle": "2026-11-14T06:30:18.300648Z", - "shell.execute_reply": "2026-11-14T06:30:18.300648Z" + "iopub.execute_input": "2026-11-14T08:05:42.204110Z", + "iopub.status.busy": "2026-11-14T08:05:42.204110Z", + "iopub.status.idle": "2026-11-14T08:05:43.433591Z", + "shell.execute_reply": "2026-11-14T08:05:43.433591Z" } }, "outputs": [ @@ -284,7 +284,7 @@ "from tatc.tradespace import pareto_probability\n", "\n", "probability = pareto_probability(results, OBJECTIVES, n_resamples=1000)\n", - "probability[\"description\"] = [describe(d) for d in space.designs_of(probability)]\n", + "probability[\"description\"] = space.designs_of(probability).map(describe)\n", "candidates = probability[probability.pareto_probability >= 0.1].sort_values([\"satellites\", \"planes\", \"sufficient\"])\n", "candidates[[\"description\", \"satellites\", \"planes\", \"sufficient\", \"pareto\", \"pareto_probability\"]].round(2)" ] @@ -303,16 +303,16 @@ "id": "19cf5721", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:18.302641Z", - "iopub.status.busy": "2026-11-14T06:30:18.302641Z", - "iopub.status.idle": "2026-11-14T06:30:18.721758Z", - "shell.execute_reply": "2026-11-14T06:30:18.721758Z" + "iopub.execute_input": "2026-11-14T08:05:43.433591Z", + "iopub.status.busy": "2026-11-14T08:05:43.433591Z", + "iopub.status.idle": "2026-11-14T08:05:43.877032Z", + "shell.execute_reply": "2026-11-14T08:05:43.877032Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -324,7 +324,9 @@ "source": [ "import matplotlib.pyplot as plt\n", "\n", - "from tatc.tradespace import COLORS, GRAY, INK, style_axes\n", + "from tatc.tradespace import COLORS, GRAY, INK, style_axes, use_style\n", + "\n", + "use_style() # the style of the plots of trade studies\n", "\n", "single = candidates[candidates.satellites == 1].sort_values(\"sufficient\")\n", "fig, ax = plt.subplots(figsize=(8, 3))\n", @@ -343,7 +345,6 @@ "ax.set_yticks(rows, single.description.str.replace(\", 60 deg FOR\", \"\"))\n", "ax.set(xlabel=\"Points sufficiently sampled (%): mean and 95% interval\", ylim=(-0.6, len(single) - 0.3))\n", "style_axes(ax, grid=\"x\")\n", - "fig.tight_layout()\n", "plt.show()" ] }, @@ -373,10 +374,10 @@ "id": "104737eb", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:18.723752Z", - "iopub.status.busy": "2026-11-14T06:30:18.723752Z", - "iopub.status.idle": "2026-11-14T06:30:31.508193Z", - "shell.execute_reply": "2026-11-14T06:30:31.508193Z" + "iopub.execute_input": "2026-11-14T08:05:43.877032Z", + "iopub.status.busy": "2026-11-14T08:05:43.877032Z", + "iopub.status.idle": "2026-11-14T08:05:57.168871Z", + "shell.execute_reply": "2026-11-14T08:05:57.168871Z" } }, "outputs": [ @@ -517,10 +518,10 @@ "id": "355e4987", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:31.510201Z", - "iopub.status.busy": "2026-11-14T06:30:31.510201Z", - "iopub.status.idle": "2026-11-14T06:30:31.616745Z", - "shell.execute_reply": "2026-11-14T06:30:31.616745Z" + "iopub.execute_input": "2026-11-14T08:05:57.168871Z", + "iopub.status.busy": "2026-11-14T08:05:57.168871Z", + "iopub.status.idle": "2026-11-14T08:05:57.312415Z", + "shell.execute_reply": "2026-11-14T08:05:57.312415Z" } }, "outputs": [ @@ -983,7 +984,7 @@ ], "source": [ "refined = refinement.summary\n", - "refined[\"description\"] = [describe(d) for d in space.designs_of(refined)]\n", + "refined[\"description\"] = space.designs_of(refined).map(describe)\n", "print(f\"{refined.pareto.sum()} designs are efficient within the tolerance; the designs refined:\")\n", "refined[refined.replicates > 5].sort_values([\"satellites\", \"planes\", \"sufficient\"])[\n", " [\"description\", \"satellites\", \"planes\", \"sufficient\", \"replicates\", \"pareto\", \"pareto_probability\", \"indifferent\"]\n", @@ -1016,10 +1017,10 @@ "id": "807da56f", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:31.618738Z", - "iopub.status.busy": "2026-11-14T06:30:31.618738Z", - "iopub.status.idle": "2026-11-14T06:30:31.708091Z", - "shell.execute_reply": "2026-11-14T06:30:31.708091Z" + "iopub.execute_input": "2026-11-14T08:05:57.312415Z", + "iopub.status.busy": "2026-11-14T08:05:57.312415Z", + "iopub.status.idle": "2026-11-14T08:05:57.407951Z", + "shell.execute_reply": "2026-11-14T08:05:57.407951Z" } }, "outputs": [ @@ -1027,14 +1028,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "39 designs confirmed, of which 35 are efficient by the new replicates" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", + "39 designs confirmed, of which 35 are efficient by the new replicates\n", "mean optimism: -0.02 percentage points\n", "mean optimism by number of satellites: {1.0: -0.39, 2.0: 0.85, 3.0: 2.09, 4.0: 2.45, 6.0: -0.18, 8.0: -0.34, 9.0: -0.34}\n" ] @@ -1162,7 +1156,7 @@ "\n", "confirmation = confirm(study, CRITERIA, refinement.results, replicates=20) # 20 new replicates of the front\n", "confirmed = confirmation.summary\n", - "confirmed[\"description\"] = [describe(d) for d in space.designs_of(confirmed)]\n", + "confirmed[\"description\"] = space.designs_of(confirmed).map(describe)\n", "print(f\"{len(confirmed)} designs confirmed, of which {confirmed.pareto.sum()} are efficient by the new replicates\")\n", "print(f\"mean optimism: {confirmation.optimism['sufficient']:.2f} percentage points\")\n", "print(\n", @@ -1189,16 +1183,16 @@ "id": "99289e48", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:31.710083Z", - "iopub.status.busy": "2026-11-14T06:30:31.710083Z", - "iopub.status.idle": "2026-11-14T06:30:31.850872Z", - "shell.execute_reply": "2026-11-14T06:30:31.849857Z" + "iopub.execute_input": "2026-11-14T08:05:57.407951Z", + "iopub.status.busy": "2026-11-14T08:05:57.407951Z", + "iopub.status.idle": "2026-11-14T08:05:57.535610Z", + "shell.execute_reply": "2026-11-14T08:05:57.535610Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1222,9 +1216,7 @@ ")\n", "ax.set_xticks(list(positions.values()), [f\"{n:.0f}\" for n in positions])\n", "ax.set(xlabel=\"Satellites\", ylabel=\"Optimism (percentage points)\")\n", - "ax.legend(loc=\"upper right\", fontsize=8, frameon=False)\n", - "style_axes(ax)\n", - "fig.tight_layout()\n", + "ax.legend(loc=\"upper right\")\n", "plt.show()" ] }, @@ -1259,10 +1251,10 @@ "id": "419f7f85", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:31.851924Z", - "iopub.status.busy": "2026-11-14T06:30:31.851924Z", - "iopub.status.idle": "2026-11-14T06:30:32.983034Z", - "shell.execute_reply": "2026-11-14T06:30:32.983034Z" + "iopub.execute_input": "2026-11-14T08:05:57.535610Z", + "iopub.status.busy": "2026-11-14T08:05:57.535610Z", + "iopub.status.idle": "2026-11-14T08:05:58.648984Z", + "shell.execute_reply": "2026-11-14T08:05:58.648984Z" } }, "outputs": [ @@ -1379,7 +1371,7 @@ " requirements=[Requirement(\"reliability\", \">=\", 0.8)],\n", ")\n", "reliable = pareto_probability(refinement.results, RELIABLE, n_resamples=1000)\n", - "reliable[\"description\"] = [describe(d) for d in space.designs_of(reliable)]\n", + "reliable[\"description\"] = space.designs_of(reliable).map(describe)\n", "print(f\"{reliable.meets_requirements.sum()} of {len(reliable)} designs meet the requirement\")\n", "reliable[reliable.pareto_probability >= 0.1].sort_values([\"satellites\", \"planes\"])[\n", " [\"description\", \"satellites\", \"planes\", \"sufficient p20\", \"reliability\", \"replicates\", \"pareto_probability\"]\n", @@ -1400,16 +1392,16 @@ "id": "da41d282", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:32.985035Z", - "iopub.status.busy": "2026-11-14T06:30:32.985035Z", - "iopub.status.idle": "2026-11-14T06:30:33.075455Z", - "shell.execute_reply": "2026-11-14T06:30:33.075455Z" + "iopub.execute_input": "2026-11-14T08:05:58.648984Z", + "iopub.status.busy": "2026-11-14T08:05:58.648984Z", + "iopub.status.idle": "2026-11-14T08:05:58.745115Z", + "shell.execute_reply": "2026-11-14T08:05:58.745115Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1433,9 +1425,8 @@ " ax.scatter(row[\"sufficient p20\"], k, marker=\"|\", s=200, color=INK, lw=2, label=\"0.2 quantile\" if k == 0 else None)\n", "ax.set_yticks(range(len(shown)), shown.description.str.replace(\", 60 deg FOR\", \"\"))\n", "ax.set(xlabel=\"Points sufficiently sampled (%)\", xlim=(0, 102), ylim=(-0.6, len(shown) - 0.4))\n", - "ax.legend(loc=\"upper left\", fontsize=8, frameon=False)\n", + "ax.legend(loc=\"upper left\")\n", "style_axes(ax, grid=\"x\")\n", - "fig.tight_layout()\n", "plt.show()" ] }, diff --git a/docs/examples/tradespace/SearchTradeSpace.ipynb b/docs/examples/tradespace/SearchTradeSpace.ipynb index 8c151b22..d8a1a025 100644 --- a/docs/examples/tradespace/SearchTradeSpace.ipynb +++ b/docs/examples/tradespace/SearchTradeSpace.ipynb @@ -34,10 +34,10 @@ "id": "01692fbc", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:07.178786Z", - "iopub.status.busy": "2026-11-14T06:30:07.178786Z", - "iopub.status.idle": "2026-11-14T06:30:09.702883Z", - "shell.execute_reply": "2026-11-14T06:30:09.702883Z" + "iopub.execute_input": "2026-11-14T08:05:32.143944Z", + "iopub.status.busy": "2026-11-14T08:05:32.143944Z", + "iopub.status.idle": "2026-11-14T08:05:34.609205Z", + "shell.execute_reply": "2026-11-14T08:05:34.609205Z" } }, "outputs": [ @@ -79,10 +79,10 @@ "id": "35495471", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:09.704893Z", - "iopub.status.busy": "2026-11-14T06:30:09.704893Z", - "iopub.status.idle": "2026-11-14T06:30:10.213052Z", - "shell.execute_reply": "2026-11-14T06:30:10.212045Z" + "iopub.execute_input": "2026-11-14T08:05:34.611199Z", + "iopub.status.busy": "2026-11-14T08:05:34.611199Z", + "iopub.status.idle": "2026-11-14T08:05:35.148670Z", + "shell.execute_reply": "2026-11-14T08:05:35.147665Z" } }, "outputs": [ @@ -245,10 +245,10 @@ "id": "01e8217c", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:10.215053Z", - "iopub.status.busy": "2026-11-14T06:30:10.215053Z", - "iopub.status.idle": "2026-11-14T06:30:11.753419Z", - "shell.execute_reply": "2026-11-14T06:30:11.753419Z" + "iopub.execute_input": "2026-11-14T08:05:35.149669Z", + "iopub.status.busy": "2026-11-14T08:05:35.149669Z", + "iopub.status.idle": "2026-11-14T08:05:36.804151Z", + "shell.execute_reply": "2026-11-14T08:05:36.804151Z" } }, "outputs": [ @@ -347,16 +347,16 @@ "id": "ce572cad", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:11.755419Z", - "iopub.status.busy": "2026-11-14T06:30:11.754420Z", - "iopub.status.idle": "2026-11-14T06:30:12.190220Z", - "shell.execute_reply": "2026-11-14T06:30:12.190220Z" + "iopub.execute_input": "2026-11-14T08:05:36.804151Z", + "iopub.status.busy": "2026-11-14T08:05:36.804151Z", + "iopub.status.idle": "2026-11-14T08:05:37.294696Z", + "shell.execute_reply": "2026-11-14T08:05:37.294696Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -368,14 +368,15 @@ "source": [ "import matplotlib.pyplot as plt\n", "\n", - "from tatc.tradespace import GRAY, plot_progress\n", + "from tatc.tradespace import GRAY, plot_progress, use_style\n", + "\n", + "use_style() # the style of the plots of trade studies\n", "\n", "ax = plot_progress(progress)\n", "ax.axhline(100, color=GRAY, lw=1, ls=\"--\")\n", "ax.annotate(\"true front\", (0, 100), xytext=(2, 4), textcoords=\"offset points\", fontsize=8, color=GRAY)\n", "ax.set(ylabel=\"Hypervolume (% of true front)\")\n", - "ax.set_title(\"Progress of the searches\", fontsize=10)\n", - "ax.figure.tight_layout()\n", + "ax.set_title(\"Progress of the searches\")\n", "plt.show()" ] }, @@ -393,16 +394,16 @@ "id": "d8c9d612", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:12.191872Z", - "iopub.status.busy": "2026-11-14T06:30:12.191872Z", - "iopub.status.idle": "2026-11-14T06:30:12.467133Z", - "shell.execute_reply": "2026-11-14T06:30:12.466481Z" + "iopub.execute_input": "2026-11-14T08:05:37.297375Z", + "iopub.status.busy": "2026-11-14T08:05:37.295717Z", + "iopub.status.idle": "2026-11-14T08:05:37.531094Z", + "shell.execute_reply": "2026-11-14T08:05:37.531094Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -431,9 +432,8 @@ " ax=ax,\n", " )\n", " ax.set(xlabel=\"Satellites\", ylabel=\"\", xticks=range(1, MAX_SATELLITES + 1), ylim=(0, 105))\n", - " ax.set_title(f\"{name}: {evaluated.sum()} designs\", fontsize=10)\n", + " ax.set_title(f\"{name}: {evaluated.sum()} designs\")\n", "axes[0].set_ylabel(\"Points sufficiently sampled (%)\")\n", - "fig.tight_layout()\n", "plt.show()" ] }, diff --git a/docs/examples/tradespace/TradeCostAndUtility.ipynb b/docs/examples/tradespace/TradeCostAndUtility.ipynb index 29dfef49..50892592 100644 --- a/docs/examples/tradespace/TradeCostAndUtility.ipynb +++ b/docs/examples/tradespace/TradeCostAndUtility.ipynb @@ -40,10 +40,10 @@ "id": "216ec565", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:42.888572Z", - "iopub.status.busy": "2026-11-14T06:30:42.887573Z", - "iopub.status.idle": "2026-11-14T06:30:45.508234Z", - "shell.execute_reply": "2026-11-14T06:30:45.507240Z" + "iopub.execute_input": "2026-11-14T08:06:08.329801Z", + "iopub.status.busy": "2026-11-14T08:06:08.329801Z", + "iopub.status.idle": "2026-11-14T08:06:10.901833Z", + "shell.execute_reply": "2026-11-14T08:06:10.901833Z" } }, "outputs": [ @@ -224,10 +224,10 @@ "id": "80fc3006", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:45.509233Z", - "iopub.status.busy": "2026-11-14T06:30:45.509233Z", - "iopub.status.idle": "2026-11-14T06:30:46.006958Z", - "shell.execute_reply": "2026-11-14T06:30:46.006958Z" + "iopub.execute_input": "2026-11-14T08:06:10.901833Z", + "iopub.status.busy": "2026-11-14T08:06:10.901833Z", + "iopub.status.idle": "2026-11-14T08:06:11.391367Z", + "shell.execute_reply": "2026-11-14T08:06:11.391367Z" } }, "outputs": [ @@ -240,7 +240,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -252,25 +252,24 @@ "source": [ "import matplotlib.pyplot as plt\n", "\n", - "from tatc.tradespace import GRAY, Criteria, Quantile, Requirement, aggregate, plot_designs\n", + "from tatc.tradespace import GRAY, Criteria, Quantile, Requirement, aggregate, plot_designs, use_style\n", + "\n", + "use_style() # the style of the plots of trade studies\n", "\n", "BUDGET = 150 # millions of dollars, at 70% confidence\n", "COST = Criteria(\n", " {\"cost p70\": \"min\", \"sufficient\": \"max\"},\n", - " statistics={\"cost p70\": Quantile(\"cost\", 0.7)},\n", + " statistics=[Quantile(\"cost\", 0.7)], # named cost p70\n", " requirements=[Requirement(\"cost p70\", \"<=\", BUDGET)],\n", ")\n", "costed = aggregate(results, COST, statistics=[\"cost development\"]) # and whether each design is efficient\n", - "costed[\"plane_group\"] = costed.planes.clip(upper=3) # 3 or 4 planes share a color\n", "print(f\"{costed.meets_requirements.sum()} of {len(costed)} designs cost at most {BUDGET} at 70% confidence\")\n", "\n", - "ax = plot_designs(\n", - " costed, \"cost p70\", \"sufficient\", by=\"plane_group\", front=\"pareto\", names=PLANE_GROUPS, legend=\"upper left\"\n", - ")\n", + "groups = costed.planes.clip(upper=3) # 3 or 4 planes share a color\n", + "ax = plot_designs(costed, \"cost p70\", \"sufficient\", by=groups, front=\"pareto\", names=PLANE_GROUPS, legend=\"upper left\")\n", "ax.axvline(BUDGET, color=GRAY, lw=1, ls=\"--\")\n", "ax.set(xlabel=\"Cost at 70% confidence (millions of dollars)\", ylabel=\"Points sufficiently sampled (%)\", ylim=(0, 105))\n", - "ax.set_title(\"Every design, with the efficient designs within the budget ringed\", fontsize=10)\n", - "ax.figure.tight_layout()\n", + "ax.set_title(\"Every design, with the efficient designs within the budget ringed\")\n", "plt.show()" ] }, @@ -288,10 +287,10 @@ "id": "c732c5b8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:46.008440Z", - "iopub.status.busy": "2026-11-14T06:30:46.008440Z", - "iopub.status.idle": "2026-11-14T06:30:46.037072Z", - "shell.execute_reply": "2026-11-14T06:30:46.037072Z" + "iopub.execute_input": "2026-11-14T08:06:11.391367Z", + "iopub.status.busy": "2026-11-14T08:06:11.391367Z", + "iopub.status.idle": "2026-11-14T08:06:11.407002Z", + "shell.execute_reply": "2026-11-14T08:06:11.407002Z" } }, "outputs": [ @@ -462,7 +461,7 @@ "source": [ "front = costed[costed.pareto].sort_values(\"cost p70\")\n", "front = front.drop_duplicates([\"cost p70\", \"sufficient\"]).reset_index(drop=True) # one of the designs that tie\n", - "front[\"description\"] = [describe(d) for d in space.designs_of(front)]\n", + "front[\"description\"] = space.designs_of(front).map(describe)\n", "front[\n", " [\"description\", \"satellites\", \"planes\", \"deployed\", \"cost development\", \"cost launch\", \"cost p70\", \"sufficient\"]\n", "].round(1)" @@ -504,16 +503,16 @@ "id": "ae075375", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:46.039067Z", - "iopub.status.busy": "2026-11-14T06:30:46.039067Z", - "iopub.status.idle": "2026-11-14T06:30:46.345156Z", - "shell.execute_reply": "2026-11-14T06:30:46.344607Z" + "iopub.execute_input": "2026-11-14T08:06:11.407002Z", + "iopub.status.busy": "2026-11-14T08:06:11.407002Z", + "iopub.status.idle": "2026-11-14T08:06:11.771508Z", + "shell.execute_reply": "2026-11-14T08:06:11.771508Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -530,10 +529,9 @@ " \"sufficiency\": Utility(CURVES, weights={\"sufficient\": 0.7, \"accurate\": 0.3}),\n", " \"accuracy\": Utility(CURVES, weights={\"sufficient\": 0.3, \"accurate\": 0.7}),\n", "}\n", - "means = aggregate(results, [\"sufficient\", \"accurate\"], statistics={\"cost p70\": Quantile(\"cost\", 0.7)})\n", - "means[\"description\"] = [describe(d) for d in space.designs_of(means)]\n", + "means = aggregate(results, [\"sufficient\", \"accurate\"], statistics=[Quantile(\"cost\", 0.7)])\n", + "means[\"description\"] = space.designs_of(means).map(describe)\n", "means = means.set_index(\"design\")\n", - "means[\"plane_group\"] = means.planes.clip(upper=3) # 3 or 4 planes share a color\n", "\n", "fig, axes = plt.subplots(1, 2, figsize=(11, 4.5), sharey=True)\n", "judged = {}\n", @@ -541,14 +539,14 @@ " judged[name] = means.assign(utility=utility(means))\n", " judged[name][\"pareto\"] = pareto_front(judged[name], {\"utility\": \"max\", \"cost p70\": \"min\"}) # of the utility\n", " legend = \"lower right\" if ax is axes[0] else None\n", + " groups = means.planes.clip(upper=3) # 3 or 4 planes share a color\n", " plot_designs(\n", - " judged[name], \"cost p70\", \"utility\", by=\"plane_group\", front=\"pareto\", names=PLANE_GROUPS, legend=legend, ax=ax\n", + " judged[name], \"cost p70\", \"utility\", by=groups, front=\"pareto\", names=PLANE_GROUPS, legend=legend, ax=ax\n", " )\n", " ax.axvline(BUDGET, color=GRAY, lw=1, ls=\"--\")\n", " ax.set(xlabel=\"Cost at 70% confidence (millions of dollars)\", ylabel=\"Utility\", ylim=(0, 1.02))\n", - " ax.set_title(f\"Weighing {name} most\", fontsize=10)\n", + " ax.set_title(f\"Weighing {name} most\")\n", " style_axes(ax, grid=\"both\")\n", - "fig.tight_layout()\n", "plt.show()" ] }, @@ -566,10 +564,10 @@ "id": "ab147572", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T06:30:46.346185Z", - "iopub.status.busy": "2026-11-14T06:30:46.346185Z", - "iopub.status.idle": "2026-11-14T06:30:46.360659Z", - "shell.execute_reply": "2026-11-14T06:30:46.360659Z" + "iopub.execute_input": "2026-11-14T08:06:11.771508Z", + "iopub.status.busy": "2026-11-14T08:06:11.771508Z", + "iopub.status.idle": "2026-11-14T08:06:11.787515Z", + "shell.execute_reply": "2026-11-14T08:06:11.787515Z" } }, "outputs": [ diff --git a/docs/examples/tradespace/trade_space_example.py b/docs/examples/tradespace/trade_space_example.py index 2e1f65b7..775a51b1 100644 --- a/docs/examples/tradespace/trade_space_example.py +++ b/docs/examples/tradespace/trade_space_example.py @@ -92,7 +92,6 @@ def count_samples(observations, duration=DURATION): build, OBSERVATIONS, count_samples, - layout="layout", replicates=N_REPLICATES, n_jobs=-1, store=ResultStore(CACHE_DIRECTORY / "results.sqlite"), diff --git a/src/tatc/tradespace/__init__.py b/src/tatc/tradespace/__init__.py index 9dd52234..3716b42c 100644 --- a/src/tatc/tradespace/__init__.py +++ b/src/tatc/tradespace/__init__.py @@ -93,7 +93,9 @@ plot_exceedance, plot_means, plot_progress, + plot_shares, style_axes, + use_style, ) from .refinement import refine from .scenarios import robustness @@ -191,5 +193,7 @@ "plot_exceedance", "plot_means", "plot_progress", + "plot_shares", "style_axes", + "use_style", ] diff --git a/src/tatc/tradespace/attribution.py b/src/tatc/tradespace/attribution.py index 277833be..186321a6 100644 --- a/src/tatc/tradespace/attribution.py +++ b/src/tatc/tradespace/attribution.py @@ -16,7 +16,7 @@ import numpy as np import pandas as pd -from .criteria import _resamples +from .criteria import _names, _resamples from .space import Design, DesignSpace, _check_uncertain, _designs, _generic from .study import Study @@ -477,12 +477,12 @@ def _shares( def attribute_variance( study: Study, - metrics: Sequence[str], + metrics: str | Sequence[str], designs: Sequence[Design] | pd.DataFrame, *, parameters: Sequence[str] | Mapping[str, Sequence[str]] | None = None, sample_size: int | None = None, - by: Sequence[str] = (), + by: str | Sequence[str] = (), n_resamples: int = 500, seed: int = 0, ) -> Attribution: @@ -537,7 +537,8 @@ def attribute_variance( Args: study (Study): The study that evaluates designs. - metrics (Sequence[str]): The metrics (columns of the results). + metrics (str | Sequence[str]): The metric (or metrics), columns of the + results. designs (Sequence[Design] | pandas.DataFrame): The designs, or a data frame of their values (such as rows of a summary that keeps them, see `DesignSpace.designs_of`). @@ -548,7 +549,7 @@ def attribute_variance( between replicates, but are not attributed variance. sample_size (int | None): The replicates of each of A and B (`n`), or `None` for the study's replicates. - by (Sequence[str]): The columns that separate the records of an + by (str | Sequence[str]): The columns that separate the records of an evaluation, if it has several (such as a sensor). n_resamples (int): The number of resamples of the bootstrap. seed (int): The seed of the bootstrap. @@ -562,7 +563,7 @@ def attribute_variance( raise ValueError("sample_size must be at least 2") resamples = _resamples(n, n_resamples, seed) groups = _groups_of(study.space, parameters) - metrics, by = list(metrics), tuple(by) + metrics, by = _names(metrics), tuple(_names(by)) unique = _designs(study.space, designs) plain = study.run(unique, replicate_indices=range(2 * n)) missing = [column for column in (*metrics, *by) if column not in plain.columns] diff --git a/src/tatc/tradespace/cache.py b/src/tatc/tradespace/cache.py index 2b4a33ed..c4b6c400 100644 --- a/src/tatc/tradespace/cache.py +++ b/src/tatc/tradespace/cache.py @@ -103,9 +103,8 @@ class SatelliteCache: the same function with other code (of the function, of TAT-C, or of Python: the same values but for code, as a study warns of its store, see `Study`), which it does not reuse, with the differences from the latest - (see `compare_definitions`), and removes the results of other - definitions with `prune` (see `Observations.prune` for the caches of the - observations of a study). A result that cannot be read (such as one + (see `compare_definitions`), and removes them with `prune` (see + `Observations.prune` for the caches of the observations of a study). A result that cannot be read (such as one written with other versions of the libraries of its data) is computed again. @@ -135,6 +134,7 @@ def __init__( self._memory: dict[str, Any] = {} self._unreadable: set[str] = set() self._folder: Path | None = None + self._definition: dict | None = None if self.directory is not None: definition = get_definition(function=function) self.fingerprint = _fingerprint_of(definition) @@ -143,6 +143,7 @@ def __init__( self._folder.mkdir(parents=True, exist_ok=True) _write(self._folder.parent / "namespace.txt", namespace.encode()) _write(self._folder / "definition.json", _canonical(definition).encode()) + self._definition = definition self._warn_other_definitions(definition) @property @@ -207,8 +208,10 @@ def _warn_other_definitions(self, definition: dict) -> None: def prune(self) -> int: """ - Removes the results on disk of the namespace by other definitions of - the function (see `SatelliteCache`). + Removes the results on disk of the namespace by the function with + other code (the same values but for code, of which the cache warns, + see `SatelliteCache`), and not those of other functions (such as of + other targets) that share the namespace. Returns: int: the number of results removed @@ -217,9 +220,13 @@ def prune(self) -> int: return 0 removed = 0 for folder in self._folder.parent.iterdir(): - if folder.is_dir() and folder != self._folder: - removed += sum(1 for _ in folder.glob("*.pkl")) - shutil.rmtree(folder, ignore_errors=True) + if not folder.is_dir() or folder == self._folder: + continue + other = _read_definition(folder) + if _with_other_code(self._definition, [other]) is None: + continue # of another function + removed += sum(1 for _ in folder.glob("*.pkl")) + shutil.rmtree(folder, ignore_errors=True) return removed def _path(self, key: str) -> Path: diff --git a/src/tatc/tradespace/constellations.py b/src/tatc/tradespace/constellations.py index ff2614b6..d181970e 100644 --- a/src/tatc/tradespace/constellations.py +++ b/src/tatc/tradespace/constellations.py @@ -612,6 +612,10 @@ def orbits(self, epoch: datetime, altitude: float | None = None) -> list[list[An """ raise NotImplementedError + def _unrealized(self) -> bool: + """Whether the layout has values that are not realized (`NaN`).""" + return _has_nan(getattr(self, "values", None)) + def describe(self) -> str: """ Gets a short description of the layout (such as `"Walker 60 deg: 3 x @@ -680,8 +684,7 @@ def build( ValueError: if the orbits or names of the satellites do not match the planes, or the layout has values that are not realized. """ - values = getattr(self, "values", None) - if values is not None and _unrealized(values): + if self._unrealized(): raise ValueError( "the layout has values that are not realized (NaN, such as of " + "uncertain parameters): build the satellites of a realized " @@ -707,16 +710,16 @@ def _get_altitude(values: Any, altitude: float | None) -> float: return altitude -def _unrealized(value: Any) -> bool: +def _has_nan(value: Any) -> bool: """Whether values (of a layout) have a missing number (`NaN`).""" if isinstance(value, float): return value != value # pylint: disable=comparison-with-itself if isinstance(value, ChoiceValues): - return _unrealized(value.value) + return _has_nan(value.value) if isinstance(value, RepeatValues): - return any(_unrealized(item) for item in value) + return any(_has_nan(item) for item in value) if isinstance(value, Values): - return any(_unrealized(value[name]) for name in value) + return any(_has_nan(value[name]) for name in value) return False @@ -1017,6 +1020,10 @@ def names(self, name: str) -> list[list[str]]: def describe(self) -> str: return "; ".join(layout.describe() for layout in self.layouts) + def _unrealized(self) -> bool: + # pylint: disable-next=protected-access + return any(layout._unrealized() for layout in self.layouts) + _KINDS = { WALKER: WalkerLayout, diff --git a/src/tatc/tradespace/cost.py b/src/tatc/tradespace/cost.py index 94cb6869..6d524875 100644 --- a/src/tatc/tradespace/cost.py +++ b/src/tatc/tradespace/cost.py @@ -57,7 +57,7 @@ def evaluate(satellites, design): import dataclasses import math import numbers -from collections.abc import Mapping, Sequence +from collections.abc import Callable, Mapping, Sequence from dataclasses import dataclass, field from typing import Any @@ -727,7 +727,12 @@ def estimate( history = ( deployment.planned() if isinstance(deployment, Deployment) else deployment ) - estimate = CostEstimate() + if self.launch.per_kg > 0 and any( + self.satellite_cost_of(kind).mass is None for kind in history.development + ): + raise ValueError("launches priced by mass require masses") + # the costs of a sustained constellation are those incurred by the end + until = history.end if history.schedule.sustained else math.inf flows: list[tuple[float, str, float]] = [] def add( @@ -736,24 +741,64 @@ def add( factor = _get_factor(factors, element, kind) flows.extend((time, element, amount * factor) for time, amount in amounts) - if self.launch.per_kg > 0 and any( - self.satellite_cost_of(kind).mass is None for kind in history.development - ): - raise ValueError("launches priced by mass require masses") - # the costs of a sustained constellation are those incurred by the end - until = history.end if history.schedule.sustained else math.inf - developed_components: set[str] = set() - for kind, developed in sorted( - history.development.items(), key=lambda item: item[1] - ): + estimate = CostEstimate() + self._add_development(history, until, add) + begun = self._add_production(history, until, add) + estimate.units = dict(begun) + estimate.blocks = { + kind: self.satellite_cost_of(kind).blocks(units) + for kind, units in begun.items() + } + estimate.launches = self._add_launches(history, add) + self._add_operations(history, add) + flows = [flow for flow in flows if flow[2] != 0] + estimate.flows = sorted(flows, key=lambda flow: (flow[0], flow[1])) + for element in ELEMENTS: + setattr( + estimate, + element, + float(sum(amount for _, kind, amount in flows if kind == element)), + ) + estimate.present = { + element: float( + sum( + amount * self.discount(time) + for time, kind, amount in flows + if kind == element + ) + ) + for element in ELEMENTS + } + return estimate + + def _add_development( + self, history: MissionHistory, until: float, add: Callable[..., None] + ) -> None: + """ + Adds the development of each type of satellite, spread over its + development: its own, and that of the components that no type + developed before it (in the order their developments end). + """ + developed: set[str] = set() + for kind, ends in sorted(history.development.items(), key=lambda item: item[1]): cost = self.satellite_cost_of(kind) amount = cost.development + sum( c.development * c.factor for c in cost.components - if c.name not in developed_components + if c.name not in developed ) - developed_components.update(c.name for c in cost.components) - add("development", _spread(amount, 0.0, developed, until), kind) + developed.update(c.name for c in cost.components) + add("development", _spread(amount, 0.0, ends, until), kind) + + def _add_production( + self, history: MissionHistory, until: float, add: Callable[..., None] + ) -> dict[Any, int]: + """ + Adds the production of each batch of satellites, on its type's + learning curve, spread over its production, and the development of + each later block of production, before its first unit, returning the + units begun before `until` of each type. + """ built: dict[Any, int] = {} begun: dict[Any, int] = {} for batch in history.production: @@ -770,70 +815,49 @@ def add( _spread(amount, batch.begin, batch.end, until), batch.kind, ) - if cost.block_size is not None and cost.redevelopment > 0: - # the development of each later block, before its first unit - duration = history.development.get(batch.kind, 0.0) - size = int(cost.block_size) - for unit in range(before, before + batch.satellites): - if unit > 0 and unit % size == 0: - begins = ( - batch.begin - + (unit - before) - * (batch.end - batch.begin) - / batch.satellites - ) - add( - "development", - _spread( - cost.redevelopment * cost.total_development, - begins - duration, - begins, - until, - ), - batch.kind, - ) - estimate.units = dict(begun) - estimate.blocks = { - kind: self.satellite_cost_of(kind).blocks(units) - for kind, units in begun.items() - } - begin, end = history.begin, history.end + if cost.block_size is None or cost.redevelopment <= 0: + continue + # the development of each later block, before its first unit + duration = history.development.get(batch.kind, 0.0) + size = int(cost.block_size) + pace = (batch.end - batch.begin) / batch.satellites + for unit in range(before, before + batch.satellites): + if unit > 0 and unit % size == 0: + begins = batch.begin + (unit - before) * pace + add( + "development", + _spread( + cost.redevelopment * cost.total_development, + begins - duration, + begins, + until, + ), + batch.kind, + ) + return begun + + def _add_launches(self, history: MissionHistory, add: Callable[..., None]) -> int: + """Adds the price of each launch when it flies, returning the launches.""" for launch in history.launches: cost = self.satellite_cost_of(launch.kind) - estimate.launches += 1 price = self.launch.per_launch + launch.satellites * ( self.launch.per_satellite + self.launch.per_kg * (cost.mass or 0.0) ) add("launch", [(launch.time, price)], launch.kind) + return len(history.launches) + + def _add_operations( + self, history: MissionHistory, add: Callable[..., None] + ) -> None: + """ + Adds the operations of each satellite while it is in orbit, and the + fixed operations over the mission. + """ for start, stop, count in history.in_orbit(): - add( - "operations", - _spread( - self.operations.per_satellite_year * count * (stop - start), - start, - stop, - ), - ) + amount = self.operations.per_satellite_year * count * (stop - start) + add("operations", _spread(amount, start, stop)) + begin, end = history.begin, history.end add("operations", _spread(self.operations.per_year * (end - begin), begin, end)) - flows = [flow for flow in flows if flow[2] != 0] - estimate.flows = sorted(flows, key=lambda flow: (flow[0], flow[1])) - for element in ELEMENTS: - setattr( - estimate, - element, - float(sum(amount for _, kind, amount in flows if kind == element)), - ) - estimate.present = { - element: float( - sum( - amount * self.discount(time) - for time, kind, amount in flows - if kind == element - ) - ) - for element in ELEMENTS - } - return estimate def _get_growth(growth: Growth) -> dict[str, float | dict[Any, float]]: diff --git a/src/tatc/tradespace/criteria.py b/src/tatc/tradespace/criteria.py index 087f1a2e..13222bd4 100644 --- a/src/tatc/tradespace/criteria.py +++ b/src/tatc/tradespace/criteria.py @@ -32,6 +32,11 @@ _DIRECTIONS = ("min", "max") +def _names(value: str | Sequence[str]) -> list[str]: + """Gets names given as a name or a sequence of names.""" + return [value] if isinstance(value, str) else list(value) + + def _as_statistic(name: str, value: Any) -> Statistic: """ Gets a statistic given by name: a statistic, or the mean of a metric @@ -45,6 +50,27 @@ def _as_statistic(name: str, value: Any) -> Statistic: return value +def _named_statistics(statistics: Any) -> dict[str, Statistic]: + """ + Gets statistics by name: of a mapping of names to statistics (or metrics, + whose means they are), or of a sequence of statistics (or metrics), named + by their conventional names (see `Statistic.name`). + """ + if statistics is None: + return {} + if isinstance(statistics, Mapping): + return {name: _as_statistic(name, value) for name, value in statistics.items()} + if isinstance(statistics, (str, Statistic)) or _is_derived(statistics): + statistics = [statistics] + named: dict[str, Statistic] = {} + for item in statistics: + statistic = _as_statistic(str(item), item) + if statistic.name in named and named[statistic.name] != statistic: + raise ValueError(f"statistics of the same name: {statistic.name!r}") + named[statistic.name] = statistic + return named + + def _is_derived(metric: Any) -> bool: """ Whether a metric is computed from others in each replicate (such as a @@ -71,6 +97,21 @@ class Statistic: def __init__(self, column: Any): self.column = column + @property + def metric(self) -> str: + """str: The name of the statistic's metric: its column, or `"utility"` + of a metric computed from others.""" + return "utility" if _is_derived(self.column) else str(self.column) + + @property + def name(self) -> str: + """str: The conventional name of the statistic (the suffixes of which + are those of `summarize` and `summarize_missions`): such as `cost` + (a mean), `cost std`, `cost se`, `cost min`, `cost max`, `cost p70` + (a quantile), or `P(cost <= 150)`, by which criteria name the + statistics given without names.""" + return self.metric + @property def columns(self) -> tuple[str, ...]: """tuple[str, ...]: The columns of the results that the statistic @@ -152,6 +193,10 @@ class StandardDeviation(Statistic): parameters (`NaN` with fewer than two replicates). """ + @property + def name(self) -> str: + return f"{self.metric} std" + def reduce(self, values: np.ndarray) -> np.ndarray: counts = np.sum(~np.isnan(values), axis=1) result = np.full(values.shape[0], np.nan) @@ -169,6 +214,10 @@ class StandardError(Statistic): replicates). """ + @property + def name(self) -> str: + return f"{self.metric} se" + def reduce(self, values: np.ndarray) -> np.ndarray: counts = np.sum(~np.isnan(values), axis=1) deviation = StandardDeviation(self.column).reduce(values) @@ -181,6 +230,10 @@ class Minimum(Statistic): metric to maximize). """ + @property + def name(self) -> str: + return f"{self.metric} min" + def reduce(self, values: np.ndarray) -> np.ndarray: return _nan_reduce(np.nanmin, values) @@ -191,6 +244,10 @@ class Maximum(Statistic): metric to minimize). """ + @property + def name(self) -> str: + return f"{self.metric} max" + def reduce(self, values: np.ndarray) -> np.ndarray: return _nan_reduce(np.nanmax, values) @@ -202,7 +259,7 @@ class Quantile(Statistic): 90% of the replicates (by linear interpolation between them). Args: - column (str): The metric. + column (str | Utility): The metric. q (float): The quantile, between 0 and 1. """ @@ -229,6 +286,10 @@ def reduce(self, values: np.ndarray) -> np.ndarray: result[counts == 0] = np.nan return result + @property + def name(self) -> str: + return f"{self.metric} p{100 * self.q:g}" + def __repr__(self) -> str: return f"Quantile({self.column!r}, {self.q!r})" @@ -239,7 +300,7 @@ class Probability(Statistic): the replicates in which it does, such as the reliability of a design. Args: - column (str): The metric. + column (str | Utility): The metric. operator (str): The comparison: `">="`, `">"`, `"<="`, or `"<"`. threshold (float): The threshold. """ @@ -259,6 +320,10 @@ def reduce(self, values: np.ndarray) -> np.ndarray: result[counts > 0] = met.sum(axis=1)[counts > 0] / counts[counts > 0] return result + @property + def name(self) -> str: + return f"P({self.metric} {self.operator} {self.threshold:g})" + def __repr__(self) -> str: return f"Probability({self.column!r}, {self.operator!r}, {self.threshold!r})" @@ -297,6 +362,24 @@ def __post_init__(self): if self.scale is not None and not self.scale > 0: raise ValueError("scale must be positive") + def met(self, statistic: np.ndarray) -> np.ndarray: + """ + Gets whether values of the statistic meet the requirement (`False` + where they are `NaN`). + + Args: + statistic (numpy.ndarray): The values. + + Returns: + numpy.ndarray: whether each meets it + """ + values = np.asarray(statistic, dtype=float) + with np.errstate(invalid="ignore"): + return _OPERATORS[self.operator](values, self.value) + + def __str__(self) -> str: + return f"{self.name} {self.operator} {self.value:g}" + def violation(self, statistic: np.ndarray) -> np.ndarray: """ Computes the violations of the requirement: 0 where the statistic @@ -316,9 +399,7 @@ def violation(self, statistic: np.ndarray) -> np.ndarray: else: gap = statistic - self.value scale = self.scale if self.scale is not None else (abs(self.value) or 1.0) - with np.errstate(invalid="ignore"): - met = _OPERATORS[self.operator](statistic, self.value) - violation = np.where(met, 0.0, np.maximum(gap / scale, 1e-9)) + violation = np.where(self.met(statistic), 0.0, np.maximum(gap / scale, 1e-9)) return np.where(np.isnan(statistic), np.nan, violation) @@ -355,7 +436,9 @@ class Across: ) The worst of a statistic needs its direction: that of the objective or - the requirements that name it, which must agree. Requirements and + the requirements that name it, which must agree; other statistics (such + as those that `summarize` adds) are combined by their means, unless a + rule asks for their worst. Requirements and tolerances apply to the combined statistics. A design is judged only if it has feasible results in every group of the results (in each group of the criteria's `by`). @@ -459,12 +542,12 @@ class Criteria: criteria = Criteria( {"cost p70": "min", "coverage": "max"}, - statistics={"cost p70": Quantile("cost", 0.7)}, + statistics=[Quantile("cost", 0.7)], # named cost p70 requirements=[Requirement("cost p70", "<=", 150)], tolerance={"coverage": 1.0}, ) summary = aggregate(results, criteria) - front = summary[pareto_front(summary, criteria)] + front = summary[summary.pareto] Objectives and requirements name statistics: those of `statistics`, or otherwise the means of the metrics of their names. A design is @@ -487,10 +570,13 @@ class Criteria: Args: objectives (Mapping[str, str]): The objectives: statistics (or metrics) and their directions (`"min"` or `"max"`). - statistics (Mapping[str, Statistic | str]): Statistics, by name, of - objectives and requirements that are not means of the metrics of - their names (a metric given as a string, or a `Utility`, is its - mean), and others to compute with them (see `aggregate`). + statistics (Mapping[str, Statistic | str] | Sequence): Statistics, + by name, of objectives and requirements that are not means of + the metrics of their names (a metric given as a string, or a + `Utility`, is its mean), and others to compute with them (see + `aggregate`), or a sequence of them, named by their conventional + names (see `Statistic.name`, such as `cost p70` of + `Quantile("cost", 0.7)`). requirements (Sequence[Requirement]): Requirements on statistics. tolerance (Mapping[str, float | str]): The tolerances of objectives (by name, zero if not given): values in their units, or @@ -504,7 +590,9 @@ class Criteria: """ objectives: Mapping[str, str] - statistics: Mapping[str, Statistic | str] = field(default_factory=dict) + statistics: Mapping[str, Statistic | str] | Sequence[Statistic | str] = field( + default_factory=dict + ) requirements: Sequence[Requirement] = () tolerance: Mapping[str, Tolerance] = field(default_factory=dict) by: Sequence[str] | str = () @@ -521,10 +609,7 @@ def __post_init__(self): raise ValueError( f"direction of {name!r} must be 'min' or 'max', not {direction!r}" ) - statistics = { - name: _as_statistic(name, value) - for name, value in dict(self.statistics).items() - } + statistics = _named_statistics(self.statistics) requirements = tuple(self.requirements) for requirement in requirements: if not isinstance(requirement, Requirement): @@ -619,10 +704,46 @@ def _bootstrap_error(sums: np.ndarray, squares: np.ndarray, n: int) -> np.ndarra return np.sqrt(np.maximum(squares - n * mean**2, 0.0) / max(n - 1, 1)) -def _costs_of(values: Mapping[str, np.ndarray], criteria: Criteria) -> np.ndarray: +def _violation_of( + values: Mapping[str, Any], requirements: Sequence[Requirement], count: int +) -> np.ndarray: + """ + Gets the total violation of requirements by `count` designs, from the + values of their statistics (by name, such as the columns of a summary; + `NaN` where a statistic is missing). + """ + violation = np.zeros(count) + for requirement in requirements: + statistic = np.asarray(values[requirement.name], dtype=float) + violation = violation + requirement.violation(statistic) + return violation + + +def _judge( + frame: pd.DataFrame, + values: Mapping[str, np.ndarray], + violation: np.ndarray, + criteria: Criteria, +) -> None: + """ + Adds the judgment of designs by criteria to the rows of a summary of + them, from the values of their statistics and the violation of the + criteria's requirements: the `violation`, whether each design meets the + requirements (`meets_requirements`), and whether it is efficient among + those that do (`pareto`). + """ + meets = violation == 0 + tolerances = _get_tolerances(criteria.objectives, criteria.tolerance) + frame["violation"] = violation + frame["meets_requirements"] = meets + frame["pareto"] = _efficient(_costs_of(values, criteria), meets, tolerances) + + +def _costs_of(values: Mapping[str, Any], criteria: Criteria) -> np.ndarray: """ Gets the objectives of criteria as costs (to minimize), from the values of - their statistics: maximized objectives are negated. + their statistics (by name, such as the columns of a summary): maximized + objectives are negated (missing values are `NaN`). """ columns = [ np.asarray(values[name], dtype=float) * sign @@ -747,10 +868,7 @@ def _evaluate( matrix if columns is None else matrix[:, columns] ) n = len(next(iter(matrices.values()))) if matrices else 0 - violation = np.zeros(n) - for requirement in requirements: - violation = violation + requirement.violation(values[requirement.name]) - return values, violation + return values, _violation_of(values, requirements, n) def _combiners(criteria: Criteria) -> dict[str, str]: @@ -768,7 +886,10 @@ def _combiners(criteria: Criteria) -> dict[str, str]: worst.setdefault(requirement.name, set()).add(sense) combiners = {} for name in criteria.names: - if across.rules.get(name, across.rule) == "mean": + rule = across.rules.get(name, across.rule) + if rule == "mean" or (name not in worst and name not in across.rules): + # statistics that are neither objectives nor required (such as + # others to compute with them) have no worst: their means combiners[name] = "mean" elif name not in worst: raise ValueError( @@ -894,10 +1015,7 @@ def evaluate( values[name] = stacked.min(axis=0) else: values[name] = self.weights @ stacked - violation = np.zeros(len(self.designs)) - for requirement in self.requirements: - violation = violation + requirement.violation(values[requirement.name]) - return values, violation + return values, _violation_of(values, self.requirements, len(self.designs)) def _design_columns(results: pd.DataFrame, excluded: set[str]) -> list[str]: @@ -988,14 +1106,7 @@ def _criteria_of( statistics to compute (by name), and the columns that group records. """ by = (by,) if isinstance(by, str) else tuple(by) - if isinstance(statistics, str): - statistics = [statistics] - if statistics is not None and not isinstance(statistics, Mapping): - statistics = {name: name for name in statistics} # their means - extra = { - name: _as_statistic(name, value) - for name, value in dict(statistics or {}).items() - } + extra = _named_statistics(statistics) if isinstance(criteria, Mapping) and not set(criteria.values()) <= {"min", "max"}: raise ValueError( "a mapping of criteria gives the directions of objectives ('min' or " @@ -1035,7 +1146,7 @@ def aggregate( results: pd.DataFrame, criteria: Criteria | Mapping[str, str] | Sequence[str] | str = (), *, - statistics: Mapping[str, Statistic | str] | Sequence[str] | None = None, + statistics: Mapping[str, Statistic | str] | Sequence | None = None, by: Sequence[str] | str = (), design_columns: Sequence[str] | None = None, ) -> pd.DataFrame: @@ -1051,11 +1162,12 @@ def aggregate( objectives to their directions, which are the means of the metrics of their names), or the means of metrics (a list of their names), and other `statistics`, by name (a statistic, or a metric given as a string, whose - mean it is), or the means of other metrics (a list of their names):: + mean it is), or a list of statistics (or metrics), named by their + conventional names (see `Statistic.name`):: aggregate(results, {"satellites": "min", "sufficient": "max"}) aggregate(results, ["sufficient", "accurate"]) - aggregate(results, statistics={"cost p70": Quantile("cost", 0.7)}) + aggregate(results, statistics=[Quantile("cost", 0.7)]) # cost p70 aggregate(results, COST, statistics=["cost development"]) With criteria, the summary also gives the `violation` of their @@ -1076,9 +1188,9 @@ def aggregate( criteria (Criteria | Mapping[str, str] | Sequence[str] | str): The criteria (or objectives and their directions), or the metrics whose means to compute. - statistics (Mapping[str, Statistic | str] | Sequence[str] | None): - Other statistics, by name, or the metrics whose means to compute - as well. + statistics (Mapping[str, Statistic | str] | Sequence | None): Other + statistics, by name, or a sequence of statistics (or metrics, + whose means they are), named by their conventional names. by (Sequence[str] | str): The columns that group records of an evaluation (those of the criteria, if they have any). design_columns (Sequence[str] | None): The columns of the values of @@ -1089,11 +1201,10 @@ def aggregate( pandas.DataFrame: a row per design (and group) """ judged, resolved, by = _criteria_of(criteria, statistics, by) - across, combiners, requirements, tolerances = None, None, (), None + across, combiners, requirements = None, None, () if judged is not None: requirements, across = judged.requirements, judged.across combiners = None if across is None else _combiners(judged) - tolerances = _get_tolerances(judged.objectives, judged.tolerance) frames = [] for frame, table in _summary_groups( results, resolved, by, requirements, across, combiners, design_columns @@ -1103,10 +1214,7 @@ def aggregate( frame[name] = value frame["replicates"] = table.counts if judged is not None: - meets = violation == 0 - frame["violation"] = violation - frame["meets_requirements"] = meets - frame["pareto"] = _efficient(_costs_of(values, judged), meets, tolerances) + _judge(frame, values, violation, judged) frames.append(frame) if not frames: status = ["violation", "meets_requirements", "pareto"] if judged else [] @@ -1116,31 +1224,35 @@ def aggregate( def summarize( results: pd.DataFrame, - metrics: Criteria | Mapping[str, str] | Sequence[str] | str, + criteria: Criteria | Mapping[str, str] | Sequence[str] | str = (), *, + statistics: Mapping[str, Statistic | str] | Sequence | None = None, by: Sequence[str] | str = (), design_columns: Sequence[str] | None = None, ) -> pd.DataFrame: """ - Summarizes the metrics of the feasible results of a study over their - replicates (see `aggregate`): for each design (and each group of the - columns `by`, such as a sensor), the mean of each metric, its standard - deviation (` std`) and standard error (` se`) between - replicates, and the number of replicates (`replicates`), with the values - of the design. Given criteria (or a mapping of objectives to their - directions), the summary is theirs (see `aggregate`: their statistics, - the violation of their requirements, and whether each design is - efficient, `pareto`), with the standard deviation and standard error of - each statistic that is the mean of a metric:: + Summarizes the feasible results of a study over their replicates (see + `aggregate`), with the spread of the means of metrics: for each design + (and each group of the columns `by`, such as a sensor), the statistics + of criteria (or the means of a list of metrics) and of other + `statistics`, the standard deviation (` std`) and standard error + (` se`) between replicates of each that is the mean of a metric, + the number of replicates (`replicates`), and the values of the design. + Of criteria (or a mapping of objectives to their directions), the + summary is theirs (see `aggregate`: the violation of their requirements, + and whether each design is efficient, `pareto`):: summary = summarize(results, {"satellites": "min", "sufficient": "max"}) front = summary[summary.pareto] + summarize(results, ACCURACY, statistics=["sufficient"]) # and its mean Args: results (pandas.DataFrame): The results (see `Study.run`). - metrics (Criteria | Mapping[str, str] | Sequence[str] | str): The - columns of the metrics, or criteria (or objectives and their - directions). + criteria (Criteria | Mapping[str, str] | Sequence[str] | str): The + criteria (or objectives and their directions), or the metrics + whose means to summarize. + statistics (Mapping[str, Statistic | str] | Sequence | None): Other + statistics (see `aggregate`). by (Sequence[str] | str): Other columns that group records of an evaluation (those of criteria, if they have any). design_columns (Sequence[str] | None): The columns of the values of @@ -1150,28 +1262,23 @@ def summarize( Returns: pandas.DataFrame: the summary, a row per design (and group) """ - if isinstance(metrics, (Criteria, Mapping)): - judged = _as_criteria(metrics) - if by: - if isinstance(metrics, Criteria): - raise ValueError( - "criteria group records by their own `by`: give it to the criteria" - ) - judged = replace(judged, by=(by,) if isinstance(by, str) else tuple(by)) - spread: dict[str, Statistic] = {} - for name in judged.names: - statistic = judged.statistic(name) - if type(statistic) is Mean and isinstance(statistic.column, str): - spread[f"{name} std"] = StandardDeviation(statistic.column) - spread[f"{name} se"] = StandardError(statistic.column) + judged, resolved, by = _criteria_of(criteria, statistics, by) + summarized: dict[str, Statistic] = {} + spread: dict[str, Statistic] = {} + for name, statistic in resolved.items(): + summarized[name] = statistic + if type(statistic) is Mean and isinstance(statistic.column, str): + spread[f"{name} std"] = StandardDeviation(statistic.column) + spread[f"{name} se"] = StandardError(statistic.column) + summarized.update( + { + f"{name} std": spread[f"{name} std"], + f"{name} se": spread[f"{name} se"], + } + ) + if judged is None: + # each mean of a metric followed by its spread return aggregate( - results, judged, statistics=spread, design_columns=design_columns + results, statistics=summarized, by=by, design_columns=design_columns ) - statistics: dict[str, Statistic] = {} - for metric in [metrics] if isinstance(metrics, str) else metrics: - statistics[metric] = Mean(metric) - statistics[f"{metric} std"] = StandardDeviation(metric) - statistics[f"{metric} se"] = StandardError(metric) - return aggregate( - results, statistics=statistics, by=by, design_columns=design_columns - ) + return aggregate(results, judged, statistics=spread, design_columns=design_columns) diff --git a/src/tatc/tradespace/deployment.py b/src/tatc/tradespace/deployment.py index aca9ac46..2b106345 100644 --- a/src/tatc/tradespace/deployment.py +++ b/src/tatc/tradespace/deployment.py @@ -35,6 +35,7 @@ from __future__ import annotations +import bisect import math from collections.abc import Callable, Mapping, Sequence from dataclasses import dataclass, field @@ -42,7 +43,14 @@ from ..schemas import Satellite from .constellations import layout_of -from .events import Launch, PerType, Production, _per_type, _per_type_values +from .events import ( + Launch, + PerType, + PlannedPlane, + Production, + _per_type, + _per_type_values, +) from .failures import FailureModel, RestorationPolicy from .histories import _expected_metrics, _simulate_many from .mission import Capability, Decision, MissionHistory, Phase @@ -122,10 +130,10 @@ class Deployment: schedule: DeploymentSchedule """DeploymentSchedule: The schedule of the deployment.""" - planes: list[tuple[Any, int, int]] = field(default_factory=list) - """list: The planes, in the order of the layouts' planes: the type of - their satellites, the number of satellites of the layout, and of - spares.""" + planes: list[PlannedPlane] = field(default_factory=list) + """list[PlannedPlane]: The planes, in the order of the layouts' planes: + the type of their satellites, the number of satellites of the layout, + and of spares.""" development: dict[Any, float] = field(default_factory=dict) """dict: The end of the development of each type of satellite (years).""" production: list[Production] = field(default_factory=list) @@ -538,6 +546,28 @@ def mass_capacity_of(self, plane: tuple[int, Any] | None = None) -> float | None raise ValueError("a launch capacity of each plane needs the plane") return float(capacity(*plane)) + def next_slot(self, booked: Sequence[float], ready: float) -> float: + """ + Gets the earliest time of a launch at or after a time that keeps the + launch interval from launches booked before (as the deployments of + plans and the launches of simulations book them). + + Args: + booked (Sequence[float]): The times of the launches booked, in + order. + ready (float): The time when the launch is ready. + + Returns: + float: the time of the launch + """ + interval = self.launch_interval + time = ready + if interval > 0: + for other in booked: + if other - interval < time < other + interval: + time = other + interval + return time + def per_launch( self, mass: float | None = None, plane: tuple[int, Any] | None = None ) -> float: @@ -672,7 +702,9 @@ def plan( for plane in layout_of(item).planes(): size, values = plane.satellites, plane.values index = len(deployment.planes) - deployment.planes.append((name, size, spares if size > 0 else 0)) + deployment.planes.append( + PlannedPlane(name, size, spares if size > 0 else 0) + ) deployment.plane_values.append(values) if size > 0 and index not in staged: listed.append((index, size + spares, values)) @@ -691,23 +723,18 @@ def plan( ) if not planes: raise ValueError("a deployment requires satellites (that are not staged)") - cadence = -math.inf + booked: list[float] = [] for ready, index, name, size, mass in sorted(planes, key=lambda p: p[0]): - carried = self.split(size, mass, (index, deployment.plane_values[index])) - first = max(ready, cadence) position = 0 - for j, satellites in enumerate(carried): + for satellites in self.split( + size, mass, (index, deployment.plane_values[index]) + ): + time = self.next_slot(booked, ready) + bisect.insort(booked, time) deployment.launches.append( - Launch( - first + j * self.launch_interval, - index, - name, - position, - satellites, - ) + Launch(time, index, name, position, satellites) ) position += satellites - cadence = first + len(carried) * self.launch_interval end = deployment.end for launch in list(deployment.launches): for production, replacement in self.replacements(launch, end): diff --git a/src/tatc/tradespace/events.py b/src/tatc/tradespace/events.py index b3d27844..0239f2c8 100644 --- a/src/tatc/tradespace/events.py +++ b/src/tatc/tradespace/events.py @@ -10,7 +10,7 @@ from collections.abc import Mapping from dataclasses import dataclass -from typing import Any +from typing import Any, NamedTuple PerType = float | Mapping[Any, float] """A value for every type of satellite, or for each (a mapping by kind).""" @@ -34,6 +34,17 @@ def _per_type_values(value: Any) -> list: return list(value.values()) if isinstance(value, Mapping) else [value] +class PlannedPlane(NamedTuple): + """A plane of a deployment (see `Deployment.planes`).""" + + kind: Any + """Any: The type of its satellites.""" + satellites: int + """int: The number of satellites of the layout (its positions).""" + spares: int + """int: The number of spares in orbit.""" + + @dataclass(frozen=True) class Launch: """ diff --git a/src/tatc/tradespace/failures.py b/src/tatc/tradespace/failures.py index f4ff89d7..78dd45b4 100644 --- a/src/tatc/tradespace/failures.py +++ b/src/tatc/tradespace/failures.py @@ -35,7 +35,10 @@ class Lifetime: """ Base class of distributions of the life (years) of a satellite from its - launch. + launch. A subclass gives its hazard (`cumulative_hazard` and `hazard`) + and its life of uniform numbers (`from_uniform`, of `dimensions` numbers), + from which simulations draw every life (see `Deployment.simulate`), with + stratified or stressed uniform numbers (see `Deployment.simulate_many`). """ def cumulative_hazard(self, age: np.ndarray) -> np.ndarray: @@ -168,9 +171,6 @@ def cumulative_hazard(self, age): def hazard(self, age): return np.full_like(np.asarray(age, dtype=float), self.rate) - def sample(self, rng): - return math.inf if self.rate == 0 else float(rng.exponential(1 / self.rate)) - def from_uniform(self, uniform): if self.rate == 0: return math.inf @@ -204,9 +204,6 @@ def hazard(self, age): with np.errstate(divide="ignore"): return (self.shape / self.scale) * (age / self.scale) ** (self.shape - 1) - def sample(self, rng): - return float(self.scale * rng.weibull(self.shape)) - def from_uniform(self, uniform): hazard = -math.log1p(-float(uniform[0])) return float(self.scale * hazard ** (1 / self.shape)) @@ -242,9 +239,6 @@ def hazard(self, age): age = np.asarray(age, dtype=float) return sum((c.hazard(age) for c in self.causes), np.zeros_like(age)) - def sample(self, rng): - return min((c.sample(rng) for c in self.causes), default=math.inf) - @property def dimensions(self) -> int: return max(sum(c.dimensions for c in self.causes), 1) @@ -310,10 +304,6 @@ def hazard(self, age): index = np.searchsorted(np.asarray(self.breaks), age, side="right") - 1 return np.asarray(self.rates)[np.clip(index, 0, len(self.rates) - 1)] - def sample(self, rng): - # the age at which the cumulative hazard reaches a unit exponential draw - return self._age_at(float(rng.exponential(1.0))) - def from_uniform(self, uniform): return self._age_at(-math.log1p(-float(uniform[0]))) @@ -461,11 +451,12 @@ def policy_space( variable) or a value. A design's policy is configured from the values of the fragment, and its - deployment planned with their spares in orbit:: + deployment planned with their spares in orbit, as an `ObservationStudy` + does with a mission plan that names the fragment (`MissionPlan.policy`):: policy = configure(BASE_POLICY, d.policy) deployment = SCHEDULE.plan(d.layout, spares=d.policy.orbit_spares) - history = deployment.simulate(FAILURES, policy, d.failure_seed) + history = deployment.simulate(FAILURE_MODEL, policy, d.failure_seed) Spares without restoration would never be used, so a constraint excludes them (unless `require_restoration` is `False`). diff --git a/src/tatc/tradespace/fingerprint.py b/src/tatc/tradespace/fingerprint.py index caeff992..7d3b405b 100644 --- a/src/tatc/tradespace/fingerprint.py +++ b/src/tatc/tradespace/fingerprint.py @@ -21,7 +21,10 @@ which is not installed (such as a module next to a notebook), so that a notebook's function that calls a function it imports from such a module is described as the module's copy of it is. Functions and classes of installed -modules are described by their names, and other objects by their type only. +modules are described by their names, and other objects by their type only, +but for the classes of the study's own modules (by the code of their +methods) and their objects (by their attributes and classes), such as a +callable object that evaluates designs. Data that functions read (such as from files) and the code of installed modules they call (other than TAT-C's) are not described: identify them by a namespace (see `ResultStore` and `SatelliteCache`). @@ -246,17 +249,87 @@ def code( """ Describes compiled code by its instructions, constants, and names (not its file or line numbers, which change as code moves, nor the - docstring `doc` of its function, which does not change results). + docstring `doc` of its function, which does not change results). The + constants include the small integers that some versions of Python + load by an instruction of their own (`LOAD_SMALL_INT`, from 3.14) + rather than from the constants of the code, so that the constants of + code are its literals in every version. """ constants = list(code.co_consts) if doc is not None and constants and constants[0] == doc: constants = constants[1:] + constants.extend( + instruction.argval + for instruction in dis.get_instructions(code) + if instruction.opname == "LOAD_SMALL_INT" + ) return { "code": code.co_code.hex(), "constants": [self.describe(c, depth + 1, seen) for c in constants], "names": list(code.co_names), } + def klass(self, cls: type, depth: int, seen: set) -> dict: + """ + Describes a class of the study's own (see `_is_own_module`): its name, + bases (other than `object`), and members: its functions (methods, + static and class methods, and the functions of properties) by their + code, and its constants. + """ + if id(cls) in seen: + return {"class": cls.__qualname__, "recursive": True} + seen = seen | {id(cls)} + members: dict[str, Any] = {} + for name, member in sorted(vars(cls).items()): + if isinstance(member, (staticmethod, classmethod)): + member = member.__func__ + if isinstance(member, property): + members[name] = { + part: self.function(accessor, depth + 1, seen) + for part, accessor in (("get", member.fget), ("set", member.fset)) + if isinstance(accessor, types.FunctionType) + } + elif isinstance(member, types.FunctionType): + members[name] = self.function(member, depth + 1, seen) + elif not name.startswith("__") and _is_constant(member): + members[name] = self.describe(member, depth + 1, seen) + return { + "class": cls.__qualname__, + "bases": [ + self.describe(base, depth + 1, seen) + for base in cls.__bases__ + if base is not object + ], + "members": members, + } + + def instance(self, value: Any, depth: int, seen: set) -> dict: + """ + Describes an object of a class of the study's own: its class (see + `klass`) and its attributes, but those that are mutable containers + (lists, dictionaries, and sets), which are often state (such as + records of calls), as globals of functions are. + """ + if id(value) in seen: + return {**_type(value), "recursive": True} + seen = seen | {id(value)} + if hasattr(value, "__dict__"): + attributes = dict(vars(value)) + else: + slots = getattr(type(value), "__slots__", ()) + slots = [slots] if isinstance(slots, str) else list(slots) + attributes = {n: getattr(value, n) for n in slots if hasattr(value, n)} + attributes = { + name: attribute + for name, attribute in attributes.items() + if not isinstance(attribute, (list, dict, set, bytearray)) + } + return { + **_type(value), + "class": self.klass(type(value), depth + 1, seen), + "attributes": self.describe(attributes, depth + 1, seen), + } + def function(self, function: types.FunctionType, depth: int, seen: set) -> dict: """ Describes a function: its code, the values it closes over, its @@ -330,7 +403,7 @@ def describe(self, value: Any, depth: int = 0, seen: set | None = None) -> Any: return {"timedelta": value.total_seconds()} if _is_dataclass(value): self.note(type(value).__module__) - return { + described = { **_type(value), **{ item.name: self.describe(getattr(value, item.name), depth + 1, seen) @@ -338,6 +411,9 @@ def describe(self, value: Any, depth: int = 0, seen: set | None = None) -> Any: if item.metadata.get("fingerprint", True) }, } + if _is_own_module(type(value).__module__): + described["class"] = self.klass(type(value), depth + 1, seen) + return described if isinstance(value, BaseModel): self.note(type(value).__module__) return {**_type(value), **value.model_dump(mode="json")} @@ -396,6 +472,8 @@ def describe(self, value: Any, depth: int = 0, seen: set | None = None) -> Any: "arguments": self.describe(value.args, depth + 1, seen), "keywords": self.describe(value.keywords, depth + 1, seen), } + if isinstance(value, type) and _is_own_module(value.__module__): + return self.klass(value, depth, seen) if isinstance(value, (types.BuiltinFunctionType, type)): self.note(getattr(value, "__module__", None)) return {"name": _name(value)} @@ -415,6 +493,8 @@ def describe(self, value: Any, depth: int = 0, seen: set | None = None) -> Any: for name, attribute in sorted(vars(value).items()) }, } + if _is_own_module(type(value).__module__): + return self.instance(value, depth, seen) return _type(value) @@ -714,17 +794,19 @@ def _differences(before: Any, after: Any, path: str) -> list[str]: def _without_code(description: Any) -> Any: """ Gets a description of values without the code of their functions (the - instructions, constants, and names of compiled code, see - `_Describer.code`), which is the same for the same values with other - code (such as a function after it is edited, or compiled by another - version of Python). + instructions and names of compiled code, see `_Describer.code`), which is + the same for the same values with other code (such as a function after + its expressions are edited, or compiled by another version of Python). + The constants of the code (such as the numbers of a constraint) are + values: functions of other constants are of other studies, whose results + are not those of the same study with other code. """ if isinstance(description, dict): code = {"code", "constants", "names"} <= set(description) return { key: _without_code(value) for key, value in description.items() - if not (code and key in ("code", "constants", "names")) + if not (code and key in ("code", "names")) } if isinstance(description, list): return [_without_code(value) for value in description] diff --git a/src/tatc/tradespace/hashing.py b/src/tatc/tradespace/hashing.py index 85b51360..e9b3019d 100644 --- a/src/tatc/tradespace/hashing.py +++ b/src/tatc/tradespace/hashing.py @@ -13,12 +13,24 @@ from typing import Any +def _plain(value: Any) -> Any: + """ + Gets a value that JSON holds of one it does not: a numpy scalar as + Python's, or another value as its string. + """ + item = getattr(value, "item", None) + if callable(item) and type(value).__module__ == "numpy": + return item() + return str(value) + + def _canonical(value: Any) -> str: """ Gets the canonical text of a plain value: its JSON, with the keys of - mappings sorted (and other values as their strings). + mappings sorted (numpy scalars as Python's, and other values as their + strings). """ - return json.dumps(value, sort_keys=True, default=str) + return json.dumps(value, sort_keys=True, default=_plain) def _digest(data: str | bytes, length: int | None = None) -> str: diff --git a/src/tatc/tradespace/histories.py b/src/tatc/tradespace/histories.py index c54b98fc..1652d4a8 100644 --- a/src/tatc/tradespace/histories.py +++ b/src/tatc/tradespace/histories.py @@ -13,23 +13,20 @@ import itertools import math import warnings -from collections.abc import Callable, Mapping, Sequence +from collections.abc import Mapping, Sequence from typing import TYPE_CHECKING, Any import numpy as np import pandas as pd -from ..schemas import Satellite -from .criteria import _OPERATORS, Requirement +from .criteria import Requirement from .failures import FailureModel, RestorationPolicy from .mission import ( PHASE_COLUMNS, + Capability, MissionHistory, Phase, - PhaseCache, - _as_cache, _position_names, - _satellite_keys, summarize_phases, ) from .simulation import _Simulation @@ -40,14 +37,10 @@ def evaluate_missions( histories: Sequence[MissionHistory], - satellites: Sequence[Satellite], - observations: pd.DataFrame, - metric: Callable[..., Mapping[str, float]] | PhaseCache, + capability: Capability, *, - context: Any = None, cost_model: Any = None, growth: Any = 1.0, - design: Any = None, ) -> pd.DataFrame: """ Evaluates histories of a mission (such as those of a replicate, see @@ -56,23 +49,15 @@ def evaluate_missions( measures (see `MissionHistory.metrics`), and its cost (see `CostEstimate.metrics`, with a cost model). The histories share the observations of the replicate, so that each set of operating satellites - is evaluated once (by a `PhaseCache` given as the metric, which keeps - them for other calls, or one of this call's own). + is evaluated once, by the capability of the satellites (see + `Capability.evaluate`, with the cache of its metric). Args: histories (Sequence[MissionHistory]): The histories. - satellites (Sequence[Satellite]): The satellites (see - `MissionHistory.phases`). - observations (pandas.DataFrame): The observations of every - satellite, with their names (`satellite`). - metric (Callable | PhaseCache): A function of the observations of a - phase that gives its metrics, or a cache of one. - context (Any): A hashable identifier of the observations, for a - cache. + capability (Capability): The capability of the satellites: their + observations (of the replicate) and metric. cost_model (CostModel | None): A model of the cost of each history. growth (float | Mapping[str, float]): The growth of the cost. - design (Design | None): The (realized) design of the mission, for a - metric with a parameter named `design` (see `PhaseCache`). Returns: pandas.DataFrame: a row per history (with its likelihood ratio, @@ -80,12 +65,8 @@ def evaluate_missions( """ rows = [] weighted = any(history.weight != 1.0 for history in histories) - keys = _satellite_keys(satellites) - cache = _as_cache(metric) for history in histories: - phases = cache.evaluate( - history.phases(satellites), keys, observations, context, design - ) + phases = capability.evaluate(history.phases(capability.satellites)) row = {**summarize_phases(phases), **history.metrics()} if weighted: row["weight"] = history.weight @@ -178,11 +159,8 @@ def summarize_missions( numeric[column].to_numpy(dtype=float), weights, q ) for requirement in requirements: - met = _OPERATORS[requirement.operator]( - missions[requirement.name].to_numpy(dtype=float), requirement.value - ) - statement = f"{requirement.name} {requirement.operator} {requirement.value:g}" - summary[f"P({statement})"] = float(np.sum(weights * met) / np.sum(weights)) + met = requirement.met(missions[requirement.name].to_numpy(dtype=float)) + summary[f"P({requirement})"] = float(np.sum(weights * met) / np.sum(weights)) return summary @@ -298,10 +276,6 @@ def _simulate_many( if stress <= 0 or (launch_stress is not None and launch_stress <= 0): raise ValueError("stress must be positive") launch_stress = stress if launch_stress is None else launch_stress - if sampling == "random" and stress == 1 and launch_stress == 1: - return [ - deployment.simulate(failures, policy, (seed, k)) for k in range(histories) - ] return [ _Simulation( deployment, @@ -392,8 +366,8 @@ def allocate_histories( Returns: dict[str, float]: the recommended `histories` (and `replicates`, with a standard error), the standard deviations `between` and - `within`, and the cost of a replicate (`replicate cost`, seconds) - and of the evaluations (`cost`, seconds, with a standard error) + `within`, and the time of a replicate (`replicate seconds`) and of + the evaluations (`seconds`, with a standard error) """ if len(records) < 2: raise ValueError("a pilot needs at least two replicates") @@ -421,7 +395,7 @@ def allocate_histories( "histories": float(count), "between": math.sqrt(between), "within": math.sqrt(within), - "replicate cost": cost, + "replicate seconds": cost, } if standard_error is not None: if standard_error <= 0: @@ -433,8 +407,8 @@ def allocate_histories( needed = math.ceil(within / (2 * standard_error**2 - between)) count = int(min(max(needed, 1), count)) cost = replicate_seconds + count * history_seconds - result.update(histories=float(count), **{"replicate cost": cost}) - result.update(replicates=float(replicates), cost=replicates * cost) + result.update(histories=float(count), **{"replicate seconds": cost}) + result.update(replicates=float(replicates), seconds=replicates * cost) return result @@ -451,14 +425,14 @@ def _launch_groups( the probability that none has succeeded (`none`), and whether the group has launched. """ - offsets = np.cumsum([0] + [built for _, built, _ in deployment.planes]) + offsets = np.cumsum([0] + [plane.satellites for plane in deployment.planes]) launches: dict[tuple[int, int], list] = {} for launch in sorted(deployment.launches, key=lambda l: l.time): launches.setdefault((launch.plane, launch.first), []).append(launch) p = failures.launch groups = [] for (plane, first), sequence in launches.items(): - built = deployment.planes[plane][1] + built = deployment.planes[plane].satellites members = [ int(offsets[plane]) + position for position in range(first, min(first + sequence[0].satellites, built)) @@ -512,12 +486,8 @@ def _set_weight(active: np.ndarray, groups: list) -> float: def expected_missions( deployment: Deployment, failures: FailureModel, - satellites: Sequence[Satellite], - observations: pd.DataFrame, - metric: Callable[..., Mapping[str, float]] | PhaseCache, + capability: Capability, *, - context: Any = None, - design: Any = None, tolerance: float = 1e-3, steps: int = 400, max_sets: int = 200_000, @@ -552,16 +522,9 @@ def expected_missions( Args: deployment (Deployment): The deployment. failures (FailureModel): The failures. - satellites (Sequence[Satellite]): The satellites, in the order of the - planes (see `MissionHistory.phases`). - observations (pandas.DataFrame): The observations of every - satellite, with their names (`satellite`). - metric (Callable | PhaseCache): A function of the observations of a - set of satellites that gives its metrics, or a cache of one. - context (Any): A hashable identifier of the observations, for a - cache. - design (Design | None): The (realized) design of the mission, for a - metric with a parameter named `design` (see `PhaseCache`). + capability (Capability): The capability of the satellites (in the + order of the planes, see `MissionHistory.phases`): their + observations and metric (see `Capability.evaluate`). tolerance (float): The share of the mission's time that the sets evaluated may leave out. steps (int): The times at which the probabilities are integrated. @@ -580,7 +543,7 @@ def expected_missions( "exact expectations need a deployment that is not staged: " + "simulate histories of a staged deployment instead" ) - names = list(_position_names(deployment.planes, satellites).values()) + names = list(_position_names(deployment.planes, capability.satellites).values()) begin, end = deployment.begin, deployment.end times = begin + (np.arange(steps) + 0.5) * (end - begin) / steps count, groups = _launch_groups(deployment, failures, times) @@ -613,13 +576,11 @@ def expected_missions( if covered >= 1 - tolerance: break weights.sort(key=lambda item: -item[0]) - keys = _satellite_keys(satellites) - cache = _as_cache(metric) totals: dict[str, float] = {} evaluated, sets = 0.0, 0 for weight, members in weights: phase = Phase(begin, end, tuple(names[k] for k in members)) - values = cache.evaluate([phase], keys, observations, context, design).iloc[0] + values = capability.evaluate([phase]).iloc[0] for name, value in values.items(): if name in PHASE_COLUMNS: continue diff --git a/src/tatc/tradespace/mission.py b/src/tatc/tradespace/mission.py index 9c58e987..f9451de7 100644 --- a/src/tatc/tradespace/mission.py +++ b/src/tatc/tradespace/mission.py @@ -21,7 +21,7 @@ from ..schemas import Satellite from .cache import get_satellite_key -from .criteria import _OPERATORS, Requirement +from .criteria import Requirement from .events import Launch, Production from .study import _takes_design @@ -429,9 +429,7 @@ def summarize_phases( values = phases[name].to_numpy(dtype=float) summary[f"{name} mission"] = float(np.sum(values * weights) / np.sum(weights)) for requirement in requirements: - met = _OPERATORS[requirement.operator]( - phases[requirement.name].to_numpy(dtype=float), requirement.value - ) + met = requirement.met(phases[requirement.name].to_numpy(dtype=float)) starts = phases["start"].to_numpy(dtype=float)[met] summary[f"{requirement.name} time"] = ( float(starts[0]) if len(starts) > 0 else math.inf @@ -604,6 +602,10 @@ class Capability: phases: the satellites operating at a decision are those of a phase of the mission, which the evaluation evaluates anyway. + A capability also evaluates the phases of the mission's histories (see + `evaluate`, `evaluate_missions`, and `expected_missions`), with its + cache. + Args: satellites (Sequence[Satellite | str]): The satellites (or their names), in the order of the planes (see `MissionHistory.phases`). @@ -650,6 +652,24 @@ def _cache(self) -> PhaseCache: """The cache of the metric (that given, or one of its own).""" return _as_cache(self.metric) + def evaluate(self, phases: Sequence[Phase]) -> pd.DataFrame: + """ + Evaluates the phases of a mission of the satellites (see + `evaluate_phases`): the metrics of the satellites that operate in + each, each set evaluated once (by the cache, with the context and the + design, see `PhaseCache.evaluate`). + + Args: + phases (Sequence[Phase]): The phases. + + Returns: + pandas.DataFrame: a row per phase: its `start`, `end`, + `duration`, number of `satellites`, and metrics + """ + return self._cache.evaluate( + phases, self._keys, self.observations, self.context, self.design + ) + def __call__(self, names: Iterable[str]) -> dict[str, float]: """ Gets the metrics of satellites that operate together. diff --git a/src/tatc/tradespace/nodes.py b/src/tatc/tradespace/nodes.py index 7664079d..71c1121b 100644 --- a/src/tatc/tradespace/nodes.py +++ b/src/tatc/tradespace/nodes.py @@ -409,8 +409,8 @@ class Choice(Node): (typically a `DesignSpace`). The nodes of the other branches are inactive. The value of a choice gives the name of the chosen branch as `choice` (and equals it), and the values of the branch as its attributes - (see `ChoiceValues`), so that its branches may not be named `choice` or - `value`. + (see `ChoiceValues`), so that its branches, and the children of branches + that are groups, may not be named `choice` or `value`. Args: **branches (Node): The alternatives, by name. @@ -423,6 +423,13 @@ def __init__(self, **branches: Any): if reserved: raise ValueError(f"reserved names of branches: {reserved}") self.branches = {name: _as_node(node) for name, node in branches.items()} + for name, node in self.branches.items(): + children = getattr(node, "children", {}) + reserved = sorted({"choice", "value"}.intersection(children)) + if reserved: + raise ValueError( + f"reserved names of the values of branch {name!r}: {reserved}" + ) def __repr__(self) -> str: return f"Choice({', '.join(self.branches)})" diff --git a/src/tatc/tradespace/observations.py b/src/tatc/tradespace/observations.py index 31e19061..a09c9631 100644 --- a/src/tatc/tradespace/observations.py +++ b/src/tatc/tradespace/observations.py @@ -21,7 +21,6 @@ import dataclasses import json -import math import numbers import os import warnings @@ -36,7 +35,7 @@ from ..analysis import collect_observations from ..schemas import Satellite -from .cache import SatelliteCache +from .cache import SatelliteCache, _write from .constellations import count_planes from .cost import CostEstimate, CostModel from .criteria import Requirement @@ -311,9 +310,9 @@ def cache_of(self, design: Design | None = None) -> SatelliteCache: """ Gets the cache of the observations of the targets of a design (by the seed of its targets and its period), in a namespace of the targets' - seed and the period (and the `namespace`), - so that a cache warns of results of other definitions (see - `SatelliteCache`) of the same targets and period. + seed and the period (and the `namespace`), so that the cache warns of + results of the analysis with other code (see `SatelliteCache`) of the + same targets and period. Args: design (Design | None): The (realized) design. @@ -350,18 +349,18 @@ def _cache(self, seed: Any, start: datetime) -> SatelliteCache: function, self.directory, self._namespace(seed, start) ) if self.directory is not None: - context = cache.folder.parent / "context.json" - if not context.exists(): - context.write_text(json.dumps(_encode([seed, start]))) + context = json.dumps(_encode([seed, start])).encode() + _write(cache.folder.parent / "context.json", context) self._caches[seed, start] = cache return self._caches[seed, start] def prune(self) -> int: """ - Removes the results on disk of the analysis with other code (or other - definitions, see `SatelliteCache.prune`) from the caches of every set - of targets (of each seed and start) of these observations in the - directory, such as after a study warns of them. + Removes the results on disk of the analysis with other code (see + `SatelliteCache.prune`) from the caches of every set of targets (of + each seed and start) of these observations in the directory, such as + after a study warns of them. The results of other observations that + share the directory (such as of other targets) are kept. Returns: int: the number of results removed (0 without a directory) @@ -435,7 +434,7 @@ def schedule(d): and costs of several kinds), as a value of the design. spares (int | Reference): The spares in orbit in each plane, or a value of the design (replaced by the `orbit_spares` of a design's - policy, see `Failures`). + policy, see `policy`). growth (float | Reference | Mapping): The growth of the costs (see `CostModel.estimate`): a factor, a value of the design, or a mapping of each element (such as `"development"`) to a factor or @@ -455,6 +454,11 @@ def schedule(d): components of the cost model is drawn (see `CostModel.draw`), as a value of the design (such as a group of `risk_space`), or `None` for the expected costs of the components. + policy (Reference | None): The value of the design that configures + the policy that restores its failures (see `Failures`) and its + spares in orbit (such as a group of `policy_space`, see + `configure`), or `None` for the policy of the failures and the + plan's `spares`. """ schedule: DeploymentSchedule | Callable[[Design], DeploymentSchedule] @@ -467,6 +471,7 @@ def schedule(d): stages: Sequence[Stage] | Callable[[Design], Sequence[Stage]] = () masses: float | Mapping[Any, float] | Reference | None = None scores: Reference | None = None + policy: Reference | None = None def schedule_of(self, design: Design) -> DeploymentSchedule: """ @@ -573,14 +578,14 @@ class Failures: The failures of the satellites of each design: histories of its mission (see `Deployment.simulate_many`), restored by a policy (by default by producing new satellites; `RestorationPolicy(restore=False)` not to - restore them; or by the policy of each design of a design space with a - value `policy`, see `policy_space`, which configures the policy, see - `configure`, and the spares in orbit), summarized over the histories - (see `summarize_missions`): the mean of each metric over the phases of - the mission and the histories, `quantiles` and `requirements` of them, - and their costs. Without restoration, the means of the metrics and the + restore them; or configured by the values of each design, see + `MissionPlan.policy`), summarized over the histories (see + `summarize_missions`): the mean of each metric over the phases of the + mission and the histories, `quantiles` and `requirements` of them, and + their costs. Without restoration, the means of the metrics and the availability are the exact expectations over the failures (see - `expected_missions`) if `exact`. + `expected_missions`) if `exact` (and the histories have failures, with a + `seed`). With a `stress`, the failures are drawn from stressed distributions for importance sampling (see `Deployment.simulate_many`), each history @@ -647,16 +652,48 @@ def __post_init__(self): @dataclasses.dataclass(frozen=True) class _Mission: """ - The mission of a design (see `_Evaluation`): its planned deployment, the - policy that restores its failures, its cost model and growth, and the - context of the metrics of its phases. + The mission of a realized design (see `_Evaluation`): its planned + deployment, the policy that restores its failures, its cost model and + growth, and the capability of its satellites (their observations and + the cache of the metrics of their phases), from which its phases, costs, + and histories follow. """ deployment: Deployment policy: RestorationPolicy cost_model: CostModel | None growth: Any - context: Any + capability: Capability + + def phases(self) -> pd.DataFrame: + """The metrics of the phases of the planned deployment.""" + satellites = self.capability.satellites + return self.capability.evaluate(self.deployment.phases(satellites)) + + def estimate(self) -> CostEstimate: + """The cost estimate of the planned deployment.""" + if self.cost_model is None: + raise ValueError("the mission plan has no cost model") + return self.cost_model.estimate(self.deployment, self.growth) + + def missions(self, failures: Failures) -> pd.DataFrame: + """The histories of the failures of the mission (see `evaluate_missions`).""" + histories = self.deployment.simulate_many( + failures.model, + self.policy, + self.seed_of(failures), + failures.histories, + sampling=failures.sampling, + stress=failures.stress, + launch_stress=failures.launch_stress, + ) + return evaluate_missions( + histories, self.capability, cost_model=self.cost_model, growth=self.growth + ) + + def seed_of(self, failures: Failures) -> Any: + """The seed of the failures of the mission's replicate.""" + return value_of(self.capability.design, failures.seed) @dataclasses.dataclass(frozen=True, eq=False) @@ -674,6 +711,9 @@ class _Evaluation: plan: MissionPlan | None = None failures: Failures | None = None phases: tuple[Requirement, ...] | None = None + _phase_cache: PhaseCache = dataclasses.field( + init=False, repr=False, metadata={"fingerprint": False} + ) def __post_init__(self): object.__setattr__(self, "_phase_cache", PhaseCache(self.metrics)) @@ -686,35 +726,36 @@ def __call__(self, satellites: Sequence[Satellite], design: Design) -> dict: record["planes"] = count_planes(layout) mission = None if self.plan is not None: - mission = self._mission(satellites, observations, design, layout) - record.update(self._planned(mission)) + mission = self.mission_of(satellites, observations, design) + record["deployed"] = mission.deployment.deployed + if mission.cost_model is not None and self.failures is None: + # (of failures, the costs are the means over the histories) + record.update(mission.estimate().metrics()) record.update(_given_design(self.metrics, design)(observations)) if mission is not None and self.failures is not None: - record.update(self._histories(mission, satellites, observations, design)) + record.update(self._histories(mission)) elif mission is not None and self.phases is not None: - record.update(self._phases(mission, satellites, observations, design)) + record.update(summarize_phases(mission.phases(), requirements=self.phases)) return record def _policy(self, design: Design) -> tuple[RestorationPolicy, Any]: """The policy of a design, and its spares in orbit in each plane.""" base = RestorationPolicy() if self.failures is None else self.failures.policy - spares = _number(design, self.plan.spares) - decided = design.values.get("policy") - if decided is None: - return base, spares + if self.plan.policy is None: + return base, _number(design, self.plan.spares) + decided = value_of(design, self.plan.policy) return configure(base, decided), decided.orbit_spares - def _mission( + def mission_of( self, satellites: Sequence[Satellite], observations: pd.DataFrame, design: Design, - layout: Any, ) -> _Mission: """ - Plans the mission of a design: its deployment (whose stages read the - capability of the satellites operating at their decisions), policy, - and costs. + Plans the mission of a realized design: its deployment (whose stages + read the capability of the satellites operating at their decisions), + policy, and costs. """ # the metrics of phases are cached by the observations and, if they # are given the design, by its scenario @@ -724,94 +765,29 @@ def _mission( policy, spares = self._policy(design) cost_model = self.plan.cost_model_of(design) deployment = self.plan.schedule_of(design).plan( - layout, + value_of(design, self.layout), kind=value_of(design, self.plan.kind), spares=spares, masses=self.plan.masses_of(design, cost_model), stages=self.plan.stages_of(design), ) - deployment.capability = Capability( + capability = Capability( satellites, observations, self._phase_cache, context, design ) + deployment.capability = capability return _Mission( - deployment, policy, cost_model, self.plan.growth_of(design), context + deployment, policy, cost_model, self.plan.growth_of(design), capability ) - @staticmethod - def _planned(mission: _Mission) -> dict[str, Any]: - """ - Gets the metrics of a planned mission: the time by which it is - deployed and, with a cost model, its costs. - """ - deployment = mission.deployment - record: dict[str, Any] = { - "deployed": deployment.deployed if deployment.launches else math.nan - } - if mission.cost_model is not None: - estimate = mission.cost_model.estimate(deployment, mission.growth) - record.update(estimate.metrics()) - return record - - def _phases( - self, - mission: _Mission, - satellites: Sequence[Satellite], - observations: pd.DataFrame, - design: Design, - ) -> dict[str, float]: - """Summarizes the metrics of the phases of a planned mission.""" - phases = self._evaluate_phases(mission, satellites, observations, design) - return summarize_phases(phases, requirements=self.phases) - - def _evaluate_phases( - self, - mission: _Mission, - satellites: Sequence[Satellite], - observations: pd.DataFrame, - design: Design, - ) -> pd.DataFrame: - """Evaluates the phases of a planned mission (see `evaluate_phases`).""" - return self._phase_cache.evaluate( - mission.deployment.phases(satellites), - satellites, - observations, - mission.context, - design, - ) - - def _histories( - self, - mission: _Mission, - satellites: Sequence[Satellite], - observations: pd.DataFrame, - design: Design, - ) -> dict[str, float]: + def _histories(self, mission: _Mission) -> dict[str, float]: """ Summarizes histories of the failures of a mission (with exact expectations of the means of missions that are not restored or - staged, if the failures are exact). + staged, if the failures are exact and have a seed). """ failures = self.failures - seed = value_of(design, failures.seed) - histories = mission.deployment.simulate_many( - failures.model, - mission.policy, - seed, - failures.histories, - sampling=failures.sampling, - stress=failures.stress, - launch_stress=failures.launch_stress, - ) - missions = evaluate_missions( - histories, - satellites, - observations, - self._phase_cache, - context=mission.context, - cost_model=mission.cost_model, - growth=mission.growth, - design=design, - ) + seed = mission.seed_of(failures) + missions = mission.missions(failures) controls = None if failures.controls and seed is not None: # other histories of the replicate (by a seed of its seed) @@ -839,17 +815,12 @@ def _histories( ) if ( failures.exact + and seed is not None and not mission.policy.restore and not mission.deployment.stages ): exact = expected_missions( - mission.deployment, - failures.model, - satellites, - observations, - self._phase_cache, - context=mission.context, - design=design, + mission.deployment, failures.model, mission.capability ) record.update( { @@ -876,20 +847,21 @@ class ObservationStudy(Study): build, # the satellites of a design Observations(Targets(generate_points_rotated_lattice, 100, seed="seed"), START, DAY), sample, # the metrics of observations - layout="layout", plan=MissionPlan(SCHEDULE, COST_MODEL), phases=True, ) Its results have the columns of every study (see `Study.run`) and: - * `satellites`, and `planes` (with a `layout`): their numbers. + * `satellites`, and `planes` (with a `layout`, by default the value + `layout` of a design space that has one): their numbers. * the metrics of the observations of every satellite (by their names). * with a plan: `deployed`, the years from the start of development to the last launch of the planned deployment (without stages that rules decide to deploy, see `Stage`), and, with a cost model, the costs of the deployment (`cost`, `cost development`, and so on, see - `CostEstimate.metrics`). + `CostEstimate.metrics`; with failures, the means of the costs of the + histories). * with phases: ` mission`, the mean of each metric over the phases of the mission as its satellites are deployed, and ` time`, the years until a phase first meets each requirement @@ -923,17 +895,25 @@ class ObservationStudy(Study): content (or the recipe of generated targets), so that its store needs no namespace but for what the fingerprint cannot see. + The parts of the evaluation of a design are also given apart, for + analyses other than its metrics: its satellites, targets, and + observations (`satellites_of`, `targets_of`, and `observations_of`), and + its planned deployment, the metrics of its phases, its cost estimate, + and the histories of its failures (`deployment_of`, `phases_of`, + `estimate_of`, and `missions_of`). + Args: space (DesignSpace): The design space. - satellites (Callable): A function of a realized design that builds - its satellites (such as with `build_constellation`). + build (Callable): A function of a realized design that builds its + satellites (such as with `build_constellation`). observations (Observations): The observations of the targets. metrics (Callable): A function of observations (and of the realized design, if it has a parameter named `design`) that gives their metrics (a mapping). layout (Reference | None): The value of the design that is its - layout (see `value_of` and `layout_of`), if any, which a `plan` - requires. + layout (see `value_of` and `layout_of`), which a `plan` + requires, or `None` for the value `layout` of a design space + that has one (and none otherwise). plan (MissionPlan | None): The deployment and costs, if any. failures (Failures | None): The failures, if any, which require a plan. @@ -947,7 +927,7 @@ class ObservationStudy(Study): def __init__( self, space: DesignSpace, - satellites: Callable[[Design], Sequence[Satellite]], + build: Callable[[Design], Sequence[Satellite]], observations: Observations, metrics: Callable[[pd.DataFrame], Mapping[str, Any]], layout: Reference | None = None, @@ -959,6 +939,8 @@ def __init__( # the requirements on the phases, if they are summarized phases = None if phases is None or phases is False else phases phases = () if phases is True else None if phases is None else tuple(phases) + if layout is None and "layout" in space.children: + layout = "layout" if plan is None and (failures is not None or phases is not None): raise ValueError("failures and phases require a mission plan") if plan is not None and layout is None: @@ -970,12 +952,12 @@ def __init__( self.observations, self.metrics, self.layout = observations, metrics, layout self.plan, self.failures, self.phases = plan, failures, phases evaluation = _Evaluation(observations, metrics, layout, plan, failures, phases) - super().__init__(space, satellites, evaluation, **options) + super().__init__(space, build, evaluation, **options) def _arguments(self) -> dict[str, Any]: return { "space": self.space, - "satellites": self.build, + "build": self.build, "observations": self.observations, "metrics": self.metrics, "layout": self.layout, @@ -1070,7 +1052,7 @@ def deployment_of( Raises: ValueError: if the study has no mission plan. """ - return self._mission_of(design, replicate, scenario)[3].deployment + return self._mission_of(design, replicate, scenario).deployment def phases_of( self, design: Design, replicate: int = 0, scenario: str | None = None @@ -1078,7 +1060,9 @@ def phases_of( """ Gets the metrics of the phases of the planned deployment of a replicate of a design (see `deployment_of` and `evaluate_phases`), - as its evaluation summarizes them (see `summarize_phases`). + which the evaluation of a study with `phases` summarizes (see + `summarize_phases`); those of the histories of failures are of + `missions_of`. Args: design (Design): The design. @@ -1092,13 +1076,7 @@ def phases_of( Raises: ValueError: if the study has no mission plan. """ - realized, satellites, observations, mission = self._mission_of( - design, replicate, scenario - ) - # pylint: disable-next=protected-access - return self.evaluate._evaluate_phases( - mission, satellites, observations, realized - ) + return self._mission_of(design, replicate, scenario).phases() def estimate_of( self, design: Design, replicate: int = 0, scenario: str | None = None @@ -1106,7 +1084,9 @@ def estimate_of( """ Gets the cost estimate of the planned deployment of a replicate of a design (see `deployment_of` and `CostModel.estimate`), with its - growth, as its evaluation estimates it. + growth, which is the cost of the evaluation of a study without + failures (the costs of a study with failures are the means of those + of the histories, see `missions_of`). Args: design (Design): The design. @@ -1119,25 +1099,53 @@ def estimate_of( Raises: ValueError: if the study's plan has no cost model. """ - mission = self._mission_of(design, replicate, scenario)[3] - if mission.cost_model is None: - raise ValueError("the study's mission plan has no cost model") - return mission.cost_model.estimate(mission.deployment, mission.growth) + return self._mission_of(design, replicate, scenario).estimate() + + def missions_of( + self, design: Design, replicate: int = 0, scenario: str | None = None + ) -> pd.DataFrame: + """ + Gets the histories of the failures of a replicate of a design, which + its evaluation summarizes (see `Failures` and `evaluate_missions`): + a row per history, with the mean of each metric over its phases, + the measures of its mission, and its costs. + + Args: + design (Design): The design. + replicate (int): The replicate. + scenario (str | None): A scenario of the study (by name), if any. + + Returns: + pandas.DataFrame: a row per history + + Raises: + ValueError: if the study has no failures. + """ + if self.failures is None: + raise ValueError("the study has no failures") + return self._mission_of(design, replicate, scenario).missions(self.failures) + + def prune(self) -> int: + """ + Removes the evaluations of the study's store by this study with other + code (see `Study.prune`), and the results of its observations' caches + with other code (see `Observations.prune`). + + Returns: + int: the number of evaluations and results removed + """ + return super().prune() + self.observations.prune() def _mission_of( self, design: Design, replicate: int, scenario: str | None - ) -> tuple[Design, list[Satellite], pd.DataFrame, _Mission]: + ) -> _Mission: """ - Plans the mission of a replicate of a design, as its evaluation does: - the realized design, its satellites, their observations, and the - mission. + Plans the mission of a replicate of a design, as its evaluation does + (see `_Evaluation.mission_of`). """ if self.plan is None: raise ValueError("the study has no mission plan") realized = self.realize(design, replicate, scenario) satellites = list(self.build(realized)) observations = self.observations(satellites, realized) - layout = value_of(realized, self.layout) - # pylint: disable-next=protected-access - mission = self.evaluate._mission(satellites, observations, realized, layout) - return realized, satellites, observations, mission + return self.evaluate.mission_of(satellites, observations, realized) diff --git a/src/tatc/tradespace/optimization.py b/src/tatc/tradespace/optimization.py index 3f9cfd12..a1ec1714 100644 --- a/src/tatc/tradespace/optimization.py +++ b/src/tatc/tradespace/optimization.py @@ -244,6 +244,7 @@ def optimize_optuna( criteria: Criteria | Mapping[str, str], n_trials: int, *, + seed: int | None = 0, sampler: Any = None, optuna_study: Any = None, batch_size: int | None = None, @@ -291,6 +292,8 @@ def optimize_optuna( (see `Criteria`), or the objectives (metrics whose means they are) and their directions (`"min"` or `"max"`). n_trials (int): The number of trials. + seed (int | None): The seed of the default sampler (`None` for one + drawn anew); a sampler given is seeded by its own arguments. sampler (optuna.samplers.BaseSampler | None): The sampler, or `None` for TPE (with a constant liar in batches); ignored with an `optuna_study`. @@ -320,7 +323,9 @@ def optimize_optuna( batch_size = batch_size or study.workers if optuna_study is None: if sampler is None: - sampler = optuna.samplers.TPESampler(constant_liar=batch_size > 1) + sampler = optuna.samplers.TPESampler( + constant_liar=batch_size > 1, seed=seed + ) optuna_study = optuna.create_study(directions=directions, sampler=sampler) constrained = constraints and hasattr(optuna.trial.Trial, "set_constraint") if requirements and not constrained: @@ -557,7 +562,12 @@ def optimize_pymoo( eliminate duplicates as pymoo's genetic algorithms do. """ # pylint: disable=import-outside-toplevel - from pymoo.optimize import minimize + try: + from pymoo.optimize import minimize + except ImportError as error: + raise ImportError( + "optimize_pymoo requires pymoo (pip install pymoo)" + ) from error if algorithm is None: from pymoo.algorithms.moo.nsga2 import NSGA2 diff --git a/src/tatc/tradespace/pareto.py b/src/tatc/tradespace/pareto.py index 90b4bc13..b0657f90 100644 --- a/src/tatc/tradespace/pareto.py +++ b/src/tatc/tradespace/pareto.py @@ -32,28 +32,26 @@ _costs_of, _get_tolerances, _groups, + _judge, _resamples, _resolve, _signs, _summary_groups, + _violation_of, aggregate, ) from .dominance import _dominated, _efficient -def _get_costs(frame: pd.DataFrame, objectives: Mapping[str, str]) -> np.ndarray: +def _get_costs(frame: pd.DataFrame, criteria: Criteria) -> np.ndarray: """ - Gets the objectives of a data frame as costs (to minimize): maximized - objectives are negated (missing values are `NaN`). + Gets the objectives of criteria of a data frame (of their columns) as + costs (to minimize, see `_costs_of`). """ - missing = [column for column in objectives if column not in frame.columns] + missing = [column for column in criteria.objectives if column not in frame] if missing: raise ValueError(f"no columns of the objectives {missing}") - columns = [] - for column, direction in objectives.items(): - values = frame[column].to_numpy(dtype=float) - columns.append(values if direction == "min" else -values) - return np.column_stack(columns) if len(frame) > 0 else np.empty((0, len(columns))) + return _costs_of(frame, criteria) def _get_violation( @@ -64,16 +62,13 @@ def _get_violation( from the columns of their statistics (infinite where a statistic is missing). """ - violation = np.zeros(len(frame)) - for requirement in requirements: - if requirement.name not in frame.columns: - raise ValueError( - f"no column of the statistic {requirement.name!r} of a requirement: " - + "aggregate the results with the criteria (see aggregate)" - ) - violation = violation + requirement.violation( - frame[requirement.name].to_numpy(dtype=float) + missing = [r.name for r in requirements if r.name not in frame.columns] + if missing: + raise ValueError( + f"no columns of the statistics {missing} of requirements: aggregate " + + "the results with the criteria (see aggregate)" ) + violation = _violation_of(frame, requirements, len(frame)) return np.where(np.isnan(violation), np.inf, violation) @@ -121,7 +116,7 @@ def pareto_front( for _, positions in _groups(summary, criteria.by): group = summary.iloc[positions] meets = _get_violation(group, criteria.requirements) == 0 - costs = _get_costs(group, criteria.objectives) + costs = _get_costs(group, criteria) efficient[positions] = _efficient(costs, meets, tolerances) return pd.Series(efficient, index=summary.index, name="pareto") @@ -158,7 +153,7 @@ def pareto_ranks( for _, positions in _groups(summary, criteria.by): group = summary.iloc[positions] violation = _get_violation(group, criteria.requirements) - costs = _get_costs(group, criteria.objectives) + costs = _get_costs(group, criteria) known = ~np.isnan(costs).any(axis=1) meets = (violation == 0) & known remaining, costs = positions[meets], costs[meets] @@ -255,7 +250,7 @@ def hypervolume( if len(summary) == 0: return 0.0 summary = summary[_get_violation(summary, criteria.requirements) == 0] - costs = _get_costs(summary, objectives) + costs = _get_costs(summary, criteria) costs = costs[np.all(costs < bound, axis=1)] return _hypervolume(costs, bound) @@ -403,11 +398,8 @@ def pareto_probability( frame[f"{name} se"] = _bootstrap_error( sums[name], squares[name], n_resamples ) - meets = violation == 0 frame["replicates"] = table.counts - frame["violation"] = violation - frame["meets_requirements"] = meets - frame["pareto"] = _efficient(_costs_of(values, criteria), meets, tolerances) + _judge(frame, values, violation, criteria) frame["pareto_probability"] = counts / n_resamples frame["requirements_probability"] = met / n_resamples frames.append(frame) diff --git a/src/tatc/tradespace/plotting.py b/src/tatc/tradespace/plotting.py index bf284850..df99ebd6 100644 --- a/src/tatc/tradespace/plotting.py +++ b/src/tatc/tradespace/plotting.py @@ -2,9 +2,14 @@ Plots of the results of trade studies (with matplotlib, an optional dependency, imported when a plot is drawn): designs by two metrics, with the efficient designs ringed and labeled; the progress of searches; the means -of metrics over replicates; and the probabilities that the metrics of -designs exceed those of others. Each plot draws on given axes (or new ones) -and returns them, for further labels and annotations. +of metrics over replicates; the probabilities that the metrics of designs +exceed those of others; and the shares of the variance of metrics that +factors explain. Each plot draws on given axes (or new ones, with a +constrained layout) and returns them, for further labels and annotations. +`use_style` gives the figures of a session (such as of a notebook) the +style of these plots: titles and legends of their sizes, frameless legends, +light grids behind the data, no top or right spines, and constrained +layouts. @author: Paul T. Grogan """ @@ -44,6 +49,39 @@ NEUTRAL = "#f0efec" """The color of the midpoint of diverging scales (such as of even odds).""" +STYLE = { + "axes.titlesize": 10, + "axes.labelcolor": INK, + "axes.axisbelow": True, + "axes.spines.top": False, + "axes.spines.right": False, + "axes.grid": True, + "axes.grid.axis": "y", + "grid.color": GRID, + "grid.linewidth": 0.8, + "legend.fontsize": 8, + "legend.frameon": False, + "figure.constrained_layout.use": True, +} +"""The matplotlib settings of `use_style`.""" + + +def use_style() -> None: + """ + Gives the figures of the session the style of the plots of trade studies + (see `STYLE`): titles of 10 points and legends of 8 without frames, light + grids (of the vertical axis) behind the data, no top or right spines, and + constrained layouts (which need no `tight_layout`). + """ + try: + # pylint: disable-next=import-outside-toplevel + import matplotlib as mpl + except ImportError as error: + raise ImportError( + "plots require matplotlib (pip install matplotlib)" + ) from error + mpl.rcParams.update(STYLE) + def _axes(ax: Any, size: tuple[float, float]) -> Any: """Gets the axes to draw on: those given, or those of a new figure.""" @@ -56,14 +94,14 @@ def _axes(ax: Any, size: tuple[float, float]) -> Any: raise ImportError( "plots require matplotlib (pip install matplotlib)" ) from error - _, ax = plt.subplots(figsize=size) + _, ax = plt.subplots(figsize=size, layout="constrained") return ax def style_axes(ax: Any, grid: str | None = "y") -> Any: """ - Styles axes plainly: a light grid behind the data, and no top or right - spines. + Styles axes plainly: a light grid behind the data (of the given axes + only), and no top or right spines. Args: ax (matplotlib.axes.Axes): The axes. @@ -73,8 +111,9 @@ def style_axes(ax: Any, grid: str | None = "y") -> Any: Returns: matplotlib.axes.Axes: the axes """ + ax.grid(False) if grid is not None: - ax.grid(axis=grid, color=GRID, lw=0.8) + ax.grid(True, axis=grid, color=GRID, lw=0.8) ax.set_axisbelow(True) for side in ("top", "right"): ax.spines[side].set_visible(False) @@ -107,13 +146,23 @@ def _name(names: Mapping[Any, str] | Callable[[Any], str] | None, value: Any) -> return names.get(value, str(value)) -def _groups(frame: pd.DataFrame, by: str) -> list: - """Gets the values of a column, sorted if they can be.""" - values = list(pd.unique(frame[by].dropna())) +def _groups(values: pd.Series) -> list: + """Gets the distinct values (of a column), sorted if they can be.""" + distinct = list(pd.unique(values.dropna())) try: - return sorted(values) + return sorted(distinct) except TypeError: - return values + return distinct + + +def _values_of(frame: pd.DataFrame, by: str | Sequence, name: str) -> pd.Series: + """Gets the values of a column of a frame, or values given for its rows.""" + if isinstance(by, str): + return frame[by] + values = pd.Series(np.asarray(by), index=frame.index) + if len(values) != len(frame): + raise ValueError(f"{name} needs a value for each row ({len(frame)})") + return values def plot_designs( @@ -121,7 +170,7 @@ def plot_designs( x: str, y: str, *, - by: str | None = None, + by: str | Sequence | None = None, front: str | Sequence[bool] | Criteria | Mapping[str, str] | None = None, labels: str | Callable[[pd.Series], str] | None = None, names: Mapping[Any, str] | Callable[[Any], str] | None = None, @@ -152,7 +201,9 @@ def plot_designs( frame (pandas.DataFrame): A row per design. x (str): The column of the horizontal axis. y (str): The column of the vertical axis. - by (str | None): A column whose values color the designs, or `None`. + by (str | Sequence | None): A column whose values color the designs, + values for the rows (such as of a column grouped, as + `summary.planes.clip(upper=3)`), or `None`. front (str | Sequence[bool] | Criteria | Mapping | None): The efficient designs: a boolean column (such as `"pareto"` of a summary of criteria) or values (one per row), criteria (see @@ -201,8 +252,9 @@ def plot_designs( label=label, ) else: - for k, value in enumerate(_groups(frame, by)): - selected = (frame[by] == value).to_numpy() & shown + groups = _values_of(frame, by, "by") + for k, value in enumerate(_groups(groups)): + selected = (groups == value).to_numpy() & shown ax.scatter( xs[selected], ys[selected], @@ -331,7 +383,7 @@ def plot_means( groups = ( [(None, results)] if by is None - else [(value, results[results[by] == value]) for value in _groups(results, by)] + else [(value, results[results[by] == value]) for value in _groups(results[by])] ) for k, (value, group) in enumerate(groups): stats = group.groupby(x)[y].agg(["mean", "std"]).sort_index() @@ -429,3 +481,105 @@ def plot_exceedance( legend.ax.tick_params(labelsize=8, length=0) legend.outline.set_visible(False) return ax + + +def plot_shares( + table: pd.DataFrame, + metrics: Sequence[str] | None = None, + *, + groups: str = "factors", + names: Mapping[Any, str] | Callable[[Any], str] | None = None, + labels: Mapping[Any, str] | Callable[[Any], str] | None = None, + horizontal: bool = False, + colors: Sequence[str] | Mapping[Any, str] = COLORS, + legend: str | None = "best", + ax: Any = None, +) -> Any: + """ + Plots the shares of the variance of metrics that factors explain (such + as those of `sensitivity`, by design variable, or of + `Attribution.summary`, by uncertain parameter) as grouped bars: a group + of bars for each factor (a row of the table), one bar for each metric + (a column), or a group for each metric (`groups="metrics"`), one bar for + each factor, with error bars of the standard errors of the shares + (` se`) where the table gives them. + + Args: + table (pandas.DataFrame): A row per factor and a column per metric + (and optionally their standard errors, ` se`). + metrics (Sequence[str] | None): The metrics, or `None` for every + numeric column but standard errors and `active`. + groups (str): `"factors"` for a group of bars for each factor, or + `"metrics"` for one for each metric. + names (Mapping | Callable | None): The names of the factors (by the + index of the table), by default their values. + labels (Mapping | Callable | None): The names of the metrics, by + default the metrics. + horizontal (bool): `True` for horizontal bars (the groups down the + vertical axis, the first at the top). + colors (Sequence[str] | Mapping): The colors of the bars of each + group, in order (or by metric or factor). + legend (str | None): The location of the legend, or `None` for none. + ax (matplotlib.axes.Axes | None): The axes, or `None` for a new figure. + + Returns: + matplotlib.axes.Axes: the axes + """ + # pylint: disable=too-many-locals + if groups not in ("factors", "metrics"): + raise ValueError(f"groups must be 'factors' or 'metrics', not {groups!r}") + if metrics is None: + metrics = [ + column + for column in table.columns + if not str(column).endswith(" se") + and column != "active" + and pd.api.types.is_numeric_dtype(table[column]) + ] + metrics = list(metrics) + factors = list(table.index) + values = table[metrics].to_numpy(dtype=float) + errors = np.column_stack( + [ + ( + table[f"{metric} se"].to_numpy(dtype=float) + if f"{metric} se" in table.columns + else np.full(len(table), np.nan) + ) + for metric in metrics + ] + ) + if groups == "metrics": + values, errors = values.T, errors.T + group_names = [_name(labels, metric) for metric in metrics] + bar_keys, bar_names = factors, [_name(names, factor) for factor in factors] + else: + group_names = [_name(names, factor) for factor in factors] + bar_keys, bar_names = metrics, [_name(labels, metric) for metric in metrics] + ax = _axes(ax, (7.5, 4) if horizontal else (8, 4)) + positions = np.arange(len(group_names)) + width = 0.8 / max(len(bar_keys), 1) + for k, (key, name) in enumerate(zip(bar_keys, bar_names)): + offset = positions + (k - (len(bar_keys) - 1) / 2) * width + error = None if np.all(np.isnan(errors[:, k])) else errors[:, k] + options = { + "color": _color(colors, key, k), + "edgecolor": "white", + "lw": 1, + "label": name, + "error_kw": {"ecolor": INK, "lw": 1}, + } + if horizontal: + ax.barh(offset, values[:, k], height=width, xerr=error, **options) + else: + ax.bar(offset, values[:, k], width=width, yerr=error, **options) + if horizontal: + ax.set_yticks(positions, group_names) + ax.invert_yaxis() + style_axes(ax, grid="x") + else: + ax.set_xticks(positions, group_names) + style_axes(ax, grid="y") + if legend is not None and len(bar_keys) > 1: + ax.legend(loc=legend, fontsize=8, frameon=False) + return ax diff --git a/src/tatc/tradespace/scenarios.py b/src/tatc/tradespace/scenarios.py index 3d3dd172..a938299e 100644 --- a/src/tatc/tradespace/scenarios.py +++ b/src/tatc/tradespace/scenarios.py @@ -14,7 +14,14 @@ import numpy as np import pandas as pd -from .criteria import Criteria, _as_criteria, _get_tolerances, _signs, aggregate +from .criteria import ( + Criteria, + _as_criteria, + _get_tolerances, + _signs, + _with_values, + aggregate, +) def _scales(criteria: Criteria, scale: Mapping[str, float] | None) -> np.ndarray: @@ -39,6 +46,16 @@ def _scales(criteria: Criteria, scale: Mapping[str, float] | None) -> np.ndarray return values +def _same_in_every(table: pd.DataFrame) -> bool: + """Whether every row of a table has the same value in each of its columns + that has one.""" + values = table.to_numpy(dtype=float) + reference = pd.DataFrame(values).bfill(axis=1).to_numpy()[:, :1] + with np.errstate(invalid="ignore"): + same = np.isclose(values, reference, rtol=1e-12, atol=0.0) | np.isnan(values) + return bool(same.all()) + + def robustness( results: pd.DataFrame, criteria: Criteria | Mapping[str, str], @@ -91,9 +108,11 @@ def robustness( Returns: pandas.DataFrame: a row per design (`design`): the values of the - design (as a summary keeps them, see `aggregate`), its - `pareto_trace`, `max_regret`, and regret in each scenario - (` regret`) + design (as a summary keeps them, see `aggregate`), each objective + in each scenario (` `, or `` if + it is the same in every scenario, such as a number of + satellites), its `pareto_trace`, `max_regret`, and regret in each + scenario (` regret`) Raises: ValueError: if the results have no scenarios, or the criteria group @@ -151,10 +170,16 @@ def robustness( "pareto", } values = [column for column in summary.columns if column not in judged_columns] - first = results.drop_duplicates("design").set_index("design") frame = pd.DataFrame({"design": designs}) - for column in values: - frame[column] = first.loc[designs, column].to_numpy() + _with_values(frame, results, designs, values) + for name in objectives: + table = summary.pivot(index="design", columns=scenario, values=name) + table = table.reindex(index=designs, columns=scenarios) + if _same_in_every(table): + frame[name] = table.bfill(axis=1).iloc[:, 0].to_numpy() + else: + for group in scenarios: + frame[f"{group} {name}"] = table[group].to_numpy() frame["pareto_trace"] = (trace / max(len(scenarios), 1)).to_numpy() frame["max_regret"] = regret.max(axis=1).to_numpy() for name in scenarios: diff --git a/src/tatc/tradespace/sensitivity.py b/src/tatc/tradespace/sensitivity.py index cc45e023..f245955d 100644 --- a/src/tatc/tradespace/sensitivity.py +++ b/src/tatc/tradespace/sensitivity.py @@ -13,7 +13,7 @@ import numpy as np import pandas as pd -from .criteria import _check_summary +from .criteria import _check_summary, _names def _levels(values: pd.Series, max_levels: int) -> pd.Series: @@ -27,7 +27,7 @@ def _levels(values: pd.Series, max_levels: int) -> pd.Series: def main_effects( - summary: pd.DataFrame, variable: str, metric: str, max_levels: int = 10 + summary: pd.DataFrame, variable: str, metric: str, *, max_levels: int = 10 ) -> pd.DataFrame: """ Computes the main effects of a design variable on a metric: the mean (and @@ -56,8 +56,9 @@ def main_effects( def sensitivity( summary: pd.DataFrame, - variables: Sequence[str], - metrics: Sequence[str], + variables: str | Sequence[str], + metrics: str | Sequence[str], + *, max_levels: int = 10, adjusted: bool = True, ) -> pd.DataFrame: @@ -90,8 +91,9 @@ def sensitivity( summary (pandas.DataFrame): The designs, a row each, with their values (see `Design.flat`) and metrics (such as a summary of a study, see `aggregate`, which keeps the values of the designs). - variables (Sequence[str]): The columns of the variables. - metrics (Sequence[str]): The columns of the metrics. + variables (str | Sequence[str]): The column (or columns) of the + variables. + metrics (str | Sequence[str]): The column (or columns) of the metrics. max_levels (int): The most levels of a numeric variable, beyond which its values are grouped in bins of equal counts. adjusted (bool): `True` for the adjusted shares, `False` for the @@ -103,6 +105,7 @@ def sensitivity( `active`, sorted by the share of the first metric """ _check_summary(summary) + variables, metrics = _names(variables), _names(metrics) rows = [] for variable in variables: row: dict = {"variable": variable} diff --git a/src/tatc/tradespace/simulation.py b/src/tatc/tradespace/simulation.py index 32582837..d6f2687e 100644 --- a/src/tatc/tradespace/simulation.py +++ b/src/tatc/tradespace/simulation.py @@ -54,6 +54,64 @@ class _Booking: order: int = 0 +class _Draws: + """ + The random numbers of the failures of a history: uniform numbers of each + draw (by its key), of a sampler of the histories of a replicate (such as + `_Sampler`) or from the seed of the history, from which the lives of + satellites and the failures of launches are drawn, stressed (with their + likelihood ratio) or not. + """ + + def __init__( + self, + seed: int | Sequence[int] | None, + uniforms: Callable[[tuple, int], np.ndarray] | None = None, + stress: float = 1.0, + launch_stress: float = 1.0, + ): + self.seed, self.stress, self.launch_stress = seed, stress, launch_stress + self.uniforms = self._from_seed if uniforms is None else uniforms + self.log_weight = 0.0 + + def _from_seed(self, key: tuple, dimensions: int) -> np.ndarray: + """The uniform numbers of a draw, from the seed and its key.""" + seed = list(self.seed) if isinstance(self.seed, Sequence) else [self.seed] + return np.random.default_rng([*seed, *key]).random(dimensions) + + @property + def weight(self) -> float: + """float: The likelihood ratio of the draws (1 without stress).""" + return math.exp(self.log_weight) + + def life(self, life: Any, key: tuple, remaining: float) -> float: + """ + Draws a life (years, infinite without a seed or a life), stressed + over the time remaining in the mission, if the draws are. + """ + if self.seed is None or life is None: + return math.inf + uniform = self.uniforms(key, life.dimensions) + if self.stress == 1.0: + return life.from_uniform(uniform) + value, log_ratio = life.stressed(uniform, self.stress, remaining) + self.log_weight += log_ratio + return value + + def launch_fails(self, probability: float, key: tuple) -> bool: + """Draws whether a launch fails (stressed, if the draws are).""" + if self.seed is None or probability == 0: + return False + uniform = self.uniforms(key, 1)[0] + if self.launch_stress == 1.0: + return bool(uniform < probability) + stressed = min(probability * self.launch_stress, 0.5) + failed = bool(uniform < stressed) + ratio = probability / stressed if failed else (1 - probability) / (1 - stressed) + self.log_weight += math.log(ratio) + return failed + + class _Simulation: """ A discrete-event simulation of a mission (see `Deployment.simulate`). @@ -72,9 +130,7 @@ def __init__( launch_stress: float = 1.0, ): self.deployment, self.failures, self.policy = deployment, failures, policy - self.seed, self.uniforms = seed, uniforms - self.stress, self.launch_stress = stress, launch_stress - self.log_weight = 0.0 + self.draws = _Draws(seed, uniforms, stress, launch_stress) self.schedule = deployment.schedule self.end = deployment.end self.history = MissionHistory( @@ -108,48 +164,15 @@ def __init__( # --- randomness - def _rng(self, *key: int) -> np.random.Generator: - seed = list(self.seed) if isinstance(self.seed, Sequence) else [self.seed] - return np.random.default_rng([*seed, *key]) - def _life( self, plane: int, position: int, generation: int, start: float = 0.0 ) -> float: - if self.seed is None: - return math.inf - life = self.failures.life_of(self.deployment.planes[plane][0]) - if life is None: - return math.inf + life = self.failures.life_of(self.deployment.planes[plane].kind) key = (0, plane, position, generation) - if self.stress != 1.0: - uniform = ( - self.uniforms(key, life.dimensions) - if self.uniforms is not None - else self._rng(*key).random(life.dimensions) - ) - value, log_ratio = life.stressed(uniform, self.stress, self.end - start) - self.log_weight += log_ratio - return value - if self.uniforms is not None: - return life.from_uniform(self.uniforms(key, life.dimensions)) - return life.sample(self._rng(*key)) + return self.draws.life(life, key, self.end - start) def _launch_fails(self, *key: int) -> bool: - if self.seed is None or self.failures.launch == 0: - return False - uniform = ( - self.uniforms((1, *key), 1)[0] - if self.uniforms is not None - else self._rng(1, *key).random() - ) - p = self.failures.launch - if self.launch_stress == 1.0: - return bool(uniform < p) - stressed = min(p * self.launch_stress, 0.5) - failed = bool(uniform < stressed) - ratio = p / stressed if failed else (1 - p) / (1 - stressed) - self.log_weight += math.log(ratio) - return failed + return self.draws.launch_fails(self.failures.launch, (1, *key)) # --- events @@ -162,12 +185,7 @@ def run(self) -> MissionHistory: for kind in self.deployment.development: count = self.policy.ground_spares_of(kind) if count > 0: - begin = self.line[kind] - ready = begin + self.schedule.production_years(kind, count) - self.history.production.append( - Production(kind, begin, ready, count, "spare") - ) - self.line[kind] = ready + ready = self._produce(self.line[kind], kind, count, "spare") self.ground.setdefault(kind, 0) self._push(ready, "stock", kind, count) for launch in self.deployment.launches: @@ -190,7 +208,7 @@ def run(self) -> MissionHistory: for plane, since in self.spares_since.items(): if self.spares[plane] > 0: self.history.parked.append((since, self.end, self.spares[plane])) - self.history.weight = math.exp(self.log_weight) + self.history.weight = self.draws.weight self.history.stages = [ self.decided.get(index) for index in range(len(self.deployment.stages)) ] @@ -205,7 +223,7 @@ def _on_stock(self, time: float, kind: Any, count: int) -> None: def _on_planned(self, time: float, launch: Launch) -> None: failed = self._launch_fails(0, launch.plane, launch.first, launch.generation) self.history.launches.append(replace(launch, failed=failed)) - built = self.deployment.planes[launch.plane][1] + built = self.deployment.planes[launch.plane].satellites positions = range(launch.first, launch.first + launch.satellites) for position in positions: if position >= built: @@ -223,7 +241,7 @@ def _on_planned(self, time: float, launch: Launch) -> None: self._up(time, launch.plane, position) spares = sum(position >= built for position in positions) if spares and not failed: - level = self.deployment.planes[launch.plane][2] + level = self.deployment.planes[launch.plane].spares if launch.purpose == "deployment": self._park(time, launch.plane, spares) else: @@ -279,23 +297,29 @@ def _on_request(self, time: float, plane: int, position: int) -> None: if slot.up is not None: # restored by a planned replacement slot.pending = False return - kind = self.deployment.planes[plane][0] + kind = self.deployment.planes[plane].kind if self.spares[plane] > 0: self._park(time, plane, -1) self._push( time + self.policy.drift_years, "activate", plane, position, "orbit" ) if self.policy.replenish: - ready = self._produce(time, kind, 1, "spare") + ready = self._produce( + time + self.policy.procurement_years, kind, 1, "spare" + ) self._book(plane, kind, ready, ("spare",)) elif self.ground.get(kind, 0) > 0: self.ground[kind] -= 1 self._book(plane, kind, time, ("slot", position, "ground")) if self.policy.replenish: - ready = self._produce(time, kind, 1, "spare") + ready = self._produce( + time + self.policy.procurement_years, kind, 1, "spare" + ) self._push(ready, "stock", kind, 1) else: - ready = self._produce(time, kind, 1, "restoration") + ready = self._produce( + time + self.policy.procurement_years, kind, 1, "restoration" + ) self._book(plane, kind, ready, ("slot", position, "production")) def _on_activate(self, time: float, plane: int, position: int, source: str) -> None: @@ -391,10 +415,7 @@ def _deploy(self, time: float, stage: Any) -> None: count = size + spares if count == 0: continue - begin = max(self.line[kind], time + stage.lead_years) - ready = begin + self.schedule.production_years(kind, count) - self.line[kind] = ready - self.history.production.append(Production(kind, begin, ready, count)) + ready = self._produce(time + stage.lead_years, kind, count) position = 0 for carried in self.schedule.split( count, self.deployment.masses.get(kind), self._plane(plane) @@ -412,22 +433,22 @@ def _deploy(self, time: float, stage: Any) -> None: self._push(replacement.time, "planned", replacement) position += carried - def _produce(self, time: float, kind: Any, count: int, purpose: str) -> float: - begin = max(self.line[kind], time + self.policy.procurement_years) + def _produce( + self, earliest: float, kind: Any, count: int, purpose: str = "deployment" + ) -> float: + """ + Produces satellites on their type's line, from a time (after the work + before them), returning when they are ready. + """ + begin = max(self.line[kind], earliest) ready = begin + self.schedule.production_years(kind, count) self.line[kind] = ready self.history.production.append(Production(kind, begin, ready, count, purpose)) return ready def _slot(self, ready: float) -> float: - """The earliest launch at or after a time, at the launch cadence.""" - interval = self.schedule.launch_interval - time = ready - if interval > 0: - for booked in self.booked: - if booked - interval < time < booked + interval: - time = booked + interval - return time + """The earliest launch at or after a time (see `next_slot`).""" + return self.schedule.next_slot(self.booked, ready) def _plane(self, plane: int) -> tuple[int, Any]: """The index and values of a plane (see `DeploymentSchedule`).""" diff --git a/src/tatc/tradespace/space.py b/src/tatc/tradespace/space.py index 885e7e64..9707155a 100644 --- a/src/tatc/tradespace/space.py +++ b/src/tatc/tradespace/space.py @@ -104,7 +104,9 @@ class _Context: `None` for nominal values), `fix(path, node)` gives a fixed value (or `None` for its value), and `check` enables constraints. If given, `record(path, domain, value)` is called with every decision, chosen or - prescribed. With an `odometer` (of an enumeration), the items of + prescribed, and `normalize(path, domain, value)` gives the value of the + domain that a prescribed decision is (such as its level, see + `_level_of`). With an `odometer` (of an enumeration), the items of unordered repetitions are only walked in the order of their levels. """ @@ -116,17 +118,22 @@ def __init__( record: Callable[[str, _Domain, Any], None] | None = None, odometer: _Odometer | None = None, fix: Callable[[str, Fixed], Any] | None = None, + normalize: Callable[[str, _Domain, Any], Any] | None = None, ): + # pylint: disable=too-many-arguments,too-many-positional-arguments self.choose, self.draw, self.check = choose, draw, check - self.fix = fix + self.fix, self.normalize = fix, normalize self.record, self.odometer = record, odometer def decide(self, path: str, domain: _Domain, prescribed: Any) -> Any: """ - Decides a value of a domain: the prescribed value, or a chosen one. + Decides a value of a domain: the prescribed value (normalized, if + the walk normalizes them), or a chosen one. """ if prescribed is _ABSENT: value = _plain(_choose(self, path, domain)) + elif self.normalize is not None: + value = self.normalize(path, domain, prescribed) else: value = prescribed if self.record is not None: @@ -172,7 +179,7 @@ def _walk( callables of later nodes within it. """ if isinstance(node, Variable): - if prescribed is not _ABSENT and ctx.record is None: + if prescribed is not _ABSENT and ctx.record is None and ctx.normalize is None: return prescribed, prescribed value = ctx.decide(path, node.domain(scope), prescribed) return value, value @@ -356,6 +363,10 @@ def _walk_repeat( count = int(node.count) if count < 0: raise Infeasible(f"the count of {path} is negative ({count})") + if prescribed is not _ABSENT and len(prescribed) != count: + raise ValueError( + f"{len(prescribed)} items are given for {path}, whose count is {count}" + ) result, decisions = _walk_items(node, path, scope, ctx, count, prescribed, publish) if not node.ordered: canonical = sorted(decisions, key=_decision_key) @@ -370,8 +381,9 @@ def _flatten(node: Node, value: Any, path: str, out: dict) -> None: """ Flattens the values of a node into `out`, by path: the chosen branch of a choice at its path (and its values under the branch's name), the count - of a repetition at `.count` (and its items at `[k]`), and the - other values (except fixed values) at their paths. + of a repetition at `.count` (also of a fixed count) and its items + at `[k]`, and the other values (except fixed values) at their + paths. """ if isinstance(node, Fixed): return @@ -434,6 +446,11 @@ def __getattr__(self, name: str) -> Any: def __getitem__(self, name: str) -> Any: return self.values[name] + def __contains__(self, name: object) -> bool: + return name in self.values + + __iter__ = None # type: ignore[assignment] + def __eq__(self, other: object) -> bool: return ( isinstance(other, Design) @@ -689,9 +706,7 @@ def design( merged[name] = ( decision.decisions if isinstance(decision, Design) else decision ) - values, merged = _walk( - self, "", Scope(), _Context(record=_check_domain), merged - ) + values, merged = _walk(self, "", Scope(), _Context(normalize=_level_of), merged) return Design(self, merged, values) def extend( @@ -721,25 +736,29 @@ def extend( def designs_of( self, frame: pd.DataFrame, keys: Iterable[str] | None = None - ) -> list[Design]: + ) -> pd.Series: """ Rebuilds designs from the rows of a data frame of their values by path (see `Design.flat`): the results of a study (see `Study.run`), or a - summary that keeps the values of the designs (see `aggregate`). Each - design is rebuilt once, from its first row, in the order of its first - row (or of `keys`), and must have the key of its row (`design`, a - column or the name of the index), if the frame has one:: + summary that keeps the values of the designs (see `aggregate`). The + designs are those of the rows, aligned with them (with the frame's + index), so that functions of designs map over the rows, or those of + `keys` (indexed by them). Each design is rebuilt once, from the first + row of its key (`design`, a column or the name of the index), whose + key it must have, if the frame has keys:: - front = summary[pareto_front(summary, criteria)] - designs = space.designs_of(front) + summary["description"] = space.designs_of(summary).map(describe) + front = space.designs_of(summary[summary.pareto]) + confirmation = confirm(study, criteria, results, front) Args: frame (pandas.DataFrame): The rows. keys (Iterable[str] | None): The keys of the designs to rebuild, - or `None` for every design of the frame. + or `None` for the design of each row of the frame. Returns: - list[Design]: the designs + pandas.Series: the designs, by row (with the frame's index) or by + key (of `keys`, each once) Raises: KeyError: if the frame has no rows of a key. @@ -749,28 +768,36 @@ def designs_of( rows = frame if "design" not in rows.columns and rows.index.name == "design": rows = rows.reset_index() - if "design" in rows.columns: - first = rows.drop_duplicates("design") - records = dict(zip(first["design"], first.to_dict("records"))) - order = list(records) if keys is None else list(dict.fromkeys(keys)) - missing = [key for key in order if key not in records] - if missing: - raise KeyError(f"no rows of designs {missing[:5]}") - pairs = [(key, records[key]) for key in order] - else: + if "design" not in rows.columns: if keys is not None: raise ValueError("the frame has no keys of designs (`design`)") - pairs = [(None, record) for record in rows.to_dict("records")] - designs: dict[str, Design] = {} - for key, record in pairs: - design = self._design(_Context(choose=partial(_decided, record))) - if key is not None and design.key != key: - raise ValueError( - f"the values of design {key} give another design ({design.key}): " - + "are they of another design space?" - ) - designs.setdefault(design.key, design) - return list(designs.values()) + designs = [self._rebuilt(record) for record in rows.to_dict("records")] + return pd.Series(designs, index=frame.index, name="design", dtype=object) + first = rows.drop_duplicates("design") + records = dict(zip(first["design"], first.to_dict("records"))) + wanted = list(rows["design"]) if keys is None else list(dict.fromkeys(keys)) + missing = [key for key in dict.fromkeys(wanted) if key not in records] + if missing: + raise KeyError(f"no rows of designs {missing[:5]}") + rebuilt = { + key: self._rebuilt(records[key], key) for key in dict.fromkeys(wanted) + } + designs = [rebuilt[key] for key in wanted] + index = frame.index if keys is None else pd.Index(wanted, name="design") + return pd.Series(designs, index=index, name="design", dtype=object) + + def _rebuilt(self, record: Mapping[str, Any], key: str | None = None) -> Design: + """ + Rebuilds a design from its values by path (see `designs_of`), which + must give its key, if given. + """ + design = self._design(_Context(choose=partial(_decided, record))) + if key is not None and design.key != key: + raise ValueError( + f"the values of design {key} give another design ({design.key}): " + + "are they of another design space?" + ) + return design def enumerate(self) -> list[Design]: """ @@ -1018,26 +1045,44 @@ def _largest_count(count: Any, path: str) -> int: raise ValueError(f"the count of {path} needs a fixed upper bound to be encoded") -def _check_domain(path: str, domain: _Domain, value: Any) -> None: +def _is_number(value: Any) -> bool: + """Whether a value is a number (not a boolean).""" + return isinstance(value, (int, float, np.number)) and not isinstance( + value, (bool, np.bool_) + ) + + +def _level_of(path: str, domain: _Domain, value: Any) -> Any: """ - Checks that a decision is a value of its domain (see `DesignSpace.design`), - raising a `ValueError` if not. + Gets the value of a domain that a decision is (see `DesignSpace.design` + and `DesignSpace.designs_of`): the level that equals it (whose type a + data frame may have changed, as integers in a column of floats, or that + is given as a numpy scalar), or the value (a float) in the range of a + continuous domain, raising a `ValueError` if there is none. """ - if domain.levels is not None: + if domain.levels is None: try: - if value in domain.levels: - return + number = float(value) except (TypeError, ValueError): - pass - raise ValueError(f"{value!r} is not a level of {path} ({domain.levels})") - try: - if domain.low <= float(value) <= domain.high: - return - except (TypeError, ValueError): - pass - raise ValueError( - f"{value!r} is not in the range of {path} ({domain.low}, {domain.high})" - ) + number = math.nan + if domain.low <= number <= domain.high: + return number + raise ValueError( + f"{value!r} is not in the range of {path} ({domain.low}, {domain.high})" + ) + for level in domain.levels: + try: + if level == value: + return _plain(level) + except (TypeError, ValueError): + continue + if _is_number(value): + for level in domain.levels: + if _is_number(level) and math.isclose( + float(level), float(value), rel_tol=1e-9, abs_tol=1e-12 + ): + return _plain(level) + raise ValueError(f"{value!r} is not a level of {path} ({domain.levels})") def _leaf_paths(node: Node, path: str, kind: type) -> list[str]: @@ -1083,24 +1128,7 @@ def _decided(values: Mapping[str, Any], path: str, domain: _Domain) -> Any: f"no value of {path}: rebuild designs from the results of a study, or " + "from a summary that keeps the values of designs (see aggregate)" ) - if domain.levels is None: - return float(value) - for level in domain.levels: - try: - if level == value: - return level - except (TypeError, ValueError): - continue - numeric = [ - level - for level in domain.levels - if isinstance(level, (int, float, np.number)) and not isinstance(level, bool) - ] - if isinstance(value, (int, float, np.number)): - for level in numeric: - if math.isclose(float(level), float(value), rel_tol=1e-9, abs_tol=1e-12): - return level - raise ValueError(f"{value!r} is not a level of {path} ({domain.levels})") + return _level_of(path, domain, value) def _design_items(designs: Iterable[Design | str] | pd.DataFrame) -> list[Design | str]: @@ -1206,7 +1234,7 @@ def _scenario_of(design: Design) -> str: Gets the description of the values of the scenario of a realized design (see `Design.realize`), `""` without one. """ - return getattr(design, "_scenario", "") + return design._scenario # pylint: disable=protected-access def _check_uncertain(space: DesignSpace, paths: Iterable[str]) -> None: diff --git a/src/tatc/tradespace/study.py b/src/tatc/tradespace/study.py index e5bad9ef..a7fda149 100644 --- a/src/tatc/tradespace/study.py +++ b/src/tatc/tradespace/study.py @@ -232,23 +232,19 @@ def _evaluate( self, design: Design, replicate: int, - shift: Mapping[str, int] | None = None, - case: _Case | None = None, + shift: Mapping[str, int] | None, + case: _Case, ) -> list[dict]: """ Evaluates a replicate of a design (with parameters drawn as in other - replicates, if shifted, and in a scenario, if any), returning its - records. + replicates, if shifted) in a case (a scenario, or none), returning + its records. """ realized = design.realize( - replicate, - self.seed, - self.common_random_numbers, - shift, - None if case is None else case.values, + replicate, self.seed, self.common_random_numbers, shift, case.values ) base: dict = {"design": design.key, "replicate": replicate} - if case is not None and case.name is not None: + if case.name is not None: base["scenario"] = case.name base.update(realized.flat()) began = time.perf_counter() @@ -297,18 +293,18 @@ def _evaluate_and_store( design: Design, replicate: int, context: str, - shift: Mapping[str, int] | None = None, - case: _Case | None = None, + shift: Mapping[str, int] | None, + case: _Case, ) -> list[dict]: """ - Evaluates a replicate of a design (shifted, if given, and in a - scenario, if any), adding its records to the store (if any, and if - they are stored, see `_UNSTORED`) in a context. + Evaluates a replicate of a design (shifted, if given) in a case, + adding its records to the store (if any, and if they are stored, see + `_UNSTORED`) in a context, as the variant of the case. """ records = self._evaluate(design, replicate, shift, case) if self.store is not None and not _unstored(records): - variant = _variant_of(shift) if case is None else case.variant - if case is not None and case.name is not None: + variant = case.variant + if case.name is not None: # the evaluations of a scenario are stored by its values, not # its name (which the results give, see `_in_scenario`) kept = [ @@ -321,19 +317,20 @@ def _evaluate_and_store( def _run_chunk( self, - tasks: list[tuple[int, Design, int, int]], + tasks: list[_Task], context: str, shift: Mapping[str, int] | None, cases: Sequence[_Case], ) -> list[list[dict]]: """ - Evaluates a chunk of tasks (index, design, replicate, and case) in - turn (shifted, if given), adding each to the store (if any) in a - context. + Evaluates a chunk of tasks in turn (shifted, if given), adding each + to the store (if any) in a context. """ return [ - self._evaluate_and_store(design, replicate, context, shift, cases[case]) - for _, design, replicate, case in tasks + self._evaluate_and_store( + task.design, task.replicate, context, shift, cases[task.case] + ) + for task in tasks ] def _cases(self, shift: Mapping[str, int]) -> list[_Case]: @@ -560,7 +557,7 @@ def run( # tasks in the order of replicates (and scenarios), whose designs share # uncertain values tasks = [ - (i, design, replicate, case) + _Task(i, design, replicate, case) for replicate in ( range(self.replicates) if replicate_indices is None @@ -572,9 +569,9 @@ def run( context, results, tasks = self._stored(tasks, cases) if tasks: first = tasks[0] - self._prepare(first[1], first[2], shift, cases[first[3]]) + self._prepare(first.design, first.replicate, shift, cases[first.case]) results.extend(self._execute(tasks, context, shift, cases, progress)) - results.sort(key=lambda result: result[:3]) + results.sort(key=lambda outcome: outcome[:3]) frame = pd.DataFrame.from_records( [ _in_scenario(record, cases[case].name) @@ -609,7 +606,7 @@ def _stored( _warn_other_definitions(self.store, context, definition) self.store.define(context, definition) outcomes = [ - (i, case, replicate, stored[design.key, replicate, case]) + _Outcome(i, case, replicate, stored[design.key, replicate, case]) for i, design, replicate, case in tasks if (design.key, replicate, case) in stored ] @@ -636,7 +633,7 @@ def _execute( records = self._evaluate_and_store( design, replicate, context, shift, cases[case] ) - outcomes.append((i, case, replicate, records)) + outcomes.append(_Outcome(i, case, replicate, records)) if progress is not None: progress(done, total) return outcomes @@ -655,7 +652,7 @@ def _execute( for future in as_completed(futures): chunk = futures[future] for (i, _, replicate, case), records in zip(chunk, future.result()): - outcomes.append((i, case, replicate, records)) + outcomes.append(_Outcome(i, case, replicate, records)) done += len(chunk) if progress is not None: progress(done, total) @@ -669,13 +666,30 @@ def _execute( return outcomes -_Task = tuple # (index of the design, design, replicate, index of the case) -"""A task of a run: the index of a design, the design, the replicate, and -the index of the case (scenario) in which to evaluate it.""" +class _Task(NamedTuple): + """ + A task of a run: the position of a design (in the designs of the run), + the design, the replicate, and the position of the case (scenario) in + which to evaluate it. + """ + + position: int + design: Design + replicate: int + case: int + + +class _Outcome(NamedTuple): + """ + The outcome of a task: the position of its design, the position of its + case, its replicate, and the records of its evaluation, in the order in + which the results of a run are sorted. + """ -_Outcome = tuple # (index of the design, index of the case, replicate, records) -"""The outcome of a task: the index of the design, the index of the case, the -replicate, and the records of the evaluation.""" + position: int + case: int + replicate: int + records: list[dict] def _in_scenario(record: dict, name: str | None) -> dict: diff --git a/src/tatc/tradespace/values.py b/src/tatc/tradespace/values.py index 08d036e2..5c7037bc 100644 --- a/src/tatc/tradespace/values.py +++ b/src/tatc/tradespace/values.py @@ -217,6 +217,11 @@ def __eq__(self, other: object) -> bool: def __hash__(self) -> int: return hash(self.choice) + __iter__ = None # type: ignore[assignment] + + def __str__(self) -> str: + return self.choice + def __repr__(self) -> str: return f"ChoiceValues({self.choice!r}, {self.value!r})" @@ -238,8 +243,10 @@ def count(self) -> int: def __getitem__(self, index: int | slice) -> Any: if isinstance(index, slice): return [self[k] for k in range(len(self))[index]] - if index < 0: - index += len(self) + position = index + len(self) if index < 0 else index + if not 0 <= position < len(self): + raise IndexError(f"the repetition has {len(self)} items, not item {index}") + index = position item = self._value.items[index] return Values(item, index) if isinstance(item, dict) else _view(item) @@ -288,6 +295,32 @@ def __getattr__(self, name: str) -> Any: return index raise AttributeError(f"{name!r} is not decided before it is used") + def get(self, name: str, default: Any = None) -> Any: + """ + Gets a value by its name, or by a path within it (see `__getitem__`), + if it is decided. + + Args: + name (str): The name or path. + default (Any): The value if it is not decided. + + Returns: + Any: the value + """ + try: + return self[name] + except KeyError: + return default + + def __contains__(self, name: object) -> bool: + if not isinstance(name, str): + return False + try: + self[name] + except KeyError: + return False + return True + def __getitem__(self, name: str) -> Any: """ Gets a value by its name, or by a path within it (see `Values`), such diff --git a/tests/tradespace/test_cache.py b/tests/tradespace/test_cache.py index 7f416156..dad1bc68 100644 --- a/tests/tradespace/test_cache.py +++ b/tests/tradespace/test_cache.py @@ -119,9 +119,10 @@ def test_disk_cache_of_other_functions(self): def make(rows): # the same function, edited to give other rows namespace = {"pd": pd} + names = ", ".join(["satellite.name"] * rows) exec( # pylint: disable=exec-used "def analysis(satellite):\n" - + f" return pd.DataFrame({{'satellite': [satellite.name] * {rows}}})", + + f" return pd.DataFrame({{'satellite': [{names}]}})", namespace, ) return SatelliteCache(namespace["analysis"], directory, namespace="x") diff --git a/tests/tradespace/test_criteria.py b/tests/tradespace/test_criteria.py index fc7e2fbb..760d6dcf 100644 --- a/tests/tradespace/test_criteria.py +++ b/tests/tradespace/test_criteria.py @@ -416,3 +416,43 @@ def test_statistics_of_names(self): """Statistics given by names are the means of the metrics.""" summary = aggregate(_results(), {"value": "max"}, statistics=["cost"]) self.assertEqual(list(summary.cost), [2.0, 2.0, 1.0]) + + +class TestNames(unittest.TestCase): + """ + Unit tests for the conventional names of statistics and requirements. + """ + + def test_names(self): + """Statistics are named by convention, and given without names.""" + self.assertEqual(Mean("cost").name, "cost") + self.assertEqual(StandardDeviation("cost").name, "cost std") + self.assertEqual(StandardError("cost").name, "cost se") + self.assertEqual(Minimum("cost").name, "cost min") + self.assertEqual(Maximum("cost").name, "cost max") + self.assertEqual(Quantile("cost", 0.7).name, "cost p70") + self.assertEqual(Probability("cost", "<=", 150).name, "P(cost <= 150)") + criteria = Criteria( + {"value p25": "max"}, statistics=[Quantile("value", 0.25), "cost"] + ) + self.assertEqual(criteria.names, ["value p25", "cost"]) + self.assertEqual( + list(aggregate(_results(), statistics=[Quantile("value", 0.25)]).columns)[ + -2: + ], + ["value p25", "replicates"], + ) + + def test_requirements(self): + """Requirements tell which values meet them, and state themselves.""" + requirement = Requirement("cost", "<=", 1.5) + np.testing.assert_array_equal( + requirement.met([1.0, 2.0, np.nan]), [True, False, False] + ) + self.assertEqual(str(requirement), "cost <= 1.5") + + def test_summarize_statistics(self): + """Summaries take other statistics, with the spread of their means.""" + summary = summarize(_results(), {"value": "max"}, statistics=["cost"]) + for column in ("value", "value se", "cost", "cost std", "cost se", "pareto"): + self.assertIn(column, summary.columns) diff --git a/tests/tradespace/test_failures.py b/tests/tradespace/test_failures.py index d3f0c03a..51560387 100644 --- a/tests/tradespace/test_failures.py +++ b/tests/tradespace/test_failures.py @@ -42,7 +42,12 @@ expected_missions, summarize_missions, ) -from tatc.tradespace.mission import PhaseCache, evaluate_phases, summarize_phases +from tatc.tradespace.mission import ( + Capability, + PhaseCache, + evaluate_phases, + summarize_phases, +) from tatc.tradespace.values import configure @@ -71,7 +76,7 @@ def cumulative_hazard(self, age): def hazard(self, age): return np.zeros_like(np.asarray(age, dtype=float)) - def sample(self, rng): + def from_uniform(self, uniform): return self.years @@ -562,14 +567,10 @@ def test_evaluate_and_summarize(self): model = CostModel( SatelliteCost(development=10, first_unit=5), launch=LaunchCost(per_launch=3) ) - missions = evaluate_missions( - histories, - self.satellites, - self.observations, - PhaseCache(self._metric), - context="r0", - cost_model=model, + capability = Capability( + self.satellites, self.observations, PhaseCache(self._metric), "r0" ) + missions = evaluate_missions(histories, capability, cost_model=model) self.assertEqual(len(missions), 30) for column in ( "share mission", @@ -598,7 +599,7 @@ def test_evaluate_and_summarize(self): ) # without a cache, the same evaluations direct = evaluate_missions( - histories, self.satellites, self.observations, self._metric + histories, Capability(self.satellites, self.observations, self._metric) ) np.testing.assert_allclose(direct["share mission"], missions["share mission"]) @@ -754,7 +755,7 @@ def test_recommendation(self): variance = result["between"] ** 2 + result["within"] ** 2 / result["histories"] self.assertEqual(result["replicates"], math.ceil(variance / 0.25)) self.assertAlmostEqual( - result["cost"], result["replicates"] * result["replicate cost"] + result["seconds"], result["replicates"] * result["replicate seconds"] ) # costlier histories call for fewer of them fewer = allocate_histories(records, "share", 20, 100, 10) @@ -816,19 +817,14 @@ def _metric(observations): def _compare(self, schedule, failures): deployment = schedule.plan(self.layout) - exact = expected_missions( - deployment, - failures, - self.satellites, - self.observations, - PhaseCache(self._metric), + capability = Capability( + self.satellites, self.observations, PhaseCache(self._metric) ) + exact = expected_missions(deployment, failures, capability) histories = deployment.simulate_many( failures, RestorationPolicy(restore=False), 3, 4000 ) - missions = evaluate_missions( - histories, self.satellites, self.observations, PhaseCache(self._metric) - ) + missions = evaluate_missions(histories, capability) error = missions["score mission"].std() / np.sqrt(len(missions)) self.assertAlmostEqual( exact["score mission"], missions["score mission"].mean(), delta=4 * error @@ -861,9 +857,8 @@ def test_without_failures(self): deployment = DeploymentSchedule( years=4, development_years=1, production_rate=2 ).plan(self.layout) - exact = expected_missions( - deployment, FailureModel(), self.satellites, self.observations, self._metric - ) + capability = Capability(self.satellites, self.observations, self._metric) + exact = expected_missions(deployment, FailureModel(), capability) phases = deployment.phases(self.satellites) planned = summarize_phases( evaluate_phases(phases, self.observations, self._metric) @@ -873,13 +868,7 @@ def test_without_failures(self): ) self.assertEqual(exact["availability"], 1.0) # every launch fails: nothing operates - lost = expected_missions( - deployment, - FailureModel(launch=1.0), - self.satellites, - self.observations, - self._metric, - ) + lost = expected_missions(deployment, FailureModel(launch=1.0), capability) self.assertEqual(lost["availability"], 0.0) self.assertEqual(lost["score mission"], 0.0) @@ -891,18 +880,14 @@ def test_limits(self): expected_missions( deployment, failures, - self.satellites, - self.observations, - self._metric, + Capability(self.satellites, self.observations, self._metric), max_sets=3, ) with self.assertRaises(ValueError): expected_missions( deployment, failures, - self.satellites[:3], - self.observations, - self._metric, + Capability(self.satellites[:3], self.observations, self._metric), ) diff --git a/tests/tradespace/test_fingerprint.py b/tests/tradespace/test_fingerprint.py index 7bdaadd2..cddbdf1a 100644 --- a/tests/tradespace/test_fingerprint.py +++ b/tests/tradespace/test_fingerprint.py @@ -11,6 +11,7 @@ import subprocess import sys import unittest +from types import SimpleNamespace from unittest import mock from datetime import datetime, timedelta, timezone from functools import partial @@ -55,8 +56,8 @@ def _uses_helper(d): TABLE = pd.DataFrame({"a": [1.0]}) -class _Opaque: - """An object described by its type only.""" +class _Own: + """An object of a class of the study's own, described by its attributes.""" def __init__(self, value): self.value = value @@ -185,7 +186,13 @@ def test_values(self): ) self.assertNotEqual(get_fingerprint(points), get_fingerprint(moved)) # other objects are described by their type only - self.assertEqual(get_fingerprint(_Opaque(1)), get_fingerprint(_Opaque(2))) + # objects of installed classes by their type, and of the study's own + # classes by their attributes (other than mutable containers) + self.assertEqual( + get_fingerprint(SimpleNamespace(value=1)), + get_fingerprint(SimpleNamespace(value=2)), + ) + self.assertNotEqual(get_fingerprint(_Own(1)), get_fingerprint(_Own(2))) def test_attributes_are_not_globals(self): """Attributes named as globals do not refer to the globals.""" @@ -418,3 +425,38 @@ def test_own_modules(self): finally: sys.path.remove(directory) sys.modules.pop("tatc_own_helpers", None) + + +class TestOwnClasses(unittest.TestCase): + """ + Unit tests for the descriptions of the classes and objects of a study's + own code. + """ + + def test_objects(self): + """Callable objects of the study's own classes are described by their + attributes and the code of their classes' methods.""" + + def classes(body): + namespace = {"__name__": "__main__"} + exec( # pylint: disable=exec-used + "class Score:\n" + " def __init__(self, k):\n" + " self.k = k\n" + " self.calls = []\n" + " def __call__(self, d):\n" + f" return {body}\n", + namespace, + ) + return namespace["Score"] + + score = classes("{'v': d.a * self.k}") + self.assertNotEqual(get_fingerprint(f=score(1)), get_fingerprint(f=score(3))) + self.assertEqual(get_fingerprint(f=score(1)), get_fingerprint(f=score(1))) + # mutable attributes (such as records of calls) are state, not described + counted = score(1) + counted.calls.append(1) + self.assertEqual(get_fingerprint(f=counted), get_fingerprint(f=score(1))) + # the code of the methods of the class + edited = classes("{'v': d.a + self.k}") + self.assertNotEqual(get_fingerprint(f=score(1)), get_fingerprint(f=edited(1))) diff --git a/tests/tradespace/test_observations.py b/tests/tradespace/test_observations.py index 23a3c331..d495b986 100644 --- a/tests/tradespace/test_observations.py +++ b/tests/tradespace/test_observations.py @@ -268,8 +268,7 @@ def test_phases_and_failures(self): _build, _observations(), _metrics, - layout="layout", - plan=PLAN, + plan=dataclasses.replace(PLAN, policy="policy"), failures=Failures(FAILURES, histories=4, seed="failure_seed"), ).run(trade.enumerate()[:4]) self.assertTrue(restored.feasible.all()) @@ -544,12 +543,18 @@ def test_replace(self): study.replace(evaluate=_metrics) def test_invalid(self): - """Failures and phases need a plan, and a plan needs a layout.""" + """Failures and phases need a plan, and a plan needs a layout (by + default, the value `layout` of the design space).""" observations = _observations() with self.assertRaises(ValueError): ObservationStudy(SPACE, _build, observations, _metrics, phases=True) + study = ObservationStudy(SPACE, _build, observations, _metrics, plan=PLAN) + self.assertEqual(study.layout, "layout") + shells = DesignSpace( + altitude=SPACE.children["altitude"], shell=SPACE.children["layout"] + ) with self.assertRaises(ValueError): - ObservationStudy(SPACE, _build, observations, _metrics, plan=PLAN) + ObservationStudy(shells, _build, observations, _metrics, plan=PLAN) with self.assertRaises(ValueError): ObservationStudy( SPACE, @@ -637,24 +642,41 @@ def test_realize(self): slow.realize(self.design, 1, "fast") def test_prune(self): - """Observations remove their caches' results of other definitions.""" + """Observations remove their caches' results of the analysis with other + code, and keep those of other observations.""" + + def analysis(source): + namespace = {"collect_observations": collect_observations} + exec(source, namespace) # pylint: disable=exec-used + return namespace["analysis"] + + plain = analysis( + "def analysis(targets, satellite, start, end):\n" + " return collect_observations(targets, satellite, start, end)\n" + ) + edited = analysis( + "def analysis(targets, satellite, start, end):\n" + " found = collect_observations(targets, satellite, start, end)\n" + " return found\n" + ) + more = Targets( + generate_points_rotated_lattice, N_POINTS + 5, seed="points_seed" + ) with tempfile.TemporaryDirectory() as directory: - first = _observations(directory) - other = Observations( - TARGETS, - START, - HOURS, - analysis=partial(collect_observations), - directory=directory, - ) + first = Observations(TARGETS, START, HOURS, plain, directory=directory) + others = Observations(more, START, HOURS, plain, directory=directory) + latest = Observations(TARGETS, START, HOURS, edited, directory=directory) realized = self.design.realize(0) satellites = _build(realized) first(satellites, realized) - with warnings.catch_warnings(): - warnings.simplefilter("ignore") - other(satellites, realized) - self.assertEqual(other.prune(), len(satellites)) - self.assertEqual(other.prune(), 0) + others(satellites, realized) + with self.assertWarnsRegex(UserWarning, "other code"): + latest(satellites, realized) + self.assertEqual(latest.prune(), len(satellites)) + self.assertEqual(latest.prune(), 0) + # the results of the other targets (another definition) are kept + kept = others.cache_of(realized).folder + self.assertEqual(len(list(kept.glob("*.pkl"))), len(satellites)) self.assertEqual(Observations(TARGETS, START, HOURS).prune(), 0) def test_failure_options(self): @@ -685,3 +707,46 @@ def test_failure_options(self): study.replace( failures=Failures(FAILURES, seed="failure_seed", controls=["other"]) ).run([self.design]) + + +class TestFailureStudies(unittest.TestCase): + """ + Unit tests for the summaries of failures of observation studies. + """ + + def test_costs_and_histories(self): + """The costs of a study of failures are the means of its histories.""" + design = SPACE.enumerate()[3] + study = ObservationStudy( + SPACE, + _build, + _observations(), + _metrics, + plan=PLAN, + failures=Failures(FAILURES, histories=5, seed="failure_seed"), + ) + result = study.run([design]).iloc[0] + missions = study.missions_of(design) + self.assertEqual(len(missions), 5) + self.assertAlmostEqual(result["cost"], missions["cost"].mean()) + self.assertAlmostEqual( + result["observed mission"], missions["observed mission"].mean() + ) + with self.assertRaisesRegex(ValueError, "failures"): + study.replace(failures=None).missions_of(design) + + def test_exact_without_seed(self): + """Without a seed, the one history without failures is not replaced by + exact expectations over failures.""" + design = SPACE.enumerate()[3] + study = ObservationStudy( + SPACE, + _build, + _observations(), + _metrics, + plan=PLAN, + failures=Failures(FAILURES, RestorationPolicy(restore=False)), + ) + result = study.run([design]).iloc[0] + self.assertEqual(result["availability"], 1.0) + self.assertEqual(result["failures"], 0.0) diff --git a/tests/tradespace/test_plotting.py b/tests/tradespace/test_plotting.py index 5eada6d0..29dc103f 100644 --- a/tests/tradespace/test_plotting.py +++ b/tests/tradespace/test_plotting.py @@ -16,6 +16,8 @@ plot_exceedance, plot_means, plot_progress, + plot_shares, + use_style, ) try: @@ -170,3 +172,49 @@ def test_highlight(self): self.assertEqual(len(ax.collections[1].get_offsets()), 2) with self.assertRaises(ValueError): plot_designs(summary, "x", "y", highlight=[True]) + + +class TestShares(unittest.TestCase): + """ + Unit tests for plots of shares, groups of values, and the style. + """ + + def tearDown(self): + plt.close("all") + + def test_shares(self): + """Shares are grouped by factor or by metric, with their errors.""" + table = pd.DataFrame( + {"a": [0.6, 0.2], "b": [0.1, 0.5], "a se": [0.05, 0.02], "active": [1, 1]}, + index=pd.Index(["x", "y"], name="parameter"), + ) + ax = plot_shares(table, labels={"a": "first"}) + self.assertEqual(len(ax.patches), 4) # two factors, two metrics + self.assertEqual( + [text.get_text() for text in ax.get_legend().get_texts()], ["first", "b"] + ) + flipped = plot_shares( + table, groups="metrics", names={"x": "ex"}, horizontal=True + ) + self.assertEqual( + [label.get_text() for label in flipped.get_yticklabels()], ["a", "b"] + ) + with self.assertRaises(ValueError): + plot_shares(table, groups="other") + + def test_groups_of_values(self): + """Designs are colored by values given for their rows.""" + summary = pd.DataFrame({"x": [1.0, 2.0, 3.0], "y": [1.0, 2.0, 3.0]}) + ax = plot_designs(summary, "x", "y", by=[1, 1, 2], names={1: "one", 2: "two"}) + self.assertEqual( + [text.get_text() for text in ax.get_legend().get_texts()], ["one", "two"] + ) + + def test_style(self): + """The style of plots applies to the figures of the session.""" + import matplotlib as mpl # pylint: disable=import-outside-toplevel + + with mpl.rc_context(): + use_style() + self.assertFalse(mpl.rcParams["axes.spines.top"]) + self.assertTrue(mpl.rcParams["figure.constrained_layout.use"]) diff --git a/tests/tradespace/test_scenarios.py b/tests/tradespace/test_scenarios.py index 4776ccb7..73833929 100644 --- a/tests/tradespace/test_scenarios.py +++ b/tests/tradespace/test_scenarios.py @@ -208,8 +208,18 @@ def test_trace_and_regret(self): """The share of scenarios in which designs are efficient, and their regret: the improvement in every objective to match the front.""" r = self._robustness() + # each objective in each scenario (cost is the same in every one) self.assertEqual( - list(r.columns), ["pareto_trace", "max_regret", "s1 regret", "s2 regret"] + list(r.columns), + [ + "s1 perf", + "s2 perf", + "cost", + "pareto_trace", + "max_regret", + "s1 regret", + "s2 regret", + ], ) np.testing.assert_allclose(r["pareto_trace"], [0.5, 1.0, 0.0]) # C in s1: 1 short of B in both objectives (3 short of A in perf) @@ -405,14 +415,20 @@ def test_invalid(self): Criteria(OBJECTIVES, by="scenario", across=Across()) with self.assertRaises(ValueError): Criteria(OBJECTIVES, across=Across(rules={"other": "mean"})) - # a statistic without a direction has no worst, unless combined by its mean - with self.assertRaises(ValueError): - Criteria(OBJECTIVES, statistics={"extra": "perf"}, across=Across()) - Criteria( - OBJECTIVES, - statistics={"extra": "perf"}, - across=Across(rules={"extra": "mean"}), + # a statistic without a direction is combined by its mean, unless a + # rule asks for its worst, which it has none of + extra = Criteria(OBJECTIVES, statistics={"extra": "perf"}, across=Across()) + summary = aggregate(RESULTS, extra).set_index("design") + means = aggregate(RESULTS, Criteria(OBJECTIVES, by="scenario")) + np.testing.assert_allclose( + summary.extra, means.groupby("design", sort=False).perf.mean() ) + with self.assertRaises(ValueError): + Criteria( + OBJECTIVES, + statistics={"extra": "perf"}, + across=Across(rules={"extra": "worst"}), + ) # an objective and a requirement that disagree on its worst with self.assertRaises(ValueError): Criteria( diff --git a/tests/tradespace/test_sensitivity.py b/tests/tradespace/test_sensitivity.py index 7e16a17b..fabdaa7b 100644 --- a/tests/tradespace/test_sensitivity.py +++ b/tests/tradespace/test_sensitivity.py @@ -56,6 +56,11 @@ def test_shares(self): def test_main_effects(self): """Main effects are the means of the metric at each level.""" effects = main_effects(self.frame, "a", "metric") + # a name is a list of one + pd.testing.assert_frame_equal( + sensitivity(self.frame, "a", "metric"), + sensitivity(self.frame, ["a"], ["metric"]), + ) np.testing.assert_allclose(effects["mean"], [10.5, 20.5, 30.5, 40.5], atol=0.1) self.assertEqual(list(effects["count"]), [50] * 4) binned = main_effects(self.frame, "c", "metric", max_levels=4) diff --git a/tests/tradespace/test_space.py b/tests/tradespace/test_space.py index 730d9734..464eb8a3 100644 --- a/tests/tradespace/test_space.py +++ b/tests/tradespace/test_space.py @@ -388,10 +388,17 @@ def test_round_trip(self): keys = [self.designs[3].key, self.designs[1].key] some = self.space.designs_of(self.frame.set_index("design"), keys) self.assertEqual([d.key for d in some], keys) - # without keys, every row's design once + # a design for each row, aligned with the rows (as of results of + # several rows of a design), each design rebuilt once + twice = pd.concat([self.frame, self.frame], ignore_index=True) + aligned = self.space.designs_of(twice) + self.assertEqual(list(aligned.index), list(twice.index)) + self.assertEqual(list(aligned.map(lambda d: d.key)), list(twice.design)) + self.assertIs(aligned.iloc[0], aligned.iloc[len(self.frame)]) + # without keys, every row's design bare = self.frame.drop(columns="design") rebuilt = self.space.designs_of(pd.concat([bare, bare])) - self.assertEqual(len(rebuilt), len(self.designs)) + self.assertEqual(len(rebuilt), 2 * len(self.designs)) def test_errors(self): """Rows without the values of decisions, or of other designs, raise.""" @@ -586,3 +593,55 @@ def test_nominal(self): self.assertEqual(space.enumerate()[0].x, 0.5) self.assertEqual(Uncertain.normal(0, 1, nominal=0.0).nominal, 0.0) self.assertIn("seed()", repr(Uncertain.seed())) + + +class TestDecisionsAndViews(unittest.TestCase): + """ + Unit tests for decisions given by value, and the views of values. + """ + + def test_levels(self): + """Decisions given by value are the levels of their domains.""" + import numpy as np # pylint: disable=import-outside-toplevel + + space = DesignSpace(a=Integer(1, 4), b=Real(0.5, 1.5, step=0.5)) + (enumerated,) = [d for d in space.enumerate() if d.a == 2 and d.b == 0.5] + for a in (2, 2.0, np.int64(2)): + design = space.design({"a": a, "b": 0.5}) + self.assertEqual(design.key, enumerated.key) + self.assertIs(type(design.a), int) + + def test_views(self): + """Designs and scopes tell whether they have values, and choices print + as the names of their branches.""" + space = DesignSpace( + a=Integer(1, 2), + layout=Choice(walker=DesignSpace(planes=Integer(1, 2))), + constraints=[lambda d: d.get("a") >= 1 and "layout.walker.planes" in d], + ) + design = space.enumerate()[0] + self.assertIn("a", design) + self.assertIn("layout.walker.planes", design) + self.assertNotIn("other", design) + self.assertEqual(str(design.layout), "walker") + with self.assertRaises(TypeError): + list(design) + with self.assertRaisesRegex(ValueError, "reserved"): + Choice(walker=DesignSpace(value=1)) + + def test_items(self): + """Items are given by index within the repetition only.""" + space = DesignSpace(parts=Repeat(Integer(0, 1), count=3)) + parts = space.enumerate()[0].parts + self.assertEqual(parts[-1], parts[2]) + for index in (3, -4): + with self.assertRaises(IndexError): + parts[index] # pylint: disable=pointless-statement + + def test_counts_given(self): + """Items given for a count that is not decided must match it.""" + space = DesignSpace( + n=Integer(1, 2), parts=Repeat(Integer(0, 1), count=Derived(lambda d: d.n)) + ) + with self.assertRaisesRegex(ValueError, "items are given"): + space.design({"n": 1, "parts": [0, 1]}) diff --git a/tests/tradespace/test_stages.py b/tests/tradespace/test_stages.py index 04a96794..7d93d499 100644 --- a/tests/tradespace/test_stages.py +++ b/tests/tradespace/test_stages.py @@ -263,7 +263,9 @@ def test_exact_expectations(self): deployment = SCHEDULE.plan(_layout(), stages=[Stage(2, 1.0)]) with self.assertRaises(ValueError): expected_missions( - deployment, FailureModel(life=Exponential(0.2)), [], None, len + deployment, + FailureModel(life=Exponential(0.2)), + Capability([], None, len), ) def test_invalid(self): diff --git a/tests/tradespace/test_store.py b/tests/tradespace/test_store.py index d5f3690e..dbefd6a2 100644 --- a/tests/tradespace/test_store.py +++ b/tests/tradespace/test_store.py @@ -10,6 +10,7 @@ import sqlite3 import tempfile import unittest +from types import SimpleNamespace import warnings from concurrent.futures import ThreadPoolExecutor from contextlib import closing @@ -51,14 +52,16 @@ def setUp(self): self.path = Path(self.directory.name) / "results.sqlite" self.space = DesignSpace(a=Integer(1, 4), noise=Uncertain.uniform(0, 1)) self.calls = [] - self.fail_at = None + # the state of the study's evaluations, which their fingerprint does not + # see (an object of an installed class is described by its type) + self.state = SimpleNamespace(fail_at=None) def tearDown(self): self.directory.cleanup() def _study(self, store, **kwargs): def evaluate(d): - if self.fail_at is not None and len(self.calls) == self.fail_at: + if self.state.fail_at is not None and len(self.calls) == self.state.fail_at: raise _Interrupt() self.calls.append((d.a, d.noise)) return {"value": d.a + d.noise} @@ -88,11 +91,11 @@ def test_store_and_get(self): def test_resume(self): """An interrupted study resumes, evaluating only what is not stored.""" store = ResultStore(self.path, "study") - self.fail_at = 5 + self.state.fail_at = 5 with self.assertRaises(_Interrupt): self._study(store).run() self.assertEqual(len(store), 5) - self.fail_at = None + self.state.fail_at = None resumed = self._study(store).run() self.assertEqual(len(self.calls), 12) # 5 before, 7 after complete = self._study(None).run() @@ -176,20 +179,27 @@ def test_other_code(self): def study(evaluate): return Study(self.space, lambda d: d, evaluate, replicates=2, store=store) - study(lambda d: {"value": d.a}).run() + study(lambda d: {"value": d.a + d.a}).run() with self.assertWarnsRegex(UserWarning, "other code.*evaluate.code"): - edited = study(lambda d: {"value": d.a + 1}).run() - self.assertEqual(list(edited.value[:2]), [2, 2]) - # another study (of other settings) shares the namespace - other = study(lambda d: {"value": d.a + 1}).replace(seed=1) + edited = study(lambda d: {"value": d.a * d.a}).run() + self.assertEqual(list(edited.value[:2]), [1, 1]) + # other studies share the namespace: of other settings, and of other + # constants (such as the numbers of a constraint), without a warning + other = study(lambda d: {"value": d.a * d.a}).replace(seed=1) other.run() + with warnings.catch_warnings(): + warnings.simplefilter("error") + constant = study(lambda d: {"value": d.a * d.a + 10}) + constant.run() # pruning removes the study's evaluations with other code, only - current = study(lambda d: {"value": d.a + 1}) + current = study(lambda d: {"value": d.a * d.a}) self.assertEqual(current.prune(), 8) self.assertEqual( - store.contexts(), {current.fingerprint: 8, other.fingerprint: 8} + store.contexts(), + {current.fingerprint: 8, other.fingerprint: 8, constant.fingerprint: 8}, ) self.assertEqual(current.prune(), 0) + self.assertEqual(constant.prune(), 0) def test_records_as_json(self): """Records are kept as JSON, and read as they were written.""" diff --git a/tests/tradespace/test_study.py b/tests/tradespace/test_study.py index 898f34e5..47b9f456 100644 --- a/tests/tradespace/test_study.py +++ b/tests/tradespace/test_study.py @@ -7,6 +7,7 @@ import importlib.util import tempfile import unittest +from types import SimpleNamespace import warnings from pathlib import Path from concurrent.futures import ThreadPoolExecutor @@ -248,10 +249,12 @@ class TestErrors(unittest.TestCase): def setUp(self): self.space = DesignSpace(a=Integer(1, 4)) - self.fail = True + # the state of the evaluations, which their fingerprint does not see + # (an object of an installed class is described by its type) + self.state = SimpleNamespace(fail=True) def _evaluate(self, d): - if self.fail and d.a == 3: + if self.state.fail and d.a == 3: raise RuntimeError("diverged") return {"value": d.a} @@ -276,7 +279,7 @@ def test_record(self): self.assertFalse([c for c in results.columns if c.startswith("_")]) self.assertEqual(len(store), 3) # a later run evaluates the failed evaluation again - self.fail = False + self.state.fail = False again = study.run() self.assertTrue(again.feasible.all()) self.assertEqual(len(store), 4) From 8efd1a1c1974c48f4e1c1de46a062e0fb318012a Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Sat, 14 Nov 2026 08:57:45 -0700 Subject: [PATCH 47/52] review the trade space a fourth time: fingerprint the globals of a study's functions by content, evaluate designs of other spaces in the study's space, check constraints in scenarios, judge designs by their feasible replicates (with the share feasible), cache the phases of missions by replicate, keep the launch interval in replacements, replace only the occupied positions, price launches by the masses of the deployment, fall back from exact expectations, chain screenings, give each step the designs it selects, configure policies and spares in one place (MissionPlan.policy), give the mission of a design (mission_of), make options keyword-only, and split criteria, space, and observations (new modules statistics, summary, walks, alerts, plans, and references) --- CHANGELOG.md | 13 +- docs/api_reference/tradespace/define.rst | 4 +- docs/api_reference/tradespace/evaluate.rst | 22 +- docs/api_reference/tradespace/index.rst | 10 +- docs/api_reference/tradespace/judge.rst | 27 +- docs/api_reference/tradespace/missions.rst | 19 +- docs/api_reference/tradespace/search.rst | 6 +- .../tradespace/CompareScenarios.ipynb | 78 +- .../tradespace/EvaluateTradeSpace.ipynb | 56 +- .../tradespace/ExplainTradeSpace.ipynb | 78 +- docs/examples/tradespace/PlanDeployment.ipynb | 80 +- .../examples/tradespace/PlanForFailures.ipynb | 271 +++--- .../tradespace/RankUncertainDesigns.ipynb | 76 +- .../tradespace/SearchTradeSpace.ipynb | 44 +- .../tradespace/TradeCostAndUtility.ipynb | 111 ++- .../tradespace/trade_space_example.py | 2 +- src/tatc/tradespace/__init__.py | 38 +- src/tatc/tradespace/alerts.py | 38 + src/tatc/tradespace/attribution.py | 13 +- src/tatc/tradespace/cache.py | 95 +- src/tatc/tradespace/comparison.py | 6 +- src/tatc/tradespace/confirmation.py | 36 +- src/tatc/tradespace/constellations.py | 41 +- src/tatc/tradespace/cost.py | 70 +- src/tatc/tradespace/criteria.py | 920 ++---------------- src/tatc/tradespace/deployment.py | 261 +++-- src/tatc/tradespace/events.py | 157 ++- src/tatc/tradespace/failures.py | 53 +- src/tatc/tradespace/fingerprint.py | 694 ++++++++----- src/tatc/tradespace/hashing.py | 4 +- src/tatc/tradespace/histories.py | 223 +++-- src/tatc/tradespace/mission.py | 83 +- src/tatc/tradespace/nodes.py | 14 + src/tatc/tradespace/observations.py | 702 +++---------- src/tatc/tradespace/optimization.py | 211 ++-- src/tatc/tradespace/pareto.py | 124 +-- src/tatc/tradespace/plans.py | 655 +++++++++++++ src/tatc/tradespace/plotting.py | 47 +- src/tatc/tradespace/references.py | 62 ++ src/tatc/tradespace/refinement.py | 67 +- src/tatc/tradespace/scenarios.py | 99 +- src/tatc/tradespace/screening.py | 91 +- src/tatc/tradespace/sensitivity.py | 14 +- src/tatc/tradespace/simulation.py | 98 +- src/tatc/tradespace/space.py | 825 ++++------------ src/tatc/tradespace/statistics.py | 323 ++++++ src/tatc/tradespace/store.py | 37 +- src/tatc/tradespace/study.py | 242 +++-- src/tatc/tradespace/summary.py | 884 +++++++++++++++++ src/tatc/tradespace/values.py | 16 +- src/tatc/tradespace/walks.py | 651 +++++++++++++ tests/tradespace/test_cache.py | 10 +- tests/tradespace/test_comparison.py | 5 +- tests/tradespace/test_constellations.py | 10 +- tests/tradespace/test_cost.py | 29 +- tests/tradespace/test_criteria.py | 152 ++- tests/tradespace/test_deployment.py | 79 +- tests/tradespace/test_failures.py | 198 +++- tests/tradespace/test_fingerprint.py | 172 +++- tests/tradespace/test_layering.py | 4 + tests/tradespace/test_observations.py | 270 ++++- tests/tradespace/test_optimization.py | 136 ++- tests/tradespace/test_pareto.py | 77 +- tests/tradespace/test_plotting.py | 51 + tests/tradespace/test_refinement.py | 40 +- tests/tradespace/test_scenarios.py | 56 +- tests/tradespace/test_screening.py | 55 +- tests/tradespace/test_sensitivity.py | 4 +- tests/tradespace/test_space.py | 242 ++++- tests/tradespace/test_stages.py | 50 +- tests/tradespace/test_store.py | 36 + tests/tradespace/test_study.py | 149 +++ tests/tradespace/test_utility.py | 22 + 73 files changed, 6932 insertions(+), 3706 deletions(-) create mode 100644 src/tatc/tradespace/alerts.py create mode 100644 src/tatc/tradespace/plans.py create mode 100644 src/tatc/tradespace/references.py create mode 100644 src/tatc/tradespace/statistics.py create mode 100644 src/tatc/tradespace/summary.py create mode 100644 src/tatc/tradespace/walks.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 82808502..2fd9f938 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -23,22 +23,25 @@ Added: - Function `tradespace.screen` (and class `Screening`), which screens designs with studies of increasing fidelity, keeping whole fronts of the best designs of each stage for the next. - Searches of design spaces with optional optimizers: `tradespace.optimize_optuna` suggests designs with Optuna trials (`DesignSpace.suggest`, define-by-run over the hierarchical space), and `optimize_pymoo` and `make_pymoo_problem` search the unit hypercube that encodes a design space (`DesignSpace.unit_paths`, `encode`, and `decode`) with pymoo, whose algorithms eliminate the proposals of designs proposed or evaluated before (`distinct`, by design, `make_pymoo_problem`'s `duplicates`). Each design is evaluated once, and the designs proposed together are evaluated together, in parallel if the study is. A search returns its results and designs (`Search`), which `refine` and `confirm` refine and confirm as for any study. Constraints of a design space may return the amount of their violation (`Infeasible.violation`), which Optuna's trials record (`set_constraint`) for its constraint-aware samplers, and which is the constraint value of pymoo problems. Optional dependencies `tradespace` (joblib, Optuna, and pymoo). - Deployment of constellations (`tradespace.DeploymentSchedule`): from the rates and durations of a study (the mission, the design life, development, and production rate of each type of satellite, its production on a line, and launches at a cadence and capacity, in number or mass, optionally in an order of planes), each design's deployment (`DeploymentSchedule.plan`, a `Deployment` of its `Production`, `Launch`es, and replacements), so that a design of more satellites and planes takes longer to deploy. A sustained constellation (`DeploymentSchedule.sustained`, such as of an operational program over the period of a study) is replaced after the end of the mission as before it, and its costs are those incurred by the end, which count the units in production then by the share produced and later blocks by the share of their development done. A deployment's launches divide the mission into phases of constant sets of operating satellites (`Deployment.phases`), evaluated over the study's representative period from the observations of the full constellation (`evaluate_phases`) and combined over the mission (`summarize_phases`: the time-weighted mean of each metric and the time until it first meets a requirement). - - Simulated missions with failures (`Deployment.simulate`, a `MissionHistory` for each replicate, drawn from its seed with common random numbers between designs): lives of satellites whose failure rates vary over the lifecycle (`tradespace.Exponential`, `Weibull`, `Bathtub` of competing causes, and `Piecewise` rates by age, `Lifetime`), failures of launches (`FailureModel`), and a policy that degrades or restores failed satellites (`RestorationPolicy`) by spares in orbit (taking a failed satellite's place after drifting), spares on the ground (launched at the next launch slot), or satellites produced when needed (after procurement, on the production line), optionally replenishing spares and batching restorations in launches. A history gives the phases in which satellites operate (`MissionHistory.phases`), measures of the mission (`MissionHistory.metrics`: failures, restorations, spares used, time to restore, and availability), and, priced by a `CostModel`, the cost of what it produces and launches. Policies are decisions of designs with a fragment of a design space (`policy_space`: whether to restore, spares in orbit and on the ground, and other fields of the policy, without spares that would never be used), and `configure` makes a policy (or a deployment schedule, or another dataclass) from the values of a design. Many histories of a replicate's mission (`Deployment.simulate_many`) share its sample of targets: `evaluate_missions` evaluates them (with their measures and costs) with a cache that evaluates each set of operating satellites once (`PhaseCache`, keyed by the content of the satellites and shared by the histories, policies, and designs of a replicate), and `summarize_missions` gives their means, quantiles (the risk of the mission), and probabilities of meeting requirements, as one record of the replicate. The histories of a replicate are stratified by default (a Latin hypercube over the histories of each satellite's life and each launch, drawn from uniform numbers by `Lifetime.from_uniform`), which estimates the means of missions 3 to 15 times more precisely than independent histories, and means may be estimated with control variates (`summarize_missions(controls=...)`, such as the availability of the mission, whose expected value simulations alone estimate, `Deployment.expected_metrics`). `allocate_histories` recommends the histories of each replicate (and the replicates, for a standard error) from a pilot with independent histories, by the variances between replicates and between histories and their costs (`summarize_missions(spread=True)` gives the standard deviations of the histories). `expected_missions` computes the expected capability and availability of a mission without restoration exactly (the sets of operating satellites by their probabilities, from the survival of each launch group, with planned replacements), without sampling error. Histories may be drawn from stressed failures for importance sampling (`simulate_many(stress=...)`: hazards and launch failures times a factor, each history weighted by its likelihood ratio censored at the end of the mission, `Lifetime.stressed` and `MissionHistory.weight`), which `summarize_missions` weighs in every statistic, with the effective number of histories: the probabilities of rare losses with 30 to 70 times less variance. + - Simulated missions with failures (`Deployment.simulate`, a `MissionHistory` for each replicate, drawn from its seed with common random numbers between designs): lives of satellites whose failure rates vary over the lifecycle (`tradespace.Exponential`, `Weibull`, `Bathtub` of competing causes, and `Piecewise` rates by age, `Lifetime`), failures of launches (`FailureModel`), and a policy that degrades or restores failed satellites (`RestorationPolicy`) by spares in orbit (taking a failed satellite's place after drifting), spares on the ground (launched at the next launch slot), or satellites produced when needed (after procurement, on the production line), optionally replenishing spares and batching restorations in launches. A history gives the phases in which satellites operate (`MissionHistory.phases`), measures of the mission (`MissionHistory.metrics`: failures, restorations, spares used, time to restore, and availability), and, priced by a `CostModel`, the cost of what it produces and launches. Policies are decisions of designs with a fragment of a design space (`policy_space`: whether to restore, spares in orbit and on the ground, and other fields of the policy, without spares that would never be used), and `configure` makes a policy (or a deployment schedule, or another dataclass) from the values of a design. Many histories of a replicate's mission (`Deployment.simulate_many`) share its sample of targets: `evaluate_histories` evaluates them (with their measures and costs) with a cache that evaluates each set of operating satellites once (`PhaseCache`, keyed by the content of the satellites and shared by the histories, policies, and designs of a replicate), and `summarize_histories` gives their means, quantiles (the risk of the mission), and probabilities of meeting requirements, as one record of the replicate. The histories of a replicate are stratified by default (a Latin hypercube over the histories of each satellite's life and each launch, drawn from uniform numbers by `Lifetime.from_uniform`), which estimates the means of missions 3 to 15 times more precisely than independent histories, and means may be estimated with control variates (`summarize_histories(controls=...)`, such as the availability of the mission, whose expected value simulations alone estimate, `Deployment.expected_metrics`). `allocate_histories` recommends the histories of each replicate (and the replicates, for a standard error) from a pilot with independent histories, by the variances between replicates and between histories and their costs (`summarize_histories(spread=True)` gives the standard deviations of the histories). `exact_expectations` computes the expected capability and availability of a mission without restoration exactly (the sets of operating satellites by their probabilities, from the survival of each launch group, with planned replacements), without sampling error. Histories may be drawn from stressed failures for importance sampling (`simulate_many(stress=...)`: hazards and launch failures times a factor, each history weighted by its likelihood ratio censored at the end of the mission, `Lifetime.stressed` and `MissionHistory.weight`), which `summarize_histories` weighs in every statistic, with the effective number of histories: the probabilities of rare losses with 30 to 70 times less variance. - Life-cycle costs of deployments for trade studies (`tradespace.CostModel`): the development of each type of satellite, the production of its units on a learning curve (`SatelliteCost`), launches (per launch, or prices per satellite and kg, `LaunchCost`), operations (`OperationsCost`), replacements, and spares in orbit, dated by the deployment for their present value at a discount rate (`CostEstimate.present_value`, metric `cost present`) and annual costs (`CostEstimate.annual`, metric `cost peak annual`), with growth factors for cost risk (such as uncertain parameters, whose quantiles over replicates give the cost at a confidence level). TAT-C does not include cost-estimating relationships: the costs are given by the study. Fingerprints describe dataclasses (such as cost models) by their fields. - Function `tradespace.confirm` (and class `Confirmation`), which evaluates selected designs (such as a front) with new replicates that played no part in their selection, removing the optimism of the selection (the winner's curse, `Confirmation.optimism`). `ResultStore` keys evaluations by the fingerprint of a study (`Study.fingerprint`, a hash of `Study.definition`, see `get_definition`: its seed, use of common random numbers, design space, and build and evaluation functions, with the data frames they are given described by their content, the version of Python, and the source of the modules of TAT-C and resource files they depend on, found from their imports) and keeps each definition, so that variants of a study share a store without mixing their evaluations, and a study warns of evaluations of the same study with other code (of its functions, of TAT-C, or of Python), which are not reused, naming what differs (`fingerprint.compare_definitions`); `Study.prune` removes them (and not the evaluations of other studies that share the store). Changes to TAT-C that a study does not depend on (such as to modules it does not use) keep its results. Namespaces of stores and caches are optional, for what fingerprints cannot see (data that functions read from files, and the code of other modules). `refine` treats designs with fewer than `min_replicates` (5) as uncertain whatever their probability, adds the replicates left to `max_replicates` in a last partial step, and warns if designs remain uncertain without a tolerance. `sensitivity` gives adjusted shares (epsilon squared) by default, without the share that the levels of a variable explain by chance (`adjusted=False` for correlation ratios). - The schedule and cost model of a `tradespace.MissionPlan` may be functions of the design (`schedule_of`, `cost_model_of`), which size them by its values with relationships of the study's own, such as the costs of a type of satellite from its payload or the capacity of launches to the design's altitude; launches limited in mass take the masses of the satellites from the cost model (`masses_of`, or the plan's `masses`). The `launch_mass_capacity` of a `DeploymentSchedule` may be a function of a plane (`mass_capacity_of`), for planes at different inclinations. - The start of the period of `tradespace.Observations` may be a value of the design (`start_of` and `end_of` give a design's period), such as an uncertain epoch drawn for each replicate over the mission, whose observations are cached apart, so that replicates average over the geometry and seasons of the mission that the one window of quasi-static phases misses (see `evaluate_phases`). The schedule of deployments states that a design life does not retire a satellite that is not replaced, and simulations that a planned replacement whose launch fails is not flown again. - Utilities of the metrics of designs (`tradespace.Utility`), for trade spaces of utility against cost: a single-attribute utility of each metric (`LinearUtility`, `ExponentialUtility` of a risk attitude, `PiecewiseUtility`, or any function), combined by weights additively or in Keeney and Raiffa's multiplicative form. A utility is a metric of any statistic (its `Mean` is the expected utility over the replicates, and a utility given as a statistic of `Criteria` is its mean), computed in each replicate, and gives the utility of each row of a data frame (such as a summary of the means of designs). Statistics name the columns they need (`Statistic.columns`). - - Staged deployments (`tradespace.Stage`, argument `stages` of `DeploymentSchedule.plan` and `MissionPlan`, which may give the stages of each design): planes that are produced and launched only if a rule decides to, at times during the mission, from what it knows then (`Decision`: the satellites operating, the history so far, and, through the design, its uncertain parameters and scenario), after a lead time and at the next launch slots, and replaced and restored as other planes. Rules may also read the capability of the satellites operating at a decision (`Decision.capability`, the study's metrics of their observations, as of a phase), which the evaluations of an `ObservationStudy` give each deployment (`Deployment.capability`, a `tradespace.Capability` of its satellites, observations, and cached phases, which also caches the phases of studies without failures), such as for a plane deployed only if those in orbit fall short. A stage that is not deployed is neither produced, launched, nor priced; `MissionHistory.stages` gives when each was deployed, and its metrics the `stages deployed`. Exact expectations of missions without restoration (`expected_missions`) need deployments that are not staged, so that studies of staged deployments sample their histories. - - Scenarios of studies (argument `scenarios` of `tradespace.Study`): conditions under which designs are compared rather than averaged over, each giving fixed values or uncertain parameters of the design space other values (`Design.realize` takes a `scenario`), so that each design is evaluated in each scenario (recorded as `scenario`, and judged in each with criteria `by` it). Each scenario's evaluations are stored by its values, so that a scenario added later is evaluated alone. Function `tradespace.robustness` gives each design's Pareto trace (the share of scenarios in which it is efficient) and its regret in each scenario (the improvement in every objective it would need to match the scenario's front) and the largest. The metrics of an `ObservationStudy` (and of `PhaseCache`, `evaluate_missions`, and `expected_missions`) are given the realized design if they have a parameter named `design`. + - Staged deployments (`tradespace.Stage`, argument `stages` of `DeploymentSchedule.plan` and `MissionPlan`, which may give the stages of each design): planes that are produced and launched only if a rule decides to, at times during the mission, from what it knows then (`Decision`: the satellites operating, the history so far, and, through the design, its uncertain parameters and scenario), after a lead time and at the next launch slots, and replaced and restored as other planes. Rules may also read the capability of the satellites operating at a decision (`Decision.capability`, the study's metrics of their observations, as of a phase), which the evaluations of an `ObservationStudy` give each deployment (`Deployment.capability`, a `tradespace.Capability` of its satellites, observations, and cached phases, which also caches the phases of studies without failures), such as for a plane deployed only if those in orbit fall short. A stage that is not deployed is neither produced, launched, nor priced; `MissionHistory.stages` gives when each was deployed, and its metrics the `stages deployed`. Exact expectations of missions without restoration (`exact_expectations`) need deployments that are not staged, so that studies of staged deployments sample their histories. + - Scenarios of studies (argument `scenarios` of `tradespace.Study`): conditions under which designs are compared rather than averaged over, each giving fixed values or uncertain parameters of the design space other values (`Design.realize` takes a `scenario`), so that each design is evaluated in each scenario (recorded as `scenario`, and judged in each with criteria `by` it). Each scenario's evaluations are stored by its values, so that a scenario added later is evaluated alone. Function `tradespace.robustness` gives each design's Pareto trace (the share of scenarios in which it is efficient) and its regret in each scenario (the improvement in every objective it would need to match the scenario's front) and the largest. The metrics of an `ObservationStudy` (and of `PhaseCache`, `evaluate_histories`, and `exact_expectations`) are given the realized design if they have a parameter named `design`. - Criteria across the scenarios of a study (`tradespace.Across`, argument `across` of `Criteria`), which judge each design once by its worst or its (weighted) mean statistics over the scenarios (or the groups of another column), so that searches find designs robust to scenarios; a requirement may be met in every scenario while objectives are means. - Function `tradespace.attribute_variance` (and class `Attribution`), which attributes the variance of metrics between the replicates of each design to its uncertain parameters (or groups of them): the share that each causes, alone or with others, and the share that knowing it would remove, with standard errors, by evaluating designs with one parameter drawn as in other replicates and the others held (which works for seeds, whose values do not order outcomes); `Attribution.summary` pools the shares of several designs, and `Attribution.differences` attributes the variance of the differences between pairs of designs, from the same evaluations (parameters that act alike on both cancel, with common random numbers). `Design.realize` and `Study.run` take a `shift`, which draws named parameters as in other replicates (kept apart in a `ResultStore` as a variant of the replicates), and `DesignSpace.uncertain_paths` lists the uncertain parameters. - Structured cost risk (after Maier, Yeakel, and Wendoloski, "Cost Variance Analysis in Constellation Architecture Studies," 2023): growth factors of each type of satellite (by kind, for development, production, and launches, in `CostModel.estimate` and `MissionPlan.growth`), and the costs of types of satellites as sums of their components (`tradespace.Component`, `SatelliteCost.components`), whose growth has a distribution by maturity (such as `tradespace.Triangular`), correlated between components (`CostModel.correlation`). `CostModel.draw` draws the growth of the components from standard normal scores of the components and a common score, which `tradespace.risk_space` declares as uncertain parameters of a design space (named by `MissionPlan.scores`, also of a nested group), so that common random numbers give the designs that share a component the same growth of it; without drawn growth, components cost their expected growth. Types of satellites that share a component (by name) develop it once in a deployment. Production in blocks (`SatelliteCost.block_size`): each block after the first develops its type again (a share of its development, `redevelopment`) before its first unit is produced, and restarts the learning curve; `CostEstimate.blocks` counts the blocks of each type. Function `tradespace.exceedance` gives the probability that a metric of each design exceeds that of each other in the same replicate (such as that one design costs more than another), and `plot_exceedance` plots them as a matrix. The validation notebook `ValidateCostVarianceNSOSA` reproduces the paper's example of two NSOSA constellations that share a configuration. - Searches with Optuna accept categorical options that depend on earlier decisions (a parameter for each set of options), use TPE with a constant liar in batches by default (which spreads the trials of a batch), and stop after `max_designs` designs evaluated (trials that suggest designs evaluated before are told their objectives without evaluating them again). A design infeasible in some of its replicates violates its feasibility by their share (`Evaluations.infeasibility`), and the first design evaluated in a search is evaluated alone, to check that evaluations give one record each. `Study` records errors of evaluations as infeasible, without storing them, with `errors="record"`. Enumeration walks the items of unordered repetitions in one order only, and `DesignSpace.size` counts designs without keeping them. Pareto fronts are found by a vectorized sweep in lexicographic order that compares designs only with the efficient designs before them, and fronts with tolerances by comparing designs only with the efficient designs without tolerances (which dominate every design that any design dominates within the tolerances), in blocks of bounded memory. - Studies of the observations of constellations (`tradespace.ObservationStudy`): the targets of each replicate (`Targets`, fixed or generated from a seed of the design), the observations of each satellite, cached on disk (`Observations`), the metrics of the observations, and, with a `MissionPlan`, the costs of the deployment and the summaries of its phases or of the histories of its `Failures`. Plots of the results of studies (`plot_designs`, `plot_progress`, and `plot_means`, with matplotlib, in the `tradespace` extra), and the hypervolume of a search as it proceeds (`hypervolume_progress`). - The steps of trade studies share their arguments and outcomes: `tradespace.refine(study, criteria, results)`, `confirm(study, criteria, results)` (by default, the front of the results), `screen(studies, criteria, designs)` (with criteria for each stage), and `attribute_variance(study, metrics, designs)` take designs as `Design` objects, their keys, or rows of a summary or of results, and `Refinement`, `Confirmation`, `Screening`, and `Search` give their `results`, the `summary` of their designs, and the `designs`. `DesignSpace.designs_of` rebuilds designs from rows of their values, which summaries keep (also those of `pareto_probability`, `confirm`, and `screen`), and `DesignSpace.extend`, `DesignSpace.design(design, **overrides)`, and `Study.replace` make variants of design spaces, designs, and studies. `aggregate` takes criteria, a mapping of objectives, or metrics (as the other functions do), and other `statistics` by name; `pareto_front`, `pareto_ranks`, `hypervolume`, `sensitivity`, and `main_effects` raise an error given the results of a study (a row per replicate) instead of a summary. Studies with a mission plan record the years by which it is `deployed`, and the parts of observation studies that refer to values of designs are typed as a `Reference`. Columns: ` se`, ` mission` for the mean over the phases of a mission, ` histories p` and ` histories std` for statistics over the histories of failures, and `pareto_trace` and `max_regret`. Package `tradespace` exports the functions and classes of trade studies; the parts from which they are made (such as `PhaseCache`, `Layout`, `configure`, and the fingerprints) are imported from its modules. - - Values of `tradespace` designs by the paths of the columns of results (`d["layout.walker.planes"]`, also in the callables of design spaces and in references), choices equal to the names of their branches, and reserved names of children that views and designs give otherwise (such as `values` and `key`). `Repeat` counts may be `Integer`, `Categorical`, `Fixed`, or `Derived`; `DesignSpace.design` checks decisions against their domains; and the constructors of uncertain parameters (with `Uncertain.triangular`) take nominal values and name their distributions. Summaries of criteria give whether each design is efficient (`pareto`, also of `summarize`, which takes criteria, and of `confirm`, `screen`, and searches), designs with a missing objective are not efficient, and `aggregate` takes `statistics` by name. `Study.realize` realizes a design as a study does (in a scenario), and an `ObservationStudy` gives the `deployment_of`, `phases_of`, and `estimate_of` a design as its evaluation plans them. `Study.prune` removes a study's evaluations with other code (and not those of other studies that share its store, `ResultStore.remove`), `Observations.prune` removes the results of its caches with other code, and caches warn of results of other code once, in the main process. Fingerprints describe geometries by their content, ignore docstrings, and describe the functions of a study's own modules (such as one next to a notebook) by their code. `Failures` restore by default, with importance sampling (`stress`), control variates (`controls`), and spreads over the histories. Layouts describe themselves (`Layout.describe`) and are built at their own altitude (the given one is for layouts without one; `soc_space` keeps the altitude its planes are derived at). `plot_designs` colors some designs over the others (`highlight`, `label`, `others`, `front_label`), and `COLORS`, `INK`, and `GRAY` name the colors of plots. Each design confirmed gives its ` optimism`, `robustness` keeps the values of designs, and `Search.summary` keeps the designs the search found feasible. The simulation of missions is in module `simulation`. - - Decisions given to `tradespace.DesignSpace.design` by value are levels of their domains (`2.0` or `numpy.int64(2)` give the key of the enumerated design), designs and scopes tell whether they have a value (`"layout.walker.planes" in design`), and the items of a `Repeat` take slices. `DesignSpace.designs_of` gives a series of designs aligned to the rows of a data frame (`space.designs_of(summary).map(describe)`). Statistics given without names are named by convention (`Statistic.name`, such as `"cost p70"` for `Quantile("cost", 0.7)` and `"P(cost <= 150)"`), so that `statistics` may be a list, `summarize(results, criteria, statistics=...)` adds the means and spreads of other metrics to a summary of criteria, criteria `across` scenarios are summarized and aggregated as others, and `Requirement.met` tells which values meet a requirement. An `ObservationStudy` counts the satellites and planes of a design's `layout` by default, gives the histories of a design's failures (`missions_of`) and its satellites, targets, and observations (`satellites_of`, `targets_of`, `observations_of`) as its evaluation realizes them, and `MissionPlan.policy` refers to each design's restoration policy (such as of `policy_space`). Fingerprints describe the classes and callable objects of a study's own modules by their attributes and the code of their methods, and tell studies that differ in constants apart from the same study with other code; `Observations.prune` removes only the results of its own analyses with other code. `plot_designs` colors designs by a column or by values of their rows (`by`), `plot_shares` plots shares of variance (of `sensitivity` or `attribute_variance`) as grouped bars with their standard errors, and `use_style` applies the style of the plots of trade studies (with constrained layouts) to the figures of a session. `robustness` gives each objective of a design in each scenario (` `). `Deployment.planes` are `PlannedPlane`s (type, satellites, and spares in orbit), `DeploymentSchedule.next_slot` gives the next launch slot that keeps the launch interval, and `Capability.evaluate` evaluates phases with a deployment's cached observations. Searches with Optuna are seeded by default (`seed=0`), and lives of satellites are drawn from uniform numbers (`Lifetime.from_uniform`, which subclasses implement). + - Values of `tradespace` designs by the paths of the columns of results (`d["layout.walker.planes"]`, also in the callables of design spaces and in references), choices equal to the names of their branches, and reserved names of children that views and designs give otherwise (such as `values` and `key`). `Repeat` counts may be `Integer`, `Categorical`, `Fixed`, or `Derived`; `DesignSpace.design` checks decisions against their domains; and the constructors of uncertain parameters (with `Uncertain.triangular`) take nominal values and name their distributions. Summaries of criteria give whether each design is efficient (`pareto`, also of `summarize`, which takes criteria, and of `confirm`, `screen`, and searches), designs with a missing objective are not efficient, and `aggregate` takes `statistics` by name. `Study.realize` realizes a design as a study does (in a scenario), and an `ObservationStudy` gives the mission of a design as its evaluation plans it (`mission_of`). `Study.prune` removes a study's evaluations with other code (and not those of other studies that share its store, `ResultStore.remove`), `Observations.prune` removes the results of its caches with other code, and caches warn of results of other code once, in the main process. Fingerprints describe geometries by their content, ignore docstrings, and describe the functions of a study's own modules (such as one next to a notebook) by their code. Missions restore failures by default, and `Failures` sample histories with importance sampling (`stress`), control variates (`controls`), and spreads over the histories. Layouts describe themselves (`Layout.describe`) and are built at their own altitude (the given one is for layouts without one; `soc_space` keeps the altitude its planes are derived at). `plot_designs` colors some designs over the others (`highlight`, `label`, `others`, `front_label`), and `COLORS`, `INK`, and `GRAY` name the colors of plots. Each design confirmed gives its ` optimism`, `robustness` keeps the values of designs, and `Search.summary` keeps the designs the search found feasible. The simulation of missions is in module `simulation`. + - Decisions given to `tradespace.DesignSpace.design` by value are levels of their domains (`2.0` or `numpy.int64(2)` give the key of the enumerated design), designs and scopes tell whether they have a value (`"layout.walker.planes" in design`), and the items of a `Repeat` take slices. `DesignSpace.designs_of` gives a series of designs aligned to the rows of a data frame (`space.designs_of(summary).map(describe)`). Statistics given without names are named by convention (`Statistic.name`, such as `"cost p70"` for `Quantile("cost", 0.7)` and `"P(cost <= 150)"`), so that `statistics` may be a list, `summarize(results, criteria, statistics=...)` adds the means and spreads of other metrics to a summary of criteria, criteria `across` scenarios are summarized and aggregated as others, and `Requirement.met` tells which values meet a requirement. An `ObservationStudy` counts the satellites and planes of a design's `layout` by default, gives the histories of a design's failures (`mission_of(design).histories()`) and its satellites, targets, and observations (`satellites_of`, `targets_of`, `observations_of`) as its evaluation realizes them, and `MissionPlan.policy` refers to each design's restoration policy (such as of `policy_space`). Fingerprints describe the classes and callable objects of a study's own modules by their attributes and the code of their methods, and tell studies that differ in constants apart from the same study with other code; `Observations.prune` removes only the results of its own analyses with other code. `plot_designs` colors designs by a column or by values of their rows (`by`), `plot_shares` plots shares of variance (of `sensitivity` or `attribute_variance`) as grouped bars with their standard errors, and `use_style` applies the style of the plots of trade studies (with constrained layouts) to the figures of a session. `robustness` gives each objective of a design in each scenario (` `). `Deployment.planes` are `PlannedPlane`s (type, satellites, and spares in orbit), `DeploymentSchedule.next_slot` gives the next launch slot that keeps the launch interval, and `Capability.evaluate` evaluates phases with a deployment's cached observations. Searches with Optuna are seeded by default (`seed=0`), and lives of satellites are drawn from uniform numbers (`Lifetime.from_uniform`, which subclasses implement). + - Designs of another design space (such as the space that a study's space extends) are evaluated in the study's space, and constraints are checked in each scenario: a design that violates them in a scenario is infeasible in it, and a constraint that gives `NaN` is violated. Children of design spaces may not take the names of the status columns of results (`design`, `feasible`, `error`, `seconds`, and `scenario`). `DesignSpace.design` takes the name of a branch for a choice (`space.design(base, layout="sso")`), unordered items are in the order of their levels, `Design.scenario` names the scenario of a realized design, `Design.realize` takes the `overrides` of a scenario, and `DesignSpace.check_uncertain` and `check_overrides` check the paths of uncertain parameters and of scenarios. The options of `Study` and `DesignSpace.sample` are keyword-only. Fingerprints describe the globals of a study's functions as they describe its given values (pydantic models, partials, objects of the study's own classes, containers by their content, and the functions of its own modules reached through them), and find the same study with other code alike in every version of Python. `Study.prune` also removes the definitions of a study without evaluations, warnings of studies and caches point at the code that runs them, and an evaluation that gives an empty data frame raises an error. + - Summaries give the share of the replicates of each design that are feasible (`feasible`, which requirements may name, such as `Requirement("feasible", ">=", 1)`), and judge designs by their feasible replicates, as searches do. Statistics are in module `statistics`, and summaries (`aggregate`, `summarize`, and `pareto_probability`) in module `summary`. The tolerances of criteria are `Criteria.tolerances`. Each step gives the designs it selects for the next step (`designs`: the efficient designs of a refinement or a search, the survivors of a screening, and the designs confirmed) and its `criteria`, with `Refinement.candidates` and `Refinement.evaluations` (those it added), `Search.evaluated`, and `Screening.history` (the results of every stage; its `results` are those of the last stage, which other steps take). `robustness` takes the column of the scenarios from the criteria, gives ` ` for every objective that is not a value of designs, and gives an infinite regret for a missing objective. `optimize_pymoo` stops after `max_designs`, `screen` checks the share or number of designs it keeps (`keep`), `plot_designs` and `plot_means` draw the designs without a group (`by`) in gray, and `summarize` gives the spread of the mean of a `Utility`. + - The mission of each design of an observation study (module `plans`): `MissionPlan.policy` gives the restoration policy of each design (by default, restoring failed satellites; a policy, a function, or a reference to values that configure it, such as those of `policy_space`), with its spares in orbit (`RestorationPolicy.orbit_spares`, launched with their planes) and on the ground, and `MissionPlan.mission_of` and `ObservationStudy.mission_of` give the `Mission` of a design (its deployment, phases, cost estimate, and histories) as its evaluation plans it. `Failures(phases=...)` gives the time until each history meets requirements, and `Failures` checks its options when it is made. Exact expectations fall back to the means of the histories for missions with too many sets of satellites (`histories.MAX_SETS`). Planned replacements keep the launch interval, spares in orbit that are never used are not replaced at the end of their design life, launches are priced by the masses of the deployment, the phases of a mission are cached by the uncertain values of its replicate, and studies of staged deployments record the `stages deployed`. Simulations take a failure model (`Deployment.simulate(model)`), the options of `DeploymentSchedule.plan` and `ObservationStudy` are keyword-only, `layout_of` is exported, a layout names its pattern (`pattern`), `Stage` takes numpy values, and the development of a staged type that is never deployed is the cost of its option. References to values of designs are in module `references`. - Trade space tutorial (`docs/examples/tradespace`): eight notebooks that follow one trade of constellations, each adding one idea to those before it: `EvaluateTradeSpace` (design space, study, and Pareto front), `ExplainTradeSpace` (sampling error, revisits, and sensitivity), `SearchTradeSpace` (hypervolume, screening, and optimizers), `RankUncertainDesigns` (probability of efficiency, refinement, confirmation, and requirements on statistics), `CompareScenarios` (scenarios, regret, and searches across scenarios), `TradeCostAndUtility` (costs with uncertain growth, budgets, and utility), `PlanDeployment` (phases and staging), and `PlanForFailures` (failures, restoration policies, and the attribution of variance). Each notebook defines what it introduces, and imports what earlier notebooks defined from `trade_space_example.py`. - The `RunOSSEMonsoon` example declares its constellation trade as a design space, caches the looks of each satellite, evaluates its replicates in parallel, and finds its Pareto-efficient designs. diff --git a/docs/api_reference/tradespace/define.rst b/docs/api_reference/tradespace/define.rst index ba462f52..6b17cb03 100644 --- a/docs/api_reference/tradespace/define.rst +++ b/docs/api_reference/tradespace/define.rst @@ -9,10 +9,10 @@ Design Spaces and Designs ========================= .. autoclass:: tatc.tradespace.DesignSpace - :members: enumerate, size, sample, design, designs_of, extend, suggest, unit_paths, uncertain_paths, encode, decode + :members: enumerate, size, sample, design, designs_of, extend, suggest, unit_paths, uncertain_paths, check_uncertain, check_overrides, encode, decode .. autoclass:: tatc.tradespace.Design - :members: flat, realize, values + :members: flat, realize, values, decisions, scenario Variables and Values ==================== diff --git a/docs/api_reference/tradespace/evaluate.rst b/docs/api_reference/tradespace/evaluate.rst index 4f545428..da04350c 100644 --- a/docs/api_reference/tradespace/evaluate.rst +++ b/docs/api_reference/tradespace/evaluate.rst @@ -15,7 +15,7 @@ Observation Studies :no-members: .. autoclass:: tatc.tradespace.ObservationStudy - :members: satellites_of, targets_of, observations_of, deployment_of, phases_of, estimate_of, missions_of, prune + :members: satellites_of, targets_of, observations_of, mission_of, prune .. autoclass:: tatc.tradespace.Observations :members: end, start_of, end_of, cache_of, context_of, prune, __call__ @@ -23,15 +23,25 @@ Observation Studies .. autoclass:: tatc.tradespace.Targets :members: of, seed_of +.. autodata:: tatc.tradespace.references.Reference + :annotation: + +.. autofunction:: tatc.tradespace.references.value_of + +Missions of Designs +=================== + +.. automodule:: tatc.tradespace.plans + :no-members: + .. autoclass:: tatc.tradespace.MissionPlan - :members: schedule_of, cost_model_of, masses_of, growth_of, stages_of + :members: schedule_of, cost_model_of, masses_of, growth_of, stages_of, policy_of, mission_of .. autoclass:: tatc.tradespace.Failures + :members: seed_of, simulate, evaluate, summarize -.. autodata:: tatc.tradespace.observations.Reference - :annotation: - -.. autofunction:: tatc.tradespace.observations.value_of +.. autoclass:: tatc.tradespace.plans.Mission + :members: planned, phases, estimate, histories, metrics, summarize Stores of Results ================= diff --git a/docs/api_reference/tradespace/index.rst b/docs/api_reference/tradespace/index.rst index 2a6e38d3..e7a5b47c 100644 --- a/docs/api_reference/tradespace/index.rst +++ b/docs/api_reference/tradespace/index.rst @@ -53,8 +53,9 @@ A study gives **results**: a row per evaluation (a design in a replicate, and a scenario), with the key of the design (`design`), the `replicate`, the values of the design by path (see `Design.flat`), whether it is `feasible`, and its metrics. A **summary** has a row per design (and per group of the -criteria's `by`): statistics over its replicates, the number of -`replicates`, and the values of the design, and, of criteria, the +criteria's `by`): statistics over its feasible replicates, the number of +them (`replicates`), the share of its replicates that are `feasible` (which +requirements may name), and the values of the design, and, of criteria, the `violation` of their requirements, whether the design meets them (`meets_requirements`), and whether it is efficient (`pareto`). Functions take one or the other: @@ -106,7 +107,8 @@ objects, their keys, or rows of a summary or of results. A design gives its values by attribute (`d.layout.planes`) or by the path of a column of the results (`d["layout.walker.planes"]`, see `Values`), and a study realizes it as it evaluates it (`Study.realize`, and, of an `ObservationStudy`, -`satellites_of`, `observations_of`, `deployment_of`, and `phases_of`):: +`satellites_of`, `observations_of`, and `mission_of`, whose `Mission` gives +its deployment, phases, cost estimate, and histories):: confirmation = confirm(study, criteria, results, summary[summary.pareto]) @@ -121,7 +123,7 @@ arguments (`Study.replace`):: The parts of an `ObservationStudy` (such as its targets and mission plan) refer to values of designs by a `Reference` (see -:py:data:`tatc.tradespace.observations.Reference`): a name or path of a +:py:data:`tatc.tradespace.references.Reference`): a name or path of a value, or a function of the realized design. Stores of Results diff --git a/docs/api_reference/tradespace/judge.rst b/docs/api_reference/tradespace/judge.rst index 3fc007ad..abac481b 100644 --- a/docs/api_reference/tradespace/judge.rst +++ b/docs/api_reference/tradespace/judge.rst @@ -11,9 +11,14 @@ Criteria, Statistics, and Requirements .. autoclass:: tatc.tradespace.Criteria :members: names, metrics, statistic -.. autofunction:: tatc.tradespace.aggregate +.. autoclass:: tatc.tradespace.Requirement + :members: met, violation -.. autofunction:: tatc.tradespace.summarize +.. autoclass:: tatc.tradespace.Across + :members: weights_of + +.. automodule:: tatc.tradespace.statistics + :no-members: .. autoclass:: tatc.tradespace.Mean @@ -29,14 +34,20 @@ Criteria, Statistics, and Requirements .. autoclass:: tatc.tradespace.Probability -.. autoclass:: tatc.tradespace.criteria.Statistic +.. autoclass:: tatc.tradespace.statistics.Statistic :members: name, metric, reduce, columns, values_of -.. autoclass:: tatc.tradespace.Requirement - :members: met, violation +Summaries +========= -.. autoclass:: tatc.tradespace.Across - :members: weights_of +.. automodule:: tatc.tradespace.summary + :no-members: + +.. autofunction:: tatc.tradespace.aggregate + +.. autofunction:: tatc.tradespace.summarize + +.. autofunction:: tatc.tradespace.pareto_probability Pareto Efficiency ================= @@ -48,8 +59,6 @@ Pareto Efficiency .. autofunction:: tatc.tradespace.pareto_ranks -.. autofunction:: tatc.tradespace.pareto_probability - .. autofunction:: tatc.tradespace.hypervolume .. autofunction:: tatc.tradespace.hypervolume_progress diff --git a/docs/api_reference/tradespace/missions.rst b/docs/api_reference/tradespace/missions.rst index 9865dcc8..24855761 100644 --- a/docs/api_reference/tradespace/missions.rst +++ b/docs/api_reference/tradespace/missions.rst @@ -19,7 +19,7 @@ Constellations .. autoclass:: tatc.tradespace.constellations.Plane -.. autofunction:: tatc.tradespace.constellations.layout_of +.. autofunction:: tatc.tradespace.layout_of .. autoclass:: tatc.tradespace.constellations.WalkerLayout @@ -46,7 +46,7 @@ Deployment :no-members: .. autoclass:: tatc.tradespace.DeploymentSchedule - :members: plan, production_years, replacements, next_slot, per_launch, split, launches_of, mass_capacity_of, design_life_of + :members: plan, production_years, next_slot, per_launch, split, launches_of, mass_capacity_of, design_life_of .. autoclass:: tatc.tradespace.Stage @@ -83,7 +83,7 @@ Failures .. autoclass:: tatc.tradespace.Piecewise .. autoclass:: tatc.tradespace.RestorationPolicy - :members: ground_spares_of + :members: orbit_spares_of, ground_spares_of Missions ======== @@ -92,7 +92,7 @@ Missions :no-members: .. autoclass:: tatc.tradespace.mission.MissionHistory - :members: phases, metrics, in_orbit + :members: phases, metrics, in_orbit, deployed .. autoclass:: tatc.tradespace.mission.Phase :members: duration @@ -109,7 +109,7 @@ Missions .. autofunction:: tatc.tradespace.mission.summarize_phases .. autoclass:: tatc.tradespace.mission.PhaseCache - :members: evaluate, clear + :members: evaluate, metrics_of, clear .. autoclass:: tatc.tradespace.mission.Capability :members: evaluate, at @@ -121,13 +121,16 @@ Missions .. automodule:: tatc.tradespace.histories :no-members: -.. autofunction:: tatc.tradespace.histories.evaluate_missions +.. autofunction:: tatc.tradespace.histories.evaluate_histories -.. autofunction:: tatc.tradespace.histories.summarize_missions +.. autofunction:: tatc.tradespace.histories.summarize_histories .. autofunction:: tatc.tradespace.histories.allocate_histories -.. autofunction:: tatc.tradespace.histories.expected_missions +.. autofunction:: tatc.tradespace.histories.exact_expectations + +.. autodata:: tatc.tradespace.histories.MAX_SETS + :annotation: Costs ===== diff --git a/docs/api_reference/tradespace/search.rst b/docs/api_reference/tradespace/search.rst index b06c50f7..cdf85c57 100644 --- a/docs/api_reference/tradespace/search.rst +++ b/docs/api_reference/tradespace/search.rst @@ -12,7 +12,7 @@ Adaptive Replication .. autofunction:: tatc.tradespace.refine .. autoclass:: tatc.tradespace.refinement.Refinement - :members: results, summary, history, designs, uncertain, indifferent + :members: results, summary, history, designs, candidates, criteria, evaluations, uncertain, indifferent Confirmation ============ @@ -28,7 +28,7 @@ Screening .. autofunction:: tatc.tradespace.screen .. autoclass:: tatc.tradespace.screening.Screening - :members: results, summary, summaries, designs + :members: results, summary, summaries, history, designs, criteria Attribution of Variance ======================= @@ -52,7 +52,7 @@ Optimizers .. autofunction:: tatc.tradespace.optimize_pymoo .. autoclass:: tatc.tradespace.optimization.Search - :members: results, summary, designs, state + :members: results, summary, designs, evaluated, criteria, state .. autofunction:: tatc.tradespace.optimization.make_pymoo_problem diff --git a/docs/examples/tradespace/CompareScenarios.ipynb b/docs/examples/tradespace/CompareScenarios.ipynb index f108db49..a31e5870 100644 --- a/docs/examples/tradespace/CompareScenarios.ipynb +++ b/docs/examples/tradespace/CompareScenarios.ipynb @@ -41,10 +41,10 @@ "id": "4c97b966", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:06:00.886245Z", - "iopub.status.busy": "2026-11-14T08:06:00.886245Z", - "iopub.status.idle": "2026-11-14T08:06:03.887357Z", - "shell.execute_reply": "2026-11-14T08:06:03.887357Z" + "iopub.execute_input": "2026-11-14T15:43:44.017812Z", + "iopub.status.busy": "2026-11-14T15:43:44.017812Z", + "iopub.status.idle": "2026-11-14T15:43:46.976490Z", + "shell.execute_reply": "2026-11-14T15:43:46.976490Z" } }, "outputs": [ @@ -100,10 +100,10 @@ "id": "8e021fe5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:06:03.887357Z", - "iopub.status.busy": "2026-11-14T08:06:03.887357Z", - "iopub.status.idle": "2026-11-14T08:06:04.128039Z", - "shell.execute_reply": "2026-11-14T08:06:04.127036Z" + "iopub.execute_input": "2026-11-14T15:43:46.976490Z", + "iopub.status.busy": "2026-11-14T15:43:46.976490Z", + "iopub.status.idle": "2026-11-14T15:43:47.214691Z", + "shell.execute_reply": "2026-11-14T15:43:47.214691Z" } }, "outputs": [ @@ -176,8 +176,8 @@ " 0.67\n", " \n", " \n", - " d5bff0394d77\n", - " 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00\n", + " 87addc291d43\n", + " 800 km, 60 deg FOR, SSO: 1 at 09:00, 2 at 15:00\n", " 3.0\n", " 2.0\n", " 40.8\n", @@ -186,8 +186,8 @@ " 0.67\n", " \n", " \n", - " dfd5eb7d33d2\n", - " 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00\n", + " 904a205f7cd9\n", + " 800 km, 60 deg FOR, SSO: 2 at 09:00, 2 at 15:00\n", " 4.0\n", " 2.0\n", " 69.0\n", @@ -244,8 +244,8 @@ "design \n", "33b006848799 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 \n", "b85daf65c3a4 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... 3.0 \n", - "d5bff0394d77 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3.0 \n", - "dfd5eb7d33d2 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4.0 \n", + "87addc291d43 800 km, 60 deg FOR, SSO: 1 at 09:00, 2 at 15:00 3.0 \n", + "904a205f7cd9 800 km, 60 deg FOR, SSO: 2 at 09:00, 2 at 15:00 4.0 \n", "cb6bd361b577 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 \n", "5529c21520be 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", "de505bc89299 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 \n", @@ -255,8 +255,8 @@ "design \n", "33b006848799 2.0 26.2 34.2 60.4 \n", "b85daf65c3a4 1.0 8.0 17.0 95.6 \n", - "d5bff0394d77 2.0 40.8 60.6 85.8 \n", - "dfd5eb7d33d2 2.0 69.0 85.4 93.0 \n", + "87addc291d43 2.0 40.8 60.6 85.8 \n", + "904a205f7cd9 2.0 69.0 85.4 93.0 \n", "cb6bd361b577 4.0 96.6 96.6 97.8 \n", "5529c21520be 3.0 97.8 97.8 97.8 \n", "de505bc89299 3.0 97.8 97.8 97.8 \n", @@ -266,8 +266,8 @@ "design \n", "33b006848799 0.67 \n", "b85daf65c3a4 0.67 \n", - "d5bff0394d77 0.67 \n", - "dfd5eb7d33d2 0.67 \n", + "87addc291d43 0.67 \n", + "904a205f7cd9 0.67 \n", "cb6bd361b577 0.67 \n", "5529c21520be 0.67 \n", "de505bc89299 0.67 \n", @@ -309,10 +309,10 @@ "id": "8b9e713f", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:06:04.128039Z", - "iopub.status.busy": "2026-11-14T08:06:04.128039Z", - "iopub.status.idle": "2026-11-14T08:06:04.761224Z", - "shell.execute_reply": "2026-11-14T08:06:04.761224Z" + "iopub.execute_input": "2026-11-14T15:43:47.216693Z", + "iopub.status.busy": "2026-11-14T15:43:47.216693Z", + "iopub.status.idle": "2026-11-14T15:43:47.846284Z", + "shell.execute_reply": "2026-11-14T15:43:47.845151Z" } }, "outputs": [ @@ -380,10 +380,10 @@ "id": "acf5055d", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:06:04.762881Z", - "iopub.status.busy": "2026-11-14T08:06:04.762881Z", - "iopub.status.idle": "2026-11-14T08:06:05.030698Z", - "shell.execute_reply": "2026-11-14T08:06:05.030698Z" + "iopub.execute_input": "2026-11-14T15:43:47.847847Z", + "iopub.status.busy": "2026-11-14T15:43:47.847331Z", + "iopub.status.idle": "2026-11-14T15:43:48.082891Z", + "shell.execute_reply": "2026-11-14T15:43:48.082891Z" } }, "outputs": [ @@ -440,7 +440,7 @@ " \n", " \n", " 3\n", - " 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00\n", + " 800 km, 60 deg FOR, SSO: 1 at 09:00, 2 at 15:00\n", " 3.0\n", " 2.0\n", " 9.8\n", @@ -450,7 +450,7 @@ " \n", " \n", " 4\n", - " 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00\n", + " 800 km, 60 deg FOR, SSO: 2 at 09:00, 2 at 15:00\n", " 4.0\n", " 2.0\n", " 5.0\n", @@ -476,8 +476,8 @@ " description satellites \\\n", "at most \n", "2 800 km, 60 deg FOR, Walker 75 deg: 2 x 1 (spac... 2.0 \n", - "3 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3.0 \n", - "4 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4.0 \n", + "3 800 km, 60 deg FOR, SSO: 1 at 09:00, 2 at 15:00 3.0 \n", + "4 800 km, 60 deg FOR, SSO: 2 at 09:00, 2 at 15:00 4.0 \n", "6 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... 6.0 \n", "\n", " planes max_regret 1 hour regret 3 hours regret 12 hours regret \n", @@ -525,16 +525,16 @@ "id": "ae6ac96b", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:06:05.030698Z", - "iopub.status.busy": "2026-11-14T08:06:05.030698Z", - "iopub.status.idle": "2026-11-14T08:06:05.220711Z", - "shell.execute_reply": "2026-11-14T08:06:05.220711Z" + "iopub.execute_input": "2026-11-14T15:43:48.082891Z", + "iopub.status.busy": "2026-11-14T15:43:48.082891Z", + "iopub.status.idle": "2026-11-14T15:43:48.272688Z", + "shell.execute_reply": "2026-11-14T15:43:48.272688Z" } }, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABYMAAAFzCAYAAABsLxaJAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAu69JREFUeJzs3QWYE1fXB/D/btbdFRb3xd0Wd4capS3tV9eXeqk7pUZb6n37UgPquBWH4u6uy7q7J99z7pLsZndZgWQt/9/zBJKZycxNNrmZOXPmXCudTqcDEREREREREREREdVr1jXdACIiIiIiIiIiIiIyPwaDiYiIiIiIiIiIiCwAg8FEREREREREREREFoDBYCIiIiIiIiIiIiILwGAwERERERERERERkQVgMJiIiIiIiIiIiIjIAjAYTERERERERERERGQBGAwmIiIiIiIiIiIisgAMBhMRERERERERERFZAAaDqU5LS0uDi4sL7r33XqPpixcvxs6dO2ukTQcPHsSvv/56zfkyr1OnTggNDVW3jz76yGTbvnjxIr7++utKL29lZYXk5GR1v3Hjxqrt4r777sPGjRtr/L0kIvOqi33ookWL0KFDB9WPtm3bFi+99BJ0Ol21bLtkf+vh4VFmfzp69GicOnVK3f/hhx9w8uRJk7SPiGqfutiP6mVlZal+VPpTU+G+KBFZQh+6efNmdO/eHe3atVP96I4dO6pt23rcF6UbwWAw1Wm//fYbunbtir///hvp6el14sejYcOGWL16NY4ePYpt27bhq6++wqZNm2pkB/xa/vvf/2LQoEHqPnfAieqvutiHDh06VC2jv61du1a1tzq2XVkrV65Eq1at1H3ugBPVb3WxH9V7/vnn0bdvX5Num/uiRFTf+9DIyEhMnz4dP/30E44dO4YDBw6gTZs21bLtyuK+KFVIR1SH9erVS7dixQrd+PHjdf/973/VNHns6empCwoK0nXs2FH33XfflXregAEDdE899ZSuf//+uoYNG+pefvll9by+ffvqGjVqpPvoo48My+7Zs0fXu3dvXfv27XXdu3fX/fvvv2p6bGysbtiwYbrQ0FA17+6779bFxMSo9bm5ualtP/jggxW+hjFjxujmzZtXanpBQYHu0Ucf1bVu3VrXoUMHXZcuXXRZWVm6vLw83fDhw3Vdu3bVtW3bVjd16lRdenq6ek6rVq10Dg4Oatvjxo1T006fPq0bPXq0rlu3bqqdc+fONWxDuoCkpCR1X173gQMHDO/PokWLrvle/vTTT7oePXroOnfurN7DgwcPquk7duxQ7ZRl27Vrp/vyyy+r9PckoupV1/vQlJQU1T9Kf1VSZmam7pZbbtG1adNGLSPbElFRUbqBAweqvkr6UOlnpb+91rZ3796tGzRokOpzO3XqpPv999/V9AsXLujc3d3L7U/lvXN2dtY1btxYrVPeI/HBBx+o90L60BEjRuguXryopi9dulS9F/o+dPHixVX+mxJR9aqr/ejatWt1kydP1m3cuFEtVxbuixKRudXFPvSll17SzZw5s8LXxn1Rqs0YDKY669ixY7rg4GBdfn6+bsmSJaqD15s+fbpuzpw513yu/HhMmTJFPTcxMVF1uNIJa7Va3ZUrV1SHKR1pTk6O6pBXr16tnrd161adv7+/Li0tTffxxx/rHnjgAcM6ExIS1P8S2J0wYUKlX4OXl5cuPDy81Lz9+/ernW/5YRDJycnqvrQxPj5eTZP7Dz30kG7WrFnqcckdenl98qNx4sQJ9TgjI0N17vKDUpkd8LLeS/nxHDVqlC47O1s93rJli/oRE/IjvmDBAsOy8t4SUe1Ul/vQbdu2qR13e3t73YwZM9R2S/r7779VsKLk+iWQIdsX0n45Ibdw4cIyty2vQXa6IyMj1eO4uDj1euQ1VmYHXP9eFQ9Wz58/X3ffffepbesDGhIkEXKgsH37dnVf+nv9+oiodqqr/aisVwIAEngoLxjMfVEiMqe62odOmjRJ7X8OGTJE9XePPfaY4YRYcdwXpdrMpuLcYaLa6fvvv8ddd90FjUajauI8+OCDOHHiRKUv0bjpppvUcz09PdG0aVOMHTtW1dkJDg6Gr6+vusxN5ltbW2PEiBHqOf369YO/v7+6fKNXr16YM2cOnn76aYSFhWHkyJFVav+VK1cwYcIEdSldgwYNSs2XNuXn5+P//u//1GVyY8aMUW3RarVquytWrFDzU1JS0KdPnzK3IXWC5NKV2267zagu0/Hjx1WNo+uxZMkSHDp0CD179jRMS0xMVHXnpJ1vvfUWzpw5g8GDB6v3i4hqp7rch0qfd+TIEcTFxWHKlCnYunWrWkdxHTt2VK/nkUcewYABA9RrFNKHyqXR//77r6o1HBsbq+q3F+8n9bZv347z589j1KhRpfpWec3XQy573LNnj7okUhQUFBjmDRkyBP/5z3/Uezt8+HCT1vEkItOrq/3oY489hhdffBF+fn5qn/BauC9KROZUV/tQ6fe2bNmCdevWqXrH99xzD1577TV8+OGHRstxX5RqM9YMpjopLy8PP//8M3788Uc12ETz5s2RmZmpflAqy8HBwXBffiRKPpZOvizyAyN69+6tfkRkR1RqHMkObfGOtDxSZ0jqXr788su4+eaby1zG3d1d1RW+/fbbVY0fGTDp7NmzWLBgATZs2KCK1ksw5JlnnkF2dnaZ65AfFy8vL6P6mhcuXFA1jq6XrFOeX3ydUVFRcHR0xIwZM9SBQWBgoDrIkB8+Iqp96nofqic7+rJj/ccff5SaJzvIEmyQHXupzy472UlJSfj444/VTveuXbtw+PBh1ceW14fKwCDF+7vLly+rAMP1knXOnDnTsD7px+UmpG3z5s2Dk5OT6mfff//9694OEZlXXe5HJQAh+4/Sbgk+SF+pry1ZHPdFichc6nIfGhISok6OSRDa1tYWU6dOLbO+MfdFqTZjMJjqpKVLl6rONSIiQp3xk5t0wPKDIj8sbm5uKkvhRsmOsZy5kwGK9GfmoqOj1Rky2ZGVM4G33HIL5s6di9OnT6ui9xVtW3ZW5YybnA0sb0dYMt4yMjLUGbl3331X/UjKj4n8gPj4+KjtSGaFFITXK7ltab9Mkw5dT3biJXuiskquc/z48fjll1/Uj5CQ92fv3r2GM5RNmjTB/fffr3bAOdgHUe1Ul/tQCUjIOoX0gXLQLwGKsq6+kJ196bMkU0N2fMPDw1UfGhAQoA4YpC3FA8klty2ZbtJOyfzQk53m3NzcSr8HJdc5ceJEdUWIvh+W91sGHtG/Ntnhl6y9hx9+mH0oUS1Wl/tRfXvlJgMVtW3b1jDqfHHcFyUic6nLfagEbzdu3IicnBz1eNWqVSoLuCTui1JtxmAw1UlyxnDatGlG0+RyErkkZNmyZbjzzjvx+++/o3Pnzmo04utlZ2enzhLKZR8SbJBsgz///FP9aGzatEldWiE/JNJJf/DBByqDQgK98sMgyz/00EOl1vnqq6+qnddPP/1UPVduxXeQ9eSHYtiwYWo9chZRbnJ5iFxKI2dN5YdNHvfv39/wHFlWOm9ZVn50bGxssHz5cvUa9PPuvfdedRldZZV8L2V7coZw0qRJ6kdP1qkf8fTzzz9Xj2VZyXr+6KOPrvu9JyLzqct9qIw6LX2c9D+S0SHL33fffaWWkwyHvn37quXkdchrknXKpW+SiSF9lUyTqzT0Sm5bMj4k2CxBEFmPBExeeOEFQzC6Mh544AH1fHmdMrKzvO933323upRZ1inTJcNOSOBC34fKwdDrr79+3e89EZlXXe5HK4v7okRkLnW5D5VlpX+TtrVv3x7x8fF45513Si3HfVGqzaykcHBNN4KIiIiIiIiIiIiIzIuZwUREREREREREREQWgMFgIiIiIiIiIiIiIgvAYDARERERERERERGRBWAwuJ6QQuBdunRRxb9lwIYff/zRMC82NhYjR45EixYt1LwtW7ZUal5xMkqwjDppLm+88YbRAED//vuvGnlTirrrSQH1V155pdz1yCjHMrqmGDhwIBYvXmzSdj766KOGQd/kJiOAfvbZZ4b3SArO6+dJQfbKkhGZZQRVc5FC8K1bt1YF4rt164Y1a9bc8DqfeOIJ9X7L30n/nl/LoUOHMGbMGFT3CLVPPvmkydf79ttvo1mzZur20ksvGabL4ChSnJ8sT13vf4UMrKEfQEP6isGDBxsGpti8ebMaqE3myaAVMhBGTEyMUftk8AwZ9KN58+aYOXNmpUY4joyMxIgRI9QARDJIxpQpU9TI9VUl/Xx5Ix3/73//U+2TQYw++eQTo3kyeIYMVKLvt5999tlrrkcG+pA+tGXLlur9kdGvKzOvPDfddBOCgoJUP5qcnIzrIe+/jPx8LeV9zvbs2WMY2KT44CHV9fqJBPtQ9qHX04dU1+uXgfKmTp2q/jbSPhl4Su/MmTNqgD39IHYywOm1yLIy6JSso3v37jh27Fil5pFlSEhIMDrGlM+CfOcSExPrTF/I43nzHs/Lcaf0xfq26QfNvF5V7UPry/G8vG/6/Y3Q0FCjQUYPHz6sBkW1GDKAHNVtWq1W5+npqTt06JB6fOHCBZ29vb0uNTVVPb7nnnt0r732mrq/e/duXXBwsC43N7fCecXNmzdPN2HCBLO9hs2bN+uaNWtmePzmm2/qevbsaWibaNmypW7Dhg3lrqdRo0a6AwcOqPsDBgzQLVq06LrblJeXV+78qKgonYODg/r/Rt8jb29v9Xczl5UrV+oyMzPV/YMHD+rc3Nx06enpN/w3Cw8PN3rPr2XUqFG6LVu26Oo6ec1t27ZV7112draua9euuuXLlxvmd+nSRXf69OkabSNVr/rQ/0ZGRqo+6OLFi4Zp+/btU69N+kF5ffJY7+TJk7q0tDR1/5tvvtG1bt1ad/78efU4IyNDN3nyZN0dd9xR4Xajo6N1W7duNTx+5plndNOnT69y++U5c+bMueZ86fOOHz+uu/POO0stV9Fz9QoKCtRvlP436IMPPtDddNNNFc6ryNq1a3UxMTEykK8uKSlJdz0q+q271udM/r5yX9ogTp06pWvYsKHht6I6Xj8R+1D2odfbh1TX63/jjTcM65W/k6+vry4+Pl497tOnj+67775T92NjY3UhISG6K1eulLmeQYMGqc+i+OOPP3TdunWr1DyyTPI9GDt2rOFxXegLeTxv3uP54vuJ0s+4urrq4uLirnt9Ve1D68vx/L///mv4eycnJ6vP7MaNGw3z5e+/fv16nSVgMLgekJ1NLy8v1QEL2aEOCgrS5eTkqMfOzs6GD7zo3r274eCvvHnFFe8YIyIi1E7K999/b+iwX3rpJV3v3r11DRo00H311Ve6//3vf7pevXqpeQsXLqzwNUhbHR0dVXBRDB48WLdixQr1A6Df0ZaOOisrS/fRRx+p7Xfs2FH9v3379gp/PP78809dhw4ddGfPnlUHGPfdd596re3bt9fdf//9hvdKnvP444+rtsuOWXnee+89ox+Lqvx4LFmyRO38y/afffZZox8PCSaOHj1avTaZP3fuXMPzFi9erJ4nr+W55567rh8d2emWH4+yniefoaZNm+oSEhLU40cffVS9V+WpKBh86dIltXOsJzvLw4YN04WGhqrXd/fddxveP3nPx40bp2vTpo2uf//+hjYePnxY17dvX13nzp3VvLfeesuwPvnbyY9Xu3bt1PsyYsSIUn8P6eBl/sMPP6yWkYDunj17DOv4+uuvdS1atFDrlx2Xa50ne+SRR3SzZs0yPP7iiy9006ZNM/pMyN+FLEd96H/l++vn52cIvhSXmJio02g0artlkQMO6auLk4Nk6c+lv60KOQDW9/klrVu3Tr2mTp06qe/vf//7XzVdti2BFnnP5TdBf1Be2QP+ygYy5OCqVatWhsfyXknASn6TyptXWRUFg+fPn6/r0aOHev3Shy1dulRNl9crn6PGjRur11/yb1He50wOIOzs7IyWlT75r7/+qvbXT5aLfSj7UFP1IeZ6/bL8jh07DI9vvvlmw3LyGSz+t5V9WDlOKUlO+sm+tz4wJZ97f39/3ZkzZ8qdR5ZLjveKB0HrQl/I4/nqO56Xk4ouLi6q/yjpl19+UQlLkrgk/YmcVHj77bdvqA+tT8fzJY0ZM8ZwMk78+uuvultuuUVnCRgMriekw5eORL6kskOh/wGQHcqSB3uyEyMdf3nzStJ/EeVLLF+8NWvWGHXYM2bMUPdlx0U6ef2XW3bwfHx8KvUahgwZovvpp59Ux9WkSRM1Tc7UyA+GHAjrO3PpfPRk56z4DmRZPx7yY9OvXz/DWXz5sfjxxx/Vfekg7733Xt37779veI50PmWdTS1JzmzqD8j175H8DeRHTX5If//99zKfJ522HPgcO3bMkBUinZV0lPn5+arzPnHihCFDRDpYeR/1z9PPkx9o/fPEK6+8on64KyI7wNJGee1leffdd1UH/ttvv6nlKtoZrygYLH/TKVOmGB5//PHHugceeMDwWB94lvdPPo+SfSJmz56tfmSE/ODL50JI1prszOt3zF9//XXd+PHjDfP1n4+SPx5yMLZz5071WN6n4cOHq/tHjhzRBQQEGHaiXn311Wv+eMiP6YIFCwyPZQdHfuT05GBW/n5kWep6/ysniCQTTQ6IJ06cqPrD4plN//nPf9QOp2QEyM6VZJAKfUarBDtKkp00fR8o/ci1AiF60vdJ/yv9Q1lkG7KMvs+Q91p/sFHZYMS1AhkSSJV+VnYGi/dl0k9Iv6o/ANH3GXqSHXbu3Lly55kqGCyfF32fLX2+BAr0fV55WTMVfc7k8yN9vf7zIsvqAxnV+frJsrEPZR96o32IOV+//O0kiKUnQR/96woLC1P7q0LaK59jCULpA0VyjCH27t2rjhuKkyCWZJ+VN48s07Zt29TvvP4EQV3pCwWP5817PP/pp5+qNjs5ORkdk5Ykx9qS1CXvyciRI6953F/ZPrQ+Hc8Xd+zYMfX30P8e6APf8hmwBDY1XaaCblx+fr6qYyr1ysLCwlQNwPHjx+PIkSOqTo+pSP0qWa/U7ZHaWMXdeuut6n+ppyV1d6QOopD6tFLrSGohenh4lLt+qckjNYUaNWqEHj16qGm9evXCjh071HR9zZ4DBw7gnXfeUbWVpJbSqVOnkJWVBUdHx1LrlPfF398fa9euVe0S0n5Z58cff6wey3M1Go3hOXfccQdsbW3LbevWrVuRlpaG0aNHG6aNHTsWt9xyC5ycnHDixAkMHz4cDRs2VK+hOKlLJnV5pG6cuPfee/H444+r+/Ja5H2+7bbbDMvLdo4fP46oqCj1PKlFJ6ZPn67qLum9+eabqMj69etVPSd5P6712XjhhRdUrRypf7t7927D+3a9rly5ov4GevJ+zJkzB08//bT6vEqNKz2plyY184Rs/+WXX0ZBQYH6Gz3yyCOqfpS1tTXCw8PVfVmX1OqdPXs27O3t1fN8fX3LbId8Nnv27KnuS+2+Dz/8UN2XGpnShoCAAPX4/vvvr9R7WRZZh7xeshz1of+V79Rff/2l6s5KbctVq1apPnbv3r1qnVIjUup1bdy4UfUhnTt3VnXHpZ5dZVRUU1xiofL99vT0xH/+858yl5H+XvrK06dPq35fHh89ehQNGjTAjZDXGRgYqN6DRYsWqb5Paje6uLgY9a817cKFC5g2bZrqX/Q1BGWa/vfgei1ZsgTPP/88Zs2apepd9uvXT61f1KbXT/UX+9CKsQ9FrX39Ut9a9mel/qQcvwwZMsTQh8rnTW5EVfX999/jrrvuMnyWTInH83X7eF7G7JGb1O+V1yjt8/b2LrXcp59+qo57pebu/v37y/09rUwfWh+P569cuYIJEybg66+/NvotkHXI5zI7O/uG4yC1HQeQqwfkSyQFwOWLKGTgAflASycrnYN0sNHR0YblpbB5SEhIufPKIoPcSCdQ1gAzxb8o0hHrH0vHIzfZ2a+I/DjIjrLcpFi8GDBggGGaDCghA2pMnjxZffFlJ05fID8nJ6fMdUpnITt+58+fN+rwZKdd3je5SYf9zTffGObLDmxlfqSl8y7+oyNF4+WHQ0gHKD8s27Ztq3BdxTtnaZuXl5ehbXKTA37Z1o2SA5R77rkHy5YtU4Xir0V+rOT9cnZ2vq6BOEqS90Q6Uz3puOV1yd9GDv7k8yo/EBUNgCfvr3ym5cdPPh/F11kZJT+j1/pMlvdjKd+NS5cuXfP7Im0qayeG6q/60v8K2TF98MEH1Q627JjJDqSe7NTLQEE///wz7rzzTvz+++/w8/NTAwfJznhxsgMlwQAZEKoyZKdWdghl4B3ZOSyL7ChLoFICRPKeSxClqn1AWaT9+m1OmjQJbm5u6jehou++9JMpKSnq71LePFORAwoZlEV+9+T1y+9UZV5/RZ8zORBcvXq1+rz+8ssv6rMsQeHa9vqp/mIfyj70RvsQc7/+8vb9ZKAr/TGFnFyTdpfVh0owSYJA+s+S7O9fvnxZrae8eWR50tPTVf/wf//3f4Zpdakv5PG8eY/n9WT/Tfrf4oPzFSeDCiYlJamBTCsaoLgyfWh9Op4Xst8xdOhQFai++eabjeZJm2TddnZ2qO8YDK4H9DsRcvZKnD17FufOnTME/OQDLmc8hGRcyAi90ilXNK8kOVskZ+RkJ/d6MyflLKdkDpRFOhHpuObPn2/04yEjPsrrk7OL8uWUHxD9D9zcuXPL3Z6M8CujII8bN06dFRMyiqqcedJ3HtJRyntWWampqWok4eI/0qL4yMcySrT8yEr2R0nSecpIlfrR36V9+lGj5W8mO9Lz5s0zLC9tk7OxcmAhz9PvZMuBe2VGmxbyIysHH7KjWvIscElyZlMy0GRHRJ4jByU3Qs5+Fj8wkB9D+YGWs67y95Mfd9nxEXJApH9f/vvf/6odCumM5W8kB4f6M8fyOdSTs9ty9lO/A1HVALZsQzJ05LOn3zG4Fvm+yIFcRkaG2p787Yqf9ZXvYEXvL9Uv9aH/le0W39GV75t8T5s1a6a+m5LlVljJoDDzQl6rzNOPbCxZAbK8ftR1yQKQoIB+mYp2QOU9k3aVt9MlbZJgiuzcSX8mO5F60mfKAfj1KJ7JL1ke0t9J1kFJXbt2RV5enjqQEXLAIb8rslNa3jwhmWJylcWNkNffpEkTQ98vjyv7+sv7nMlnV++7775TJwHlQM2Ur5+oPOxD2YfeSB9aHa+/+OdM/k4SfJFjCf3+vgRbhOxLSubf7bffXmodEviX4L7030KCWLJfK+9VefPI8khATo4lSl75Uxf6QsHjefMdz0v/oie/kxJU1WcmFyfviRyfvvXWWypzWo65rxVor2wfWp+O5+VzKL8rzz//fJkBevmNDg0NvWZgvF6p6ToVZBpSM0YKeEuNMflfavIUHylSarU0b95c1QcqPoJnefOKK16vRWq8SB0eKfJdVs3YkkXQpbaLfqRLKRZevNB3SbJeqfdSnDzWFxHX156RWl9dunRRdXCK11q8VsF5qdEjdYtk9EgZwVlq6EgBcqnfI0XG9fXpKjNiqdQEkhphJc2cOVO9h1JjSNYrg4tdS3mF46UovtSmlXXI+mRb+tpzf//9t3qebEPef6ljpn/t5dUYkr+vDG4iz9PfpF5USVLcXor9S/07Ie+vFL8vq86Q1AmSgU/k7yvrLj56bHFSr0n+LvpaQlIbST6j0gb5G3z22WdGBeelXpC87uIF5/fv32/4e0k9PllGX99NX3Be/95LTb6yagzJPD2pKyRt0pO/lbxH8lmQv6O7u3u5o0rLZ0luL7zwgtE8KZ7/888/X/O5VD/V9f734sWLquaWDLqg/16+8847hvpe8n2TefL6ZB1PPvmk0ejMMpCOPEf6JhmAUuop6mt+lVfvUvpj6b/1fZrc5Ptdln/++Ue9T7KM1HeUOm7F+3d5/6T2WFmD/8j7J32V1FeT77bclz5FX9tO3x/JQCPF/wbF610KGdxE+iB5L+S34vLlyxXOkxps8je5Vr1P6V+lPfI+yABG1xq4Q/oVqcspr/Gpp55Sv4H6v/uyZctU/bhrDSBX3udMarRJm2We1Iov/ppM8fqJKoN9KPvQ6+lDq+v1p6enq8GE5G8j7dPXWReyvOz/Sh88cOBAtX+pV7xmsH7AJ3mPZB1ST7T4fnh588iyyGdTjpVKqgt9oR6P581zPC912fVtk37iWvWMn376acOAbvoB0B966KEb6kPr0/G8DDwov2cdi8VFin/nZN+4+OB29ZmV/FPTAWmyDHKGR86WFz8LRFUjl865urqq+3JGd+bMmYZsmtrsgw8+UP8/++yz11zmhx9+UK9JbjX5vspZSblsWjJ5qiI+Pl5l1EmNQEu4rITqFva/NUMydCTLTTIjiKjuYh9aM9iHEtUu7AtvHI/na+/xfG5urqqRLRnhUtKivuMAclRtpBA4fzhujFyGIZcPSU0eufxELsGpC6QYfXmXa9Q0GTRPLvGUyxSlllbxmlOVJZfryCVaDARTbcT+t2bI5ZJyI6K6jX1ozWAfSlS7sC+8cTyer73H8xcuXMB7771nEYFgwcxgIiIiIiIiIiIiIgtgAVWRiYiIiIiIiIiIiIjBYCIiIiIiIiIiIiILwGAwERERERERERERkQVgMBiAlE1OTU1V/xMRUdWwDyUiun7sQ4mIbgz7USKiqmEwGEBaWhrc3d3V/0REVDXsQ4mIrh/7UCKiG8N+lIioahgMJiIiIiIiIiIiIrIADAYTERERERERERERWQAGg4mIiIiIiIiIiIgsAIPBRERERERERERERBaAwWAiIiIiIiIiIiIiC8BgMBEREREREREREZEFYDCYiIiIiIiIiIiIyAIwGExERERERERERERkARgMJiIiIiIiIiIiIrIANRoM3rJlC8aNG4egoCBYWVlh8eLFRvN1Oh1effVVBAYGwtHREUOHDsWZM2eMlklMTMS0adPg5uYGDw8P3HvvvUhPT6/mV0JERERERERERERUu9VoMDgjIwMdO3bEF198Ueb8999/H5999hm+/vpr7Nq1C87OzhgxYgSys7MNy0gg+NixY1i7di2WL1+uAswPPPBANb4KIiIiIiIiIiIiotrPSifpt7WAZAYvWrQIEydOVI+lWZIx/PTTT+OZZ55R01JSUuDv748ffvgBt912G06cOIG2bdtiz5496Natm1pm9erVGD16NK5cuaKeXxmpqalwd3dX65cMYyIiqjz2oURE1499KBHRjWE/SkRUNTaopS5cuIDo6GhVGkJPOviePXtix44dKhgs/0tpCH0gWMjy1tbWKpN40qRJZa47JydH3Yr/eAitVqtuRESWTPrQ8rAPJSK6NvahRETm60MF+1EiohvrR2ttMFgCwUIygYuTx/p58r+fn5/RfBsbG3h5eRmWKcusWbPwxhtvlJoeGxuFrCzWGyYiyxYY2KDc+exDiYiujX0oEZH5+lDBfpSI6Mb60VobDDanmTNn4qmnnjI6k9iwYUP4+QXyshIiogqwDyUiun7sQ4mopiUlJeLo0SOqrIJcfRsa2h6enl6oK9iPElFNik9IwJKtpxGVnI1ADwdM6N8SPt7eqEtqbTA4ICBA/R8TE4PAwEDDdHncqVMnwzKxsbFGz8vPz0diYqLh+WWxt7dXt7JSqSuTTk1EZMnYhxIRXT/2oURUk44cOYw1a1YaTduzZxdGjhyN0NAOqAvYjxJRTfl+5RF8vS0PmdqiE2jf7gvHQ32jce/o9qgram1P2aRJExXQXb9+vdEZP6kF3Lt3b/VY/k9OTsa+ffsMy2zYsEHVCZLawkRERERERERUmBEsgWAZrL3kbfXqlWo+EZEl0ul0Krk0Ozsb6enpKtYYHx+P6OgoXLlyBYmJCVi8KxIfb9UgU+tg9Fx5LNNlfl1Ro5nB8gafPXvWaNC4gwcPqpq/ISEhmDFjBt5++220aNFCBYdfeeUVBAUFYeLEiWr5Nm3aYOTIkbj//vvx9ddfIy8vD4899pgaXE6WIyIiIiIiIrJkcpx85Uo4/v13iwp4lJc1HBY2sFrbRkRUkvRTBQUFKjhbeMsrdj8f/v4BsLW1NSwfHx+HixcvGJbNy8tHQUHR8vJYpjs4OGDcuMJ4ot6KFctw5swp1U9qdYAWGhTorFEAaxToNIb/GzVtjR+O+13NqbUq0WJ5rMOHqxMxrnsgNNYl59c+NRoM3rt3LwYNGmR4rK/7M336dPzwww947rnnkJGRgQceeEBF5fv164fVq1erP6De/PnzVQB4yJAh6pKQKVOm4LPPPquR10NERERERERU04GU2NgYXLx4EZcuXVCBYAmsVCQlJbla2kdUH2vILt5yElFJ2Qj0dMDEsNZ1roZsRRmzxoFZCdTmwcbGFr6+vkbLnzhxTCV+Xus5+mkdOnREq1ZtDM9LTk3D/+bNQ06+Fjn5usKA7NVgrLZYUFb+7xc2FPaOLsgt0CEnT4fLV6Jx4vSVwvlGgVxbaHUOhsc6a1v8fOmCWn9OnhZ5BTqkZTRGTn4jFQTWllc84WBF75QVkrI12HcxEz2aOqO2s9KVd2rQQkj5CSmcLwX0WXCeiKhq2IcSEV0/9qFEZEpS7uHcuTPIzMys0vOsrKzQo0evOpkZzH6UakcNWUfDNCfrLDzU19bkNWSlJGrxIKtkv+qzXmUQSEfHojakp6fh9OlTpYKwJYO08vwJk25GntYKuRIkzddh1569OHj4KHLzJWBqdTWYKkFWjdH/ru7eaNe+c2FwVZbN1+HI8ZNIz8wxCt5qiwV29c/X2DoC1rZqG/J8ycqtD96/NQhjOrmjtqu1A8gREREREZVF6lrK5cySxebu7oH27TuogyAiIkuRk5OjalgGBhqXR5QAUMlAsARIGzduAm9vX2zatP6apSKkLyWiytPXkAXkVrKGLODtHYmJPYNw4cJ5te+iD9zqA7k5ufnIzi1ATp7ctPAPaoiWrdur4KgEZiVQunjpMmTm5Kss2HytlQqmFpUyKMqEDWncAk4u7oaAbkp6JsKvZBQLyjqUGdCVdb158EyJV+YBoF/Fb0AmsC4qrsRE/8q9eTnyT8VXLJiaxhqws7GCvY311f+t1P/FpxVNL1omMSMf646lV7h+X7e6EWatG60kIiIiIrpa01IGQCpu9+6dGDlyNEJDGcggovpJMgKjoiJx6dJFVRtT7ssl2o8/PkOVS9Rr1KgJIiIi1Bg8cr9x48bqZJlk/goHB3uVPVyS9KE8qUZ0bTk52WpAMTkRLWVMI+JSMXu3nIyxu2YN2VeXJGP+7mwkJKUiM0enyhYUSNmCq0HYUmUJDgFYdb7EujpWqn3HTsq/KSWmSo3b2sNWUxiItdNYwd7W2jj4ant1ukzT35f/5bHhflHQtrwgrqzb9upz1HIaK9jZFq7HRnN99XwLtDoMe/8sYlLyyvh7Cx0C3G3RtbET6gIGg4mIiIioTpCsGgkEl5XVJsGN4OAGDGYQUb0g/VxycpIK/Ert3/DwSyobuLjc3BwVFJa+T69Tp87o2rWbUYC4ODlpJsvz6goiY5KtK6VGUlKSVLC3Zas2SMuzQ3hiLsIT8rD3RDgOn4tGWoEz0rSuyNVVVBNYsniB45HyvbW/eqsZErq0s7kajJXAqCEAWxiQdZBAqbp/rQzZwqCsYb4K1loXBWivBneNArI21rA13LdSwVnrOjCw2rXIoHAzx/rjyfkRKOvaCitY4YWx/nVi8DjBYDARERER1QkSvKhofl2sd0lEVJyUefjllx9UYOpaJHgrWb8ODkU1QoWtrW2F65fnsq8kS86wl2CvnAyJT0zG5bgshCflIy7DGqkq0OuMtAInZFpdRl5ByfBZ0YmXypLYoJ1GArE6FRCV+8XLEBRmr8r/1nCw06ibPmCrAqzFsmLLCtKWV9pAnmerkSzZwrrgdGOGhbphzjRg1vIYxKTkG6YHuNuoQLDMrysYDCYiIiKiOiEhIf6atS6FHNgREdWlTMTIyAgVoJKavnoyCJRMK06mhYQ0VgFgKf8gA6YRkbG8vDxDGQd95ntAg6YIT8zD5YRcXE7IwcpNR1R2b6rWGRlayYivWpDUCjr4uljB3dEaZ+KMv6dl+f6+EPRo6nwDr4pqk2Ghbhjc1hX7LmYiLjVf1QiW0hB1JSNYj8FgIiIiIqozB3nlkYM+IqLaSk5mSc3RS5ek9MMFXLkSrvq1wMBAo2CwZPA1a9YciYmJanqjRo3h7x/AzD6iq+Lj4xAdHa0CvklJyYhMSFcB39gM66tlHJxVlm+mVTYy80+XeHbjCtcvWbzBHrZo7OeAhl52aOhlixDvwv+DPO1U5m19qyFLlSeB37oe4GcwmIiIiIjqhKFDh+P777+95nype0lEVJukp6dfDf5eVIO/ZWSUHo1eglrZ2VlGJR+GDh1htuCvBLHqelYb1V+5ublXa/dKhm8S0tLS0K//IESn5uNyfK4K+m47cB5no9KvlnRojPzrCG252AHBnho08nVEYx97NPS2MwR8fV1tKqxvW99qyJJlYTCYiIiIiGrtAaGdnYzSXcjLyxtDhgzDhg3rSi07cuRoDoBERLXKhQvn8eefv11zvrOzi6Hsg7W1xmieuQLBa4+mlqp36e9uo4JadaneJdV9WVlZOHfujCrpILe4pFSEJ+QWy+51uvq/GzLXnUKBUUUG+axW/Hn1cbZCYz9HhHjbFmb4Xg32yv/ujsbfOUuvIUuWhcFgIiIiIqp1zpw5jTVrVmLcuInqEmm9Ll26oUmTpmqwOH09QMkIZiCYiGqq9ENMTLQq+xAYGGTUX0n5Bwnq6mudy+BuDRuGqGWk/IO3t0+1ln6QQHBZWYyxKflqugS1GLwiU8jNzUFyckqx+r1JaN68Jdx9GyI8IQ+XE3Nx+koKNu2Juhr0bYAsnfFgiJVhYw0EumsQ4mOPRpLdqwK+hYHfBl62cLC1hrnVlxqyZFkYDCYiIiKiWjWg0pYtG7Fv3171eMWKpZg+/V44OxfVZpPAb1jYwBpsJRFZMrmEvaj0wwVkZ2er6aGhHYyCwVL2ITS0vcoAlulBQcGwsamZQ3ApDSHZi2Vdzi7TJGz13vIYFdRiEIuq4tSpk4iNjTHU741IzDaq3VtYysENmZszkZV/psSzQypcv5MtCks4FAv2hlz9X2ry1obPa32oIUuWhcFgIiIiIqoVkpISsWzZEpVlpxcc3AAazY1fyklEdL1ycrJx+fJllf0rwd+kpKQyl5N5kgVcPNt35MgxqEmZuVpciMvB2iNpRpexlxUQjk7JV9mNDGqRyMnJuZrVW5Tdq9HYoF/YYFxJzEN4Yq7K8l2/MwaRKVqkFgQiXdsMWlT9N9vLyQoNvfXZvYVlHPSDtnk6azh4IpGJMRhMRERERDXu5MnjWLNmlaoTLCQAPGjQUHTq1JkHgURUo+RKhW3btpY5z97eASEhjQy1f2uqv0rNKsD52Byci83F+bgcnIspvB+ZnFel9chl7mR5YmNj1e+wPvAbm5SOOMnu1TojVZ/hW+CMdJ0LMtadwtXKJ1f5Vbh+Sd6VOrr6YK8aqM1QzsEOzvbmL+dAREUYDCYiIiKiGpOXl6cGhDt8+KBRGQipFezv71+jbSMiyyDZvImJiVdLP1xQZWh8fHwN86XEgz4YbG1trco9SM1fmR4QEKimVZfE9Hyci83B+bjcqwHfwvuxJgriSr1Tqj+khIk+wFuU5ZukTrbC3gOXr9bvPXg6AftO5iKtwBdp2sbI0dlXeVv2NlCBXQn0qmCvIcPXDkGetrDV8MQuUW3Bnp6IiIiIakRiYgKWLFmE+Pg4w7Q2bdph+PARsLOr+oEoEVFlZWZm4tKli4bav2lpqYZ5DRs2MgoGy8Bw3br1QEhIiBoAztz9kwSnJbirAr2xuep/fdA3KaOg0utxsbdGUz87NPOzRxNfO/xvSyKSM8t+voTp/N0LB76iukk+N1u2bDIEfxOTU5CQaVy7tzDLtwneOxKPnPz4EmtoWOE23B2tr2b1FgV79fV7fV1teCUPUR3BYDARERER1Rg5aBUyqNLQoSPUYEs8mCQic7hyJRznzp1V2b8y4NW1REVFGj2WzN9Bg4aYvD1arU6VcTAK+F69n56jrfR6PJw0aHY16Cs3fQDYz804OCdBvCfnR6j7xa/y1y/xwlj/WjEYFxnLzs4yqt2rvwUFBaFrz/4IT8g11O9dtTUPSTleSNU2RIbWETpULWtdf1KgMMhblNmrL+ng5sga/kT1AYPBRERERFQjvLy8MWzYSOzevVOVhfDx8anpJhFRPVFyIDexf/9enDp1stSycjJKBqssLP3QBH5+FddArYr8Ap0K1pUM+kpt3+w8o+Kr5ZLgblPfq0Fff3vDfS+Xyh3WDwt1w5xpwKzlMUaDyUnwTwLBMp9uXHxCAhZvOYmopGwEejpgYlhr+Hh7V/r5Urv31KlTKviblJSM1GwtUq/W7NXX7k2TYO9RN2SsPFXl7F5bDdDAsyjAW3ywtmBPW9jbsn4vUX13Q8FgGeDDzs7OdK0hIiIionorLi4OHh4esLW1NUxr1y4UrVu3UQPGERHdiLS0NEPd34iICPzf/91v1N9IoFcfDPbz81c1fyUALIHg4stdr9x8LS7FS8DXOOh7MT4XeQWVD/oGedgWZvqqgK9k+9qhqZ+9SbIyJeA7uK0r9l3MVIPFSY1gKQ3BjGDT+H7lEXy9LQ+ZWi/DtG/2XsK9PS9jQnd/owxf+V9u0+++HwkZULV7LyfkYufhLJy87Io0bYAK/Oah6p9NKRGiD/YWH6xNAr/+bjb8exNZuCoFg7du3YJVq1Zh//59iI6OhlarhaOjI9q0aYPevftg0qTJJj+LSkRERER1P0Pv0KEDaqC40NAOGD58pNF8BoKJ6HqTk8LDLxsCwAkJCaXKQjRp0tTwuFmz5hg7djxCQhrD2dn5urebmavFxbgcQ9D3vAr8Fl6qX1DJ6g4Si5PgXDP/wuxeFfT1t0MTX3s42Zk3M1MCgT2aXv/rp7It3hWJj7fK75nxb1qm1gFzdwC7Dm2Fq3VmsSzfQKQVNMeXb55FnlEpZ6nbXHHtZh9XzdWB2krX75XSISy5REQ3FAxet24d5sz5CBkZGejfPwz/93/3qqCvvb09UlJScPbsWezcuRPffPM1JkyYiMcffwJeXkVnwoiIiIjIMuXkZGPNmlWGbDwJCktARm5ERNdzcmnnzu0q+BsZGaESlMpia2unMoWLc3FxUYNUVlZadkGJ0g6FQd+IpLxKr8NGAzT2KczuLaznW3i/kbcdL8evRwq0OnywOlHC/MWqMOvJYx12Z3ao0jo11oVZ4sXLOOjr9zbwsjP7SQMisvBg8Lx53+O5515A//79VfH8a4mJicGCBfOxfPky3HXXdFO2k4iIiIjqGBmEadmyJYZB4kSXLl3VpdlERJU9oWRv72B4LNmOJ04cR0JCvNFyMj0gIFCVfZBbYGBQpa86SMrIL5XlK/djU4vq6lbEwdYKTXxLD+ImQTtbDTM06zspu5GcXd7nrezPgKOtlSHYaxis7er9QA9bfnaIqOaCwfPnL6zUyvz9/fHkk0/daJuIiIiIqI5n7u3btwebN280ZO1JMGfkyNFo2bJVTTePiGqx7OwsXLp0CZcuXVTZvzY2Gvzf/z1gtEzjxo1VMNjDw1Pdl1rAISGN4OBQFDQuq1+KS7sa9I3JUYO36YO+SRlG1+iXy9neulSWr9yXDE5r1mG1WFJ/uTKGtHXFkHYuhvq9Pi4s50BEdWwAOZGZmal28uWSGyIiIiKybFlZmVi1agXOnTtrmCYZeuPGTYS7u3uNto2Iap+CggJV7qGw7u9FREdHqcBtcWlpqXB1dTM87tq1B7p06a4GpCxJq9UhKiUP52JyrwZ8c9R9+T89p5IFfQFVc7WsoK+fmw2Dd1SKDMRXGXf09WS9ZiKqu8Fg2cGfOXOmukRHfgybNWuGt956B6GhoaZtIRERERHVCTI6+q+//mJUp7NHj17o1y+Mg8QRUakA7z//rFYDwOXllV2DV0oUBgc3QFZWtlEwWE4s5RfoDIO4qaBvTOH9C3E5yMozDiaXx9fVpsygr5fLDedNkQXp2tgJ/u42iEmRz3JZJwt0CHC3VcsREdW06/6Fe+ON13H77bdjxIiR6sf7p59+xEsvzcSSJctM20IiIiIiqhPc3NzUZdsSDHZ0dMTo0ePQtGmzmm4WEdUwGYg8NzcHnp5Fg4w7ODiqUhCSGVycj4+vqisudX8bNGgIWNvgUnwuDhxJvRrwLQz6XozPRV5B5YO+UsZBAr2FAV97w303R56oohunsbbCzLH+eHJ+BMr6VFrBCi+M9VfLERHVmWDw448/ipdfflXVBRZJSUkYNGiQ2tGXW1hYGH79tXK1hYmIiIio/pEsvrFjx2P9+rUYMmQYXFxca7pJRFQDJFnoypVwVfNXAr5xcbFo2bI1JkyYZFjG1tZWBXvj4+NU8DewQRNonYIRna7BkdgcLN4mdX3DcTkhFwWVrO4gcTapxdrM3w5Nfa8Gff3t0NjHXtX6JTKnYaFumDMNmLU8BjEpRTWEA9xtVCBY5hMR1alg8Nix43DvvffgttumYtq0OzB16u2YMGE8unXrjvz8fOzevQvTp99t3tYSERERUa0hgR57e3tVE1hPAsATJkyu0XYRUfWSGr+xsTGqT5C6vxER4aUyfi9fvqjGmsnI1eG8lHaIzcF5hzBcdCrAkmO5iNiWB50uplLbs9FABXhVdq8Eff0L7zfytoO9LYO+VHMk4Du4rSv2XcxUg8pJLWEpDcGMYCKqTax0Javzl0Mu+fv4449w8uQJvPrqa9BobLBnz271o96pU2e0b98edVFqaqqqO5WSkqIubyQiospjH0pkeWTfb9u2rdi5czvc3Nwxffo96pLv6lKg1dWbA232oVTXyVgyq1YtR1ZWltH0bK0dUgpckVzgilx7f2RaeyEhzwmxqcZB4vLY21ihaRn1fBt42cFWUze/82R67EeJiMxYM9jV1RWvvfY69u/fhxdffBF9+vTGY489ocpEEBEREZFlDPq0bNkSRERcUY9TU1Nw8OAB9OrVp1q2v/ZoaqlLcGXQHqnVyEtwicx3ciUnJ0cN9ubt7W2o/St5RbnWLjiX6oyUgkAV+JVbqtYNWVq7oidnGrZWZhukhENZ9Xylzm9dPdFDRERUL4LBKSnJuHIlAi1atMTvv/+B7777FjffPAXPPfc8wsIGmK+VRERERFTrMgCtrKzQv/8A9OjRq9oCwWUNzhObkq+mS61GBoSJqvademdpFOLSiory+rpa46XxgRjS1gVRUZGG0g9nI5KQmOcMj4YdoXXOVqUeZDC3tGx5br9Kbc/dUYPm/qWDvv5uNqo/ISIiolpUJmLFiuV47bVX4ezsjNzcXLz77iwMGjQY58+fx5tvvgFvby/MnPkSfHx8zN9qE+NlJURE1499KFH9J7U/t2zZhL17dxumyfd97NgJCA5uUD1t0Oow7P2zRhnBxVldzRD+57nmdSqTkH0o1WQgeMb8K8W+QXqFh4fNHCIBbYHK9JVyD/lVyCPydbUpM9PXy1nDoC+ZHPtRIqKqqfQv+iefzMGbb76N0aNH49ixY3jllZdVMLhp06b44Ycf8eeff+COO27H6tX/VLEJRERERFRbJScnY/nyxYiKijJMa968BUaOHFOtpcL2Xsi4ZiBYH76KTslXl7v3aOpcbe0iqovk5IpkBBcqGZwtfHwuO7jC9UgZB31N3+JBXzdHjRlaTURERNUaDM7MzESTJo3V/YYNGyI723iAgJtuulkFh4mIiIiofsjLy8P8+T8hMzNDPdZoNBgwYBC6dOlWrdl9ey9k4rW/oyu1rNQ9JaLyLdhy5WppiIq/x1ZWOjTwsEHzAEdD0FcCwE187VWtXyIiIqqnweAJEybikUceRvfuPXDs2FGMGze+1DIymAARERER1Q+2trbo06cf1q1bAw8PD4wbNxEBAYHVtv3T0dn4ZHUcNp9Kr/RzZAAsIirtdHgCFmy+hE1ntYjLqVz2/JMjfHFnXy/Y2zLoS0REVF9Uem9ZBonr0aOHqhEsgeG+ffuat2VEREREVOM6deoMrbYAoaEdYG9vXy3bjEzOwxfr4rBkfwqKj26hsZbL21FuzeCujZ2qpY1EdUFkfBoWbDqPdSdzEJ7hCqBqpV06hDgyEExERFTPVCl1YuDAQepGRERERPXP8eNHkZSUhL59+xumSTmIrl27V8v2kzML8N9N8Zi/Iwm5+UVR4AB3Gzw2zBdOdtZ4ekGEmlZ8BGT9he4vjPWvU4PHEZlDclo2ftt8DquOpuNsigt0sAPUrUigQzqS852QlS/fl7K+Mzr4uWp4coWIiMhSg8ErV65UA8dVhgwuIrcuXbrcaNuIiIiIqBrk5uZiw4a1OHLksHocGBiEpk2bVdv2s/O0+GV7Iv67KQFp2UWpv24O1rh/kA9u7+0Jh6vZidbTgFnLY4wGk5OMYAkEDwvlKPJkmeTkybYz6VhxMBXrjyUjt0C+L8bfBy/bTIQ1A6b2D0Fo0zZYezQVM+ZfuXpqpXhAuPBUy4vjA3lyhYiIyFKDwb///iu++upLTJo0CQMGDESzZsYHB2lpaThwYD+WL1+OHTu248033zJXe4mIiIjIhOLi4rBs2WIkJMQbpl26dLFagsH5BTosPZCCz9fGIabYwG92Nla4o48X7hvoDXdHjdFzJOA7uK0r9l3MVIPFSY1gyV5k0IosTUGBFqv3XMKOyzZYfzITqVn6EylFZR1cNNno3TAft/QNQq+2rWBtbW30XfpkWgO8szTq6mByhSQjWALBPLlCRERUP1npdMUrsV3bxo0bMH/+fOzevQuOjo5qsDipG5eamor4+Hg1qMjEiZNw5513wcfHB3WJvAZ3d3ekpKTAzY07PUREVcE+lKhukl3AI0cOYf36tcjPzzcMGDds2Ai0a9fe7NveeCIdn6yJxbnYXMN0iedO7OqOR4b4ItDDFpaAfShVhVarxfZjkfh9exR2hdsgvcCh1DLujtbo6JuB8V29MLxrCDRSbLscBVodT65QncZ+lIjITDWDBw0arG5SR27//n2IjIxCTk42PDw80aZNG3UrfqaZiIiIiGqnnJwc/PPPKpw8ecIwzdfXD+PHT4SXl7dZt33gUiY+Xh2L/RezjKYPbOOCGcN90SKgdHCLyNIdOR+LhVvCsfU8kJgndXxdjOY72lqpjPkxndzQu7mLyq6vLAn89mjqbIZWExERUZ0fQE54enpiyJCh5mkNEREREZlVTEw0li5dhOTkZMO0Tp26YNCgIbCxqfKuYaWdi83Bp2tisf54utH0TiGOeGqkH7o24UBVRMVdjErBgk3nseF0PqKyJfhr/B2xghYt3dMxqoMLbh/SGs72xiVViIiIiMpivj1+IiIiIqpVpDzDhg3rDIFgOzt7jBw5Gq1atTbbNmNS8vDF+ngs2psMbbHiZE187TBjhC+GtHWFlRUvSScSadkFWHc0DSsOpWLnuXTodKUz5UOc0zCsjQOmDmyCQG/XGmknERER1V0MBhMRERFZCAm6jho1Fj/99D94enph3LgJquSXOaRmFeB/WxLw87ZEZOcVRYF9XW3w6FAfTOrqARsNg8BEaZk5+Gvreey8YotdF/ORm6//vhR9P/zs0zGwhQ1uH9AILRq0qbG2EhERUd1Xq4PBBQUFeP311/HLL78gOjoaQUFBuPvuu/Hyyy8bMkgkw+W1117Dd999p7Jc+vbti6+++gotWrSo6eYTERER1Yr9KY2m6PJxGfT31ltvh4+Pr9F0U8nN12LBjiR8uzEBKVkFhuku9ta4d4A37uzrBUc7jjNBli03rwArdl3A4r0JOBTriDydDJiYZ7RMQy9b9AjOwYRu3ujakgFgIiIisoBg8OzZs1Vg98cff0S7du2wd+9e3HPPPWqk0CeeeEIt8/777+Ozzz5TyzRp0gSvvPIKRowYgePHj8PBgQOQEBERkWWSE+a7d+/E8ePHMG3aXbCzszPM8/cPMPn2CrQ6rDiYirlr4xCZXBTUstVYYWovTzwwyBuezrV615PIrLRaLTYcDMdfO2OwJ8IOWVp7AG5Gy3i7aDCqgxvGdHJH+wYOLKFCREREJler98i3b9+OCRMmYMyYMepx48aNsXDhQuzevdtwkPPJJ5+oTGFZTvz000/w9/fH4sWLcdttt9Vo+4mIiIhqQkZGBlauXIaLFy+ox+vW/YPRo8eaZVuyP/bv6Qx8vDoWp6NzDNMlhjW2oxseH+6LYM+iQDSRpTl0Ph4/b7iI7ZeskZLvCMC4zq+tVR46+WWpDOAxPZvAzpYDwREREVENB4Pff392pVf43HPPw1T69OmDb7/9FqdPn0bLli1x6NAh/Pvvv/j444/V/AsXLqjyEUOHDjU8R7KGe/bsiR07dlwzGJyTk6NueqmpqYaz9XIjIrJk1tblX77NPpSodgsPv4wVK5YhIyPdMM3FxUWVizB1luHRK1n4eHUc9lzIMpret4UzZgz3Qeugwqu0LKlvYB9KIio5D6sOp2LloTScUidJnI3ma1CA1p4ZGNPJDZP7toSzY9EJE34OyJJV1IcK9qNERDfWj1YqGHzixIkSj4+rAwrJ1BUXL15UNefatm0HU3rhhRdUx966dWu1ftnmO++8g2nTpqn5EggWkglcnDzWzyvLrFmz8MYbb5SaHhsbhaysogMnIiJLFBjYoNz57EOJaic5AD569AiOHDmisnWFlMyS8RQCA4PUd9RUriRr8b/tOdhyNt9oeks/a9zf1x6dG8pOaCJiYmBx2IdarpjkLCzbm4D9Mc44nVD6MMsKOjRyTsWAZlYY29UHnq4eanp6ajzSC2NZRBavoj5UsB8lIrqxftRKpz9aqKQff/wBe/bswTvvvKuycEVKSgpeeeUldOnSFXfffQ9M5ddff8Wzzz6LDz74QNUMPnjwIGbMmKEyg6dPn67KSMgBTmRkJAIDAw3Pu+WWW1Tmy2+//VbpM4kNGzZEUlIS3NyM63YREVma68lqYx9KVLPS09OwcuVylRWsFxLSSJWGcHZ2Mdl24tPy8fWGBPy1Nxn5WuOBrp4Y7oMRoa4WX+OUfahlSU7Pxh9bLmD10XScSXGBDqX//h0aOqBPIy3GdfFCiH/h8RMRmTYzmP0oEZGJM4NLBoO//fY7QyBYyP3HH/8PHnjgPpMGgyUQLNnB+nIP7du3x6VLl9SZQAkGBwQUDn4SExNjFAyWx506dbrmeu3t7dWtrDesMm8aEZElYx9KVLtcuHBe1QfOzMxUjyUY27dvf/Ts2dtk38mMnALM25KIH/5NQFauzmiwq4cH++CmHp5qoDiqGPvQui87Jx+Ltp3DsgPJOBbvhHx1SGUcgGrkbYPxXTwxuqMbQrxZM5vIlNiPEhHdmCoHg9PT05GYmFRqelJSohqsxJTkoKZkZy7lIvR1gJo0aaICwuvXrzcEf+Ws4K5du/Dwww+btC1EREREtVFsbKwhEOzi4oqxY8ejYcMQk6w7N1+HP3Yn4esN8UjMKDBMd7Kzxj39vTC9vzec7XngTfWfVqvD1uNxaiC4/dH2yNHZlQoAu2iy0athPm7pE4Te7QIZlCIiIqL6EQweMmSoKgnxzDPPqUxdceTIYXz00YcYOnSYSRs3btw4VSM4JCRElYk4cOCAKhHxf//3f4bMFykb8fbbb6NFixYqOPzKK68gKCgIEydONGlbiIiIiGqjHj164vLliyrwNGrUWDg5OZkk8LX6SCo++ycO4Yl5huk21sAtPT3x4CAf+LhWeTeSqE6Ranono3Kw4lAKVh1KRXSK1Mh2NVrG3ioXXQJzMKWnH4Z3bQWNhgFgIiIiqt2qXDM4KysLH374ARYt+hv5+fmGbN3Jk6fg6aefMckBiF5aWpoK7i5atEhlvUiQd+rUqXj11VdhZ1d4uZU0/7XXXsO3336L5ORk9OvXD19++SVatmxZ6e1INrGUupDax6wxRERUNexDiaqXXI3l6ellNC03Nxe2trYmqde742wGPl4Vi+OR2UbTR3Vww+PDfNHIh5e8mxL70NrnyPk4LNxyGXsi7RGZpik13wb5CPXJxLgunpjYpykc7HlihKgmsR8lIjJzMFhPLkcMDw9X96VYuymDwNWNPx5ERNePfShR9ZCT8Fu2bMT+/ftw6623m6wUhN7xiCzMWR2H7WeNy371bOaEp0b6IbSBo0m3R4XYh9YOl6JTMH/TBWw4nYeorNKDLkpWfN+WLhjUwgbDO3jC3cWhRtpJRKWxHyUiqprrPo0dHx+nbl27doODg4PK0LX00aOJiIiIzJUNvGzZEsTERKvHy5cvwT333K/2wW5UeGIu5v4ThxWHUo2mtw60V0HgPi2cuY9H9VJ8SiYWbjyHf45n4UKaC3SQAamMB6XqEKTBpB6+GB7qCg9nZgATERFR3VflPRopxfD0009i9+7d6sBgxYpVKjP4lVdehru7G5599nnztJSIiIjIAp08eRxr1qxSpSD05bl69epb5kjqVZGYno9vNsbj111JyC8aGw7BnrZ4YpgvRnd0g7U1g8BUv+TkafHPoQT8vOE8TiY5o0AdDhnXAfazz8CA5ta4fUAjtGzoXWNtJSIiIqoVweDZs9+DjY0t1q5dj/Hjxxqmjxo1Cu+/P5vBYCIiIiITyMvLw4YN63D48EHDNKkVPG7cRPj7+1/3ejNztfjp30T8b0sCMnK0hukeTho8NNgHt/b0gJ1cE09UT+QX6LD7fIbKfl93NA3p6nNvfCm5u00W+jbW4tZ+DdCtVZsaaysRERFRrQsGb9++Dd988x0CAgKMpoeENEJkZKQp20ZERERkkRIS4rF06WJVkkuvTZt2GD58BOzsri8jOK9Ah7/3JuPL9XGITytKBXa0tcJd/bxwT5g3XB1KD5ZFVBdptVpsPBiOv3bGYF+0I9LzSh/2OFrnoEdwLqb08segTq1gbc2TIERERFT/VTkYnJWVBUfH0vXppFi7nR1HlyYiIiK6EWfOnMaKFUtVZrCwsbHB0KEjEBra/rpq98q4DmuPpeHTNXG4GF9YakJorIEp3TzwyBAf+LrZmvQ1ENWUvaei8du/V7DtojVS8h1LlYBwtrfGsFBXDG/riN4t3GBnyxMgREREZFmqHAzu2rUrli5discff0I9loMSOfM+b9736NGjpznaSERERGQxpBSEno+PryoL4ePjc13r2nM+Ax+tisWRK9lG0yUY9p/hvmjie2N1h4lqgzNXEjF/00VsPluA2BwXCfkazdegAD0a2+CWvkEIa+UCB1tmABMREZHlqnIw+KmnnsG99/4fjh07qjJWPv74Q5w9e1ZlBv/883zztJKIiIjIQkjgd+jQ4YiIiMDgwUNha1v1rN3T0dn4ZHUcNp9KN5retbEjnh7lj44hkjFJVHclZeRj1aFk/LThPMIzJPvX+DNtBR2auKZjeDtHTB3QFD4exgFiIiIiIktV5WBwixYtsGLFSixYMB/Ozs7IzMzE0KHDMHXq7fD19TVPK4mIiIjqISnhcPLkcbRo0UqVg9ALDe2gblUVmZyHz9fGYemBFOh0RdNb+NvjyZG+KivyekpNENUGGdkF2HgyHSsPpmLbmXTkq/EPjctABDmmY1BLW9w+oAkaB7rXVFOJiIiI6k8wWLi6uuLBBx8yfWuIiCxAUlIijhw5jJSUZLi7e6B9+w5Gl4UTkWXIycnGmjWrcOrUSXTu3FVlA1+v5Ix8fLc5AQt2JCE3vygKHOBug8eG+WJ8Z3dorBkEpronOycfi7efw7L9yTiW4Iw8Xekav162mQhrBtzWvyHaN21TI+0kIiIiqlfB4FOnTlV6ha1atbqR9hAR1WsSBF6zZqXRtN27d2LkyNHXlQVIRHVTVFQkli1bok4KiQMH9qFDh47w8/Ov0nqy87T4ZXsi/rspAWnZKk1ScXO0xgMDfTC1tyfro1KdU1CgxZq9l/D37jjsj7JHjk4GqXYzWkZOdIzq6IbR7V3ROsgB1tb8nBMRERGZLBh8002T1SWFciljeWSZw4ePVmrDRESWmBEsgeCy+tLVq1ciOLgBM4SJ6jn5/u/btwebN29UA/AKe3sHdUKoKoHg/AIdluxPwRfr4hCTmm+Ybm9jhTv6euHeAd5wdyydQUlUW8n3YcexKPy+PRI7w22QXuBQqgSEvVUuBrSwxbSBjdGlkSOsme1OREREZJ5g8Jo1/1R9zUREVCoruKL5YWEDq609RFS9srIysWrVCpw7d9YwLTAwCOPGTYS7u3ulg8kbT6TjkzWxOBeba5guMbGJXd3xyBBfBHpUfcA5oppyOSEXKw+mYMHWcCTkyCBwLkbzbZCPUJ9MjOvigYl92sHB/rqq3BERERHRVZXamwoKCq7MYkREVEFmcHlXWOgvFyei+ufKlXAsX74EaWlphmk9evRCv35h0Ggql8G7/2ImPl4diwOXsoymD2rjghkj/NDc397k7SYyh8iEDGw4mYMVh1JwODz76lQJBBeyghYt3NMxsr0Lbg1rAQ9XyRImIiIiIlO4rlPrFy5cwIIF83H+/Dn1uGnTZrj99mlo0qSJSRpFRFTfpKSkIDw8vNxlZDA5Iqp/wsMv47ffFhhOBjk6OmL06HFq/6kyzsXmqEzgDcfTjaZ3CnHEUyP90LWJk1naTWRK8SmZWLjpHP45lokLaa7QoXSJh4bOaRja2h63D2yKIB/jEhFEREREVEPB4LVr/8Gzzz6Ddu3aoWPHTmraoUOHMGnSBHzwwYcYNuz6R8ImIqqPIiKuYPHiv9Ql4uVp354DyBHVR1IPXK6ykr6gYcMQjB07Hi4uFQe6YlLy8MX6eCzamwxtsYsKmvraqUzgwW1d1HgNRLVVRlYu/tx6DisOpuJkkjMK1KGH8UBwrQLtMaajuxoMLoglToiIiIhqXzD4o48+wn333Y/HHnvcaPrnn89V8xgMJiIqcvToEfzzzyoUFBSox46OTsjONr7EW8jgURw8jqh+sra2xrhxE3Ds2FFVGkIelyc1qwDfb07Az9sSkZNfFAX2dbXBo0N9MKmrB2w0DAJT7ZSbV4AVuy5g8d4EHIp1RJ7OtlQA2M0mS2UATx/anOVNiIiIiGp7MDg+Pg7jx48vNX3cuHH44Yd5pmoXEVG9KA1RPBAcEtII48dPUsFgGSxOagRLaQjJCGYgmKh+0Gq12L59K5o1a6EGh9NzdXVDr159yn1uTp4WC3cm4duNCUjJKuw3hIu9Ne4b6I07+njB0a78QDJRTZASKEfCs1UN4EW7Y5GRXzoA7Gidg+7BuZjSyx+DO7Wq8KQIEREREdWSYHD37t2xb98+FdQobv/+/ejSpasp20ZEVKe5u7tj+PCRWLVqBTp27IwhQ4apgaKkXmhY2MCabh4RmVhaWiqWLVuiykEcP34c06ffA3v7ige+KtDqsPxgCuaujUNUcr5huq3GClN7eeLBQd7wcL6uYR6Irot8JvddzERcaj583WzQtbETNNals9EPnI3F1vPAykOpCE/Muzq1qNSDrVUeOvplYWI3b4zp2RJ2tpUbLJGIiIiIzKfKRxYDBw7CnDkfq4OcDh0K61sePnwYa9aswaOPPoqNGzcYlh00aLBpW0tEVMeEhhZm/UrNUCKqv86dO4tVq5YjK6uwDExqauGgkc2btyg3m3LrqQzMWROL09E5hulSBnhcJ3c8NswHwZ521dJ+Ir21R1PxztIoxKVpDdN8Xa3x0vhADAt1w5kriViw6SI2ndUiNse51PMl3tvSLRWjO7phSv9WcHViGQgiIiKi2sRKpx/aupLat29XuRVbWeHw4aOoC1JTU1UGn1zS7eZmfEkbEVFlXbkSjsjICFUT1JKwDyVLJmVgtmzZhL17dxumyfdg7NgJ5Z4EOhyehY9Xx2LPeeOBJfu3dMaMkX5oHVhxRjHVD7WpD5VA8Iz5V64+Kp4JXHi44GOfjfgcx1LPk6Thns2cMaajG4a0c4WbIzOAicgy+1EionqZGXzkyDHztISIqA47elSukFil6oW6urqiTZvKnTgjororOTkZy5cvRlRUlGFa8+Yt1YCQUg6mLJfic/HJmlj8czTNaHpoAwc8NdJPBdSIaqo0hGQEFypZEqLwcclAcKBDOkaEOuLuYa3g61ZUHoKIiIiIai8WoCMiugES/N28eaNRVuCJE8fRunVbdYUEEdVPp06dxJo1K5GTU1jeQeqBDxw4GJ07dy3zux+Xlo+v1sfhzz3JKCi6+h4h3raYMcIPw0Nd2WdQjVI1glVpiPI/hy6abAxprsXUsIZo37RNtbWPiIiIiGowGHzkyBHs2bMbCQkJqt5dcc8997yJmkZEVLtJEGj58iU4f/6cYZoEggYPHsqgDlE9HyhuxYqlqkSE8PDwwLhxExEQEFhq2fTsAszbmogftyYgK69on8nbRYNHhvhiSncPNVAcUU2TweIq45UpTTC2s4fZ20NEREREtSQY/O2332Du3M/QuHETeHt7GwU8GPwgIkuRnJyERYv+RHx8vKH/Gzp0ODp16lLTTSMiM3N1dVNZwOvXr0Xr1m0wfPgo2NsbD5KVm6/DH7uT8PWGeCRmFAaNhZOdNe4J88L0ft5wtreugdYTlc3XrXKHBX7uLAdBREREZFHB4F9++QVvvfU2Jk6cZJ4WERHVcuHhl7Fkyd/IyspSjx0cHDB+/CQ0atS4pptGRGYiV0IVP+ktVwF4enqiceOmRtO1Wh1WHU7F3LVxCE/MM0y3sQZu6emJhwb7wNuFVbqo9una2Am+rtaIS5OTF2UleOjg56pRyxERERFR3VXloxFrayt07tzZPK0hIqoDdUKlNITUChZeXt6YPPkmeHp61XTTiMgMcnNzsWHDWjg5OSMsbKBhugSAmzRpZrTsjrMZ+HhVLI5HZhtNH9XBDU8M90WIt121tZuoqjTWVnhpfCBmzL+iAr/GAeHCEicvjg9UyxERERGRBQWD77prOhYuXIgXXphpnhYREdViAQEBKhM4MzNTlcuROqHymIjqn7i4OCxbthgJCYXlYBo2DEGTJk1LLXc8IgtzVsdh+9kMo+m9mjnhqVF+aBfsWG1tJroRw0Ld8Mm0BnhnadTVweQKSUawBIJlPhERERFZWDD47rvvwSOPPISRI0egWbNmsLExXsWnn35myvYREdUq7u4emDBhMs6cOY0BAwbB2po1P4nqY0mII0cOqZrA+fmFg2rZ2toiNzfHaLnwxFx89k8cVh5KNZreOtAeT430Q58WzhxPgeocCfgObuuKfRcz1aByUktYSkMwI5iIiIjIQoPBs2a9i927d6NHjx5q9Gwe4xBRfR8oTi4Pt7Mrury7QYOG6kZE9U9OTg7++WcVTp48YZjm6+uH8eMnqrIwIjE9H99sjMevu5KQXzQ2HII9bVU5iNEd3FRZLaK6SgK/PZo613QziIiIiKg2BIOXLFmMOXM+xYABA8zRHiKiWuPy5UtqoLiGDRthwoRJzPAjqudiYqKxdOkiJCcnG6Z16tQFgwYNUVdCZeRo8dO/CZi3NVHd1/N01uChQT64pacH7GSkOCIiIiIiovoSDHZ3d0fDhsyII6L67eDBA1i//h81UNyZM6ewb98edOvWo6abRURmKgtx4MA+bNq0AQUFham+dnb2GDlyNFq1ao28Ah1+25WEL9bFISG9KBXY0dYKd/Xzwv+FecPFQVODr4CIiIiIiMhMweBHHnkUX3zxOd5++x04OnJAFCKqXyT4u3HjOuzfv88wTQaMat++Q422i4jM+70/evSIIRAcEBCIceMmqBrha46k4tM1cbiUkGtYXmMN3NTdAw8P9oGvm20NtpyIiIiIiMjMweD5839BeHg4Bgzoj+Dg4FIDyP3xx19VXSURUa2QnZ2NZcsW4+LFC4Zpkg3MgeKI6jeNRqOCvz/99AM6dOiIsLCB2H8pGx/Nv4gjV7KNlh0W6or/DPdFE1/7GmsvERERERFRtQWDBw8ect0bIyKqrZKSEvH3338gMTFRPZbg77BhI1VgiIjqX1mIzMxMODsXDZDl6emF++57EFdSNXjs5whsOZVh9JxuTZzw1Eg/dAzhVVFERERERGRhZSKIiOqTS5cuqkGjJDNYSAmcCRMmo2HDkJpuGhGZWEZGBlauXIa0tDTcccd02NnZqemRSXmYuzYFyw6mQKcrWr6Fvz2eHOmLsFYuHESSiIiIiIgsLxhMRFTfHDiw3xAI9vHxwaRJN8PDw6Omm0VEJnb58iUsX74UGRnp6vGGDevQq/9wfLspAQt2JKmB4vQC3G3w+DBfjOvsDo01g8BERERERGShwWAZXOWnn37EmjVrEBUViby8PKP527fvNGX7iIjMbvToMZg/PxHu7u4YM2Y87O3NWwu0QKvDvouZiEvNh6+bDbo2dmKwicjMA8Tt2LFN3aREhLB1cMHhrBZ4/cNzSMvWGpZ1c7TGg4N8MLWXJ+xtWSuciIiIiIgsPBj81Vdf4q+//sT06Xdj7tzP8MADDyIiIgIbNqzHQw89bJ5WEhGZkZ2dPW699XY4ODiYfaC4tUdTMWt5DGJS8g3T/N1tMHOsP4aFupl120SWKD09TWUDh4dfVo+1OiskuXTGzuQmiNtd9D20t7HCHX29cN8Ab7g5amqwxURERERERLUoGLx8+XK8/vqbGDBgAL788guMGjUaISEhaNmyJQ4fPmyeVhIRmUhiYgLWrFmlMoDd3IqCr05OTmbftgSCn5wfgWLlSJXYlHw1fc40MCBMZEIXLpxX9YFlsDhJCA7PD8QJXTdEhUuwt0AtI0n5k7q645Ghvghwt63pJhMREREREdWuYHBCQjxatmxhCJ6kpxfW3RswYCA+/3yu6VtIRGTCwNCyZYuRk5ODRYv+xNSpdxgGjzI3KQ0hGcElA8FCpkmRiPeWx2BwW1eWjCAygX//3YwdO7ar+zF5XjiY2wFROca1wAe1ccGMEX5o7m/e0jBERERERER1Nhjs7++PuLg4BAYGoWHDEGzfvg1t27bF0aNHqy2oQkRUFVIj9MCBfWqwKH29UPk/Nzen2votqRFcvDREqTYCiE7JV8v1aOpcLW0iqi/iExKweMtJRCVlI9DTARPDWsPGxhbJBa7Yl9kW4XmBRst3auSIp0b6qXrdRERERERElqTKweAhQ4Zi586d6NChI26/fRpmznwef//9F6KionDXXdPN00oiouskg16uX78Whw4dMExr3ryFKhNRnSewZLA4Uy5HRIW+X3kEX2/LQ6bWyzDt6z2X0czPDcdSBkOn8u4LNfW1U5nAg9u6wMqKGfhERERERGR5qhwMfvLJpwz3R40ahcDAQBw6dBCNGjXCwIGDTN0+IqLrlpWViSVLFhkGjhI9e/ZG//4Dqj0QVNlx6XzdqtwtE1msxbsi8fFWqf9rPOBbls4eR2OKvuN+bjZ4dKgPJnbxgI2GQWAiIiIiIrJclQxPXFunTp0wffrdZgsER0RE4I477oC3tzccHR3Rvn177N271zBfLvV+9dVXVVBa5g8dOhRnzpwxS1uIqO6Q+ua//PKjIRCs0WgwevQ4hIUNrPZA8IbjaXhjUVS5y0iLAtxteNk6UTm0Wi1iY2Nw8OB+LF+xDO8ujb46p+R3Wv9YhyeG+2Dl081wU3dPBoKJiIiIiMjiVTkFbcmSxfDw8MSAAQPU448++hB//vkHmjZthg8++ABBQcEma1xSUhL69u2LQYMGYdWqVfD19VWBXk9PT8My77//Pj777DP8+OOPaNKkCV555RWMGDECx48fh4ODg8naQkR1hwxs+csvP6mawMLJyRmTJk0xaf9UGTl5Wny4KhYLdiSVu5w+PPXCWH8OHkdUhu3b/1UndqQkVV5erpoWleeDDG3zCp5phc6NnOBod8PnvomIiIiIiCwzGPzdd9/ilVdeVfcPHjyIhQsX4PnnX8DmzZsxe/ZsfPrpZyZrnKyvYcOGmDdvnmGaBHyLZwV/8sknePnllzFhwgQ17aefflKD3C1evBi33XZbmevNyclRN73U1FRDxpHciKhuc3JyQseOnbBnzy74+vph4sQpcHNzq9bv9/m4HDz3axRORRf1NcPauWBgGxd89k88YorVBvZ3t8HzY/wwpK1LreiDrCuoacE+lMxBPjuS0Z+ZmYlGjRobzTt79gxiYgqzgLU6K4TnBWB/ZptKrTc2JY+fS6pW7EOJiMzXhwr2o0REN9aPVjkYHB0djZCQEHV/w4b1GDZsOG6++RZ07twZ99xzN0xp6dKlKsv35ptvVsHm4OBgPPLII7j//vvV/AsXLqj2SGkIPXd3d/Ts2RM7duy4ZjB41qxZeOONN0pNj42NQlZWuklfAxHVjBYtmiM/Pw+tWrVU3+vq+m7LSao1J/Lx+aZsZF+N99ppgEfC7DEmFLCyysBPdzngSGQBEjN08HK2QvsgDTTWaYiJSUNtEBjYoNz57EPJFOQgLj4+HnFxcYiPj0NCQgLy8vLg7CyZ/JONlvXwcMelqERc1DbHiazGSMmr/OCPmvxkxMTwc0nVh30oEZH5+lDBfpSI6Mb6USudRC6qICysH7755lu0adMWN900GXfddTfGjx+Py5cvY8qUSdizZx9MRV/m4amnnlIB4T179uA///kPvv76a0yfPh3bt29XZSQiIyNVzWC9W265RdUE/e233yp9JlEykKUshWQPElHdIpmEsbHRaNy4aY22Iz27AG8tjcHKQ0VB3WZ+dvjgtiC08LdHfc5qYx9KFcnMzFAZvvKbHRkZgaSkxGsu++CDj8DFxVXdPx6RjR+3xGLdiSzkFhgvp7EGCrSyG1NWeRUdAtxtsfqZpiy/QtWKfSgRUfVnBrMfJSIyY2Zw79698dprr6J16za4dOkSwsLC1PRz586qzF1Tkks8unXrhnfffVc9luzjo0ePGoLB18ve3l7dynrDKvOmEVHtIRmFf//9J9LT03DbbdOqvS6w3tErWXhmYQTCE/MM027q7qHqANe3eqXsQ6ki2dlZkFPNMrCrXlpaGtauXXPN50jwV76/ctNZ2WDV4TQs2JmEg5eyjJaT8R/DWrrg9j6eyMzR4qkFESjrrLYVrNT3z9ZGY9LXRnSj2IcSEd0Y9qNERDemysHgl156BXPnfobo6CjMmfMJPDw81PRjx45h1KjRMCXJ9m3btq3RtDZt2uCvv/5S9wMCAtT/MTExRpnB8rhTp04mbQsR1T5yEmr58iXIzS0cUEoCTXfddY+6MqC6aLU6/LQtEXPWxCL/ataii7013pgciJEdmJlA9Z9cYCS1fiXbV3+Tkg9hYQPRs2dvw3J+fv6wsbFBfn6+OlCT+v764G9QUAOVyROXmoffdyfjmbkRiE8zTgN2c7DGpG4euK2XJ0K8i8pEzJkGzFoeg5iUojrcAe42KhA8LJTfQSIiIiIiohsKBsvB2ksvvVxq+mOPPQ5TkxIQp06dMpp2+vRpNGrUyDCYnASE169fbwj+yiUiu3btwsMPP2zy9hBR7Qk+7d27G5s2bTBM8/cPwKRJU6o1EJyYno8X/4jE1tMZhmkdGjrgg9uC0cCr8jVNieqS7OxsREUVlnqQm9wvfqmmnpSDKE6j0WDEiFFwc/NQgWBbW1vD9/ng5SwsWBmBf46kIr/EuC9SYkWygMd2codTGVn2EvAd3NYV+y5mIi41H75uNuja2ImlIYiIiIiIiEwRDK5OTz75JPr06aPKREgd4N27d+Pbb79VNyFBnxkzZuDtt99GixYtVHD4lVdeQVBQECZOnFjTzSciM5CsQskAPnr0sGFay5atMWrUGNjZVV8Adue5DLzwWyTi0oqyEe8d4I3Hh/nCVsMgFNUPEqgteYJl48Z1OHr0yDWfI1m/kgXs5+dXal7btqGG+9l5Wqw6lIoFO5JwPDK7VC1gCfDe3tsT3Zs4VXiSRwK/PZo6V+GVERERERERWaZaHQzu3r07Fi1ahJkzZ+LNN99Uwd5PPvkE06ZNMyzz3HPPISMjAw888ACSk5PRr18/rF692jD4HBHVr4HiFi/+CxERVwzTevfui759+1dbRnB+gQ5frI/Dd5sSVE1U4e2iwaybg9C3pUu1tIHIXHJysg0DvMlNSkI98MDDsLcv+k0NDAw2CgY7OzsXK/cQrLL09Vm/ZYlMzsNvO5Pw555kJGcal4LwdNbg5u4euKWnJwI9rr0OIiIiIiIiuj5WOkn7sXBSWsLd3R0pKSkcfZSoloqLi8OiRX+o76mQ2qOSDdy6tXFdcXOSINZzv0bgQLEBrfo0d8a7twTB17VWn1szK/ahdZP8/CcmJhar9XsF8fHxpZa7+ebb0LhxE8PjxMQEHDiwzxD8dXNzr/BkjGxr1/lMLNyRhA3H06AtsefRLthBZQGP6uAGe1sO/EKWhX0oEdGNYT9KRFQ1lhu9IKI6JTc3B+np6eq+s7OLqg8cGBhUbdtfezQVr/4VhdTswoKmNtbAE8P9cE9/L1izNinVwXIrX3/9ObKyik5slMXJyanUMl5e3hgyZHiltpORo8XygymqFMTZGOO6wjYaYGR7N9ze20vV2q7Oet9ERERERESWqsrB4M8/n4vJkyerbCAiouoSHNwAw4ePwoEDezFx4k1wdXWtlu1KXdP3V8Tgt13JRW3xtFWDxHUMcayWNhBVlWTiJiUVZv1GRESoUg79+oUZ5ktmvYuLq1GgV4KxUutX6u7rs37d3T2uK0h7KT4XC3cmYfG+ZKRdPYGiJ1n0t/T0wM09PC06o56IiIiIiKgmVPkobOPGDfjuu2/RrVs3TJ48BcOGDa/WQZuIyHIyFzUajVEgKjS0Pdq2bacGqKoO52Jz8MzCCJyOLspoHNHeFa9PCoSbo6Za2kBU2cz5qKioYiUfIpCdXTQom4eHp1EwWDRt2kxdUlm81u+N/J5rtTpsO5OB+dsTsfV0Rqn5nRs5YlofLwxt58pBFomIiIiIiOpKMPivvxbhxInjamC3996bhXfeeRsjR47CpEmT0b59e/O0kogsigwKKQPFhYQ0Qv/+A4zmVUcgWLIq/96bglnLopGVV1jc1N7GCjPH+eOm7teXKUlkDhcvXsCmTRsQHx+nPrfXkpKSjOzsLDg4FGWzh4UNNEkb0rILsGhvChbuTMTlhDyjefK9GdOpsBREmyAO7EpERERERFTTruv6zDZt2qrbs88+h02bNmHx4kW4885paNKkqcoWnjhxYrVdwk1E9UtsbAwWLfpTDQQh2Y3e3t5o2za02rYvga03FkVj1eFUw7Tm/vb4aGqw+p+ouuXm5iI6ujDrt0WLlvD29jHMs7GxRVxcbKnnODo6GjJ+5RYQEGjyq3ikBvCCHYlYeiAFWbnGgeggD1vc1ssTU7q5w8OZpSCIiIiIiIhqixs8QtOpS7nz8gozgdzd3bBw4Xx8/vlneP31NzFq1CjTtJKILMKZM6exYsVSQ58iNU2LB77M7Uh4Fp79NQLhiUXZjbf29MBzY/zhYFs9pSnIskl2b3JyUrFyD5Eq2KvP+pVav8W/EwEBAWqap6eXIfAbHBysykKYI4M9v0CHTSfTMH97Enafzyw1v1czJ1UKYkBrF2g4sCIREREREVH9CAYfO3ZMZQOvXLlCZRqNHz8BL7/8srqkW8yf/wtmzXqXwWAiqhQJdO3atQNbt242TJNMxkmTboKLi4vZty+1Tn/8NxGfrIlF/tWxrlwdrPHG5ECMaO9m9u0THT58EOfOnVUB4MzM0kFWPZlfnASCH3tsBmxtbc3avqSMfPy5Jxm/7UpCVHK+0TxHOytM6OKBqb08mT1PRERERERU34LBkyZNwIULF9C7dx+8+eZbGDhwkBrkqbjRo8eoesJERBWRqwtWr16JEyeOGaZJGZoRI0abPcAlEtLzMfP3SDXwlV6nEEe8f1sQgj05OCaZOus3GYmJ8WjWrIXRvMuXL+Hs2TOlniPZvT4+vlezfoMQHNyw1DLm/J4cj8jC/B1JWHkoFbn5xqUgGnnb4fbenpjQ1R2uDhxQkYiIiIiIqF4Gg0eMGKkGi/P397/mMp6enjhypCiwQ0RUlvT0dDVQXFRUpGFav35h6NWrT7UM0rbjbAZe+D0C8WkF6rFs8r4B3nh0qC9sNbzEnW6MlDvR1/rV3yTrVz7bTzzxlFENXwn2yuCsDg4ORrV+AwOl1m/1ZttK0Hft0VQs2JmEg5eyjObJdySspQtu7+OJPs2dYc1SEERERERERPU7GPzQQw+bpyVEZHHWrFlpCARLduPo0ePQsmUrs283r0CHL9bF4b+bE3C1FCu8XTSYfWswejd3Nvv2qf4O9Hb27GlDrV8ZDFFf67c4mSZBYn1pJdG6dVs0atQEXl5e1XIipCxxqXn4fXcyft+dZDhBoidlUyZ381CDwoV4M2OeiIiIiIioXgeD339/dqVX+Nxzz99Ie4jIggwdOgK//PIDNBobVR+4vCsOTCUiKRfP/RqJg5eLMh77tnDGuzcHwcf1BsfUJIvK+pXgr7Nz0ckDrbYAK1Ysu+Zz7O0l6zdIZfy6uRnXonZyclK36iaBafkuLNiRhH+OpBpqZuu18LdXpSDGdnaHkx0HUSQiIiIiIqrrKhX5OHHiRKVWVlPZTERUN7m7u2PKlFvg4uJaLQPFrTmSitf+jkJadmHEy8YamDHCD9P7efFydyo3YJqammJU7iE2Nhbt2oVi5MgxhuUcHBzh7e2NhIQE9djHx8eo5IOXl3et+Z3MztNi1aFUFQQ+HpltNE9jDQxu66qCwN2bONWaNhMREREREVE1BYPnzfvBBJsiIkvPpNy5czt69uxtVCs1ICCwWgJfs5fHqEvg9Rp42uKDqcHo0NDR7NunuvdZjYmJNgr+ZmQUDTCoJ9NLCgsrHFRVMoAlE7i2iUzOw287k/DnnmQkZxqXgvB01uCm7h64tacnAj3MP3gjERERERERVb/rviZaRj4PDw9H167d1IA3kjnF7CEiKkt6ehoWLfpL1UmNj4/HxImTq62/OBuTg2cWRuBMTI5h2qgObnhtUgBcHTTV0gaqvfQ1fYt/Hvft24OtWzeX+zxvbx8EBweX+u1r3rwFahtp467zmVi4IwkbjqdBW6KMcbtgB5UFLN8Le1uWgiAiIiIiIqrPqhwMTk5OxtNPP4ndu3erA+AVK1ahYcOGeOWVl+Hu7oZnn2XNYCIqIgFgCQRLQFhcunQBCQnx8PHxNXsATLIf31seg+y8wuiXg60VXhwXgMnd3Hnyqh5LSkrEkSOHkZKSDHd3D7Rv3wGenl5qXn5+fqmsX6lXXTxDXUo6FGdnZ4/AwEA1XQLAgYFBqiREbZeRo8XygymqFIScFCnORgOMCHXDtD5e6NDQgd8HIiIiIiIiC1HlYPDs2e/BxsYWa9eux/jxYw3TR40apQaaYzCYiPROnTqBlSuXqwCckEGzJk262eyB4LTsArz+dxRWHykMQIuWAfb44LZgNPe3N+u2qWZJEHjNmpVG03bt2oFGjZogNzcHsbExKCgwLo8gAeHiwWC5HxrawVDrV2r/1qVg6aX4XCzcmYTF+5IN9bH1fF1tcEtPD9zcw1PdJyIiIiIiIstS5SPB7du34ZtvvkNAQIDR9JCQRoiMjDRl24iojpKs3O3b/1U3veDgBpgwYTKcnZ3Nuu3Dl7PwzK8RiEjKM0y7tacHnhvjDwdeAl/vM4IlEKwv/VCcZKSXxdbWDrm5uUbTpKb1qFFFA8PVBVqtDtvOZGD+9kRsPV26vnHnRo4qC3hIW1fY2dSdwDYRERERERHVcDA4KysLjo6lB8VJSUkxGhSKiCx38K1Vq1aorGC9du3aY/jwkbCxsTFrMOx/WxMw95845F9NhnRzsMabUwIxLNTNbNul2pUVXBEpF6HP+NVn/Vpb192TBJIFv2hvChbuTMTlhKITIMLexgpjOrnh9t5eaBNU+wazIyIiIiIioupX5chM165dsXTpUjz++BPqsVw6q9VqMW/e9+jRo6c52khEdUR2dhZ+//1XVZNVb8CAwejevYdZL7OPT8vHzN8jsf1sUUZkp0aO+ODWYAR52pptu1S7SI3g8rRo0RITJ05BfSA1gBfsSMTSAynIyjXOhA7ysMVtvTwxpZs7PJxZCoKIiIiIiIiKVPko8amnnsG99/4fjh07qjIAP/74Q5w9e1ZlBv/88/yqro6I6hF7ewe4urqpYLBcfj9u3Hg0a9bCrNvcfiYdL/weiYT0wjqwEnO+f6A3Hh3iCxsNL4e3JDJY3LXIyQgvL2/UZfkFOmw6mYb525Ow+3xmqfm9mjmpUhADWrtAY83PPhEREREREZkgGNyiRQusWLESCxbMV7U/MzMzMXToMEydejt8fc07KBQR1W4ScBszZhxWrFiGfv3CzNon5BXoMHdtHL7fnGCY5uOqwexbg9GrmXnrElPt1L59B+zevbPc+XVRUkY+/tyTjN92JSEquXAwRj1HOytM6OKBqb08OTgiERERERERmT4YHBUVqUZaf/DBh8qcFxgYVNVVElEdJQN1paamGGVkSu3wSZPMeyn+lcRcPPtrBA6HZxum9W/pjHduDoK3Cy+Lt1RSD3jkyNFYvXplqXkyXebXJccjsjB/RxJWHkpFbr5xKYhG3na4vbcnJnR1h6uDpsbaSERERERERHVLlaMmI0YMx8aNm+HtbXy5bXJyspp3+PBRU7aPiGqp3NxcrFq1HFeuhOPOO++Gm5t7tWx39eFUvPZ3FNJzCkeJs9EAT47ww119vWDNS+MtXmhoBwQHN1CDyUkNYTlRIRnBdSUQLEHftUdTsWBnEg5eyjKaJyVQwlq6YGpvT/Rt4czPOxEREREREZk/GCyZgGUNBJWZmQF7e16iSmQJUlNTsWjRn4iNjVGPFy/+G3fcMR3W1tZm22ZWrhbvLY9Rl8vrNfSyxQe3BaN9Q0ezbZfqHgn8hoUNRF0Sl5qHP3Yn47fdSYhPK6x/refqYI3J3Txwa09PNPKxq7E2EhERERERkQUFg99/f7b6XwLBc+d+BkfHouBLQUGBysJq1aq1eVpJRLVGZGQEFi36S50A0peF6Nevv1kDwWeis/H0wgici801TBvd0Q2vTQyACy+RpzpKTq4evJyFBTuS8M+RVOQXJrsbtPC3V6UgxnZ2h5Od+b5fREREREREZDkqHQw+ceKE4eD1zJkzsLW1NcyT+61atcLdd99jnlYSUa1w/PgxrF69Qp0AEnIJ/uTJN8HHxzwDxUl/I9mSkhGcc7VmqqOtFV4aH4CJXd3LvEqBqLbLztNi1aFUFQQ+HllU91pI5YfBbV0xrY8nujdx4meciIiIiIiIaiYYPG/eD+r/l19+ES+88CJcXFxM2xIiqrUkKPvvv1uwc+d2w7QGDRpiwoTJcHJyMss2U7MK8OrfUVh7NM0wrWWAPT6aGoymfixJQ3VPZHIeftuZpEqdJGcal4LwdNbgpu4euKWnJ4I8ik62EhEREREREdVozeC3337XpA0goto/UNzKlctw5sxpw7QOHTpi6NAR0GjMU6Lh4KVMPPtrpAqe6U3t5YlnR/vB3paXy1PdOpGy+3ymygLecDwN2sIEd4N2wQ6qFMSoDm78bBMREREREVHtCwaLo0ePYs2a1YiKikJeXlGwRnz66WemahsR1QKXLl00BILlkvVBg4agS5duZrl8XavV4fstCZi7Ng4FV+unujla460pgRjazs3k2yMyl4wcLZYfTFFB4LMxOUbzbDTAiFA3TOvjhQ4NHVgKgoiIiIiIiGpvMHjlypV48cUX0LdvP2zfvg19+vRVwaKEhAQMGTLEPK0kohrTokVL9OzZGwcO7Mf48RPQpEkzs2wnLi0fM3+PxI6zhQPTiS6NHTH71mBeNk91xqX4XCzcmYTF+5KRlm08Ipyvqw1u6emBm3t4qvtERERERERE1a3KR6Pfffctnn/+BUydejt69OiGF16YiQYNGuCNN16Hj4+PeVpJRDWqf/8B6Nixkxowzhz+PZ2OF/+IREJ6YR1VSZR8cJAPHh7sAxsNsyapdpOM9m1nMjB/eyK2ni46maHXuZGjygIe0tYVdjb8PBMREREREVEdCgZfuRKOsLAB6r6trS2ysrLUJa533nkX7r33Hjz22OPmaCcRVQOtVoutWzfD29sHoaHtDdPlO26OQHBuvg6frY3FvC2Jhml+bjZ475Yg9GzmbPLtEZlSWnYBFu1NwcKdibicYFwyyd7GCmM6ueH23l5oE+RQY20kIiIiIiIiuqFgsJubGzIyCjOf/Pz8cfbsGbRs2RJpaWnIzs6u6uqIqJbIzc3B8uVLce7cWTUwnKenJ4KDG5hte+GJuXhmYQSOXinqN8JaOeOdm4Lg5cJL6Kn2khrAC3YkYumBFGTlGo8IJyVNbuvliSnd3OHhzM8xERERERER1S5VPlLt2rUbduzYrgLAI0aMwHvvzcKuXbvUtJ49e5mnlURkVikpyfj77z8RHx9nyBBOTEwwWzB45aEUvLEoGuk5WsOAWk+N9MNdfb04mBbVSvkFOmw6mYb525Ow+3xmqfm9mjmpLOCBbVygseZnmIiIiIiIiOpJMPill15CTk6uuv/AAw/CxsYGBw8exLBhw/DAAw+Zo41EZEZS+mXJkr+RmVkY4LK3t8f48ZPQuHETk28rM1eL95ZF46+9KYZpId62+HBqMNoFO5p8e0Q3KikjH3/uScZvu5IQlZxvNM/RzgoTunhgai9PNPe3r7E2EhEREREREZklGJyfn49Nmzajb9++6rG1tTXuu+/+qqyCiGqRo0cPY82aVSoTWEhpiMmTb4aXl7fJt3U6OhtPL4zA+djCk0libCc3vDoxAM72GpNvj+hGHI/IwoIdSVhxKFXVti6ukbcdpvb2xMSu7nB14GeXiIiIiIiI6mkwWLKA33rrDSxdusx8LSIis5Pg7+bNG7F3727DtEaNGmP8+IlwcDBthq5Op8Nvu5Ixe0WMIajmaGuFlycEYEIXd5aFoFpDPp9rj6Ziwc4kHLyUZTRPPqZhLV1UELhvC2dYsxQEERERERERWUKZiNDQ9jh58iSCgoLN0yIiMrt//lmFI0cOGx537twFgwYNVQPHmVJKVgFe/SsK646lGaa1DrRXZSGa+PKyeqod4lLz8MfuZPy2OwnxaQVG81wdrDGpq4caFK6Rj12NtZGIiIiIiIioRoLBt912G95//31ER0ejbdt2cHQ0ziJs1aqVSRpGRObToUMnHD9+TGUIDxkyXAWDTW3/xUw891uEUZ3Vab098fQoP9jbWpt8e0RVzVg/eLmwFMQ/R1KRX1gpxUBqAMvndWxndzjZ8fNKRERERERE9YOVTo6Iq6B9+3alV2JlpQ6s5f/Dh4+irklNTYW7uztSUlLg5uZW080hqhYnTx6Ho6OTKg9hSgVaHf67OQFfrItDwdUAm7ujBm/fFIjBbV1Nui2qHWpbHyqfwX0XMxGXmg9fNxt0bewEzdWyDtl5Wqw6lKqCwMcjs42eJ4vIZ3RaH090b+LEEiZEZJF9KBFRXcN+lIjIzJnBa9b8U9WnEFENu3DhPBo3bmIU3Grduq3JtxObmocXfo/ErnOZhmldGzti9q3BCPSwNfn2iEqSmr+zlscgJqUoI93f3QYPDvJBZFIe/tyTjORM41IQns4a3NTdA7f09EQQP6dERERERERUj1U5GMxawUR1h5SB2LRpA/bt24MePXphwIBBZtvW1lPpmPlHJJIyCgxZlg8N9lFBOBsNMyypegLBT86PQMnLXSQw/Obi6FLLtwt2wO29PTGqgxtLlxAREREREZFFqHIweMmSJeXOnzBhAszlvffew8yZM/Gf//wHn3zyiZqWnZ2Np59+Gr/++itycnIwYsQIfPnll/D39zdbO4jqgpycbCxbtkRlBYvdu3eiZctWCAwMMul2cvN1+GRNLH78N9Ewzc/NBrNvDUKPps4m3RZReaUhJCO4orpHGmtgZHs3TOvjhQ4NHVgKgoiIiIiIiCxKlYPBs2fPMnqcl5enArK2trZwcHAwWzB4z549+Oabb9ChQwej6U8++SRWrFiBP/74Q9UJeuyxxzB58mRs27bNLO0gqguSkpKwaNEfSEhIUI+tra0xdOhwkweCL8Xn4tlfI3Asoqj26oDWLnjnpkB4Ole5eyG6blIjuHhpiGv5cGowhoeylhwRERERERFZpipHa7Zv31lq2qVLF/HWW2/innv+D+aQnp6OadOm4bvvvsPbb79tmC4F4r///nssWLAAgwcPVtPmzZuHNm3aYOfOnejVq5dZ2kNUm12+fAlLlvytTtKIwpM0kxES0sik21l+MEVdep+RUzhKnK3GCs+M8lODbzHbkqqbDBZXGXn5VRozlYiIiIiIiKheMUnqXqNGjTFjxlOYOfN5LFu2Aqb26KOPYsyYMRg6dKhRMHjfvn0qM1mm67Vu3RohISHYsWPHNYPBUk5CbsVHH9XXV5UbUV11+PBBrF+/1vA59vLyxsSJU+Dp6Wmyz3ZmrhazlsVg8f7C741o5G2L928NQttgB+h0OnWjuksyyctTG/tQHxdNpZdjP09E5lQX+1AiorrShwr2o0REN9aPmuw6bhsbDWJjY2FqUgt4//79qkxESdHR0bCzs4OHh4fRdKkXLPOuZdasWXjjjTdKTY+NjUJWVrqJWk5UfWSnR06OnDp10jAtKCgI/fr1R25uFmJiskyynXNxBXh7dTbCk4p2soa2tsETA+3hZJOImBiTbIZqWGBgg3Ln18Y+NNhRBx8XK8SnX/tEhK+LFYIdkxATk1ytbSMiy1IX+1AiorrShwr2o0REN9aPWumqmMK3ceMGo8fy9Li4OCxcuAABAQH4+utvYSrh4eHo1q0b1q5da6gVPHDgQHTq1EkNICflIe655x6js4KiR48eGDRoEGbPnl3pM4kNGzZUdVbd3FhLkuqevLxcLFw4H3FxhSdkunbthrCwQZU6I1QZ8j1fuDMZH62OUwPGCUc7K7w83h/jO7ubZBtUt7PaakMfuu5YGp5aEKnuF/9h0xct+fj2IAxt51ojbSMiy1FX+1AiorqcGcx+lIjIjJnBTzzxuNFjqQ0ql6D37NkLzz77HExJMh0l27hLly6GaQUFBdiyZQs+//xzrFmzBrm5uUhOTjbKDo6JiVGB6Wuxt7dXt7LeMFMFz4iqk729AyZPvgkLFvyCPn36oUOHjiZbd3JmAV75KxIbjhedZW8TZI8PbwtGY9/S3yOq/2prHzq8vTvmTLPCrOUxRoPJ+bvb4IWx/hjGgeOIqBaorX0oEVFdwX6UiOjGVDkYfOTIMVSXIUOG4MiRI0bTJBNY6gI///zz6uyfra0t1q9fjylTpqj5p06dwuXLl9G7d+9qaydRTZWGKL6z4+bmjnvvfUB9J0xl38VMPPdrBKKLBdbu6OOJp0f5wc6GO1pU+0jAd3BbV/XZlUHlfN1s0LWxEzTWHNSQiIiIiIiIyGQ1g83B1dUVoaGhRtOcnZ3h7e1tmH7vvffiqaeegpeXl7ok5PHHH1eB4GsNHkdUHxw4sB9HjhzCbbfdDju7orPipgoEF2h1+HZjPL5cHw/t1evtPZw0ePumQAxqw8vsqXaTwG+Pps413QwiIiIiIiKiWqfKqX0zZvwH33//31LT//e/7/HUUzNQ3ebMmYOxY8eqzOCwsDBVHuLvv/+u9nYQVVc28Lp1a9QtJiYaK1YsU/V8TSkmJQ/3fn8Zn68rCgR3a+KEv55owkAwEREREREREZElZQbv27cXjzzyaKnp/fr1xw8//ABz27Rpk9FjBwcHfPHFF+pGVJ9lZ2dh6dLFuHTpomGap6eXCgZL7W5T2HwyDS/+EaXqBAu5sv7hIT54cJAPL7MnIiIiIiIiIrK0YHBmZmaZl6Lb2NggI6NogCkiMp3ExAT8/fcfaoRcIbWCR4wYhdDQDiZZf26+Fh+vjsPP2xIN0wLcbTD71mCVFUxERERERERERBZYJqJFi5ZYvXpVqemrVq1Es2bNTNUuIrrq4sUL+OWXnwyBYCcnJ9x66zSTBYIvxedi2leXjALBg9q44K/HmzAQTERERERERERkyZnBDz30kKobHB4ejp49e6ppO3fuVMHgjz762BxtJLJIUv7hwIF92LBhnaEusI+PLyZPvgnu7h4m2cayAyl4c3E0MnO16rGtxgrPjvbD7b09TVZ6goiIiIiIiIiI6mgweODAQfj007n47rtvsXbtP7C3t0fLlq3w3Xffo3v37uZpJZEFOnfuLNavX2t43Lx5C4wZMw52dvY3vO6MHC3eXhKNpQdSDNMa+9jhw6nBaBPkcMPrJyIiIiIiIiKiehAMFgMGDFA3IjKNpKREHDlyGCkpySrrt337DmjWrDlatGiFM2dOoWfP3ujff4BJsnVPRGbjmYURuBifa5g2oYs7XhofAGf7KleOISIiIiIiIiKi+hoMPnLkCHQ6LTp06Gg0/fDhQ7C21iA0NNSU7SOq9yQIvGbNSqNpu3fvxMiRozF69FhcuhSqanXfKCk1MX97Ej5cFYu8gsKyE0521nh1YgDGdXa/4fUTEREREREREVHtVuU0wHfeeRvR0dGlpsfExOKdd94yVbuILCYjWALBEqgteVu9eiUyMtJNEghOzsjHYz9fwazlMYZAcNsgB/z5eBMGgomIiIiIiIiILITN9dQxbdOmbanpbdq0wblz50zVLqJ6S6vVIjk5CfHx8di7d7dhcLhrZQ2HhQ28oe3tvZCJ536NQExqvmHaXX298ORIX9jZsCwEEREREREREZGlqHIw2M7ODgkJCWjYsKHR9Li4ONjYXFcJYqJ6Lz8/H2vWrEJ8fBwSExPU48qQGsLXq0Crwzcb4vHVhnhor8abPZ01eOemQAxo7Xrd6yUiIiIiIiIiorqpytHbPn364pNP5mDu3M/h6loYUEpNTcWnn36C3r17m6ONRLVeRkaGCvQW3uLh4+ODrl27G+ZrNBqcP38W2dnZVVqvDCZ3PaJT8vD8b5EqK1ive1MnzL4lCP7utte1TiIiIiIiIiIisrBg8DPPPIvp0+/C8OFD0bp1GzXt1KmT8Pb2xqxZ75mjjUS1Rk5ONuLi4osFfgtvWVlZRsuFhDQ2CgZbWVnBx8cXERFX4Onpqe7LzcHBERs3rrtmqYj27TtUuY0bT6ThpT+ikJJVoB5bWwGPDvXF/QO9oZEHRERERERERERkkaocDPb398fffy/CihXLcerUKdjb22PixEkYPXo0bG2ZcUj1Q25urirn4OfnD2vrorq6u3fvws6d2yt8vgSISxo7dgIcHR1LlVOxt7dTg8WVNHLkaHh6elW+zflafLQqFr9sTzJMC3C3wfu3BaNrY6dKr4eIiIiIiIiIiOqn6yry6+TkhJtvvsX0rSGqZgUFBSroqy/voM/0TU4urNV7330PGgVkpfxDSc7OzoZMX5kv/3t7l15OX1alpNDQDggObqAGi5MawVIaQjKCqxIIvhiXg2d+jcCJyBzDtCFtXfDmlCB4OGkqvR4iIiIiIiIiIqq/rnvEt3PnziIqKgp5eXlG0wcNGmyKdhGZNetXMnEl6JuUlAitVnvNZSVAXDwoGxAQiE6dOsPb2xe+voVBXzk5cqNkG2FhA6/ruUv2J+OtJdHIyi0sNWFnY4VnR/thai9PVZ6CiIiIiIiIiIjouoLB4eHh+M9/nsCZM6dVoElf61QfdDp8+CjfWaox8nlMS0tVgV59bd+AgACj+r1SzuTChfPIzS3Koi1O5uszfCXrt2TQdtiwkagNMnIK8NbiaCw7mGqY1sTXDh9ODUbrQIcabRsREREREREREdWDYPB7781CgwbB+P77/2HEiGFYuPA3dWn7Bx+8rwaXI6ouWVmZiI2NLVXiQTJ/i8vMzChjMDcfxMREw8vL2xD41d/c3d1rfUbt8YgsPL0wApcTijLzJ3dzx8xxAXCyK6pxTEREREREREREdN3B4EOHDuL77+fB09NTDawlty5dumLGjCcxa9a7+PPPv6u6SqJyZWdnq2BvcHCwUZB2166d2LNnV4XPT0hIKDVt4sQpcHBwgEajqXOZzz9vS8JHq2OQX1A4zdneGq9ODMDYTu413TwiIiIiIiIiIqpPwWCpr6q/dN7DwxNxcbFo0qQJAgODcPHiRXO0kSyEZPTqB3OLiyvM8pUgcHp6mpr/wAMPq8HV9CSLtyQ3N/dSmb7e3t6llitZ/qEuSMrIx0t/RmHzyXTDtHbBDqosRIi3XY22jYiIiIiIiIiI6mEwuHnz5jh16iQaNGiADh064H//+x42Nrb4888/1DSiqsjJycbKlctV8FfKjZRHgsPFg8FBQUGq/ENh0FcCwD6ws7NHfbT7fAae/y0Ssan5hml39/fCf4b7qQHjiIiIiIiIiIiITB4MfvDBh5CZmaXuP/bYY3j00Ucwffqd8PDwwIcfflTV1VE9JlnkEuAtnuUrpR6K1++V4O2lSxeRl1dU+7Y4e3sH+PpKdq8PnJ1djOZJvd/Bg4eiPssv0OGrDfH4ZmM8ro7VCE9nDWbdHIT+rYzfDyIiIiIiIiIiIpMGg/v27We4HxLSCMuWrVABP7k8v7YPukXmk56ejtjYaMTFFQ3kJiUf8vOLMllFXl5uqcHcJNCbkBBvKO/g7V2Y6StBYAkAW8LnqkCrw76LmYhLzYevmw26NnZSWcDP/RaB/RcLT76Ins2c8N4tQfBzs63R9hIRERERERERkQUEg8tS/NJ9qr9k8LLMzEwV6JUTAcWDtLt378S+fXsqXEdSUmKpaTfddAscHBwtIuhblrVHUzFreQxiUooC5x5OGuTka5GVW5gOrLEGHhvqi3sHeENjbZnvExERERERERER1YJgMNU/2dlZqqxD4U1f5iEOWVmFWaoPPfQoXF3dDMtLFm9xEtj19PS8mulbmOUr92XQwZIcHZ1gqSQQ/OT8CFytAGGQnFlguB/oYYP3bw1Gl8aW+z4REREREREREdGNYzCYDLKyMrF8+VIVAE5PTyt3WQkMFw8GBwU1QI8eva4O5iYBYG/Y2PDjVVFpCMkILhkILs7exgq/P9YEXs58L4mIiIiIiIiI6MYwwmQhCgoKVA1f/UBu+lIPxev3ymBt4eGX1bJlcXZ2NgR7nZ1djeZJ8HfAgEFmfx31qeTGP0dSjUpDlCUnX4ezMTno0ZRfVSIiIiIiIiIiujGMMNVDqakpiI6ONgr8Sq1erVZbatniwWBra2tV0iElJeVqWYfCAd0Kbz4WXc7hRgO/4Yl5OB6RjeOR2YX/R2QjJavsoHtJMqgcERERERERERFRtQeDlyxZrOq+DhgwQD3+6KMP8eeff6Bp02b44IMPEBQUfMONsnQSuD1y5DBSUpLV4Hzt23eAp6dXqQBjWloqEhLi0bhxU6PB1/bs2YX9+/dVuJ3k5ORS0267bRrs7OwsdjC3G6XV6nApIdco8HsiMhtp2aUD8ZXl68ZzNkREREREREREdOOqHGX67rtv8corr6r7Bw8exK+/LsRzzz2PzZs3Y/bs2fj0089M0CzLJUHgNWtWGk3bvXsnunXrAVdXV6MB3XJzc9X8Rx55QpVw0JNM3uI0Gg28vLxLZPr6wt3dvdT27e3tzfba6mPN3wtxxQO/WTgRmYPM3IoDv17OGrQJssfBy9nIyCl7eQnH+7vboCsHjiMiIiIiIiIiopoIBkv5gZCQEHV/w4b1GDp0GG6++RZ07twZ99xztynaZNEZwRIIlqzfkiTb91okMFw8GNygQUP07t33aqkHX5XJLQFhun55BTqcj80pCvxGZuNUZDay8sob/q2Qn5sN2gQ5oF2wg/q/bbAD/N1sVPb12qOpeHJ+hFqu+Jr0edkvjPWHxppZ2kREREREREREVAPBYCcnJ1VeIDAwCNu3b8NddxUGgO3s7JGdnW2CJll2VnBlSVavBHqlxq+Li4vRPJnWr1+YGVpoGXLVoG3G9X1PR+eowdwqEuBuYwj6tgt2RJtgB/i6XvtrNizUDXOmAbOWxxgNJicZwRIIlvlEREREREREREQ1Egzu3bs3XnvtVbRu3QaXLl1CWFhh0PHcubMIDma94BshNYLLExAQiCFDhqlyDxJ8pxuXk6dVgV6jwG9MNvIrMbZbA09bleWrbkGFAWAvl6rX95WA7+C2rth3MVMNFic1gqU0BDOCiYiIiIiIiIjIlKocuXrppVcwd+5niI6Owpw5n8DDw0NNP3bsGEaNGm3SxlkaGSzuWqSkQKNGjTlA3w3IytXiVFSxjN/IbJyLyUF+JcZ2a+RtZxz4DXaAu6PpSm9I4LdH06JSH0RERERERERERDUeDM7ISMfMmS/C2traaPqjjz6mAsR0/dq376AGiytvPlVORk4BTkYWy/iNzFY1f7UVVHqwsgKa+BQGfvV1flsHOcDVgTWXiYiIiIiIiIjIwoLBI0YMx8aNm+Ht7W00PSUlRc07fPioKdtnUTw9vTBy5GisXr2y1DyZLvOptLTsApwoVuZBAr8X43NRxjh8RqQKQzM/e0O2r/zfKtABzvbGJzqIiIiIiIiIiIgsMhisu0aELTMzA/b2rGN7o0JDOyA4uIEaTE5qCEvpCMkIZiC4UHJm8cBvlgr8Xk7Iq/B5NtZAc//igV9HtAywh6MdA79ERERERERERGQZKh0Mfv/92YbatZ9/PheOjo6GeQUFBSp42apVa/O00sJI4DcsbCAsXWJ6Po5FZKvgr/7/iKSKA7+2GisV6C2e8dvC3x72tgz8EhERERERERGR5ap0MPjEiROGzOAzZ87A1tbWME/ut2rVCnfffY95Wkn1Xlxqnsry1Qd9JfM3OiW/wufZ21ihVaAEfh0NgV8p/WBnY1Ut7SYiIiIiIiIiIqp3weB5835Q/7/88ot44YUX4eLiYs52UT0lJxNiUvOL6vterfEbl1Zx4NfR1koN5qYP+sqtqa89bDQM/BIREREREREREZm8ZvDbb79b1aeQBQd+I5PzCrN9rwZ9JfibmFFQ4XNlEDcJ+rYJckC7YAe0CXZAYx87aGTUNyIiIiIiIiIiIjJ/MDgzMxPff/9f7Ny5E4mJCaUGlFu9+p+qt4LqPPkcyEBuxev7SuA3JaviwK+bg7UK9upr/LYLdkRDL1tYM/BLRERERERERERUc8Hg1157FXv37sG4cePh6+srQ8qZrjVUJ2i1OlxKyDUa3O1kZDbSsrUVPtfDSaOCvirb92rWb7CnrRqYkIiIiIiIiIiIiGpRMPjff7fiiy++QpcuXczTIqpVCrQ6XIjLVVm+xyKyVPD3RGQOMnMrDvx6u2iKBX0dVfZvoLsNA79ERERERERERER1IRjs5uYGd3d3VIdZs2bh77//xsmTJ+Ho6Ig+ffpg9uzZaNWqlWGZ7OxsPP300/j111+Rk5ODESNG4Msvv4S/v3+1tLE+ySvQ4Vxsjqrvq8/6PRmVjew841IgZfF3szGUeZCgrwSBfV0Z+CUiIiIiIiIiIqqzweDHHnscX3wxF++8M0sFaM1p8+bNePTRR9G9e3fk5+fjxRdfxPDhw3H8+HE4OzurZZ588kmsWLECf/zxhwpSP/bYY5g8eTK2bdtm1rbVdbn5WpyNyTEq9XA6Oge5+RUHfoM8bAsDv/rgb5ADfFyr/FEiIiIiIiIiIiKiamSlKzkCXAVuumkywsPD1YBhwcHBsLExDgL+8cdfMJe4uDj4+fmpIHFYWBhSUlJU3eIFCxbgpptuUstIFnGbNm2wY8cO9OrVq1LrTU1NVYFkWZ9kPtc3OXlanIrOKRrcTQK/MdnIr3hsNzWQW9ti9X3lf09nBn6JyHL6UCIic2IfSkR0Y9iPEhFVTZWjeoMHD0FNkc5deHl5qf/37duHvLw8DB061LBM69atERISUm4wWMpJyK34j4fQarXqVhvq9O6/mIW4tHxVaqFLY0dorCtXbiErV4tTUTk4HpmtblLfV0o/FFTiZTX2sVXB3sJsX3u0DnKAu6Om1HK14T0iIvOxtrYud35t70OJiGoS+1AiIvP1oYL9KBHRjfWjVQ4GP/LIo6gJ0qnPmDEDffv2RWhoqJoWHR0NOzs7eHh4GC0r9YJlXnm1iN94441S02Njo5CVlY6atPVsHr7YkoP49KKEbR8XKzwaZo/+zW2Nls3M1eFcXAFOx2pxJq4AZ2K1CE/SQltBrrfElRt6WqOFrzVa+GnQws8azXw0cLbXB5yz1S07NQXZhb+rRGRBAgMblDu/NvehREQ1jX0oEZH5+lDBfpSI6Mb60SqXiagpDz/8MFatWoV///0XDRoUvjApD3HPPfcYnRUUPXr0wKBBg9Rgc5U9k9iwYUMkJSXV6GUl646l4akFkSj5B5EQrUx7ZIg3nOysr9b5zcGlhFxU9NfTWAPN/OxVpq8q9RDkgJaB9mo9RESmymqrDX0oEVFtwD6UiKj6M4PZjxIRmTgzuE+fXlixYhU8PT3V/fJs374TpiaDwi1fvhxbtmwxBIJFQEAAcnNzkZycbJQdHBMTo+Zdi729vbqV9YZV5k0zV2mI91bElgoEC/20L9cnlLsOGw3Qwt8ebYMdVakHqfXbMsAeDrYM/BKR6dTGPpSIqK5gH0pEdGPYjxIR3ZhKBYOff/4FODs7G+5XF0lafvzxx7Fo0SJs2rQJTZo0MZrftWtX2NraYv369ZgyZYqadurUKVy+fBm9e/dGXbLvYiZiUvIrvbydjZUK9OqDvnKTQLCdDX/8iIiIiIiIiIiI6DqDwRMmTCzzvrk9+uijqhTEkiVL4OrqaqgDLCOFOjo6qv/vvfdePPXUU2pQObkkRILHEgi+1uBxtVVcauUCwTf38MBtvTxV6QdbTeUGlSMiIiIiIiIiIiKq8gByoqCgABs2rMf58+fV42bNmqsavRqNxqSN++qrr9T/AwcONJo+b9483H333er+nDlz1KUgkhksdYNGjBiBL7/8EnWNr1vl/hSjO7qhdaCD2dtDREREREREREREFh4Mvnz5Eh5++CHExsaicePGatp///udqtH7xRdfISQkxGSNq8zYdg4ODvjiiy/UrS7r2tgJ/u42iE3JL7NusOQAy3xZjoiIiIiIiIiIiKiqqlxgdtasd9VInevWrccff/ylbmvXrkdwcLCaR9dHY22FmWP91f2SxR/0j18Y66+WIyIiIiIiIiIiIjJ7MHjv3r146qln4O7uYZjm4eGBGTOewt69e6rcACoyLNQNc6YFw8/dOGFbMoJluswnIiIiIiIiIiIiqpYyEba2tsjIyCg1PTMzU82jGyMB38FtXbHvYqYaVE5qCUtpCGYEExERERERERERUbVmBg8YMBBvvPEaDh8+pGr6yu3QoUN46603MGjQ4BtqDBWSwG+Pps4Y08ld/c9AMBEREREREREREVV7ZvDMmS/ipZdmYtq022FjU/j0goICDBw4CC+8MPOGG0REREREREREREREtSAY7Obmhrlzv8Dly5dw/vx5Na1p06YICWlkhuYRERERERERERERUbUGg7VaLebN+x82btyIvLw89OrVCw8//AgcHBxM0hAiIiIiIiIiIiIiqgU1g7/99ht8+ukncHJygr+/H3755We8/fZbZmwaEREREREREREREVV7ZvDSpUvw8suv4JZbblWPd+zYjkceeRhvvvkWrK2rPA4dEREREREREREREVWjSkdxo6Ki0L9/mOFx7959YGVlhdjYWHO1jYiIiIiIiIiIiIiqOxhcUFAAe3t7o2k2NjbIz883VVuIiIiIiIiIiIiIqKbLROh0Orz00ouws7MzTMvNzcWbb74BR0dHw7RPP/3M9K0kololKSkRR44cRkpKMtzdPdC+fQd4enrVdLOIiIiIiIiIiMgUmcETJkyAt7cXXF1dDLexY8fCz8/XaBoR1W8SBP7++2+xe/dOnDp1Uv0vj48ePWyS9Uv5meTkZJOs6+DBg/j111+v67nnzp1Dly5d0LlzZ8ybN89o3sWLF/H1118bTWvcuLHa3o2699570bZtW0yaNAlLly7Fk08+WeFzfvjhB0ycOLHMeUePHlVtIyIiIiIiIiKqdGbw22+/a96WEFGdyAhes2alulKgpNWrVyI4uEGtyhCW4OzixYtx2223Vfm5f/75J7p3745vvvmm1Dx9MPihhx6CKcXExKjgdWpqKjQajZo2fvx4k26DiIiIiIiIiCxXpYPBRGQZ9uzZjb17d5c5Lycnp8xAsN6ff/6G/PyCMud169YD3bv3qFQbPvzwQ6xYsQIZGRl47bXXMG3atKtt24Pnn39eBUuljvmLL76Im2++GXFxcWoZGehSMou7du2K2bNn49VXX0VKSgo6deqEXr16lcrmTU9PxxNPPIHduwtfr6xLtvfTTz9hzpw5ahu7du3CggULVLaungSBL126pNYbEhKiMnjF33//jYcffhjR0dEqw/fll19W0+WxbEeCyFlZWepKi7ffftuoLZINPWjQIGRnZ6v2SwA7ICBABbPlJn7++Wd8/vnnyMvLg4uLC+bOnYuOHTuWev9ef/11zJ8/H25ubhg1alSl3nMiIiIiIiIiqv8YDCYiI7m5OUhPT7uu52Zn5yA7O+ua660sCegeOHAA58+fR7du3dC3b194eHjggQcewMqVKxEYGIj4+HhVxqFPnz74/fff0aRJE/zzzz/q+YmJifDy8sKbb75pFEwt6a233lIB7sOHD6sgbb9+/dC6dWvcddddatsSoP3kk09KPU+CyjNmzChVFkKW37Fjh2pbs2bNcM899yA4OBjTp09XgesBAwaoQTelxM4ff/yhgs968vrktUmAWb9eKf+gt23bNixcuBBbtmxRg3lu3boVt99+O44dO2bUBgmiy7r37dsHV1dX3HnnnZV+34mIiIiIiIiofmMwmIiM2NnZw8XFtcx5EjjNy8u95nMdHOxhY2NzzfVW1n333af+b9q0KcLCwlQA1MfHRwVoS2a6njp1SmX9Sibv008/rZYfOXJkpbazbt06fPTRR7C2toazs7MKAq9duxa33norrocEZ4W0Vdp+4cIFFeRdv369KgFRPCNZ2l0VS5Ys+f/27gM6inL94/gTepHQu0hUEKkhtIigIE1EqpTcCwICF5B+RUACArEBgkrRCIiColyV+0eUi1IURelIE7GAdJEOktBDkvmf5+Xssks2yW4KSXa+n3Nykp2ZnXmn7G9z3vedd+Snn36S0NBQ5zSt9NZKbFe6rS5duphewap///6ybt26FO0PAAAAAADwL1QGA3CjQzkkNpyDjhmsD4tLbKiITp3C0mXMYO0prNusWrWqbNiwweMy2ptWK3d1qIZx48aZnsUp2U5q5MmTx/m3jvmrvYAdx2rTpk1u832l69EexhMnTryt+wQAAAAAAPxHtowuAICsQyt6W7ZsZSoYb/3R6WlVETx//nzzW8fY1eEQHnroITMchPa01Qpf1wrgmJgYM13H0NUesTqO7t69e03vW+0dq2MGJ6ZZs2by3nvvmYpWHZ9Yx+Rt0aJFsuVLbr2utFw6FvDkyZOd044dOyZHjx4VX+iD5D766CM5cuSIeR0fHy9bt271uE86TMSFCxfMfr3zzjs+bQcAAAAAAPgvegYD8Em1ajWkbNk75eefd0lU1HkpWLCQVK9eI017BOuD20JCQkwF7cyZMyUoKMg5Hu6IESPMcBD6EDV9eJuOB7xmzRp54403nL1xp06dKgULFpSmTZuah9HVqFHDVCbf+gA57UGsD3arXr26ea1j+GqFcnJ0fdpLuVq1amY4CMcD5BKjD3MbPny4WV4rznVIijlz5sidd97p9THRCvEpU6ZIhw4dzD5qJfjjjz9uxlR21apVK/NAPB1PmQfIAQAAAAAAVwFWYvd720h0dLSpONKefo5xNgEA3iFDASDlyFAASB1yFAB8wzARAAAAAAAAAGADVAYDAAAAAAAAgA1QGQwAAAAAAAAANkBlMAAAAAAAAADYAJXBAAAAAAAAAGADOTK6AACynrh4S7Yduiyno2OleGAOqR2UT7JnC8joYgEAAAAAACAJ9AwG4JOvd0dL8yn7pNfcIzLq02Pmt77W6bdbUFCQ7Ny5M83WFxERIVevXvVq2YsXL0pAQMorwJcuXSrPPPNMit8PAAAAAADgKyqDAXhNK3yfWfiXnIyKdZt+KirWTE/rCuHYWPftpLcXXnjB68rg1Grbtq1MmzbttmwLAAAAAABAURkMwOuhISYtOymWh3mOaZOXnTTLpYb2tp0wYYLUrVtXwsPD5dSpU/LEE09I9erVpVq1ajJnzhy35RcuXCi1a9eWChUqyNSpUxPtNVynTh1Zs2aN+fvll1+WypUrS82aNc3P4cOH5emnnzbzHnroITNNt3sr3XbFihUlJCQkQUXujz/+KE2aNDHb0fn//e9/zfTTp09LixYtTPlr1KghvXr1MtPff/99ad++vfP9us+6D7rfzz//vCm/OnTokBQqVMjMd+znV199lapjDAAAAAAA7IkxgwE4dXnroJy54Lk3bkxsvPx9OT7R92oV8ImoWGn0yl7JlcNzO1OxAjlk0eC7ky1H9uzZTeWqCgsLk0qVKslnn31mKmi1QjQ4OFgeeOABM//kyZOydetWOXv2rNSqVUsaNGggDz74YKLr/vvvv+W1116T48ePS968eeXy5cuSLVs2mT17tqnsXbt2ral8vdXu3btNheyOHTukdOnSMmbMGOe88+fPS79+/Uwlrc47c+aMKYuWY9GiRXL33XfLqlWrzLLnzp1LsO4vv/xSFi9ebNZ9xx13SO/evd3mR0VFmYpk7bm8YsUKGTZsmLRq1SrZ4wgAAAAAAOCKnsEAnLQi+GS055+kKoJd6XKJrSOxiuZbuVaGfvPNN9K/f3/zd4kSJUwvYZ3m0KdPH9ObuFixYgnmeRIYGGh69z755JOm8lcrZ/PkyZNsmb799lt57LHHTGWvGjBggHPehg0b5MCBA2a+9ipu1qyZmb5nzx5Tab18+XJ59tln5YsvvpD8+fMnWPfq1aulc+fOUqBAAbMvuk+utHy6b6p+/fqyf//+ZMsLAAAAAABwK3oGA3DruZuY5HoGOxTOly3JnsHe0N6xiUnuoW2O+Tly5JC4uDjndMdYwNrreNOmTaYCV4eN0Mrajz/+2AwP4QvXcliWJVWrVjXr9ESHq9BKau3dPG7cONMD2Nt1q9y5czunafld9wsAAAAAAMBbVAYDcEpqCAcdC7j5lH3mYXGeRgXWqsqSBXPIqlEVJHu2pCtsfaG9bOfOnSuvvPKKGX9XK1Qd4/E6xt5t1KiR6eG7ZMkSU7GrdGzdzZs3m2EltmzZYnrpqgsXLpgfrfzVn19++cVUzurf2jNXh2TwNEyEjgc8adIkOXHihJQqVcoMK+Ggw0EcPHjQVPg6egVrBXCVKlXkr7/+krJly0qXLl2kZcuWpnfzxYsXE6xbh53Q3sPac3jevHlpdvwAAAAAAAAcGCYCgFe0gje8dUnz961VvY7Xo1uXTNOKYDVz5kz57bffzAPYHnnkERk7dqyEhoY65xcvXtxU+NarV08GDx7sHC9YHxIXGRlpxhfWylXtuau0stfxQDodh/f69evSs2dPM08rY5s3b+7xAXL68LqIiAhTaawPiNPeug6FCxc24/5OnDjRbE8rgUePHi3x8fGm97GWT9epZdOH3BUsWNBt3a1bt5Z27dqZZfQBcloZ7alCGgAAAAAAIDUCLL2/2eaio6NN5YxWEul4ogAS9/XuaJm07KScjLo5/m+pgjlMRXDzanx+Ukp7K2vPZI1krZS+cuWKzJo1S7ICMhQAUo4MBYDUIUcBwDcMEwHAJ1rh26RKAdl26LKcjo6V4oE5pHZQvjTvEWw3PXr0kEOHDpmxjbUXs+swFAAAAAAAAGmBymAAPtOK33r35M/oYvgVHe8YAAAAAAAgPTFmMAAAAAAAAADYAJXBAAAAAAAAAGADVAYDAAAAAAAAgA1QGQwAAAAAAAAANkBlMAAAAAAAAADYgN9UBkdGRkpQUJDkyZNHQkNDZcuWLRldJAAAAAAAAADINPyiMvjTTz+V4cOHy4QJE2T79u0SHBwsjz76qJw6dSqjiwYAAAAAAAAAmYJfVAa/8cYb0rdvX+nVq5dUqVJFZs+eLfny5ZN58+ZldNEAAAAAAAAAIFPIIVlcTEyMbNu2TcLDw53TsmXLJs2aNZONGzd6fM+1a9fMj0NUVJT5ff78eYmPj78NpQaAzEsztECBAhIQEOBxPhkKAIkjQwEg/TJUkaMAkLoczfKVwWfOnJG4uDgpWbKk23R9/fvvv3t8z6RJk+SFF15IML18+fLpVk4AyEr0n+rAwECP88hQAEgaGQoA6ZOhihwFgNTlaIBlWZZkYceOHZOyZcvKhg0bpH79+s7po0aNku+//142b96cbEuith6eO3dOihYtmmTN+e0UHR0t5cqVkz///DPJEwj/wTm3l8x+vn3p1UaGIjPgnNtPZj7nWT1DM/vxRdrjfNtPZj7nvvYMzow5mpmPL9IH59xeojP5+fb7nsHFihWT7Nmzy8mTJ92m6+tSpUp5fE/u3LnNj6tChQpJZqQXVWa8sJB+OOf2khXPNxmKzIxzbj9Z7ZxnpQzNiscXqcP5tp+seM6zUo5mxeOL1OGc20tgFj3fWf4Bcrly5ZLatWvL6tWr3VoG9bVrT2EAAAAAAAAAsLMs3zNYDR8+XHr27Cl16tSRevXqyfTp0+XSpUvSq1evjC4aAAAAAAAAAGQKflEZHBYWJqdPn5bx48fLiRMnpGbNmrJixYoED5XLSvS2lwkTJiS4/QX+i3NuL5zv9MXxtR/Ouf1wztMXx9deON/2wzlPXxxf++Gc20vuLH6+s/wD5AAAAAAAAAAANhgzGAAAAAAAAACQPCqDAQAAAAAAAMAGqAwGAAAAAAAAABugMjgDRUREmIfdwX899dRT0r59+4wuBjJQ48aN5d///ndGF8MvkaH+jwwFGZp+yFD/R4ZCkaPpgwy1B3IUjf00Q6kMTiM//PCDtGnTRsqUKSMBAQHy+eefZ3SRkMZmzZolNWrUkMDAQPNTv359Wb58eUYXC7fpM3z9+nV57rnnpHr16pI/f36zXI8ePeTYsWMZVmZ/Qob6PzLUv5GhGYsM9X9kqP8jRzMOGWoP5Kh/I0N9Q2VwGrl06ZIEBwdLZGSkZHYxMTEZXYQs6c4775TJkyfLtm3bZOvWrdKkSRNp166d/PLLL5LZcI7T/jN8+fJl2b59u4wbN878/uyzz2TPnj3Stm1byYyy2jVAhvo/MtS/kaEZiwz1f2So/yNHMw4Zag/kqH8jQ31kIc3pYV2yZEmyy02YMMEKDg62FixYYJUvX94KDAy0wsLCrOjoaOcyV69etYYMGWIVL17cyp07t9WgQQNry5Ytzvnz58+3ChYs6LZe3bbrqXVsZ+7cuVZQUJAVEBCQZvtqd4ULF7befffdROf37NnTateunTV16lSrVKlSVpEiRayBAwdaMTExzmXOnTtnde/e3SpUqJCVN29eq2XLltbevXsTnD9X06ZNM9fMrdt5+eWXrdKlS5vzrCIjI60KFSqYa6dEiRJWx44d0/gI2PszrJ9FXfbw4cOJLtOoUSPzGR45cqS5XkqWLGnOqSt9f9u2ba38+fNbBQoUsDp37mydOHEiwfl1NWzYMLNu1+0MGjTITC9atKjVuHFjKz4+3myrXLlyVq5cucy1oWXJ7MhQ+yBD/RMZmrHIUPsgQ/0XOZpxyFB7IUf9ExmaPHoGZ7D9+/eb7uvLli0zP99//71prXIYNWqULF68WD744APTelGhQgV59NFH5dy5cz5tZ9++fWY92vqxc+fOdNgTe4mLi5NPPvnEtD7p7SVJ+e6778x51t96Ht9//33z4zoOkbZMLl26VDZu3Kjf/NKqVStzG4MvVq9ebVq2vv76a3Mt6TqHDh0qL774opm+YsUKefjhh1O8z0goKirK3IJSqFChJJfT8663omzevFmmTJlizomeJxUfH29apPUzrZ9/nX7gwAEJCwvzuTy6nVy5csn69etl9uzZ5jM/bdo0mTNnjvzxxx8ma/S2GH9ChmZNZCgUGZrxyNCsiQyFAzmascjQrIschdg9Q72oMEY6tibmy5fPrfVQWxtCQ0PN3xcvXrRy5sxpLVy40DlfW6DKlCljTZkyxafWRF3PqVOn0mT/7GzXrl2mtSd79uzmuH/55ZdJLq8tQNriFxsb65ymrUTaaqy0xVDP1fr1653zz5w5Y1oUFy1a5FNLorZQXbt2zTlt8eLFpoXa9fpC2n2Gr1y5YtWqVcvq2rVrkstpC1/Dhg3dptWtW9d67rnnzN+rVq0y19ORI0ec83/55RdTBkfPAW9bEkNCQtyWef3116377rvPreU6KyBD/RcZag9kaMYiQ/0XGWof5GjGIUP9GzlqD2Ro8ugZnMGCgoKkQIECztelS5eWU6dOmb+19Ulbkxo0aOCcnzNnTqlXr5789ttvPm2nfPnyUrx48TQsuT1VqlTJtMZqi9CAAQOkZ8+e8uuvvyb5nqpVq0r27Nk9nmM9jzly5JDQ0FDn/KJFi5rt+HqOtYVIW5Ecmjdvbs77PffcI927d5eFCxeacXKQevq57NKli2n11QcRJEcfVODq1mugXLly5sehSpUqpnXS12ugdu3abq87d+4sV65cMddA3759ZcmSJRIbGyv+hAzNWshQKDI08yBDsxYyFA7kaOZAhmY95CjUdTKUB8hlNP1CcKVd1LWbubeyZctmLmBXnm5H0C7tSD0NZ729Rz+kkyZNMgOUz5gxI1OeY/3HRG9H+vjjj01YjR8/3pT3/PnzXm8biX9xHD582NwCok+iTU5GXQP6haS3FL399tuSN29eGThwoLm1yNdbljIzMjRrIUNBhmYuZGjWQoZCkaOZBxma9ZCjIENvoDI4E7v33nud44U46En/8ccfTUuD0hbCCxcumLFuHBhH6PbRALh27VqK31+5cmXTsqMtkw5nz541H3jXc3zixAm38PD2HGsrZbNmzcy4Nrt27ZJDhw7Jt99+m+Ly2p3ji0PH6/nmm29Mq29q6TXw559/mh8HbZ3WL3nXa+D48eNu7/P2GtAvjTZt2sjMmTNlzZo1Zhyrn3/+WeyADM38yFB7IUOzFjI08yND7YcczTrI0KyBHLUXMvSmHC5/IxUuXrxoBnZ3OHjwoDm5RYoUkbvuuitF69RWAb11YeTIkc71aAjorQF9+vQxy+jtCPny5ZMxY8aYwcU1hFwHM0faCQ8Pl8cee8ycB/3S/s9//mM+jCtXrkzxOitWrGgGG9cu/zoouLb+jR49WsqWLWumq8aNG8vp06fNue/UqZMZOH758uXJtmDpoPM6cLm2HBUuXFi++uor82Wnt6zA98+wfnHo8dfWWT22+tAB/VJXuozrLT2+0C93vSWoW7duMn36dPPPhLb4NWrUSOrUqWOWadKkiUydOlUWLFhgHnDw0Ucfye7duyUkJCTJdWsWaDkdOaHv0y8Tvd0osyFD/R8Z6t/I0IxFhvo/MtT/kaMZhwy1B3LUv5GhvqFncBrRJz3qiXSczOHDh5u/tSt/aujTSDt27GjGiKlVq5a5uDWsNAwcF61eEBoMegHqLQQRERFpsk9wp2PC9OjRw4Rv06ZNTauungsdyyc15s+fb25Tad26tQkGbTHU8+m4FUFbmvS2gMjISHNbyJYtW2TEiBHJrlfHqNEnzmrw6Dr0aZR6feiYR/D9M/zXX3+ZJ8QePXpUatasaW7Vcfxs2LAhxdvVW0y++OIL85nWL3r9MtExgT799FPnMvrU4XHjxpknEtetW9f886LXojfXwNy5c81YZTrOkbZ+/u9//0uTFtC0Rob6PzLUv5GhGYsM9X9kqP8jRzMOGWoP5Kh/I0N9E6BPkfPxPQAAAAAAAACALIaewQAAAAAAAABgA1QGAwAAAAAAAIANUBkMAAAAAAAAADZAZTAAAAAAAAAA2ACVwQAAAAAAAABgA1QGAwAAAAAAAIANUBkMAAAAAAAAADZAZTAAAAAAAAAA2ACVwfAbLVo0kw8/XJBp1pPVtp2cAwcOSNeu/5BatWpKx44dvH7fli1bpFq1KhIdHZ3mZYqMfEsefvghs/7Vq7+RsWPHyNChg9O0bJ9/vkTq1w9NoxIDmRcZmr7IUMD/kaPpixwF/BsZmr7IULjK4fYKfk8/XF988bn5O0eOHBIYWFDuu+8+adWqlbRv30GyZbNP+4CGwquvTpaNGze7Tf/kk0WSN29ev912aoJay7Zs2ZeSL19+j8s89VRPuf/++2X06PB0L8/+/ftl1qy3ZcaMmRIcHGyu5Xr1QsWyrHTfNuyLDL2JDPUNGQrcQI7eRI76hhwFyFBXZKhvyFC4ojLYhho2bCgvv/yKxMXFy9mzZ2XdurUyefIk+frrVfLmm5HmSyUjxMXFSUBAQIIvsOvXYyRnzly3rRxFihS5bdvKTNtOzp9//ikPP/ywlClTVjJLeVSTJk3NdaNy5bp91wnsiwxNGhnqGRkK3ESOJo0c9YwcBW4gQ5NGhnpGhsKVfZqN4KQfsGLFikvJkiWlSpUq0q9ff3nzzbdk7dq18vnnN1oZlXa1Hz9+nDz0UAMJDa0rvXv3kt9//91tXWvWfCdhYV3MrQYNGz4oQ4cOcc6LioqS8PDR8uCDD0idOrXk6af7yeHDhxJ01//uu2+lbdvWZh3Hjx83t1bMnj3LvFe3GxERYZbfvn2b9OjxpNSuHSJNmzaRiRNfkcuXLye6nx988L506NBO6tatbZZ/6aUX5fLlS87bCZ5/fqxcuHDB3FagP9pS5unWjuPHj8mQIYPMerQ8zz77jJw5c8Y5X9+nt1ksXbrUvPeBB+rJiBHPyqVLN7Z1K1+2rfMWLfpUBg4cYI5hmzatZefOnXLkyGHTaqdl6tatqxw5csRtG99+u1o6d+5ojmnLli3k7bcjJTY2NtFjFR8fb1rlmjZ9REJCgs3+6D8VruX49ddfzHlxLe+trdRbt/4oH330oXO//vrrL+d8fX+XLp3NfmiZDx48mOIy6/YHDx5o/q5evarZlqMMrreV6H7NnfuOPPpoc3PdPPFEB1m1aqUkRa/LZs2amHLq9Xz+/Pkkl4f9kKFk6K3I0JvIUHiDHCVHb0WO3kSOIjlkKBl6KzL0JjLUSxZsZcyYcGvIkEEe5z3xRHvr6af7OV/36dPbGjRooPXzzz9bhw4dtKZMedVq0KC+df7832b+mjVrrBo1qllvvjnT2rdvn/Xbb79Z77wzx/n+wYMHWm3aPG5t3fqjmdevX1/rsccetWJiYsz8JUs+s4KDq1vdunW1tm/fbh04cMC6fPmy1bx5Uys0tK41f/486/Dhw86fOnVqWQsWfGDKost36vSENXZsuHN7+j6d76B/b968yTp69Ki1adNGq3XrVtaLL75g5sXEXLMWLFhgtnP69Cnzc+nSxQTriYuLszp27GB1797N2r17t/XTTzutzp07WT179nBu56233rTq1q1tDRs21Nq7d6/Z30aNHrKmT5/m8Th7u21VtWplq0mTxtby5V9ZBw8etIYMGWy1aNHM6t37KWvdurXmuHft+g+rf/++zvfo9nXdn3++xDpy5Ii1fv16857IyLcSvS4++OB9854vv/zSnIfXX3/NnBs91krL2K5dG3MNuJbXVXR0tNW16z+tCRPGO/crNjbW2rx5s9mPf/4zzNqyZYu1b98fVo8eT5rzntIy6/b1+tH1Orbl6fqePXuW1br14+ZY6Xr1PSEhwaYcylG2qKgo81rPb/XqVa333nvXHO8PP1xg1a8faj3wQL1Ejx3shQwlQz0hQ8lQeI8cJUc9IUfJUXiHDCVDPSFDyVBfURlsM0l9eTz77HAT9mrbtq3mw3zt2jW3ZVq2bGEtWvSp+VuDYtSokR7XpaGjH0oNeYe///7bql07xFqxYrl57fjw6xeLKw1QDUlX48Y9b0VEjHebpmXUD/rVq1c9Bu+tVq5cYb78HHT7nkLBdT0aYvoFeezYMed8DT8t965du5xfHvrFdvHizUB97bWpJiwT4822lW5n5swZztc7d+400xYv/j/nNA38WrVqOl/36dPL7UtcLV36hdW48cOJlueRRxpZc+bMdpsWFtbFeumlF93+udB9TYp+qU6aNNFtmiOgN27c4Jz2/fdrzDTHuUtJmb/55muzjsSub7129bzs2LEjwbU0cuQIj18eOv3pp/sn+Fzw5QEHMpQM9YQMJUPhPXKUHPWEHCVH4R0ylAz1hAwlQ33FmMFw0sYBx1gte/bsMbdsNGhQ322Za9euOcd22bPnd+nUqVOiT6rUsYpq1KjhnFaoUCEJCgoy8xxy5swplSpVSvD+qlWrur3W8uzdu0eWLVvmNl1vGzh69Kjce++9CdaxceMGeffdueb2hYsXL5oxjLT8V65c8XpQ9wMH9kupUqWkdOnSzmn33ltBAgMDzX5Ur17dTCtTpozkz39zEPbixYvLuXPnJC3oAwEcihYtan5XrHhzWrFiRc1+6T7ecccd5ljt2LFD3nlnjttxSmzf9X2nTp2SkJBabtNDQkLMutLKffdVcjs+6ty5s1K6dBmfy+wNvfVG39u3bx+36devX5fKlSsner6bNm3mNi04uKasX7/O5+3DfshQT/tBhqYVMhR2QI562g9yNK2Qo/B3ZKin/SBD0woZ6l+oDIaThmHZsneav/WLQz/g8+e/n2C5AgUCze/cuXOnept58uRxfmG5ypcvn9trLU/nzl3kySefTLCsa7A76Ng2gwYNlLCwf8jQof+WggULmjGKdMwkDY+0fsLnrYP06z5p+KX1uh3HKmdO1+3dmObYnh6rQYMGS7Nm7iGYVucsLfcjPt5KtzI7xp96++3ZUrJkCbd5t/MBBrAPMjTlyNDkkaGwA3I05cjR5JGj8HdkaMqRockjQ/0LlcEwNm/eJH/8sVd69OhhXleuXMUMqp49ew4pW7Zsoi1DmzZtkg4dnkgw75577jGDhe/atcu0SCkduPvQoUMeW/2SU6VKZdPKc9dd5b1aXgc31zAdOXKU82mmK1eucFtGWzG1dTEp99xzr5w4ccIMhO/4ktq/f58ZjD8l++HLtlNKz522nnp7rLT1sUSJErJjx3apW7euc7q27DlaSn3Zr/j4uHQvsze0xVcfrqDnznW/kjvfes262rXrpzQrE/wXGeoZGUqGkqHwFjnqGTlKjpKj8AYZ6hkZSoaSoZ5RGWxDMTExcubMaYmLi5ezZ8+ap0zq7ReNGjWWtm3bmWXq168vwcHB5kmOw4ePMLeD6K0HP/zwvel2X61aNRkwYKD861+9pVy5cvLYY61MGK5d+4P06fMvKV8+SJo0aSIREeNlwoQIyZcvv0yf/oYJqUceaeJzmXv3/pd06/ZPeeWVl6Vjx46mJXD//v2yceNGGTv2+QTLlyt3l/nyWrhwoTRu3NgEoT7F01WZMmVNa9OmTRulUqX7TavmrS2MehwqVqwoo0ePkueeC5e4uFh56aWXpE6duuYYpJQ3206pAQMGmFZU/bJr0aKFBARkM7dt7Nv3hwwdOszje3r16m2e6KnH7f777zdP4Pz999/k1Vdf9Wnb+o/Grl0/m5ZcbQ3WFtz0KnNy9Dafp57qJVOmTBbLije3zegtNPolqV+Y7dq1T/Cebt2elO7du8n8+fPM9bt+/XpuKUECZOgNZOhNZOgNZCi8RY7eQI7eRI7eQI7CG2ToDWToTWToDWSo96gMtqF169ZJ48aNTDd/HStHWwTDw8eYD5Oj1U27/c+aNUdmzJgu48aNNePlFCtWTGrXruMc56ZevXry+uvTZM6cWfLee++aD6TOd3jppVdk8uRJJhT0Vg6dN2vWbNPa5Csdh2j+/A9k5swZ0qNHdzMekgZdy5YtPS6vAThq1HMyb967MmPGNLPtYcOekTFjRjuX0RbOLl3CZMSIZ00rp34Z6q0NrvQ4vPnmWzJx4ivSs2d3c3waNmwo4eFjJTW82XZKNWjQUCIj35ZZs2bJvHnvmfN89913S8eOnseDcoTmhQsX5LXXpph/KLSV9K23Is0/Ab7QsB47NlzatWsjV69elZUrv063MntjyJChUrhwEfPPkY6Npde7tlr27dvP4/L6D1NExAsSGRlpvkwfeKC+9OvXX+bMmZ2qcsC/kKE3kKE3kaE3kKHwFjl6Azl6Ezl6AzkKb5ChN5ChN5GhN5Ch3gvQp8j5sDwAAAAAAAAAIAu60WwEAAAAAAAAAPBrVAYDAAAAAAAAgA1QGQwAAAAAAAAANkBlMAAAAAAAAADYAJXBAAAAAAAAAGADVAYDAAAAAAAAgA1QGQwAAAAAAAAANkBlMAAAAAAAAADYAJXBAAAAAAAAAGADVAYDAAAAAAAAgA1QGQwAAAAAAAAA4v/+H3RFh9H1ofdYAAAAAElFTkSuQmCC", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABYMAAAFzCAYAAABsLxaJAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAvNRJREFUeJzs3QWYE+fWB/D/btbdFRb3xd3dHWqUtrRfXS+lSvVWKfWWtrdye6kBddxK8eLursu6uyffc94l2c36ssla/r/nCSQzk8mbbPLOzJkz57XS6XQ6EBEREREREREREVGDZl3bDSAiIiIiIiIiIiIi82MwmIiIiIiIiIiIiMgCMBhMREREREREREREZAEYDCYiIiIiIiIiIiKyAAwGExEREREREREREVkABoOJiIiIiIiIiIiILACDwUREREREREREREQWgMFgIiIiIiIiIiIiIgvAYDARERERERERERGRBWAwmOq11NRUuLi44N577zWavmzZMuzevbtW2nT48GH8/PPPZc6XeV26dEFoaKi6ffDBByZ77cuXL+PLL7+s9PJWVlZISkpS95s2baraLu677z5s3ry51j9LIjKv+tiHLl26FJ06dVL9aPv27fHiiy9Cp9PVyGsX7289PDxK7U/HjRuHM2fOqPvfffcdTp8+bZL2EVHdUx/7Ub3MzEzVj0p/aircFyUiS+hDt27dip49e6JDhw6qH921a1eNvbYe90WpOhgMpnrtl19+Qffu3fHnn38iLS2tXmw8GjdujHXr1uH48ePYsWMH/vOf/2DLli21sgNelv/+978YOnSous8dcKKGqz72oSNGjFDL6G8bNmxQ7a2J166sNWvWoE2bNuo+d8CJGrb62I/qPffcc+jfv79JX5v7okTU0PvQiIgIzJo1Cz/88ANOnDiBQ4cOoV27djXy2pXFfVGqkI6oHuvTp49u9erVukmTJun++9//qmny2NPTUxcUFKTr3Lmz7ptvvinxvMGDB+vmzJmjGzhwoK5x48a6l156ST2vf//+uiZNmug++OADw7L79u3T9e3bV9exY0ddz549df/884+aHhMToxs5cqQuNDRUzbv77rt10dHRan1ubm7qtR988MEK38P48eN1CxcuLDE9Pz9f9+ijj+ratm2r69Spk65bt266zMxMXW5urm7UqFG67t2769q3b6+bMWOGLi0tTT2nTZs2OgcHB/XaEydOVNPOnj2rGzdunK5Hjx6qnQsWLDC8hnQBiYmJ6r6870OHDhk+n6VLl5b5Wf7www+6Xr166bp27ao+w8OHD6vpu3btUu2UZTt06KD74osvqvT3JKKaVd/70OTkZNU/Sn9VXEZGhu6WW27RtWvXTi0jryUiIyN1Q4YMUX2V9KHSz0p/W9Zr7927Vzd06FDV53bp0kX366+/qumXLl3Subu7l9ufymfn7Oysa9q0qVqnfEbivffeU5+F9KGjR4/WXb58WU1fsWKF+iz0feiyZcuq/DcloppVX/vRDRs26KZNm6bbvHmzWq403BclInOrj33oiy++qJs7d26F7437olSXMRhM9daJEyd0wcHBury8PN3y5ctVB683a9Ys3UcffVTmc2XjMX36dPXchIQE1eFKJ6zVanXXrl1THaZ0pNnZ2apDXrdunXre9u3bdf7+/rrU1FTdhx9+qHvggQcM64yPj1f/S2B38uTJlX4PXl5eurCwsBLzDh48qHa+ZcMgkpKS1H1pY1xcnJom9x966CHdvHnz1OPiO/Ty/mSjcerUKfU4PT1dde6yQanMDnhpn6VsPMeOHavLyspSj7dt26Y2YkI24osXLzYsK58tEdVN9bkP3bFjh9pxt7e3182ePVu9bnF//vmnClYUX78EMuT1hbRfTsgtWbKk1NeW9yA73REREepxbGysej/yHiuzA67/rIoGqxctWqS777771GvrAxoSJBFyoLBz5051X/p7/fqIqG6qr/2orFcCABJ4KC8YzH1RIjKn+tqHTp06Ve1/Dh8+XPV3jz32mOGEWFHcF6W6zKbi3GGiuunbb7/FXXfdBY1Go2riPPjggzh16lSlL9G46aab1HM9PT3RvHlzTJgwQdXZCQ4Ohq+vr7rMTeZbW1tj9OjR6jkDBgyAv7+/unyjT58++Oijj/DUU09h0KBBGDNmTJXaf+3aNUyePFldSteoUaMS86VNeXl5+L//+z91mdz48eNVW7RarXrd1atXq/nJycno169fqa8hdYLk0pXbbrvNqC7TyZMnVY2jG7F8+XIcOXIEvXv3NkxLSEhQdeeknW+88QbOnTuHYcOGqc+LiOqm+tyHSp937NgxxMbGYvr06di+fbtaR1GdO3dW7+eRRx7B4MGD1XsU0ofKpdH//POPqjUcExOj6rcX7Sf1du7ciYsXL2Ls2LEl+lZ5zzdCLnvct2+fuiRS5OfnG+YNHz4c//rXv9RnO2rUKJPW8SQi06uv/ehjjz2GF154AX5+fmqfsCzcFyUic6qvfaj0e9u2bcPff/+t6h3fc889ePXVV/H+++8bLcd9UarLWDOY6qXc3Fz8+OOP+P7779VgEy1btkRGRobaoFSWg4OD4b5sJIo/lk6+NLKBEX379lUbEdkRlRpHskNbtCMtj9QZkrqXL730Em6++eZSl3F3d1d1hW+//XZV40cGTDp//jwWL16MTZs2qaL1Egx5+umnkZWVVeo6ZOPi5eVlVF/z0qVLqsbRjZJ1yvOLrjMyMhKOjo6YPXu2OjAIDAxUBxmy4SOiuqe+96F6sqMvO9a//fZbiXmygyzBBtmxl/rsspOdmJiIDz/8UO1079mzB0ePHlV9bHl9qAwMUrS/u3r1qgow3ChZ59y5cw3rk35cbkLatnDhQjg5Oal+9t13373h1yEi86rP/agEIGT/UdotwQfpK/W1JYvivigRmUt97kNDQkLUyTEJQtva2mLGjBml1jfmvijVZQwGU720YsUK1bmGh4erM35ykw5YNiiyYXFzc1NZCtUlO8Zy5k4GKNKfmYuKilJnyGRHVs4E3nLLLViwYAHOnj2rit5X9Nqysypn3ORsYHk7wpLxlp6ers7Ivf3222ojKRsT2YD4+Pio15HMCikIr1f8taX9Mk06dD3ZiZfsicoqvs5Jkybhp59+UhshIZ/P/v37DWcomzVrhvvvv1/tgHOwD6K6qT73oRKQkHUK6QPloF8CFKVdfSE7+9JnSaaG7PiGhYWpPjQgIEAdMEhbigaSi7+2ZLpJOyXzQ092mnNycir9GRRf55QpU9QVIfp+WD5vGXhE/95kh1+y9h5++GH2oUR1WH3uR/XtlZsMVNS+fXvDqPNFcV+UiMylPvehErzdvHkzsrOz1eO1a9eqLODiuC9KdRmDwVQvyRnDmTNnGk2Ty0nkkpCVK1fizjvvxK+//oquXbuq0YhvlJ2dnTpLKJd9SLBBsg1+//13tdHYsmWLurRCNiTSSb/33nsqg0ICvbJhkOUfeuihEut85ZVX1M7rJ598op4rt6I7yHqyoRg5cqRaj5xFlJtcHiKX0shZU9mwyeOBAwcaniPLSucty8pGx8bGBqtWrVLvQT/v3nvvVZfRVVbxz1JeT84QTp06VW30ZJ36EU8/++wz9ViWlaznDz744IY/eyIyn/rch8qo09LHSf8jGR2y/H333VdiOclw6N+/v1pO3oe8J1mnXPommRjSV8k0uUpDr/hrS8aHBJslCCLrkYDJ888/bwhGV8YDDzygni/vU0Z2ls/97rvvVpcyyzplumTYCQlc6PtQORj697//fcOfPRGZV33uRyuL+6JEZC71uQ+VZaV/k7Z17NgRcXFxeOutt0osx31RqsuspHBwbTeCiIiIiIiIiIiIiMyLmcFEREREREREREREFoDBYCIiIiIiIiIiIiILwGAwERERERERERERkQVgMLiBkELg3bp1U8W/ZcCG77//3jAvJiYGY8aMQatWrdS8bdu2VWpeUTJKsIw6aS6vvfaa0QBA//zzjxp5U4q660kB9Zdffrnc9cgoxzK6phgyZAiWLVtm0nY++uijhkHf5CYjgH766aeGz0gKzuvnSUH2ypIRmWUEVXORQvBt27ZVBeJ79OiB9evXV3udTzzxhPq85e+k/8zLcuTIEYwfPx41PULtk08+afL1vvnmm2jRooW6vfjii4bpMjiKFOcny1Pf+18hA2voB9CQvmLYsGGGgSm2bt2qBmqTeTJohQyEER0dbdQ+GTxDBv1o2bIl5s6dW+kRjm+66SYEBQWpfiQpKemG2i6vLyMfl6W8z3nfvn2GgT2KDp5RGhnoQ5Zr3bq1+nxk9OvKzCtLREQERo8erQZgkkFCpk+fjtjYWFSVbOfKG+n5f//7n/r7yCBOH3/8sdE8GTxEBmrRb7eeeeaZGnv/RHrsQ2+sD62pPkQGipsxY4Zqm/zGZeAlvXPnzqkB5vSDuMkAn2WRZWXQJVlHz549ceLEiUrNK0tWVpb6u8pz5PWlHefPn0dVybHGunXrypwvAzfJ39be3l4NPFWUDKzk6+tr6EOLD4ZlzvdPDUt8fLzRMaZ8F2S7nZCQUG/6Qh7Pm/d4Xo47ZVuhb5t+0MwbVdVtSEM5npfPTb+/ERoaajTI6NGjR9WgqBZDBpCj+k2r1eo8PT11R44cUY8vXbqks7e316WkpKjH99xzj+7VV19V9/fu3asLDg7W5eTkVDivqIULF+omT55stvewdetWXYsWLQyPX3/9dV3v3r0NbROtW7fWbdq0qdz1NGnSRHfo0CF1f/DgwbqlS5fecJtyc3PLnR8ZGalzcHBQ/1f3M/L29lZ/N3NZs2aNLiMjQ90/fPiwzs3NTZeWllbtv1lYWJjRZ16WsWPH6rZt26ar7+Q9t2/fXn12WVlZuu7du+tWrVplmN+tWzfd2bNna7WNVLMaQv8bERGh+qDLly8bph04cEC9N+kH5f3JY73Tp0/rUlNT1f2vvvpK17ZtW93FixfV4/T0dN20adN0d9xxR6Vee8OGDbro6GgZyFaXmJh4Q+2vqK8v63OW9yf3pQ3izJkzusaNGxv6yqLy8/PVNkq/DXrvvfd0N910U4XzyhMVFaXbvn274fHTTz+tmzVrVpXfvzzno48+KnO+9PknT57U3XnnnSWWq+i55nz/RIJ96I33oTXVh7z22muG9Uo7fX19dXFxcepxv379dN988426HxMTowsJCdFdu3at1PUMHTpU/S3Eb7/9puvRo0el5pUlMzNTt3r1avU5iwULFqjtQVXJd+hf//pXmfNl2yD96IsvvlhiuYqea873Tw2bbEsnTJhgeFwf+kIez5v3eL7ofrL0s66urrrY2NgbXl9VtyEN5Xj+n3/+Mfy9k5KS1Hd28+bNhvny99+4caPOEjAY3ADITpCXl5fqgIXsUAcFBemys7PVY2dnZ8MXXvTs2dNw8FvevKKKdozh4eFqJ+Xbb781dNiyg9S3b19do0aNdP/5z390//vf/3R9+vRR85YsWVLhe5C2Ojo6quCiGDZsmNrB0+/UyY62dNSy4/fBBx+o1+/cubP6f+fOnRVuPH7//Xddp06ddOfPn1cHGPfdd596rx07dtTdf//9hs9KnvP444+rtsuOWXneeecdo41FVTYey5cvVzv/8vrPPPOM0cZDgonjxo1T703my86t3rJly9Tz5L08++yzN7TRkQN32XiU9jz5DjVv3lwXHx+vHj/66KPqsypPRcHgK1euqIMDPTlYGDlypC40NFS9v7vvvtvw+clnPnHiRF27du10AwcONLTx6NGjuv79++u6du2q5r3xxhuG9cnfTjZeHTp0UJ/L6NGjS/w9pIOX+Q8//LBaRgK6+/btM6zjyy+/1LVq1UqtX3ZcyjpP9sgjj+jmzZtnePz555/rZs6cafSdkL8LWY6G0P/K79fPz88QfCkqISFBp9Fo1OuWRg44pK8uSoIE0p9Lf1tZFQWDFy1apOvVq5euS5cu6je8YsUKNV2CEPI5Nm3aVG0TirelvM9ZdqDt7OyMlpU+6Y8//iixDjm4atOmjeGxfFYSsJJtUnnzqkICAGUFMv7++2/1N5X3L/3Xf//7XzVd3q8EmuQ7J+9fH5SpbMCnssHgmnj/ZJnYh5qmDzVnHyLL79q1y/D45ptvNiwnf4Oi70324WQ/vTg56Sf7nvrAjPzd/f39defOnSt3XlXIfp38zUpT1n6k/O3ktXx8fNT7l8B3WUoL/FY2GFwT758aFjneKxoErQ99IY/na+54Xk4quri4qP6juJ9++kklLEnikvQnclLhzTffrNY2pCEdzxc3fvx4w8k48fPPP+tuueUWnSVgMLiBkA5fOhL5kcoOhX4DIDuUxQ92ZSdOOv7y5hWn/yHKj1h+eOvXrzfqsGfPnq3uy46LdPL6H7ccJMoOVmUMHz5c98MPP6iOq1mzZmqanKmRDYYEAvSduXQ+erJzWvQgtLSNh2xsBgwYYMhikI3F999/r+5LB3nvvffq3n33XcNzpPMp7WxqcXJmUx+Q0H9G8jeQjZpsSH/99ddSnyedthz4nDhxwpAVIp2VdJR5eXmq8z516pQhQ0Q6WPkc9c/Tz5MNtP554uWXX1Yb7orIAYC0UZ9JUdzbb7+tOvBffvlFLVfRAX1FwWD5m06fPt3w+MMPP9Q98MADhsf6wLN8fvJ9lAw2MX/+fLWREbLBl++FkKw9OZjRH5j8+9//1k2aNMkwX//9KL7xkIOx3bt3q8fyOY0aNUrdP3bsmC4gIMCwE/XKK6+UufGQjenixYsNj2UHRzZyenIwK38/siz1vf+VE0SSiSYBgSlTpqj+sGhmlxzoyg6nZATIzpVkSQl9Rq8EO4qTnTR9Hyj9SFmBkMoGg+Xz0vdZ0ufJgbL+N19e1khFn7N8ftLX6T8vWVYfyJB+QvpV/QGIvs/Qk+y4CxculDuvsqTvl/ch/WNp5DOWZfR9pnzX9AdblQ3olhUMlkC6bGdkZ7hoX16T758sG/vQ6veh5uxDpO0SxNGToIe+bxg0aJDaXxPym5e/owRh9IES2ccW+/fvV/vNRUkQR7KvyptXFZJN/cQTT5Q6r7z9yMoGdMsKBksgXf5ecpxSNOOxpt8/NRw7duxQ+zn6EwT1pS8UPJ437/H8J598otrs5ORkdExanBxrS1KXfCZjxowp87i/stuQhnQ8X9SJEyfU30O/PdQHvuU7YAlYM7gByMvLU3VMpV7ZlStXsHHjRtx5552Ii4sz6etI/apJkyZh8eLFGDVqlNG8W2+9Vf0v9cSk7o7UgRRSn1ZqHVWmFqTU5JGaQlJ7sFevXmpanz59sGvXLjVdX7Pn0KFDGDx4sKrxInWHzpw5g8zMzFLXKZ+LfB4bNmyAt7e3miZ1h9577z1VK6Zr167Yvn27UY2xO+64A7a2tuW2VZ6TmpqKcePGGaZNmDABV69eVTWOvv32W8yZM6fUGmwyTerySN04ce+998LOzk7dl/cin/Ntt92m2if1w+R1Tp48aXie1KITs2bNMjxPvP766+rzKI98FlLPSWq6SQ2n0jz//POqVp3Uv/3111/V37M6rl27Bn9/f8Nj+ZuuXbsWTz31FJYvXw5nZ2fDPHm/UjNPyOvL3z0/P1/9faUGldRJkufL91xfS0pq9f7rX/9StdyE1G4rjXw3e/fure5L7b4LFy6o+1IjVOpsBQQEqMf333//Db9XWYe8X7IcDaH/tba2xh9//IGdO3eq38KOHTtU7Ud9vyh1Zo8fP45bbrkFZ8+eVf2m1IGrLPmtSl3g6rh06ZKq4SX9vtS7k/cl06pL+iCpqSvv6ZNPPsGAAQNUjT4h/an0q+YmsfBHHnkEnp6eqi8rq5bgzTffrN6/1CKVx/I3qa633npL9YVSI022RfIZp6Wl1ej7J8vGPrT6fWht9iFS31n222WfVeo6Dh8+3NCHyuf93//+FzXh7bffVp/3vHnzSp1f3n5kdUg/KTVCpZbmG2+8ob5Lsu6afv/UsMhx5F133WX4LZkSj+fr9/G8jNkj65ftjfR70peXRvZp5f0tWLAAP/74Y5nH/ZXdhjTE4/lr165h8uTJ+PLLL9GoUSPDdFmHfK5Sl76hYzC4AZAfkRQAHzRokHosAw/IF1o6WekwZUMSFRVlWF52WkJCQsqdVxrZEZVOoLQBdooGDDUajeGxdDxyk539isjGYfPmzeomxeKFbCT002TnVYKU06ZNw/vvv692YvUF8rOzs0tdp3QWsuN98eJFow5Pdtrlc5ObdKhfffWVYb6Li0uFbZWNg3Te8l6LFo13cnJS96UDlA2LHBBUpGjnLG3z8vIytE1uEvCQ16ouGcDknnvuwcqVK1Wh+LLIxko+L+nUb2QgkuLkMynamUrHLe9L/jZy8CffV9lAVDQAnny+8p2WHW75flS1gy7+HS3rO1nexlJ+G/qd/NJ+L9ImR0fHKrWL6reG0v8K2TF98MEH1Q627KTJoA16TZo0UYONyQ6lBGrkRJGfn58afEx28IuSHSgZDEcGhDIV2aGWHUjp9+Uzl366Mn1ARZ+zDDokAwfJ3+unn35Sf0sJ4lT025d+Mjk5Wf1dyptXGbJjHxYWpk7SSVCpNHJgIIHqY8eOqfcvA8uYYidV/n7615w6dSrc3NzUNrEm3z9ZNvah1e9Dzd2HlLfvIwM96fepJSAgv/3S+tDGjRsjMjLS8FnK/q4EXGQ95c2rDDkmkP1JCUzo98PNsR9ZGgka6ANOMjCgBKX2799fo++fGhY5ISv9w//93/8ZptWnvpDH8+Y9nteT/VfZfhQdnK8oGVQwMTFRDWRaURC/MtuQhnQ8L2S/Y8SIEXjppZfUidKipE2y7qJB+oaKweAGQL8TcerUKfVYzorJWRJ9wE++4HLGQz9yuozyLZ1yRfOKk7NFckZOdnJvNFtIznIuXbq01HnSiUjHtWjRIqONh4z4KO9Pzi7Kj1M2IPoNnJztKo+MLCxZXxMnTsTBgwfVNMkqmz9/vqHzkI6yKqMPp6SkqJGUi26kRdHR02WUaNnIyk5hcdJ5ShbW6dOn1WNpn37UaPmbycH4woULDctL2+RsrBxYyPP0B+oSuKjMaNNCNrJy8CE76rLxKI+c2ZTRkGVHRJ5T1hnHypKzn0WDC7IxlA20ZMjI30827vpMNDkg0n8ukk0hOxTSGcvfSA4OZWdH1iXfQz05uy1nP/U7EFUNYMtrrF+/Xn339DsGZZHfixzIpaenq9eTv50EqfTkN1jR50sNS0Pof+V1i+7oyu9NfqctWrRQv005wC6o5FCQXSXvVebpRzaWrAB9lq6MOi9ZABJY1C9jCtKmZs2aGfo+eawnfaYEIMpS3ucsfzu9b775Rp0EkwOV4mQk+dzcXHUgI+SAQ7YrslNa3jwhmXJ79+4tcwdcvjPydylvp1PerwSTZOdW+nPZia7s+y9P0SsZJFtF+nvJujDl+ycqD/vQ6vWhNdGHFP2cpZ0SfJB9af3+rgQbhOxLSebb7bffXmIdEviW4Lb030KCOLJfJ/1NefMqOnb48MMPsWTJEvW39fDwKPf9l7Ufaao+VAL4EhyRrDdTvn+yLBKQk2MJfeaoXn3oCwWP5813PC/9q55sJyWoqs9MLko+Ezk+lasVpI+UY+6yAu2V3YY0pON5+R7Kvvlzzz1XaoBettGSsV5WYLxBqe06FWQaUjNGCnhLzSr5X2ryFB0pUmq1tGzZUtUHKlrPqrx5RRWt1yI1XqQOjxT5Lq1mbPEi6FLbRT/SpRQLL1rouzhZr9R7KUoe64uI62vPSK2zbt26qTo4RWtNllVwXmr0SN0iGT1SRnCWGjpSgFzq90iRcX19usqMWCo1gaRGWnFz585Vn6HUGJL1yuBiZSmvcLwUxZfatLIOWZ+8lr723J9//qmeJ68hn7/UcdO/9/JqDMnfVwY3kefpb1Ivqjgpbi/F/qX+nZDPV4rfl1ZnSOoEycAn8veVdRcdPbYoqdckfxd9LSGpjSTfUWmD/A0+/fRTo4LzUi9I3nfRgvMHDx40/L2kHp8so69vpy84r//spSZfaTWGZJ6e1BUqOsiI/K3kM5Lvgvwd3d3dy/zbyeAi8l2S2/PPP280T4rn//jjj2U+lxqm+t7/Xr58WdXckkEX9L/Lt956y1DfS35vMk/en6zjySefNBqdWQYSkudI3yQDUEo9SX3Nr4rqXUr/Iv2I9ONSd7GsgSvkdyW1baW+2Jw5c9Q2QP++V65cqeqnlTWAXHmfs9Qok/cm86RW+tWrV0utmStkcBPpg2R5aWfRZcuaJzXY5G9S2vuX7ZG8b32fLjfp30rz119/qTbKMlLfU+rYFd2+yfuSz6a0wZ/k+yOfsdSXk75N7kufqq/tp++PZaCVop+NKd4/UWWwD72xPrSm+pC0tDQ1mI60Td6Hvs66vu2y/yd98JAhQ9T+VWk1c/UDHkk/I+uQeppF90PLm1fW5y41HuX9S7v0718GGi1NefuRFy9eVO+9rAHkZPA96TelnrXsd8t9eW/irrvuUuuV58pxiQzAZOr3T5ZFfptyrFRcfegL9Xg8b57jeRnbQd826SfKqmf81FNPGQZ00w+A/tBDD1VrG9KQjudl4EHZJ+5cJC5S9DcnxwZFB7dryKzkn9oOSJNlkDM8ki1Q9CwQVY1cfuvq6qruyxnduXPnGrJp6jKp6SSeeeaZMpf57rvv1HuSW21+rnJWUi4bl0yeqpD6hpJRKJcHWsJlJVS/sP+tHZKhI5myrBtJVL+xD60d/NyJ6hb+JquPx/N193g+JydH1ciWjHApadHQmb4qOVEZpBA4NxzVI5dhyOVDUpNHLj+RS3DqAykIX97lGrVNBs2TSzzlUmeppVW05lRlyeU6cokWA8FUF7H/rR1yuaTciKh+Yx9aO/i5E9Ut/E1WH4/n6+7x/KVLl/DOO+9YRCBYMDOYiIiIiIiIiIiIyAJYQFVkIiIiIiIiIiIiImIwmIiIiIiIiIiIiMgCMBhMREREREREREREZAEYDAYgZZNTUlLU/0REVDXsQ4mIbhz7UCKi6mE/SkRUNQwGA0hNTYW7u7v6n4iIqoZ9KBHRjWMfSkRUPexHiYiqhsFgIiIiIiIiIiIiIgvAYDARERERERERERGRBWAwmIiIiIiIiIiIiMgCMBhMREREREREREREZAEYDCYiIiIiIiIiIiKyAAwGExEREREREREREVkABoOJiIiIiIiIiIiILACDwUREREREREREREQWgMFgIiIiIiIiIiIiIgtQq8Hgbdu2YeLEiQgKCoKVlRWWLVtmNF+n0+GVV15BYGAgHB0dMWLECJw7d85omYSEBMycORNubm7w8PDAvffei7S0tBp+J0RERERERERERER1W60Gg9PT09G5c2d8/vnnpc5/99138emnn+LLL7/Enj174OzsjNGjRyMrK8uwjASCT5w4gQ0bNmDVqlUqwPzAAw/U4LsgIiIiIiIiIiIiqvusdJJ+WwdIZvDSpUsxZcoU9ViaJRnDTz31FJ5++mk1LTk5Gf7+/vjuu+9w22234dSpU2jfvj327duHHj16qGXWrVuHcePG4dq1a+r5lZGSkgJ3d3e1fskwJiKiymMfSkR049iHEhFVD/tRIqKqsUEddenSJURFRanSEHrSwffu3Ru7du1SwWD5X0pD6APBQpa3trZWmcRTp04tdd3Z2dnqVnTjIbRarboREVky6UPLwz6UiKhs7EOJiMzXhwr2o0RE1etH62wwWALBQjKBi5LH+nnyv5+fn9F8GxsbeHl5GZYpzbx58/Daa6+VmB4TE4nMTNYbJiLLFhjYqNz57EOJiMrGPpSIyHx9qGA/SkRUvX60zgaDzWnu3LmYM2eO0ZnExo0bw88vkJeVEBFVgH0oEdGNYx9KRLUtMTEBx48fU2UV5Orb0NCO8PT0Qn3BfpSIalNcfDyWbz+LyKQsBHo4YPLA1vDx9kZ9UmeDwQEBAer/6OhoBAYGGqbL4y5duhiWiYmJMXpeXl4eEhISDM8vjb29vbqVlkpdmXRqIiJLxj6UiOjGsQ8lotp07NhRrF+/xmjavn17MGbMOISGdkJ9wH6UiGrLt2uO4csducjQFp5A+/pAGB7qH4V7x3VEfVFne8pmzZqpgO7GjRuNzvhJLeC+ffuqx/J/UlISDhw4YFhm06ZNqk6Q1BYmIiIiIiIiooKMYAkEy2DtxW/r1q1R84mILJFOp1PJpVlZWUhLS1Oxxri4OERFReLatWtISIjHsj0R+HC7BhlaB6PnymOZLvPri1rNDJYP+Pz580aDxh0+fFjV/A0JCcHs2bPx5ptvolWrVio4/PLLLyMoKAhTpkxRy7dr1w5jxozB/fffjy+//BK5ubl47LHH1OByshwRERERERGRJZPj5GvXwvDPP9tUwKO8rOFBg4bUaNuIiIqTfio/P18FZwtuuUXu58HfPwC2traG5ePiYnH58iXDsrm5ecjPL1xeHst0BwcHTJxYEE/UW716Jc6dO6P6Sa0O0EKDfJ018mGNfJ3G8H+T5m3x3Um/6zm1VsVaLI91eH9dAib2DITGuvj8uqdWg8H79+/H0KFDDY/1dX9mzZqF7777Ds8++yzS09PxwAMPqKj8gAEDsG7dOvUH1Fu0aJEKAA8fPlxdEjJ9+nR8+umntfJ+iIiIiIiIiGo7kBITE43Lly/jypVLKhAsgZWKJCcn1Uj7iBpiDdll204jMjELgZ4OmDKobb2rIVtRxqxxYFYCtbmwsbGFr6+v0fKnTp1QiZ9lPUc/rVOnzmjTpp3heUkpqfjfwoXIztMiO09XEJC9HozVFgnKyv8DBo2AvaMLcvJ1yM7V4eq1KJw6e61gvlEg1xZanYPhsc7aFj9euaTWn52rRW6+DqnpTZGd10QFgbXlFU84XNEnZYXELA0OXM5Ar+bOqOusdOWdGrQQUn5CCudLAX0WnCciqhr2oUREN459KBGZkpR7uHDhHDIyMqr0PCsrK/Tq1adeZgazH6W6UUPW0TDNyToTD/W3NXkNWSmJWjTIKtmv+qxXGQTS0bGwDWlpqTh79kyJIGzxIK08f/LUm5GrtUKOBEnzdNizbz8OHz2OnDwJmFpdD6ZKkFVj9L+ruzc6dOxaEFyVZfN0OHbyNNIyso2Ct9oigV398zW2joC1rXoNeb5k5TYE794ahPFd3FHX1dkB5IiIiIiISiN1LeVyZslic3f3QMeOndRBEBGRpcjOzlY1LAMDjcsjSgCoeCBYAqRNmzaDt7cvtmzZWGapCOlLiajy9DVkAbkVryELeHtHYErvIFy6dFHtu+gDt/pAbnZOHrJy8pGdKzct/IMao3Xbjio4KoFZCZQuW7ESGdl5Kgs2T2ulgqmFpQwKM2FDmraCk4u7IaCbnJaBsGvpRYKyDqUGdGVdrx8+V+ydeQAYUPEHkAH8HRlbbKJ/5T68bPmn4isWTE1jDdjZWMHexvr6/1bq/6LTCqcXLpOQnoe/T6RVuH5ft/oRZq0frSQiIiIiul7TUgZAKmrv3t0YM2YcQkMZyCCihkkyAiMjI3DlymVVG1PuyyXajz8+W5VL1GvSpBnCw8PVGDxyv2nTpupkmWT+CgcHe5U9XJz0oTypRlS27OwsNaCYnIiWMqbhsSmYv1dOxtiVWUP2leVJWLQ3C/GJKcjI1qmyBflStuB6ELZEWYIjANZeLLauzpVq34nT8m9ysalS47busNUUBGLtNFawt7U2Dr7aXp8u0/T35X95bLhfGLQtL4gr67a9/hy1nMYKdrYF67HR3Fg933ytDiPfPY/o5NxS/t5ChwB3W3Rv6oT6gMFgIiIiIqoXJKtGAsGlZbVJcCM4uBGDGUTUIEg/l5SUqAK/Uvs3LOyKygYuKicnWwWFpe/T69KlK7p372EUIC5KTprJ8ry6gsiYZOtKqZHk5EQV7G3dph1Sc+0QlpCDsPhc7D8VhqMXopCa74xUrStydBXVBJYsXuBkhPxu7a/faoeELu1srgdjJTBqCMAWBGQdJFCq7peVIVsQlDXMV8Fa68IA7fXgrlFA1sYatob7Vio4a10PBlYriwwKN3eCP55cFI7Srq2wghWen+BfLwaPEwwGExEREVG9IMGLiubXx3qXRERFSZmHn376TgWmyiLBW8n6dXAorBEqbG1tK1y/PJd9JVlyhr0Ee+VkSFxCEq7GZiIsMQ+x6dZIUYFeZ6TmOyHD6ipy84uHzwpPvFSWxAbtNBKI1amAqNwvWoagIHtV/reGg51G3fQBWxVgLZIVW1qQtrzSBvI8W41kyRbUBafqGRnqho9mAvNWRSM6Oc8wPcDdRgWCZX59wWAwEREREdUL8fFxZda6FHJgR0RUnzIRIyLCVYBKavrqySBQMq0omRYS0lQFgKX8gwyYRkTGcnNzDWUc9JnvAY2aIywhF1fjc3A1PhtrthxT2b0pWmekayUjvmpBUivo4OtiBXdHa5yLNf6dlubb+0LQq7lzNd4V1SUjQ90wrL0rDlzOQGxKnqoRLKUh6ktGsB6DwURERERUbw7yyiMHfUREdZWczJKao1euSOmHS7h2LUz1a4GBgUbBYMnga9GiJRISEtT0Jk2awt8/gJl9RNfFxcUiKipKBXwTE5MQEZ+mAr4x6dbXyzg4qyzfDKssZOSdLfbsphWuX7J4gz1s0dTPAY297NDYyxYh3gX/B3naqczbhlZDlipPAr/1PcDPYDARERER1QsjRozCt99+XeZ8qXtJRFSXpKWlXQ/+XlaDv6WnlxyNXoJaWVmZRiUfRowYbbbgrwSx6ntWGzVcOTk512v3SoZvIlJTUzFg4FBEpeThalyOCvruOHQR5yPTrpd0aIq8GwhtudgBwZ4aNPF1RFMfezT2tjMEfH1dbSqsb9vQasiSZWEwmIiIiIjq7AGhnZ2M0l3Ay8sbw4ePxKZNf5dYdsyYcRwAiYjqlEuXLuL3338pc76zs4uh7IO1tcZonrkCwRuOp5Sod+nvbqOCWvWp3iXVf5mZmbhw4Zwq6SC32MQUhMXnFMnudbr+vxsy/j6DfKOKDPJdrfj76uNshaZ+jgjxti3I8L0e7JX/3R2Nf3OWXkOWLAuDwURERERU55w7dxbr16/BxIlT1CXSet269UCzZs3VYHH6eoCSEcxAMBHVVumH6OgoVfYhMDDIqL+S8g8S1NXXOpfB3Ro3DlHLSPkHb2+fGi39IIHg0rIYY5Lz1HQJajF4RaaQk5ONpKTkIvV7E9GyZWu4+zZGWHwuribk4Oy1ZGzZF3k96NsImTrjwRArw8YaCHTXIMTHHk0ku1cFfAsCv428bOFgaw1zayg1ZMmyMBhMRERERHVqQKVt2zbjwIH96vHq1Sswa9a9cHYurM0mgd9Bg4bUYiuJyJLJJeyFpR8uISsrS00PDe1kFAyWsg+hoR1VBrBMDwoKho1N7RyCS2kIyV4s7XJ2mSZhq3dWRaugFoNYVBVnzpxGTEy0oX5veEKWUe3eglIObsjYmoHMvHPFnh1S4fqdbFFQwqFIsDfk+v9Sk7cufF8bQg1ZsiwMBhMRERFRnZCYmICVK5erLDu94OBG0GiqfyknEdGNys7OwtWrV1X2rwR/ExMTS11O5kkWcNFs3zFjxqM2ZeRocSk2GxuOpRpdxl5aQDgqOU9lNzKoRSI7O/t6Vm9hdq9GY4MBg4bhWkIuwhJyVJbvxt3RiEjWIiU/EGnaFtCi6ttsLycrNPbWZ/cWlHHQD9rm6azh4IlEJsZgMBERERHVutOnT2L9+rWqTrCQAPDQoSPQpUtXHgQSUa2SKxV27Nhe6jx7eweEhDQx1P6trf4qJTMfF2OycSEmBxdjs3EhuuB+RFJuldYjl7mT5YmJiVHbYX3gNyYxDbGS3at1Roo+wzffGWk6F6T/fQbXK59c51fh+iV5V+ro6oO9aqA2QzkHOzjbm7+cAxEVYjCYiIiIiGpNbm6uGhDu6NHDRmUgpFawv79/rbaNiCyDZPMmJCRcL/1wSZWh8fHxNcyXEg/6YLC1tbUq9yA1f2V6QECgmlZTEtLycCEmGxdjc64HfAvux5goiCv1TqnhkBIm+gBvYZZvojrZCnsPXL1ev/fw2XgcOJ2D1HxfpGqbIltnX+XXsreBCuxKoFcFew0ZvnYI8rSFrYYndonqCvb0RERERFQrEhLisXz5UsTFxRqmtWvXAaNGjYadXdUPRImIKisjIwNXrlw21P5NTU0xzGvcuIlRMFgGhuvRoxdCQkLUAHDm7p8kOC3BXRXojclR/+uDvonp+ZVej4u9NZr72aGFnz2a+drhf9sSkJRR+vMlTOfvXjDwFdVP8r3Ztm2LIfibkJSM+Azj2r0FWb7N8M6xOGTnxRVbQ+MKX8Pd0fp6Vm9hsFdfv9fX1YZX8hDVEwwGExEREVGtkYNWIYMqjRgxWg22xINJIjKHa9fCcOHCeZX9KwNelSUyMsLosWT+Dh063OTt0Wp1qoyDUcD3+v20bG2l1+PhpEGL60FfuekDwH5uxsE5CeI9uShc3S96lb9+iecn+NeJwbjIWFZWplHtXv0tKCgI3XsPRFh8jqF+79rtuUjM9kKKtjHStY7QoWpZ6/qTAgVB3sLMXn1JBzdH1vAnaggYDCYiIiKiWuHl5Y2RI8dg797dqiyEj49PbTeJiBqI4gO5iYMH9+PMmdMllpWTUTJYZUHph2bw86u4BmpV5OXrVLCueNBXavtm5RoVXy2XBHeb+14P+vrbG+57uVTusH5kqBs+mgnMWxVtNJicBP8kECzzqfri4uOxbNtpRCZmIdDTAVMGtYWPt3elny+1e8+cOaOCv4mJSUjJ0iLles1efe3eVAn2HndD+pozVc7utdUAjTwLA7xFB2sL9rSFvS3r9xI1dNUKBssAH3Z2dqZrDRERERE1WLGxsfDw8ICtra1hWocOoWjbtp0aMI6IqDpSU1MNdX/Dw8Pxf/93v1F/I4FefTDYz89f1fyVALAEgosud6Ny8rS4EicBX+Og7+W4HOTmVz7oG+RhW5DpqwK+ku1rh+Z+9ibJypSA77D2rjhwOUMNFic1gqU0BDOCTePbNcfw5Y5cZGi9DNO+2n8F9/a+isk9/Y0yfOV/uc26+37Ep0PV7r0an4PdRzNx+qorUrUBKvCbi6p/N6VEiD7YW3SwNgn8+rvZ8O9NZOGqFAzevn0b1q5di4MHDyAqKgparRaOjo5o164d+vbth6lTp5n8LCoRERER1f8MvSNHDqmB4kJDO2HUqDFG8xkIJqIbTU4KC7tqCADHx8eXKAvRrFlzw+MWLVpiwoRJCAlpCmdn5xt+3YwcLS7HZhuCvhdV4LfgUv38SlZ3kFicBOda+Bdk96qgr78dmvnaw8nOvJmZEgjs1fzG3z+VbtmeCHy4XbZnxtu0DK0DFuwC9hzZDlfrjCJZvoFIzW+JL14/j1yjUs5St7ni2s0+rprrA7WVrN8rpUNYcomIqhUM/vvvv/HRRx8gPT0dAwcOwv/9370q6Gtvb4/k5GScP38eu3fvxldffYnJk6fg8cefgJdX4ZkwIiIiIrJM2dlZWL9+rSEbT4LCEpCRGxHRjZxc2r17pwr+RkSEqwSl0tja2qlM4aJcXFzUIJWVlZqVX6y0Q0HQNzwxt9LrsNEATX0KsnsL6vkW3G/ibcfL8RuQfK0O761LkDB/kSrMevJYh70Znaq0To11QZZ40TIO+vq9jbzszH7SgIgsPBi8cOG3ePbZ5zFw4EBVPL8s0dHRWLx4EVatWom77pplynYSERERUT0jgzCtXLncMEic6Natu7o0m4iosieU7O0dDI8l2/HUqZOIj48zWk6mBwQEqrIPcgsMDKr0VQeJ6XklsnzlfkxKYV3dijjYWqGZb8lB3CRoZ6thhmZDJ2U3krLK+76V/h1wtLUyBHsNg7Vdvx/oYcvvDhHVXjB40aIllVqZv78/nnxyTnXbRERERET1PHPvwIF92Lp1syFrT4I5Y8aMQ+vWbWq7eURUh2VlZeLKlSu4cuWyyv61sdHg//7vAaNlmjZtqoLBHh6e6r7UAg4JaQIHh8KgcWn9Umzq9aBvdLYavE0f9E1MN7pGv1zO9tYlsnzlvmRwWrMOq8WS+suVMby9K4Z3cDHU7/VxYTkHIqpnA8iJjIwMtZMvl9wQERERkWXLzMzA2rWrceHCecM0ydCbOHEK3N3da7VtRFT35Ofnq3IPBXV/LyMqKlIFbotKTU2Bq6ub4XH37r3QrVtPNSBlcVqtDpHJubgQnXM94Jut7sv/admVLOgLqJqrpQV9/dxsGLyjEmQgvsq4o78n6zUTUf0NBssO/ty5c9UlOrIxbNGiBd544y2EhoaatoVEREREVC/I6Og///yTUZ3OXr36YMCAQRwkjohKBHj/+mudGgAuN7f0GrxSojA4uBEyM7OMgsFyYikvX2cYxE0FfaML7l+KzUZmrnEwuTy+rjalBn29XKqdN0UWpHtTJ/i72yA6Wb7LpZ0s0CHA3VYtR0RU2254C/faa//G7bffjtGjx6iN9w8/fI8XX5yL5ctXmraFRERERFQvuLm5qcu2JRjs6OiIceMmonnzFrXdLCKqZTIQeU5ONjw9CwcZd3BwVKUgJDO4KB8fX1VXXOr+NmrUGLC2wZW4HBw6lnI94FsQ9L0cl4Pc/MoHfaWMgwR6CwK+9ob7bo48UUXVp7G2wtwJ/nhyUThK+1ZawQrPT/BXyxER1Ztg8OOPP4qXXnpF1QUWiYmJGDp0qNrRl9ugQYPw88+Vqy1MRERERA2PZPFNmDAJGzduwPDhI+Hi4lrbTSKiWiDJQteuhamavxLwjY2NQevWbTF58lTDMra2tirYGxcXq4K/gY2aQesUjKg0DY7FZGPZDqnrG4ar8TnIr2R1B4mzSS3WFv52aO57Pejrb4emPvaq1i+ROY0MdcNHM4F5q6IRnVxYQzjA3UYFgmU+EVG9CgZPmDAR9957D267bQZmzrwDM2bcjsmTJ6FHj57Iy8vD3r17MGvW3eZtLRERERHVGRLosbe3VzWB9SQAPHnytFptFxHVLKnxGxMTrfoEqfsbHh5WIuP36tXLaqyZ9BwdLkpph5hsXHQYhMtO+Vh+IgfhO3Kh00VX6vVsNFABXpXdK0Ff/4L7TbztYG/LoC/VHgn4DmvvigOXM9SgclJLWEpDMCOYiOoSK13x6vzlkEv+PvzwA5w+fQqvvPIqNBob7Nu3V23Uu3Tpio4dO6I+SklJUXWnkpOT1eWNRERUeexDiSyP7Pvt2LEdu3fvhJubO2bNukdd8l1T8rW6BnOgzT6U6jsZS2bt2lXIzMw0mp6ltUNyviuS8l2RY++PDGsvxOc6ISbFOEhcHnsbKzQvpZ5vIy872Grq52+eTI/9KBGRGWsGu7q64tVX/42DBw/ghRdeQL9+ffHYY0+oMhFEREREZBmDPq1cuRzh4dfU45SUZBw+fAh9+vSrkdffcDylxCW4MmiP1GrkJbhE5ju5kp2drQZ78/b2NtT+lbyiHGsXXEhxRnJ+oAr8yi1F64ZMrV3hkzMMr1ZqG6SEQ2n1fKXOb3090UNERNQggsHJyUm4di0crVq1xq+//oZvvvkaN988Hc8++xwGDRpsvlYSERERUZ3LALSyssLAgYPRq1efGgsElzY4T0xynpoutRoZECaq2m/qrRWRiE0tLMrr62qNFycFYnh7F0RGRhhKP5wPT0RCrjM8GneG1jlLlXqQwdxSs+S5Ayr1eu6OGrT0Lxn09XezUf0JERER1aEyEatXr8Krr74CZ2dn5OTk4O2352Ho0GG4ePEiXn/9NXh7e2Hu3Bfh4+Nj/labGC8rISK6cexDiRo+qf25bdsW7N+/1zBNfu8TJkxGcHCjmmmDVoeR7543ygguyup6hvBfz7asV5mE7EOpNgPBsxddK/IL0is4PGzhEAFo81Wmr5R7yKtCHpGvq02pmb5ezhoGfcnk2I8SEVVNpbfoH3/8EV5//U2MGzcOJ06cwMsvv6SCwc2bN8d3332P33//DXfccTvWrfurik0gIiIioroqKSkJq1YtQ2RkpGFay5atMGbM+BotFbb/UnqZgWB9+CoqOU9d7t6ruXONtYuoPpKTK5IRXKB4cLbg8YWs4ArXI2Uc9DV9iwZ93Rw1Zmg1ERER1WgwOCMjA82aNVX3GzdujKws4wECbrrpZhUcJiIiIqKGITc3F4sW/YCMjHT1WKPRYPDgoejWrUeNZvftv5SBV/+MqtSyUveUiMq3eNu166UhKv4dW1np0MjDBi0DHA1BXwkAN/O1V7V+iYiIqIEGgydPnoJHHnkYPXv2wokTxzFx4qQSy8hgAkRERETUMNja2qJfvwH4++/18PDwwMSJUxAQEFhjr382Kgsfr4vF1jNplX6ODIBFRCWdDYvH4q1XsOW8FrHZlcuef3K0L+7s7wV7WwZ9iYiIGopK7y3LIHG9evVSNYIlMNy/f3/ztoyIiIiIal2XLl2h1eYjNLQT7O3ta+Q1I5Jy8fnfsVh+MBlFR7fQWMvl7Si3ZnD3pk410kai+iAiLhWLt1zE36ezEZbuCqBqpV06hTgyEExERNTAVCl1YsiQoepGRERERA3PyZPHkZiYiP79BxqmSTmI7t171sjrJ2Xk479b4rBoVyJy8gqjwAHuNnhspC+c7Kzx1OJwNa3oCMj6C92fn+BfrwaPIzKHpNQs/LL1AtYeT8P5ZBfoYAeoW6FAhzQk5TkhM09+L6X9ZnTwc9Xw5AoREZGlBoPXrFmjBo6rDBlcRG7dunWrbtuIiIiIqAbk5ORg06YNOHbsqHocGBiE5s1b1NjrZ+Vq8dPOBPx3SzxSswpTf90crHH/UB/c3tcTDtezE61nAvNWRRsNJicZwRIIHhnKUeTJMsnJkx3n0rD6cAo2nkhCTr78Xox/D162GRjUApgxMAShzdthw/EUzF507fqplaIB4YJTLS9MCuTJFSIiIksNBv/668/4z3++wNSpUzF48BC0aGF8cJCamopDhw5i1apV2LVrJ15//Q1ztZeIiIiITCg2NhYrVy5DfHycYdqVK5drJBicl6/DikPJ+GxDLKKLDPxmZ2OFO/p54b4h3nB31Bg9RwK+w9q74sDlDDVYnNQIluxFBq3I0uTna7Fu3xXsumqDjaczkJKpP5FSWNbBRZOFvo3zcEv/IPRp3wbW1tZGv6WPZzbCWysirw8mV0AygiUQzJMrREREDZOVTle0ElvZNm/ehEWLFmHv3j1wdHRUg8VJ3biUlBTExcWpQUWmTJmKO++8Cz4+PqhP5D24u7sjOTkZbm7c6SEiqgr2oUT1k+wCHjt2BBs3bkBeXp5hwLiRI0ejQ4eOZn/tzafS8PH6GFyIyTFMl3julO7ueGS4LwI9bGEJ2IdSVWi1Wuw8EYFfd0ZiT5gN0vIdSizj7miNzr7pmNTdC6O6h0AjxbbLka/V8eQK1WvsR4mIzFQzeOjQYeomdeQOHjyAiIhIZGdnwcPDE+3atVO3omeaiYiIiKhuys7Oxl9/rcXp06cM03x9/TBp0hR4eXmb9bUPXcnAh+ticPByptH0Ie1cMHuUL1oFlAxuEVm6YxdjsGRbGLZfBBJypY6vi9F8R1srlTE/vosb+rZ0Udn1lSWB317Nnc3QaiIiIqr3A8gJT09PDB8+wjytISIiIiKzio6OwooVS5GUlGSY1qVLNwwdOhw2NlXeNay0CzHZ+GR9DDaeTDOa3iXEEXPG+KF7Mw5URVTU5chkLN5yEZvO5iEyS4K/xr8RK2jR2j0NYzu54PbhbeFsb1xShYiIiKg05tvjJyIiIqI6RcozbNr0tyEQbGdnjzFjxqFNm7Zme83o5Fx8vjEOS/cnQVukOFkzXzvMHu2L4e1dYWXFS9KJRGpWPv4+norVR1Kw+0IadLqSmfIhzqkY2c4BM4Y0Q6C3a620k4iIiOovBoOJiIiILIQEXceOnYAffvgfPD29MHHiZFXyyxxSMvPxv23x+HFHArJyC6PAvq42eHSED6Z294CNhkFgotSMbPyx/SJ2X7PFnst5yMnT/14Kfx9+9mkY0soGtw9uglaN2tVaW4mIiKj+q9PB4Pz8fPz73//GTz/9hKioKAQFBeHuu+/GSy+9ZMggkQyXV199Fd98843Kcunfvz/+85//oFWrVrXdfCIiIqI6sT+l0RRePi6D/t566+3w8fE1mm4qOXlaLN6ViK83xyM5M98w3cXeGvcO9sad/b3gaMdxJsiy5eTmY/WeS1i2Px5HYhyRq5MBE3ONlmnsZYtewdmY3MMb3VszAExEREQWEAyeP3++Cux+//336NChA/bv34977rlHjRT6xBNPqGXeffddfPrpp2qZZs2a4eWXX8bo0aNx8uRJODhwABIiIiKyTHLCfO/e3Th58gRmzrwLdnZ2hnn+/gEmf718rQ6rD6dgwYZYRCQVBrVsNVaY0ccTDwz1hqdznd71JDIrrVaLTYfD8MfuaOwLt0Om1h6Am9Ey3i4ajO3khvFd3NGxkQNLqBAREZHJ1ek98p07d2Ly5MkYP368ety0aVMsWbIEe/fuNRzkfPzxxypTWJYTP/zwA/z9/bFs2TLcdttttdp+IiIiotqQnp6ONWtW4vLlS+rx33//hXHjJpjltWR/7J+z6fhwXQzORmUbpksMa0JnNzw+yhfBnoWBaCJLc+RiHH7cdBk7r1gjOc8RgHGdX1urXHTxy1QZwON7N4OdLQeCIyIioloOBr/77vxKr/DZZ5+DqfTr1w9ff/01zp49i9atW+PIkSP4559/8OGHH6r5ly5dUuUjRowYYXiOZA337t0bu3btKjMYnJ2drW56KSkphrP1ciMismTW1uVfvs0+lKhuCwu7itWrVyI9Pc0wzcXFRZWLMHWW4fFrmfhwXSz2Xco0mt6/lTNmj/JB26CCq7QsqW9gH0oiMikXa4+mYM2RVJxRJ0mcjeZrkI+2nukY38UN0/q3hrNj4QkTfg/IklXUhwr2o0RE1etHKxUMPnXqVLHHJ9UBhWTqisuXL6uac+3bd4ApPf/886pjb9u2rVq/vOZbb72FmTNnqvkSCBaSCVyUPNbPK828efPw2muvlZgeExOJzMzCAyciIksUGNio3PnsQ4nqJjkAPn78GI4dO6aydYWUzJLxFAIDg9Rv1FSuJWnxv53Z2HY+z2h6az9r3N/fHl0by05oAqKjYXHYh1qu6KRMrNwfj4PRzjgbX/Iwywo6NHFOweAWVpjQ3Qeerh5qelpKHNIKYllEFq+iPlSwHyUiql4/aqXTHy1U0vfff4d9+/bhrbfeVlm4Ijk5GS+//CK6deuOu+++B6by888/45lnnsF7772nagYfPnwYs2fPVpnBs2bNUmUk5AAnIiICgYGBhufdcsstKvPll19+qfSZxMaNGyMxMRFubsZ1u4iILM2NZLWxDyWqXWlpqVizZpXKCtYLCWmiSkM4O7uY7HXiUvPw5aZ4/LE/CXla44Gunhjlg9GhrhZf45R9qGVJSsvCb9suYd3xNJxLdoEOJf/+nRo7oF8TLSZ280KIf8HxExGZNjOY/SgRkYkzg4sHg7/++htDIFjI/ccf/xceeOA+kwaDJRAs2cH6cg8dO3bElStX1JlACQYHBBQMfhIdHW0UDJbHXbp0KXO99vb26lbaB1aZD42IyJKxDyWqWy5duqjqA2dkZKjHEozt338gevfua7LfZHp2PhZuS8B3/8QjM0dnNNjVw8N8cFMvTzVQHFWMfWj9l5Wdh6U7LmDloSSciHNCnjqkMg5ANfG2waRunhjX2Q0h3qyZTWRK7EeJiKqnysHgtLQ0JCQklpiemJigBisxJTmoKd6ZS7kIfR2gZs2aqYDwxo0bDcFfOSu4Z88ePPzwwyZtCxEREVFdFBMTYwgEu7i4YsKESWjcOMQk687J0+G3vYn4clMcEtLzDdOd7Kxxz0AvzBroDWd7HnhTw6fV6rD9ZKwaCO5glD2ydXYlAsAumiz0aZyHW/oFoW+HQAaliIiIqGEEg4cPH6FKQjz99LMqU1ccO3YUH3zwPkaMGGnSxk2cOFHVCA4JCVFlIg4dOqRKRPzf//2fIfNFyka8+eabaNWqlQoOv/zyywgKCsKUKVNM2hYiIiKiuqhXr964evWyCjyNHTsBTk5OJgl8rTuWgk//ikVYQq5huo01cEtvTzw41Ac+rlXejSSqV6Sa3unIbKw+koy1R1IQlSw1sl2NlrG3ykG3wGxM7+2HUd3bQKNhAJiIiIjqtirXDM7MzMT777+HpUv/RF5eniFbd9q06XjqqadNcgCil5qaqoK7S5cuVVkvEuSdMWMGXnnlFdjZFVxuJc1/9dVX8fXXXyMpKQkDBgzAF198gdatW1f6dSSbWEpdSO1j1hgiIqoa9qFENUuuxvL09DKalpOTA1tbW5PU6911Ph0fro3ByYgso+ljO7nh8ZG+aOLDS95NiX1o3XPsYiyWbLuKfRH2iEjVlJhvgzyE+mRgYjdPTOnXHA72PDFCVJvYjxIRmTkYrCeXI4aFhan7UqzdlEHgmsaNBxHRjWMfSlQz5CT8tm2bcfDgAdx66+0mKwWhdzI8Ex+ti8XO88Zlv3q3cMKcMX4IbeRo0tejAuxD64YrUclYtOUSNp3NRWRmyUEXJSu+f2sXDG1lg1GdPOHu4lAr7SSiktiPEhFVzQ2fxo6Li1W37t17wMHBQWXoWvro0URERETmygZeuXI5oqOj1ONVq5bjnnvuV/tg1RWWkIMFf8Vi9ZEUo+ltA+1VELhfK2fu41GDFJecgSWbL+Cvk5m4lOoCHWRAKuNBqToFaTC1ly9GhbrCw5kZwERERFT/VXmPRkoxPPXUk9i7d686MFi9eq3KDH755Zfg7u6GZ555zjwtJSIiIrJAp0+fxPr1a1UpCH15rj59+pc6knpVJKTl4avNcfh5TyLyCseGQ7CnLZ4Y6Ytxnd1gbc0gMDUs2bla/HUkHj9uuojTic7IV4dDxnWA/ezTMbilNW4f3AStG3vXWluJiIiI6kQweP78d2BjY4sNGzZi0qQJhuljx47Fu+/OZzCYiIiIyARyc3OxadPfOHr0sGGa1AqeOHEK/P39b3i9GTla/PBPAv63LR7p2VrDdA8nDR4a5oNbe3vATq6JJ2og8vJ12HsxXWW//308FWnqe298Kbm7TSb6N9Xi1gGN0KNNu1prKxEREVGdCwbv3LkDX331DQICAoymh4Q0QUREhCnbRkRERGSR4uPjsGLFMlWSS69duw4YNWo07OxuLCM4N1+HP/cn4YuNsYhLLUwFdrS1wl0DvHDPIG+4OpQcLIuoPtJqtdh8OAx/7I7GgShHpOWWPOxxtM5Gr+AcTO/jj6Fd2sDamidBiIiIqOGrcjA4MzMTjo4l69NJsXY7O44uTURERFQd586dxerVK1RmsLCxscGIEaMRGtrxhmr3yrgOG06k4pP1sbgcV1BqQmisgek9PPDIcB/4utma9D0Q1Zb9Z6Lwyz/XsOOyNZLzHEuUgHC2t8bIUFeMau+Ivq3cYGfLEyBERERkWaocDO7evTtWrFiBxx9/Qj2WgxI5875w4bfo1au3OdpIREREZDGkFISej4+vKgvh4+NzQ+vadzEdH6yNwbFrWUbTJRj2r1G+aOZbvbrDRHXBuWsJWLTlMraez0dMtouEfI3ma5CPXk1tcEv/IAxq4wIHW2YAExERkeWqcjB4zpynce+9/4cTJ46rjJUPP3wf58+fV5nBP/64yDytJCIiIrIQEvgdMWIUwsPDMWzYCNjaVj1r92xUFj5eF4utZ9KMpndv6oinxvqjc4hkTBLVX4npeVh7JAk/bLqIsHTJ/jX+TltBh2auaRjVwREzBjeHj4dxgJiIiIjIUlU5GNyqVSusXr0GixcvgrOzMzIyMjBixEjMmHE7fH19zdNKIiIiogZISjicPn0SrVq1UeUg9EJDO6lbVUUk5eKzDbFYcSgZOl3h9Fb+9nhyjK/KiryRUhNEdUF6Vj42n07DmsMp2HEuDXlq/EPjMhBBjmkY2toWtw9uhqaB7rXVVCIiIqKGEwwWrq6uePDBh0zfGiIiC5CYmIBjx44iOTkJ7u4e6Nixk9Fl4URkGbKzs7B+/VqcOXMaXbt2V9nANyopPQ/fbI3H4l2JyMkrjAIHuNvgsZG+mNTVHRprBoGp/snKzsOynRew8mASTsQ7I1dXssavl20GBrUAbhvYGB2bt6uVdhIRERE1qGDwmTNnKr3CNm3aVKc9REQNmgSB169fYzRt797dGDNm3A1lARJR/RQZGYGVK5erk0Li0KED6NSpM/z8/Ku0nqxcLX7amYD/bolHapZKk1TcHK3xwBAfzOjryfqoVO/k52uxfv8V/Lk3Fgcj7ZGtk0Gq3YyWkRMdYzu7YVxHV7QNcoC1Nb/nRERERCYLBt900zR1SaFcylgeWebo0eOVemEiIkvMCJZAcGl96bp1axAc3IgZwkQNnPz+DxzYh61bN6sBeIW9vYM6IVSVQHBevg7LDybj879jEZ2SZ5hub2OFO/p74d7B3nB3LJlBSVRXye9h14lI/LozArvDbJCW71CiBIS9VQ4Gt7LFzCFN0a2JI6yZ7U5ERERknmDw+vV/VX3NRERUIiu4ovmDBg2psfYQUc3KzMzA2rWrceHCecO0wMAgTJw4Be7u7pUOJm8+lYaP18fgQkyOYbrExKZ0d8cjw30R6FH1AeeIasvV+BysOZyMxdvDEJ8tg8C5GM23QR5CfTIwsZsHpvTrAAf7G6pyR0RERETXVWpvKigouDKLERFRBZnB5V1hob9cnIganmvXwrBq1XKkpqYapvXq1QcDBgyCRlO5DN6DlzPw4boYHLqSaTR9aDsXzB7th5b+9iZvN5E5RMSnY9PpbKw+koyjYVnXp0oguIAVtGjlnoYxHV1w66BW8HCVLGEiIiIiMoUbOrV+6dIlLF68CBcvXlCPmzdvgdtvn4lmzZqZpFFERA1NcnIywsLCyl1GBpMjooYnLOwqfvllseFkkKOjI8aNm6j2nyrjQky2ygTedDLNaHqXEEfMGeOH7s2czNJuIlOKS87Aki0X8NeJDFxKdYUOJUs8NHZOxYi29rh9SHME+RiXiCAiIiKiWgoGb9jwF5555ml06NABnTt3UdOOHDmCqVMn47333sfIkTc+EjYRUUMUHn4Ny5b9oS4RL0/HjhxAjqghknrgcpWV9AWNG4dgwoRJcHGpONAVnZyLzzfGYen+JGiLXFTQ3NdOZQIPa++ixmsgqqvSM3Pw+/YLWH04BacTnZGvDj2MB4JrE2iP8Z3d1WBwQSxxQkRERFT3gsEffPAB7rvvfjz22ONG0z/7bIGax2AwEVGh48eP4a+/1iI/P189dnR0QlaW8SXeQgaP4uBxRA2TtbU1Jk6cjBMnjqvSEPK4PCmZ+fh2azx+3JGA7LzCKLCvqw0eHeGDqd09YKNhEJjqppzcfKzecwnL9sfjSIwjcnW2JQLAbjaZKgN41oiWLG9CREREVNeDwXFxsZg0aVKJ6RMnTsR33y00VbuIiBpEaYiigeCQkCaYNGmqCgbLYHFSI1hKQ0hGMAPBRA2DVqvFzp3b0aJFKzU4nJ6rqxv69OlX7nOzc7VYsjsRX2+OR3JmQb8hXOytcd8Qb9zRzwuOduUHkolqg5RAORaWpWoAL90bg/S8kgFgR+ts9AzOwfQ+/hjWpU2FJ0WIiIiIqI4Eg3v27IkDBw6ooEZRBw8eRLdu3U3ZNiKies3d3R2jRo3B2rWr0blzVwwfPlINFCX1QgcNGlLbzSMiE0tNTcHKlctVOYiTJ09i1qx7YG9f8cBX+VodVh1OxoINsYhMyjNMt9VYYUYfTzw41Bsezjc0zAPRDZHv5IHLGYhNyYOvmw26N3WCxrpkNvqh8zHYfhFYcyQFYQm516cWlnqwtcpFZ79MTOnhjfG9W8POtnKDJRIRERGR+VT5yGLIkKH46KMP1UFOp04F9S2PHj2K9evX49FHH8XmzZsMyw4dOsy0rSUiqmdCQwuyfqVmKBE1XBcunMfatauQmVlQBiYlpWDQyJYtW5WbTbn9TDo+Wh+Ds1HZhulSBnhiF3c8NtIHwZ52NdJ+Ir0Nx1Pw1opIxKZqDdN8Xa3x4qRAjAx1w7lrCVi85TK2nNciJtu5xPMl3tvaLQXjOrth+sA2cHViGQgiIiKiusRKpx/aupI6duxQuRVbWeHo0eOoD1JSUlQGn1zS7eZmfEkbEVFlXbsWhoiIcFUT1JKwDyVLJmVgtm3bgv379xqmye9gwoTJ5Z4EOhqWiQ/XxWDfReOBJQe2dsbsMX5oG1hxRjE1DHWpD5VA8OxF164/KpoJXHC44GOfhbhsxxLPk6Th3i2cMb6zG4Z3cIWbIzOAicgy+1EiogaZGXzs2AnztISIqB47flyukFir6oW6urqiXbvKnTgjovorKSkJq1YtQ2RkpGFay5at1YCQUg6mNFficvDx+hj8dTzVaHpoIwfMGeOnAmpEtVUaQjKCCxQvCVHwuHggONAhDaNDHXH3yDbwdSssD0FEREREdRcL0BERVYMEf7du3WyUFXjq1Em0bdteXSFBRA3TmTOnsX79GmRnF5R3kHrgQ4YMQ9eu3Uv97cem5uE/G2Px+74k5BdefY8Qb1vMHu2HUaGu7DOoVqkawao0RPnfQxdNFoa31GLGoMbo2LxdjbWPiIiIiGoxGHzs2DHs27cX8fHxqt5dUc8++5yJmkZEVLdJEGjVquW4ePGCYZoEgoYNG8GgDlEDHyhu9eoVqkSE8PDwwMSJUxAQEFhi2bSsfCzcnoDvt8cjM7dwn8nbRYNHhvtiek8PNVAcUW2TweIq4+XpzTChq4fZ20NEREREdSQY/PXXX2HBgk/RtGkzeHt7GwU8GPwgIkuRlJSIpUt/R1xcnKH/GzFiFLp06VbbTSMiM3N1dVNZwBs3bkDbtu0watRY2NsbD5KVk6fDb3sT8eWmOCSkFwSNhZOdNe4Z5IVZA7zhbG9dC60nKp2vW+UOC/zcWQ6CiIiIyKKCwT/99BPeeONNTJky1TwtIiKq48LCrmL58j+RmZmpHjs4OGDSpKlo0qRpbTeNiMxEroQqetJbrgLw9PRE06bNjaZrtTqsPZqCBRtiEZaQa5huYw3c0tsTDw3zgbcLq3RR3dO9qRN8Xa0RmyonL0pL8NDBz1WjliMiIiKi+qvKRyPW1lbo2rWreVpDRFQP6oRKaQipFSy8vLwxbdpN8PT0qu2mEZEZ5OTkYNOmDXBycsagQUMM0yUA3KxZC6Nld51Px4drY3AyIsto+thObnhilC9CvO1qrN1EVaWxtsKLkwIxe9E1Ffg1DggXlDh5YVKgWo6IiIiILCgYfNdds7BkyRI8//xc87SIiKgOCwgIUJnAGRkZqlyO1AmVx0TU8MTGxmLlymWIjy8oB9O4cQiaNWteYrmT4Zn4aF0sdp5PN5rep4UT5oz1Q4dgxxprM1F1jAx1w8czG+GtFZHXB5MrIBnBEgiW+URERERkYcHgu+++B4888hDGjBmNFi1awMbGeBWffPKpKdtHRFSnuLt7YPLkaTh37iwGDx4Ka2vW/CRqiCUhjh07omoC5+UVDKpla2uLnJxso+XCEnLw6V+xWHMkxWh620B7zBnjh36tnDmeAtU7EvAd1t4VBy5nqEHlpJawlIZgRjARERGRhQaD5817G3v37kWvXr3U6Nk8xiGihj5QnFwebmdXeHl3o0aN1Y2IGp7s7Gz89ddanD59yjDN19cPkyZNUWVhREJaHr7aHIef9yQir3BsOAR72qpyEOM6uamyWkT1lQR+ezV3ru1mEBEREVFdCAYvX74MH330CQYPHmyO9hAR1RlXr15RA8U1btwEkydPZYYfUQMXHR2FFSuWIikpyTCtS5duGDp0uLoSKj1bix/+icfC7Qnqvp6nswYPDfXBLb09YCcjxRERERERETWUYLC7uzsaN2ZGHBE1bIcPH8LGjX+pgeLOnTuDAwf2oUePXrXdLCIyU1mIQ4cOYMuWTcjPL0j1tbOzx5gx49CmTVvk5uvwy55EfP53LOLTClOBHW2tcNcAL/zfIG+4OGhq8R0QERERERGZKRj8yCOP4vPPP8Obb74FR0cOiEJEDYsEfzdv/hsHDx4wTJMBozp27FSr7SIi8/7ujx8/ZggEBwQEYuLEyapG+PpjKfhkfSyuxOcYltdYAzf19MDDw3zg62Zbiy0nIiIiIiIyczB40aKfEBYWhsGDByI4OLjEAHK//fZHVVdJRFQnZGVlYeXKZbh8+ZJhmmQDc6A4ooZNo9Go4O8PP3yHTp06Y9CgITh4JQsfLLqMY9eyjJYdGeqKf43yRTNf+1prLxERERERUY0Fg4cNG37DL0ZEVFclJibgzz9/Q0JCgnoswd+RI8eowBARNbyyEBkZGXB2Lhwgy9PTC/fd9yCupWjw2I/h2HYm3eg5PZo5Yc4YP3QO4VVRRERERERkYWUiiIgakitXLqtBoyQzWEgJnMmTp6Fx45DabhoRmVh6ejrWrFmJ1NRU3HHHLNjZ2anpEYm5WLAhGSsPJ0OnK1y+lb89nhzji0FtXDiIJBERERERWV4wmIiooTl06KAhEOzj44OpU2+Gh4dHbTeLiEzs6tUrWLVqBdLT09TjTZv+Rp+Bo/D1lngs3pWoBorTC3C3weMjfTGxqzs01gwCExERERGRhQaDZXCVH374HuvXr0dkZARyc3ON5u/cuduU7SMiMrtx48Zj0aIEuLu7Y/z4SbC3N28t0HytDgcuZyA2JQ++bjbo3tSJwSYiMw8Qt2vXDnWTEhHC1sEFRzNb4d/vX0BqltawrJujNR4c6oMZfTxhb8ta4UREREREZOHB4P/85wv88cfvmDXrbixY8CkeeOBBhIeHY9OmjXjooYfN00oiIjOys7PHrbfeDgcHB7MPFLfheArmrYpGdHKeYZq/uw3mTvDHyFA3s742kSVKS0tV2cBhYVfVY63OCokuXbE7qRli9xb+Du1trHBHfy/cN9gbbo6aWmwxERERERFRHQoGr1q1Cv/+9+sYPHgwvvjic4wdOw4hISFo3bo1jh49ap5WEhGZSEJCPNavX6sygN3cCoOvTk5OZn9tCQQ/uSgcRcqRKjHJeWr6RzPBgDCRCV26dFHVB5bB4iQhOCwvEKd0PRAZJsHefLWMJOVP7e6OR0b4IsDdtrabTEREREREVLeCwfHxcWjdupUheJKWVlB3b/DgIfjsswWmbyERkQkDQytXLkN2djaWLv0dM2bcYRg8ytykNIRkBBcPBAuZJkUi3lkVjWHtXVkygsgE/vlnK3bt2qnuR+d64XBOJ0RmG9cCH9rOBbNH+6Glv3lLwxAREREREdXbYLC/vz9iY2MRGBiExo1DsHPnDrRv3x7Hjx+vsaAKEVFVSI3QQ4cOqMGi9PVC5f+cnOwa67ekRnDR0hAl2gggKjlPLderuXONtImooYiLj8eybacRmZiFQE8HTBnUFjY2tkjKd8WBjPYIyw00Wr5LE0fMGeOn6nUTERERERFZkioHg4cPH4Hdu3ejU6fOuP32mZg79zn8+ecfiIyMxF13zTJPK4mIbpAMerlx4wYcOXLIMK1ly1aqTERNnsCSweJMuRwRFfh2zTF8uSMXGVovw7Qv911FCz83nEgeBp3Kuy/Q3NdOZQIPa+8CKytm4BMRERERkeWpcjD4ySfnGO6PHTsWgYGBOHLkMJo0aYIhQ4aaun1ERDcsMzMDy5cvNQwcJXr37ouBAwfXeCCosuPS+bpVuVsmsljL9kTgw+1S/9d4wLdMnT2ORxf+xv3cbPDoCB9M6eYBGw2DwEREREREZLkqGZ4oW5cuXTBr1t1mCwSHh4fjjjvugLe3NxwdHdGxY0fs37/fMF8u9X7llVdUUFrmjxgxAufOnTNLW4io/pD65j/99L0hEKzRaDBu3EQMGjSkxgPBm06m4rWlkeUuIy0KcLfhZetE5dBqtYiJicbhwwexavVKvL0i6vqc4r9p/WMdnhjlgzVPtcBNPT0ZCCYiIiIiIotX5RS05cuXwcPDE4MHD1aPP/jgffz++29o3rwF3nvvPQQFBZuscYmJiejfvz+GDh2KtWvXwtfXVwV6PT09Dcu8++67+PTTT/H999+jWbNmePnllzF69GicPHkSDg4OJmsLEdUfMrDlTz/9oGoCCycnZ0ydOt2k/VNlZOdq8f7aGCzelVjucvrw1PMT/Dl4HFEpdu78R53YkZJUubk5alpkrg/StS0reKYVujZxgqNdtc99ExERERERWWYw+JtvvsbLL7+i7h8+fBhLlizGc889j61bt2L+/Pn45JNPTdY4WV/jxo2xcOFCwzQJ+BbNCv7444/x0ksvYfLkyWraDz/8oAa5W7ZsGW677bZS15udna1ueikpKYaMI7kRUf3m5OSEzp27YN++PfD19cOUKdPh5uZWo7/vi7HZePbnSJyJKuxrRnZwwZB2Lvj0rzhEF6kN7O9ug+fG+2F4e5c60QdZV1DTgn0omYN8dySjPyMjA02aNDWad/78OURHF2QBa3VWCMsNwMGMdpVab0xyLr+XVKPYhxIRma8PFexHiYiq149WORgcFRWFkJAQdX/Tpo0YOXIUbr75FnTt2hX33HM3TGnFihUqy/fmm29Wwebg4GA88sgjuP/++9X8S5cuqfZIaQg9d3d39O7dG7t27SozGDxv3jy89tprJabHxEQiMzPNpO+BiGpHq1YtkZeXizZtWqvfdU39tuUk1fpTefhsSxayrsd77TTAI4PsMT4UsLJKxw93OeBYRD4S0nXwcrZCxyANNNapiI5ORV0QGNio3PnsQ8kU5CAuLi4OsbGxiIuLRXx8PHJzc+HsLJn804yW9fBwx5XIBFzWtsSpzKZIzq384I+avCRER/N7STWHfSgRkfn6UMF+lIioev2olU4iF1UwaNAAfPXV12jXrj1uumka7rrrbkyaNAlXr17F9OlTsW/fAZiKvszDnDlzVEB43759+Ne//oUvv/wSs2bNws6dO1UZiYiICFUzWO+WW25RNUF/+eWXSp9JlAxkKUsh2YNEVL9IJmFMTBSaNm1eq+1Iy8rHGyuiseZIYVC3hZ8d3rstCK387dGQs9rYh1JFMjLSVYavbLMjIsKRmJhQ5rIPPvgIXFxc1f2T4Vn4flsM/j6ViZx84+U01kC+VnZjSiuvokOAuy3WPd2c5VeoRrEPJSKq+cxg9qNERGbMDO7bty9effUVtG3bDleuXMGgQYPU9AsXzqvMXVOSSzx69OiBt99+Wz2W7OPjx48bgsE3yt7eXt1K+8Aq86ERUd0hGYV//vk70tJScdttM2u8LrDe8WuZeHpJOMIScg3TburpoeoAN7R6pexDqSJZWZmQU80ysKteamoqNmxYX+ZzJPgrv1+56axssPZoKhbvTsThK5lGy8n4j4Nau+D2fp7IyNZizuJwlHZW2wpW6vdna6Mx6Xsjqi72oURE1cN+lIioeqocDH7xxZexYMGniIqKxEcffQwPDw81/cSJExg7dhxMSbJ927dvbzStXbt2+OOPP9T9gIAA9X90dLRRZrA87tKli0nbQkR1j5yEWrVqOXJyCgaUkkDTXXfdo64MqClarQ4/7EjAR+tjkHc9a9HF3hqvTQvEmE7MTKCGTy4wklq/ku2rv0nJh0GDhqB3776G5fz8/GFjY4O8vDx1oCb1/fXB36CgRiqTJzYlF7/uTcLTC8IRl2qcBuzmYI2pPTxwWx9PhHgXlon4aCYwb1U0opML63AHuNuoQPDIUP4GiYiIiIiIqhUMloO1F198qcT0xx57HKYmJSDOnDljNO3s2bNo0qSJYTA5CQhv3LjREPyVS0T27NmDhx9+2OTtIaK6E3zav38vtmzZZJjm7x+AqVOn12ggOCEtDy/8FoHtZ9MN0zo1dsB7twWjkVfla5oS1SdZWVmIjCwo9SA3uV/0Uk09KQdRlEajwejRY+Hm5qECwba2tobf8+GrmVi8Jhx/HUtBXrFxX6TEimQBT+jiDqdSsuwl4DusvSsOXM5AbEoefN1s0L2pE0tDEBERERERmSIYXJOefPJJ9OvXT5WJkDrAe/fuxddff61uQoI+s2fPxptvvolWrVqp4PDLL7+MoKAgTJkypbabT0RmIFmFkgF8/PhRw7TWrdti7NjxsLOruQDs7gvpeP6XCMSmFmYj3jvYG4+P9IWthkEoahgkUFv8BMvmzX/j+PFjZT5Hsn4lC9jPz6/EvPbtQw33s3K1WHskBYt3JeJkRFaJWsAS4L29ryd6NnOq8CSPBH57NXeuwjsjIiIiIiKyTHU6GNyzZ08sXboUc+fOxeuvv66CvR9//DFmzpxpWObZZ59Feno6HnjgASQlJWHAgAFYt26dYfA5ImpYA8UtW/YHwsOvGab17dsf/fsPrLGM4Lx8HT7fGItvtsSrmqjC20WDeTcHoX9rlxppA5G5ZGdnGQZ4k5uUhHrggYdhb1+4TQ0MDDYKBjs7Oxcp9xCssvT1Wb+liUjKxS+7E/H7viQkZRiXgvB01uDmnh64pbcnAj3KXgcRERERERHdGCudpP1YOCkt4e7ujuTkZI4+SlRHxcbGYunS39TvVEjtUckGbtvWuK64OUkQ69mfw3GoyIBW/Vo64+1bguDrWqfPrZkV+9D6STb/CQkJRWr9XkNcXFyJ5W6++TY0bdrM8DghIR6HDh0wBH/d3NwrPBkjr7XnYgaW7ErEppOp0Bbb8+gQ7KCygMd2coO9LQd+IcvCPpSIqHrYjxIRVY3lRi+IqF7JyclGWlqauu/s7KLqAwcGBtXY6284noJX/ohESlZBQVMba+CJUX64Z6AXrFmblOphuZUvv/wMmZmFJzZK4+TkVGIZLy9vDB8+qlKvk56txarDyaoUxPlo47rCNhpgTEc33N7XS9Xarsl630RERERERJaqysHgzz5bgGnTpqlsICKimhIc3AijRo3FoUP7MWXKTXB1da2R15W6pu+ujsYve5IK2+JpqwaJ6xziWCNtIKoqycRNTCzI+g0PD1elHAYMGGSYL5n1Li6uRoFeCcZKrV+pu6/P+nV397ihIO2VuBws2Z2IZQeSkHr9BIqeZNHf0tsDN/fytOiMeiIiIiIiotpQ5aOwzZs34ZtvvkaPHj0wbdp0jBw5qkYHbSIiy8lc1Gg0RoGo0NCOaN++gxqgqiZciMnG00vCcTaqMKNxdEdX/HtqINwcNTXSBqLKZs5HRkYWKfkQjqyswkHZPDw8jYLBonnzFuqSyqK1fquzPddqddhxLh2LdiZg+9n0EvO7NnHEzH5eGNHBlYMsEhERERER1Zdg8B9/LMWpUyfVwG7vvDMPb731JsaMGYupU6ehY8eO5mklEVkUGRRSBooLCWmCgQMHG82riUCwZFX+uT8Z81ZGITO3oLipvY0V5k70x009byxTksgcLl++hC1bNiEuLlZ9b8uSnJyErKxMODgUZrMPGjTEJG1IzcrH0v3JWLI7AVfjc43mye9mfJeCUhDtgjiwKxERERERUW27oesz27Vrr27PPPMstmzZgmXLluLOO2eiWbPmKlt4ypQpNXYJNxE1LDEx0Vi69Hc1EIRkN3p7e6N9+9Aae30JbL22NAprj6YYprX0t8cHM4LV/0Q1LScnB1FRBVm/rVq1hre3j2GejY0tYmNjSjzH0dHRkPErt4CAQJNfxSM1gBfvSsCKQ8nIzDEORAd52OK2Pp6Y3sMdHs4sBUFERERERFRXVPMITacu5c7NLcgEcnd3w5Ili/DZZ5/i3/9+HWPHjjVNK4nIIpw7dxarV68w9ClS07Ro4MvcjoVl4pmfwxGWUJjdeGtvDzw73h8OtjVTmoIsm2T3JiUlFin3EKGCvfqsX6n1W/Q3ERAQoKZ5enoZAr/BwcGqLIQ5Mtjz8nXYcjoVi3YmYu/FjBLz+7RwUqUgBrd1gYYDKxIRERERETWMYPCJEydUNvCaNatVptGkSZPx0ksvqUu6xaJFP2HevLcZDCaiSpFA1549u7B9+1bDNMlknDr1Jri4uJj99aXW6ff/JODj9THIuz7WlauDNV6bFojRHd3M/vpER48exoUL51UAOCOjZJBVT+YXJYHgxx6bDVtbW7O2LzE9D7/vS8IvexIRmZRnNM/RzgqTu3lgRh9PZs8TERERERE1tGDw1KmTcenSJfTt2w+vv/4GhgwZqgZ5KmrcuPGqnjARUUXk6oJ169bg1KkThmlShmb06HFmD3CJ+LQ8zP01Qg18pdclxBHv3haEYE8OjkmmzvpNQkJCHFq0aGU07+rVKzh//lyJ50h2r4+P7/Ws3yAEBzcusYw5fycnwzOxaFci1hxJQU6ecSmIJt52uL2vJyZ3d4erAwdUJCIiIiIiapDB4NGjx6jB4vz9/ctcxtPTE8eOFQZ2iIhKk5aWpgaKi4yMMEwbMGAQ+vTpVyODtO06n47nfw1HXGq+eiwved9gbzw6whe2Gl7iTtUj5U70tX71N8n6le/2E0/MMarhK8FeGZzVwcHBqNZvYKDU+q3ZbFsJ+m44noLFuxNx+Eqm0Tz5jQxq7YLb+3miX0tnWLMUBBERERERUcMOBj/00MPmaQkRWZz169cYAsGS3Thu3ES0bt3G7K+bm6/D53/H4r9b43G9FCu8XTSYf2sw+rZ0NvvrU8Md6O38+bOGWr8yGKK+1m9RMk2CxPrSSqJt2/Zo0qQZvLy8auRESGliU3Lx694k/Lo30XCCRE/Kpkzr4aEGhQvxZsY8ERERERFRgw4Gv/vu/Eqv8Nlnn6tOe4jIgowYMRo//fQdNBobVR+4vCsOTCU8MQfP/hyBw1cLMx77t3LG2zcHwce1mmNqkkVl/Urw19m58OSBVpuP1atXlvkce3vJ+g1SGb9ubsa1qJ2cnNStpklgWn4Li3cl4q9jKYaa2Xqt/O1VKYgJXd3hZMdBFImIiIiIiOq7SkU+Tp06VamV1VY2ExHVT+7u7pg+/Ra4uLjWyEBx64+l4NU/I5GaVRDxsrEGZo/2w6wBXrzcncoNmKakJBuVe4iJiUGHDqEYM2a8YTkHB0d4e3sjPj5ePfbx8TEq+eDl5V1ntpNZuVqsPZKigsAnI7KM5mmsgWHtXVUQuGczpzrTZiIiIiIiIqqhYPDChd+Z4KWIyNIzKXfv3onevfsa1UoNCAiskcDX/FXR6hJ4vUaetnhvRjA6NXY0++tT/fuuRkdHGQV/09MLBxjUk+nFDRpUMKiqZABLJnBdE5GUi192J+L3fUlIyjAuBeHprMFNPT1wa29PBHqYf/BGIiIiIiIiqnk3fE20jHweFhaG7t17qAFvJHOK2UNEVJq0tFQsXfqHqpMaFxeHKVOm1Vh/cT46G08vCce56GzDtLGd3PDq1AC4OmhqpA1Ud+lr+hb9Ph44sA/bt28t93ne3j4IDg4use1r2bIV6hpp456LGViyKxGbTqZCW6yMcYdgB5UFLL8Le1uWgiAiIiIiImrIqhwMTkpKwlNPPYm9e/eqA+DVq9eicePGePnll+Du7oZnnmHNYCIqJAFgCQRLQFhcuXIJ8fFx8PHxNXsATLIf31kVjazcguiXg60VXpgYgGk93HnyqgFLTEzAsWNHkZycBHd3D3Ts2Amenl5qXl5eXomsX6lXXTRDXUo6FGVnZ4/AwEA1XQLAgYFBqiREXZeercWqw8mqFIScFCnKRgOMDnXDzH5e6NTYgb8HIiIiIiIiC1HlYPD8+e/AxsYWGzZsxKRJEwzTx44dqwaaYzCYiPTOnDmFNWtWqQCckEGzpk692eyB4NSsfPz7z0isO1YQgBatA+zx3m3BaOlvb9bXptolQeD169cYTduzZxeaNGmGnJxsxMREIz/fuDyCBISLBoPlfmhoJ0OtX6n9W5+CpVficrBkdyKWHUgy1MfW83W1wS29PXBzL091n4iIiIiIiCxLlY8Ed+7cga+++gYBAQFG00NCmiAiIsKUbSOiekqycnfu/Efd9IKDG2Hy5GlwdnY262sfvZqJp38OR3hirmHarb098Ox4fzjwEvgGnxEsgWB96YeiJCO9NLa2dsjJyTGaJjWtx44tHBiuPtBqddhxLh2LdiZg+9mS9Y27NnFUWcDD27vCzqb+BLaJiIiIiIioloPBmZmZcHQsOShOcnKy0aBQRGS5g2+tXbtaZQXrdejQEaNGjYGNjY1Zg2H/2x6PBX/FIu96MqSbgzVenx6IkaFuZntdqltZwRWRchH6jF991q+1df09SSBZ8Ev3J2PJ7gRcjS88ASLsbawwvosbbu/rhXZBdW8wOyIiIiIiIqp5VY7MdO/eHStWrMDjjz+hHsuls1qtFgsXfotevXqbo41EVE9kZWXi119/VjVZ9QYPHoaePXuZ9TL7uNQ8zP01AjvPF2ZEdmniiPduDUaQp63ZXpfqFqkRXJ5WrVpjypTpaAikBvDiXQlYcSgZmTnGmdBBHra4rY8npvdwh4czS0EQERERERFRoSofJc6Z8zTuvff/cOLEcZUB+OGH7+P8+fMqM/jHHxdVdXVE1IDY2zvA1dVNBYPl8vuJEyehRYtWZn3NnefS8PyvEYhPK6gDKzHn+4d449HhvrDR8HJ4SyKDxZVFTkZ4eXmjPsvL12HL6VQs2pmIvRczSszv08JJlYIY3NYFGmt+94mIiIiIiMgEweBWrVph9eo1WLx4kar9mZGRgREjRmLGjNvh62veQaGIqG6TgNv48ROxevVKDBgwyKx9Qm6+Dgs2xOLbrfGGaT6uGsy/NRh9Wpi3LjHVTR07dsLevbvLnV8fJabn4fd9SfhlTyIikwoGY9RztLPC5G4emNHHk4MjEhERERERkemDwZGREWqk9QcffKjUeYGBQVVdJRHVUzJQV0pKslFGptQOnzrVvJfiX0vIwTM/h+NoWJZh2sDWznjr5iB4u/CyeEsl9YDHjBmHdevWlJgn02V+fXIyPBOLdiVizZEU5OQZl4Jo4m2H2/t6YnJ3d7g6aGqtjURERERERFS/VDlqMnr0KGzevBXe3saX2yYlJal5R48eN2X7iKiOysnJwdq1q3DtWhjuvPNuuLm518jrrjuaglf/jERadsEocTYa4MnRfrirvxeseWm8xQsN7YTg4EZqMDmpISwnKiQjuL4EgiXou+F4ChbvTsThK5lG86QEyqDWLpjR1xP9Wznz+05ERERERETmDwZLJmBpA0FlZKTD3p6XqBJZgpSUFCxd+jtiYqLV42XL/sQdd8yCtbW12V4zM0eLd1ZFq8vl9Rp72eK924LRsbGj2V6X6h8J/A4aNAT1SWxKLn7bm4Rf9iYiLrWg/rWeq4M1pvXwwK29PdHEx67W2khEREREREQWFAx+99356n8JBC9Y8CkcHQuDL/n5+SoLq02btuZpJRHVGRER4Vi69A91AkhfFmLAgIFmDQSfi8rCU0vCcSEmxzBtXGc3vDolAC68RJ7qKTm5evhqJhbvSsRfx1KQV5DsbtDK316VgpjQ1R1Odub7fREREREREZHlqHQw+NSpU4aD13PnzsHW1tYwT+63adMGd999j3laSUR1wsmTJ7Bu3Wp1AkjIJfjTpt0EHx/zDBQn/Y1kS0pGcPb1mqmOtlZ4cVIApnR3L/UqBaK6LitXi7VHUlQQ+GREYd1rIZUfhrV3xcx+nujZzInfcSIiIiIiIqqdYPDChd+p/1966QU8//wLcHFxMW1LiKjOkqDsP/9sw+7dOw3TGjVqjMmTp8HJycksr5mSmY9X/ozEhuOphmmtA+zxwYxgNPdjSRqqfyKScvHL7kRV6iQpw7gUhKezBjf19MAtvT0R5FF4spWIiIiIiIioVmsGv/nm2yZtABHV/YHi1qxZiXPnzhqmderUGSNGjIZGY54SDYevZOCZnyNU8ExvRh9PPDPOD/a2vFye6teJlL0XM1QW8KaTqdAWJLgbdAh2UKUgxnZy43ebiIiIiIiI6l4wWBw/fhzr169DZGQkcnMLgzXik08+NVXbiKgOuHLlsiEQLJesDx06HN269TDL5etarQ7fbovHgg2xyL9eP9XN0RpvTA/EiA5uJn89InNJz9Zi1eFkFQQ+H51tNM9GA4wOdcPMfl7o1NiBpSCIiIiIiIio7gaD16xZgxdeeB79+w/Azp070K9ffxUsio+Px/Dhw83TSiKqNa1atUbv3n1x6NBBTJo0Gc2atTDL68Sm5mHurxHYdb5gYDrRrakj5t8azMvmqd64EpeDJbsTsexAElKzjEeE83W1wS29PXBzL091n4iIiIiIiKimVflo9JtvvsZzzz2PGTNuR69ePfD883PRqFEjvPbav+Hj42OeVhJRrRo4cDA6d+6iBowzh3/OpuGF3yIQn1ZQR1USJR8c6oOHh/nARsOsSarbJKN9x7l0LNqZgO1nC09m6HVt4qiygIe3d4WdDb/PREREREREVI+CwdeuhWHQoMHqvq2tLTIzM9UlrnfeeRfuvfcePPbY4+ZoJxHVAK1Wi+3bt8Lb2wehoR0N0+U3bo5AcE6eDp9uiMHCbQmGaX5uNnjnliD0buFs8tcjMqXUrHws3Z+MJbsTcDXeuGSSvY0Vxndxw+19vdAuyKHW2khERERERERUrWCwm5sb0tMLMp/8/Pxx/vw5tG7dGqmpqcjKyqrq6oiojsjJycaqVStw4cJ5NTCcp6cngoMbme31whJy8PSScBy/VthvDGrjjLduCoKXCy+hp7pLagAv3pWAFYeSkZljPCKclDS5rY8npvdwh4czv8dERERERERUt1T5SLV79x7YtWunCgCPHj0a77wzD3v27FHTevfuY55WEpFZJScn4c8/f0dcXKwhQzghId5sweA1R5Lx2tIopGVrDQNqzRnjh7v6e3EwLaqT8vJ12HI6FYt2JmLvxYwS8/u0cFJZwEPauUBjze8wERERERERNZBg8Isvvojs7Bx1/4EHHoSNjQ0OHz6MkSNH4oEHHjJHG4nIjKT0y/LlfyIjoyDAZW9vj0mTpqJp02Ymf62MHC3eWRmFP/YnG6aFeNvi/RnB6BDsaPLXI6quxPQ8/L4vCb/sSURkUp7RPEc7K0zu5oEZfTzR0t++1tpIREREREREZJZgcF5eHrZs2Yr+/furx9bW1rjvvvursgoiqkOOHz+K9evXqkxgIaUhpk27GV5e3iZ/rbNRWXhqSTguxhScTBITurjhlSkBcLbXmPz1iKrjZHgmFu9KxOojKaq2dVFNvO0wo68npnR3h6sDv7tERERERETUQIPBkgX8xhuvYcWKleZrERGZnQR/t27djP379xqmNWnSFJMmTYGDg2kzdHU6HX7Zk4T5q6MNQTVHWyu8NDkAk7u5sywE1Rny/dxwPAWLdyfi8JVMo3nyNR3U2kUFgfu3coY1S0EQERERERGRJZSJCA3tiNOnTyMoKNg8LSIis/vrr7U4duyo4XHXrt0wdOgINXCcKSVn5uOVPyLx94lUw7S2gfaqLEQzX15WT3VDbEouftubhF/2JiIuNd9onquDNaZ291CDwjXxsau1NhIRERERERHVSjD4tttuw7vvvouoqCi0b98Bjo7GWYRt2rQxScOIyHw6deqCkydPqAzh4cNHqWCwqR28nIFnfwk3qrM6s68nnhrrB3tba5O/HlFVM9YPXy0oBfHXsRTkFVRKMZAawPJ9ndDVHU52/L4SERERERFRw2ClkyPiKujYsUPJlVhZqQNr+f/o0eOob1JSUuDu7o7k5GS4ubnVdnOIasTp0yfh6OikykOYUr5Wh/9ujcfnf8ci/3qAzd1RgzdvCsSw9q4mfS2qG+paHyrfwQOXMxCbkgdfNxt0b+oEzfWyDlm5Wqw9kqKCwCcjsoyeJ4vId3RmP0/0bObEEiZEZJF9KBFRfcN+lIjIzJnB69f/VdWnEFEtu3TpIpo2bWYU3Grbtr3JXycmJRfP/xqBPRcyDNO6N3XE/FuDEehha/LXIypOav7OWxWN6OTCjHR/dxs8ONQHEYm5+H1fEpIyjEtBeDprcFNPD9zS2xNB/J4SERERERFRA1blYDBrBRPVH1IGYsuWTThwYB969eqDwYOHmu21tp9Jw9zfIpCYnm/IsnxomI8KwtlomGFJNRMIfnJROIpf7iKB4deXRZVYvkOwA27v64mxndxYuoSIiIiIiIgsQpWDwcuXLy93/uTJk2Eu77zzDubOnYt//etf+Pjjj9W0rKwsPPXUU/j555+RnZ2N0aNH44svvoC/v7/Z2kFUH2RnZ2HlyuUqK1js3bsbrVu3QWBgkElfJydPh4/Xx+D7fxIM0/zcbDD/1iD0au5s0tciKq80hGQEV1T3SGMNjOnohpn9vNCpsQNLQRAREREREZFFqXIweP78eUaPc3NzVUDW1tYWDg4OZgsG79u3D1999RU6depkNP3JJ5/E6tWr8dtvv6k6QY899himTZuGHTt2mKUdRPVBYmIili79DfHx8eqxtbU1RowYZfJA8JW4HDzzczhOhBfWXh3c1gVv3RQIT+cqdy9EN0xqBBctDVGW92cEY1Qoa8kRERERERGRZapytGbnzt0lpl25chlvvPE67rnn/2AOaWlpmDlzJr755hu8+eabhulSIP7bb7/F4sWLMWzYMDVt4cKFaNeuHXbv3o0+ffqYpT1EddnVq1ewfPmf6iSNKDhJMw0hIU1M+jqrDierS+/TswtGibPVWOHpsX5q8C1mW1JNk8HiKiM3r0pjphIRERERERE1KCZJ3WvSpClmz56DuXOfw8qVq2Fqjz76KMaPH48RI0YYBYMPHDigMpNlul7btm0REhKCXbt2lRkMlnIScis6+qi+vqrciOqro0cPY+PGDYbvsZeXN6ZMmQ5PT0+TfbczcrSYtzIayw4W/G5EE29bvHtrENoHO0Cn06kb1V+SSV6eutiH+rhoKr0c+3kiMqf62IcSEdWXPlSwHyUiql4/arLruG1sNIiJiYGpSS3ggwcPqjIRxUVFRcHOzg4eHh5G06VesMwry7x58/Daa6+VmB4TE4nMzDQTtZyo5shOj5wcOXPmtGFaUFAQBgwYiJycTERHZ5rkdS7E5uPNdVkISyzcyRrR1gZPDLGHk00CoqNN8jJUywIDG5U7vy72ocGOOvi4WCEurewTEb4uVgh2TER0dFKNto2ILEt97EOJiOpLHyrYjxIRVa8ftdJVMYVv8+ZNRo/l6bGxsViyZDECAgLw5Zdfw1TCwsLQo0cPbNiwwVAreMiQIejSpYsaQE7KQ9xzzz1GZwVFr169MHToUMyfP7/SZxIbN26s6qy6ubGWJNU/ubk5WLJkEWJjC07IdO/eA4MGDa3UGaHKkN/5kt1J+GBdrBowTjjaWeGlSf6Y1NXdJK9B9TurrS70oX+fSMWcxRHqftENm75oyYe3B2FEB9daaRsRWY762ocSEdXnzGD2o0REZswMfuKJx40eS21QuQS9d+8+eOaZZ2FKkuko2cbdunUzTMvPz8e2bdvw2WefYf369cjJyUFSUpJRdnB0dLQKTJfF3t5e3Ur7wEwVPCOqSfb2Dpg27SYsXvwT+vUbgE6dOpts3UkZ+Xj5jwhsOll4lr1dkD3evy0YTX1L/o6o4aurfeioju74aKYV5q2KNhpMzt/dBs9P8MdIDhxHRHVAXe1DiYjqC/ajRETVU+Vg8LFjJ1BThg8fjmPHjhlNk0xgqQv83HPPqbN/tra22LhxI6ZPn67mnzlzBlevXkXfvn1rrJ1EtVUaoujOjpubO+699wH1mzCVA5cz8OzP4YgqEli7o58nnhrrBzsb7mhR3SMB32HtXdV3VwaV83WzQfemTtBYc1BDIiIiIiIiIpPVDDYHV1dXhIaGGk1zdnaGt7e3Yfq9996LOXPmwMvLS10S8vjjj6tAcFmDxxE1BIcOHcSxY0dw2223w86u8Ky4qQLB+Vodvt4chy82xkF7/Xp7DycN3rwpEEPb8TJ7qtsk8NuruXNtN4OIiIiIiIiozqlyat/s2f/Ct9/+t8T0//3vW8yZMxs17aOPPsKECRNUZvCgQYNUeYg///yzxttBVFPZwH//vV7doqOjsHr1SlXP15Sik3Nx77dX8dnfhYHgHs2c8McTzRgIJiIiIiIiIiKypMzgAwf245FHHi0xfcCAgfjuu+9gblu2bDF67ODggM8//1zdiBqyrKxMrFixDFeuXDZM8/T0UsFgqd1tCltPp+KF3yJVnWAhV9Y/PNwHDw714WX2RERERERERESWFgzOyMgo9VJ0GxsbpKcXDjBFRKaTkBCPP//8TY2QK6RW8OjRYxEa2skk68/J0+LDdbH4cUeCYVqAuw3m3xqssoKJiIiIiIiIiMgCy0S0atUa69atLTF97do1aNGihanaRUTXXb58CT/99IMhEOzk5IRbb51pskDwlbgczPzPFaNA8NB2Lvjj8WYMBBMRERERERERWXJm8EMPPaTqBoeFhaF3795q2u7du1Uw+IMPPjRHG4kskpR/OHToADZt+ttQF9jHxxfTpt0Ed3cPk7zGykPJeH1ZFDJytOqxrcYKz4zzw+19PU1WeoKIiIiIiIiIiOppMHjIkKH45JMF+Oabr7Fhw1+wt7dH69Zt8M0336Jnz57maSWRBbpw4Tw2btxgeNyyZSuMHz8Rdnb21V53erYWby6PwopDyYZpTX3s8P6MYLQLcqj2+omIiIiIiIiIqAEEg8XgwYPVjYhMIzExAceOHUVycpLK+u3YsRNatGiJVq3a4Ny5M+jduy8GDhxskmzdUxFZeHpJOC7H5RimTe7mjhcnBcDZvsqVY4iIiIiIiIiIqKEGg48dOwadTotOnTobTT969AisrTUIDQ01ZfuIGjwJAq9fv8Zo2t69uzFmzDiMGzcBV66Eqlrd1SWlJhbtTMT7a2OQm19QdsLJzhqvTAnAxK7u1V4/ERERERERERHVbVVOA3zrrTcRFRVVYnp0dAzeeusNU7WLyGIygiUQLIHa4rd169YgPT3NJIHgpPQ8PPbjNcxbFW0IBLcPcsDvjzdjIJiIiIiIiIiIyELY3Egd03bt2peY3q5dO1y4cMFU7SJqsLRaLZKSEhEXF4f9+/caBocrK2t40KAh1Xq9/Zcy8OzP4YhOyTNMu6u/F54c4ws7G5aFICIiIiIiIiKyFFUOBtvZ2SE+Ph6NGzc2mh4bGwsbmxsqQUzU4OXl5WH9+rWIi4tFQkK8elwZUkP4RuVrdfhqUxz+sykO2uvxZk9nDd66KRCD27re8HqJiIiIiIiIiKh+qnL0tl+//vj444+wYMFncHUtCCilpKTgk08+Rt++fc3RRqI6Lz09XQV6C25x8PHxQffuPQ3zNRoNLl48j6ysrCqtVwaTuxFRybl47pcIlRWs17O5E+bfEgR/d9sbWicREREREREREVlYMPjpp5/BrFl3YdSoEWjbtp2adubMaXh7e2PevHfM0UaiOiM7OwuxsXFFAr8Ft8zMTKPlQkKaGgWDrays4OPji/Dwa/D09FT35ebg4IjNm/8us1REx46dqtzGzadS8eJvkUjOzFePra2AR0f44v4h3tDIAyIiIiIiIiIiskhVDgb7+/vjzz+XYvXqVThz5gzs7e0xZcpUjBs3Dra2zDikhiEnJ0eVc/Dz84e1dWFd3b1792D37p0VPl8CxMVNmDAZjo6OJcqp2NvbqcHiihszZhw8Pb0q3+Y8LT5YG4OfdiYapgW42+Dd24LRvalTpddDREREREREREQN0w0V+XVycsLNN99i+tYQ1bD8/HwV9NWXd9Bn+iYlFdTqve++B40CslL+oThnZ2dDpq/Ml/+9vUsupy+rUlxoaCcEBzdSg8VJjWApDSEZwVUJBF+OzcbTP4fjVES2Ydrw9i54fXoQPJw0lV4PERERERERERE1XDc84tuFC+cRGRmJ3Nxco+lDhw4zRbuIzJr1K5m4EvRNTEyAVqstc1kJEBcNygYEBKJLl67w9vaFr29B0FdOjlSXvMagQUNu6LnLDybhjeVRyMwpKDVhZ2OFZ8b5YUYfT1WegoiIiIiIiIiI6IaCwWFhYfjXv57AuXNnVaBJX+tUH3Q6evQ4P1mqNfJ9TE1NUYFefW3fgIAAo/q9Us7k0qWLyMkpzKItSubrM3wl67d40HbkyDGoC9Kz8/HGsiisPJximNbM1w7vzwhG20CHWm0bERERERERERE1gGDwO+/MQ6NGwfj22/9h9OiRWLLkF3Vp+3vvvasGlyOqKZmZGYiJiSlR4kEyf4vKyEgvZTA3H0RHR8HLy9sQ+NXf3N3d63xG7cnwTDy1JBxX4wsz86f1cMfciQFwsiuscUxERERERERERHTDweAjRw7j228XwtPTUw2sJbdu3bpj9uwnMW/e2/j99z+rukqicmVlZalgb3BwsFGQds+e3di3b0+Fz4+Pjy8xbcqU6XBwcIBGo6l3mc8/7kjEB+uikZdfMM3Z3hqvTAnAhC7utd08IiIiIiIiIiJqSMFgqa+qv3Tew8MTsbExaNasGQIDg3D58mVztJEshGT06gdzi40tyPKVIHBaWqqa/8ADD6vB1fQki7c4Nzf3Epm+3t7eJZYrXv6hPkhMz8OLv0di6+k0w7QOwQ6qLESIt12tto2IiIiIiIiIiBpgMLhly5Y4c+Y0GjVqhE6dOuF///sWNja2+P3339Q0oqrIzs7CmjWrVPBXyo2UR4LDRYPBQUFBqvxDQdBXAsA+sLOzR0O092I6nvslAjEpeYZpdw/0wr9G+akB44iIiIiIiIiIiEweDH7wwYeQkZGp7j/22GN49NFHMGvWnfDw8MD7739Q1dVRAyZZ5BLgLZrlK6UeitbvleDtlSuXkZtbWPu2KHt7B/j6SnavD5ydXYzmSb3fYcNGoCHLy9fhP5vi8NXmOFwfqxGezhrMuzkIA9sYfx5EREREREREREQmDQb37z/AcD8kpAlWrlytAn5yeX5dH3SLzCctLQ0xMVGIjS0cyE1KPuTlFWayitzcnBKDuUmgNz4+zlDewdu7INNXgsASALaE71W+VocDlzMQm5IHXzcbdG/qpLKAn/0lHAcvF5x8Eb1bOOGdW4Lg52Zbq+0lIiIiIiIiIiILCAaXpuil+9RwyeBlGRkZKtArJwKKBmn37t2NAwf2VbiOxMSEEtNuuukWODg4WkTQtzQbjqdg3qpoRCcXBs49nDTIztMiM6cgHVhjDTw2whf3DvaGxtoyPyciIiIiIiIiIqoDwWBqeLKyMlVZh4KbvsxDLDIzC7JUH3roUbi6uhmWlyzeoiSw6+npeT3TtyDLV+7LoIPFOTo6wVJJIPjJReG4XgHCICkj33A/0MMG794ajG5NLfdzIiIiIiIiIiKi6mMwmAwyMzOwatUKFQBOS0std1kJDBcNBgcFNUKvXn2uD+YmAWBv2Njw61VRaQjJCC4eCC7K3sYKvz7WDF7O/CyJiIiIiIiIiKh6GGGyEPn5+aqGr34gN32ph6L1e2WwtrCwq2rZ0jg7OxuCvc7OrkbzJPg7ePBQs7+PhlRy469jKUalIUqTnafD+ehs9GrOnyoREREREREREVUPI0wNUEpKMqKioowCv1KrV6vVlli2aDDY2tpalXRITk6+XtahYEC3gpuPRZdzqG7gNywhFyfDs3AyIqvg//AsJGeWHnQvTgaVIyIiIiIiIiIiqvFg8PLly1Td18GDB6vHH3zwPn7//Tc0b94C7733HoKCgqvdKEsngdtjx44iOTlJDc7XsWMneHp6lQgwpqamID4+Dk2bNjcafG3fvj04ePBAha+TlJRUYtptt82EnZ2dxQ7mVl1arQ5X4nOMAr+nIrKQmlUyEF9Zvm48Z0NERERERERERNVX5SjTN998jZdffkXdP3z4MH7+eQmeffY5bN26FfPnz8cnn3xqgmZZLgkCr1+/xmja3r270aNHL7i6uhoN6JaTk6PmP/LIE6qEg55k8hal0Wjg5eVdLNPXF+7u7iVe397e3mzvrSHW/L0UWzTwm4lTEdnIyKk48OvlrEG7IHscvpqF9OzSl5dwvL+7Dbpz4DgiIiIiIiIiIqqNYLCUHwgJCVH3N23aiBEjRuLmm29B165dcc89d5uiTRadESyBYMn6LU6yfcsigeGiweBGjRqjb9/+10s9+KpMbgkI043LzdfhYkx2YeA3IgtnIrKQmVve8G8F/Nxs0C7IAR2CHdT/7YMd4O9mo7KvNxxPwZOLwtVyRdekz8t+foI/NNbM0iYiIiIiIiIioloIBjs5OanyAoGBQdi5cwfuuqsgAGxnZ4+srCwTNMmys4IrS7J6JdArNX5dXFyM5sm0AQMGmaGFliFHDdpmXN/3bFS2GsytIgHuNoagb4dgR7QLdoCva9k/s5GhbvhoJjBvVbTRYHKSESyBYJlPRERERERERERUK8Hgvn374tVXX0Hbtu1w5coVDBpUEHS8cOE8goNZL7g6pEZweQICAjF8+EhV7kGC71R92blaFeg1CvxGZyGvEmO7NfK0VVm+6hZUEAD2cql6fV8J+A5r74oDlzPUYHFSI1hKQzAjmIiIiIiIiIiITKnKkasXX3wZCxZ8iqioSHz00cfw8PBQ00+cOIGxY8eZtHGWRgaLK4uUFGjSpCkH6KuGzBwtzkQWyfiNyMKF6GzkVWJstybedsaB32AHuDuarvSGBH57NS8s9UFERERERERERFTrweD09DTMnfsCrK2tjaY/+uhjKkBMN65jx05qsLjy5lPlpGfn43REkYzfiCxV81dbQaUHKyugmU9B4Fdf57dtkANcHVhzmYiIiIiIiIiILCwYPHr0KGzevBXe3t5G05OTk9W8o0ePm7J9FsXT0wtjxozDunVrSsyT6TKfSkrNysepImUeJPB7OS4HpYzDZ0SqMLTwszdk+8r/bQId4GxvfKKDiIiIiIiIiIjIIoPBujIibBkZ6bC3Zx3b6goN7YTg4EZqMDmpISylIyQjmIHgAkkZRQO/mSrwezU+t8Ln2VgDLf2LBn4d0TrAHo52DPwSEREREREREZFlqHQw+N135xtq13722QI4Ojoa5uXn56vgZZs2bc3TSgsjgd9Bg4bA0iWk5eFEeJYK/ur/D0+sOPBrq7FSgd6iGb+t/O1hb8vALxERERERERERWa5KB4NPnTplyAw+d+4cbG1tDfPkfps2bXD33feYp5XU4MWm5KosX33QVzJ/o5LzKnyevY0V2gRK4NfREPiV0g92NlY10m4iIiIiIiIiIqIGFwxeuPA79f9LL72A559/AS4uLuZsFzVQcjIhOiWvsL7v9Rq/sakVB34dba3UYG76oK/cmvvaw0bDwC8REREREREREZHJawa/+ebbVX0KWXDgNyIptyDb93rQV4K/Cen5FT5XBnGToG+7IAd0CHZAu2AHNPWxg0ZGfSMiIiIiIiIiIiLzB4MzMjLw7bf/xe7du5GQEF9iQLl16/6qeiuo3pPvgQzkVrS+rwR+kzMrDvy6OVirYK++xm+HYEc09rKFNQO/REREREREREREtRcMfvXVV7B//z5MnDgJvr6+MqSc6VpD9YJWq8OV+Byjwd1OR2QhNUtb4XM9nDQq6Kuyfa9n/QZ72qqBCYmIiIiIiIiIiKgOBYP/+Wc7Pv/8P+jWrZt5WkR1Sr5Wh0uxOSrL90R4pgr+norIRkZOxYFfbxdNkaCvo8r+DXS3YeCXiIiIiIiIiIioPgSD3dzc4O7ujpowb948/Pnnnzh9+jQcHR3Rr18/zJ8/H23atDEsk5WVhaeeego///wzsrOzMXr0aHzxxRfw9/evkTY2JLn5OlyIyVb1ffVZv6cjs5CVa1wKpDT+bjaGMg8S9JUgsK8rA79ERERERERERET1Nhj82GOP4/PPF+Ctt+apAK05bd26FY8++ih69uyJvLw8vPDCCxg1ahROnjwJZ2dntcyTTz6J1atX47ffflNB6sceewzTpk3Djh07zNq2+i4nT4vz0dlGpR7ORmUjJ6/iwG+Qh21B4Fcf/A1ygI9rlb9KREREREREREREVIOsdMVHgKvATTdNQ1hYmBowLDg4GDY2xkHA3377A+YSGxsLPz8/FSQeNGgQkpOTVd3ixYsX46abblLLSBZxu3btsGvXLvTp06dS601JSVGBZFmfZD43NNm5WpyJyi4c3E0Cv9FZyKt4bDc1kFv7IvV95X9PZwZ+ichy+lAiInNiH0pEVD3sR4mIqqbKUb1hw4ajtkjnLry8vNT/Bw4cQG5uLkaMGGFYpm3btggJCSk3GCzlJORWdOMhtFqtutWFOr0HL2ciNjVPlVro1tQRGuvKlVvIzNHiTGQ2TkZkqZvU95XSD/mVeFtNfWxVsLcg29cebYMc4O6oKbFcXfiMiMh8rK2ty51f1/tQIqLaxD6UiMh8fahgP0pEVL1+tMrB4EceeRS1QTr12bNno3///ggNDVXToqKiYGdnBw8PD6NlpV6wzCuvFvFrr71WYnpMTCQyM9NQm7afz8Xn27IRl1aYsO3jYoVHB9ljYEtbo2UzcnS4EJuPszFanIvNx7kYLcIStdBWkOstceXGntZo5WuNVn4atPKzRgsfDZzt9QHnLHXLSklGVsF2lYgsSGBgo3Ln1+U+lIiotrEPJSIyXx8q2I8SEVWvH61ymYja8vDDD2Pt2rX4559/0KhRwRuT8hD33HOP0VlB0atXLwwdOlQNNlfZM4mNGzdGYmJirV5W8veJVMxZHIHifxAJ0cq0R4Z7w8nO+nqd32xcic9BRX89jTXQws9eZfqqUg9BDmgdaK/WQ0Rkqqy2utCHEhHVBexDiYhqPjOY/SgRkYkzg/v164PVq9fC09NT3S/Pzp27YWoyKNyqVauwbds2QyBYBAQEICcnB0lJSUbZwdHR0WpeWezt7dWttA+sMh+auUpDvLM6pkQgWOinfbExvtx12GiAVv72aB/sqEo9SK3f1gH2cLBl4JeITKcu9qFERPUF+1AiouphP0pEVD2VCgY/99zzcHZ2NtyvKZK0/Pjjj2Pp0qXYsmULmjVrZjS/e/fusLW1xcaNGzF9+nQ17cyZM7h69Sr69u2L+uTA5QxEJ+dVenk7GysV6NUHfeUmgWA7G278iIiIiIiIiIiI6AaDwZMnTyn1vrk9+uijqhTE8uXL4erqaqgDLCOFOjo6qv/vvfdezJkzRw0qJ5eESPBYAsFlDR5XV8WmVC4QfHMvD9zWx1OVfrDVVG5QOSIiIiIiIiIiIqIqDyAn8vPzsWnTRly8eFE9btGiparRq9FoTNq4//znP+r/IUOGGE1fuHAh7r77bnX/o48+UpeCSGaw1A0aPXo0vvjiC9Q3vm6V+1OM6+yGtoEOZm8PERERERERERERWXgw+OrVK3j44YcQExODpk2bqmn//e83qkbv55//ByEhISZrXGXGtnNwcMDnn3+ubvVZ96ZO8He3QUxyXql1gyUHWObLckRERERERERERERVVeUCs/Pmva1G6vz774347bc/1G3Dho0IDg5W8+jGaKytMHeCv7pfvPiD/vHzE/zVckRERERERERERERmDwbv378fc+Y8DXd3D8M0Dw8PzJ49B/v376tyA6jQyFA3fDQzGH7uxgnbkhEs02U+ERERERERERERUY2UibC1tUV6enqJ6RkZGWoeVY8EfIe1d8WByxlqUDmpJSylIZgRTERERERERERERDWaGTx48BC89tqrOHr0iKrpK7cjR47gjTdew9Chw6rVGCoggd9ezZ0xvou7+p+BYCIiIiIiIiIiIqrxzOC5c1/Aiy/OxcyZt8PGpuDp+fn5GDJkKJ5/fm61G0REREREREREREREdSAY7ObmhgULPsfVq1dw8eJFNa158+YICWlihuYRERERERERERERUY0Gg7VaLRYu/B82b96M3Nxc9OnTBw8//AgcHBxM0hAiIiIiIiIiIiIiqgM1g7/++it88snHcHJygr+/H3766Ue8+eYbZmwaEREREREREREREdV4ZvCKFcvx0ksv45ZbblWPd+3aiUceeRivv/4GrK2rPA4dEREREREREREREdWgSkdxIyMjMXDgIMPjvn37wcrKCjExMeZqGxERERERERERERHVdDA4Pz8f9vb2RtNsbGyQl5dnqrYQERERERERERERUW2XidDpdHjxxRdgZ2dnmJaTk4PXX38Njo6OhmmffPKp6VtJRHVKYmICjh07iuTkJLi7e6Bjx07w9PSq7WYREREREREREZEpMoMnT54Mb28vuLq6GG4TJkyAn5+v0TQiatgkCPztt19j797dOHPmtPpfHh8/ftQk65fyM0lJSSZZ1+HDh/Hzzz/f0HMvXLiAbt26oWvXrli4cKHRvMuXL+PLL780mta0aVP1etV17733on379pg6dSpWrFiBJ598ssLnfPfdd5gyZUqp844fP67aRkRERERERERU6czgN99827wtIaJ6kRG8fv0adaVAcevWrUFwcKM6lSEswdlly5bhtttuq/Jzf//9d/Ts2RNfffVViXn6YPBDDz0EU4qOjlbB65SUFGg0GjVt0qRJJn0NIiIiIiIiIrJclQ4GE5Fl2LdvL/bv31vqvOzs7FIDwXq///4L8vLyS53Xo0cv9OzZq1JteP/997F69Wqkp6fj1VdfxcyZM6+3bR+ee+45FSyVOuYvvPACbr75ZsTGxqplZKBLySzu3r075s+fj1deeQXJycno0qUL+vTpUyKbNy0tDU888QT27i14v7Iueb0ffvgBH330kXqNPXv2YPHixSpbV0+CwFeuXFHrDQkJURm84s8//8TDDz+MqKgoleH70ksvqenyWF5HgsiZmZnqSos333zTqC2SDT106FBkZWWp9ksAOyAgQAWz5SZ+/PFHfPbZZ8jNzYWLiwsWLFiAzp07l/j8/v3vf2PRokVwc3PD2LFjK/WZExEREREREVHDx2AwERnJyclGWlrqDT03KysbWVmZZa63siSge+jQIVy8eBE9evRA//794eHhgQceeABr1qxBYGAg4uLiVBmHfv364ddff0WzZs3w119/qecnJCTAy8sLr7/+ulEwtbg33nhDBbiPHj2qgrQDBgxA27Ztcdddd6nXlgDtxx9/XOJ5ElSePXt2ibIQsvyuXbtU21q0aIF77rkHwcHBmDVrlgpcDx48WA26KSV2fvvtNxV81pP3J+9NAsz69Ur5B70dO3ZgyZIl2LZtmxrMc/v27bj99ttx4sQJozZIEF3WfeDAAbi6uuLOO++s9OdORET/3959gEdR7f8f/wZClwAC0kQigkgNoUUEAWkilyJSci8ICAhIv9IkIBAbIKgUjYAoKFeuV+4fEX4oKKCodGkiXgXpIh0koYck83++h2eXXbJJdlNIsvN+PU+eZGdmZ86U/Wyec86cAQAAAPwblcEA3OTOnUfuuqugx3lacXrjRmyS782bN48EBgYmuV5vPfvss+Z3+fLlpVGjRqYCtFixYqaC9vaernv37jW9frUn74gRI8zyrVq18mo7a9askTfffFNy5MghBQoUMJXAq1evlvDwcEkNrZxVWlYt+6FDh0wl79q1a80QEK49krXcvli2bJn89NNPEhYW5pymld5aie1Kt9WlSxfTK1j1799f1q9fn6r9AQAAAAAA/oXKYABudCiHpIZz0DGD9WFxSQ0V0alTeIaMGaw9hXWbVatWlY0bN3pcRnvTauWuDtUwfvx407M4NdtJi7x58zr/1jF/tRew41ht3rzZbb6vdD3aw3jSpEl3dJ8AAAAAAID/yJHZBQCQfWhFb6tWrU0F4+0/Oj29KoIXLFhgfusYuzocwqOPPmqGg9Cetlrh61oBHBsba6brGLraI1bH0d23b5/pfau9Y3XM4KQ0b95cPvjgA1PRquMT65i8LVu2TLF8Ka3XlZZLxwKeMmWKc9rx48fl2LFj4gt9kNzHH38sR48eNa8TEhJk27ZtHvdJh4m4ePGi2a/33nvPp+0AAAAAAAD/Rc9gAD6pVq2GlClzr/z8826Jjr4ghQoVlurVa6Rrj2B9cFtoaKipoJ01a5YEBwc7x8MdOXKkGQ5CH6KmD2/T8YDXrVsnb731lrM37rRp06RQoULSrFkz8zC6GjVqmMrk2x8gpz2I9cFu1atXN691DF+tUE6Jrk97KVerVs0MB+F4gFxS9GFuw4cPN8trxbkOSTF37ly59957vT4mWiE+depU6dChg9lHrQT/29/+ZsZUdtW6dWvzQDwdT5kHyAEAAAAAAFcBVlL3e9tITEyMqTjSnn6OcTYBAN4hQwEg9chQAEgbchQAfMMwEQAAAAAAAABgA1QGAwAAAAAAAIANUBkMAAAAAAAAADZAZTAAAAAAAAAA2ACVwQAAAAAAAABgA4GZXQAA2U98giXbD1+RMzFxUjwoUGoH55ecOQIyu1gAAAAAAABIBj2DAfhk9Z4YaTF1v/Sad1RGf3rc/NbXOv1OCw4Oll27dqXb+iIjI+XatWteLXvp0iUJCEh9Bfjy5cvl+eefT/X7AQAAAAAAfEVlMACvaYXv84v+lFPRcW7TT0fHmenpXSEcF+e+nYz20ksveV0ZnFbt2rWT6dOn35FtAQAAAAAAKCqDAXg9NMTkFafE8jDPMW3KilNmubTQ3rYTJ06UunXrSkREhJw+fVqeeuopqV69ulSrVk3mzp3rtvyiRYukdu3aUqFCBZk2bVqSvYbr1Kkj69atM3+/+uqrUrlyZalZs6b5OXLkiDz33HNm3qOPPmqm6XZvp9uuWLGihIaGJqrI/fHHH6Vp06ZmOzr/v//9r5l+5swZadmypSl/jRo1pFevXmb6hx9+KE8++aTz/brPug+63y+++KIpvzp8+LAULlzYzHfs55dffpmmYwwAAAAAAOyJMYMBOHV555Ccvei5N25sXIL8dSUhyfdqFfDJ6Dhp/No+yR3ouZ2pWMFAWTz4/hTLkTNnTlO5qsLDw6VSpUry2WefmQparRANCQmRhx9+2Mw/deqUbNu2Tc6dOye1atWSBg0ayCOPPJLkuv/66y9544035MSJE5IvXz65cuWK5MiRQ+bMmWMqe3/44QdT+Xq7PXv2mArZnTt3SqlSpWTs2LHOeRcuXJB+/fqZSlqdd/bsWVMWLcfixYvl/vvvl6+//tose/78+UTr/uKLL2TJkiVm3XfddZf07t3bbX50dLSpSNaey6tWrZJhw4ZJ69atUzyOAAAAAAAArugZDMBJK4JPxXj+Sa4i2JUul9Q6kqpovp1rZeiaNWukf//+5u977rnH9BLWaQ59+vQxvYmLFSuWaJ4nQUFBpnfv008/bSp/tXI2b968KZbpm2++kSeeeMJU9qoBAwY4523cuFEOHjxo5muv4ubNm5vpe/fuNZXWK1eulBEjRsiyZcukQIECida9du1a6dy5sxQsWNDsi+6TKy2f7puqX7++HDhwIMXyAgAAAAAA3I6ewQDceu4mJaWewQ5F8udItmewN7R3bFJSemibY35gYKDEx8c7pzvGAtZex5s3bzYVuDpshFbWfvLJJ2Z4CF+4lsOyLKlatapZpyc6XIVWUmvv5vHjx5sewN6uW+XJk8c5Tcvvul8AAAAAAADeojIYgFNyQzjoWMAtpu43D4vzNCqwVlWWKBQoX4+uIDlzJF9h6wvtZTtv3jx57bXXzPi7WqHqGI/XMfZu48aNTQ/fpUuXmopdpWPrbtmyxQwrsXXrVtNLV128eNH8aOWv/vzyyy+mclb/1p65OiSDp2EidDzgyZMny8mTJ6VkyZJmWAkHHQ7i0KFDpsLX0StYK4CrVKkif/75p5QpU0a6dOkirVq1Mr2bL126lGjdOuyE9h7WnsPz589Pt+MHAAAAAADgwDARALyiFbwRbUqYv2+v6nW8HtOmRLpWBKtZs2bJr7/+ah7A9thjj8m4ceMkLCzMOb948eKmwrdevXoyePBg53jB+pC4qKgoM76wVq5qz12llb2OB9LpOLw3btyQnj17mnlaGduiRQuPD5DTh9dFRkaaSmN9QJz21nUoUqSIGfd30qRJZntaCTxmzBhJSEgwvY+1fLpOLZs+5K5QoUJu627Tpo20b9/eLKMPkNPKaE8V0gAAAAAAAGkRYOn9zTYXExNjKme0kkjHEwWQtNV7YmTyilNyKvrW+L8lCwWaiuAW1fj8pJb2VtaeyRrJWil99epVmT17tmQHZCgApB4ZCgBpQ44CgG8YJgKAT7TCt2mVgrL98BU5ExMnxYMCpXZw/nTvEWw3PXr0kMOHD5uxjbUXs+swFAAAAAAAAOmBymAAPtOK33rlC2R2MfyKjncMAAAAAACQkRgzGAAAAAAAAABsgMpgAAAAAAAAALABKoMBAAAAAAAAwAaoDAYAAAAAAAAAG6AyGAAAAAAAAABswG8qg6OioiQ4OFjy5s0rYWFhsnXr1swuEgAAAAAAAABkGX5RGfzpp5/K8OHDZeLEibJjxw4JCQmRxx9/XE6fPp3ZRQMAAAAAAACALMEvKoPfeust6du3r/Tq1UuqVKkic+bMkfz588v8+fMzu2gAAAAAAAAAkCUESjYXGxsr27dvl4iICOe0HDlySPPmzWXTpk0e33P9+nXz4xAdHW1+X7hwQRISEu5AqQEg69IMLViwoAQEBHicT4YCQNLIUADIuAxV5CgApC1Hs31l8NmzZyU+Pl5KlCjhNl1f//bbbx7fM3nyZHnppZcSTS9XrlyGlRMAshP9pzooKMjjPDIUAJJHhgJAxmSoIkcBIG05GmBZliXZ2PHjx6VMmTKyceNGqV+/vnP66NGj5bvvvpMtW7ak2JKorYfnz5+XokWLJltzfifFxMRI2bJl5Y8//kj2BMJ/cM7tJaufb196tZGhyAo45/aTlc95ds/QrH58kf443/aTlc+5rz2Ds2KOZuXji4zBObeXmCx+vv2+Z3CxYsUkZ86ccurUKbfp+rpkyZIe35MnTx7z46pw4cKSFelFlRUvLGQczrm9ZMfzTYYiK+Oc2092O+fZKUOz4/FF2nC+7Sc7nvPslKPZ8fgibTjn9hKUTc93tn+AXO7cuaV27dqydu1at5ZBfe3aUxgAAAAAAAAA7Czb9wxWw4cPl549e0qdOnWkXr16MmPGDLl8+bL06tUrs4sGAAAAAAAAAFmCX1QGh4eHy5kzZ2TChAly8uRJqVmzpqxatSrRQ+WyE73tZeLEiYluf4H/4pzbC+c7Y3F87Ydzbj+c84zF8bUXzrf9cM4zFsfXfjjn9pInm5/vbP8AOQAAAAAAAACADcYMBgAAAAAAAACkjMpgAAAAAAAAALABKoMBAAAAAAAAwAaoDM5EkZGR5mF38F/PPPOMPPnkk5ldDGSiJk2ayD//+c/MLoZfIkP9HxkKMjTjkKH+jwyFIkczBhlqD+QomvhphlIZnE6+//57adu2rZQuXVoCAgLk888/z+wiIZ3Nnj1batSoIUFBQeanfv36snLlyswuFu7QZ/jGjRvywgsvSPXq1aVAgQJmuR49esjx48czrcz+hAz1f2SofyNDMxcZ6v/IUP9HjmYeMtQeyFH/Rob6hsrgdHL58mUJCQmRqKgoyepiY2MzuwjZ0r333itTpkyR7du3y7Zt26Rp06bSvn17+eWXXySr4Ryn/2f4ypUrsmPHDhk/frz5/dlnn8nevXulXbt2khVlt2uADPV/ZKh/I0MzFxnq/8hQ/0eOZh4y1B7IUf9GhvrIQrrTw7p06dIUl5s4caIVEhJiLVy40CpXrpwVFBRkhYeHWzExMc5lrl27Zg0ZMsQqXry4lSdPHqtBgwbW1q1bnfMXLFhgFSpUyG29um3XU+vYzrx586zg4GArICAg3fbV7ooUKWK9//77Sc7v2bOn1b59e2vatGlWyZIlrbvvvtsaOHCgFRsb61zm/PnzVvfu3a3ChQtb+fLls1q1amXt27cv0flzNX36dHPN3L6dV1991SpVqpQ5zyoqKsqqUKGCuXbuueceq2PHjul8BOz9GdbPoi575MiRJJdp3Lix+QyPGjXKXC8lSpQw59SVvr9du3ZWgQIFrIIFC1qdO3e2Tp48mej8uho2bJhZt+t2Bg0aZKYXLVrUatKkiZWQkGC2VbZsWSt37tzm2tCyZHVkqH2Qof6JDM1cZKh9kKH+ixzNPGSovZCj/okMTRk9gzPZgQMHTPf1FStWmJ/vvvvOtFY5jB49WpYsWSIfffSRab2oUKGCPP7443L+/HmftrN//36zHm392LVrVwbsib3Ex8fLf/7zH9P6pLeXJOfbb78151l/63n88MMPzY/rOETaMrl8+XLZtGmTfvNL69atzW0Mvli7dq1p2Vq9erW5lnSdQ4cOlZdfftlMX7VqlTRq1CjV+4zEoqOjzS0ohQsXTnY5Pe96K8qWLVtk6tSp5pzoeVIJCQmmRVo/0/r51+kHDx6U8PBwn8uj28mdO7ds2LBB5syZYz7z06dPl7lz58rvv/9uskZvi/EnZGj2RIZCkaGZjwzNnshQOJCjmYsMzb7IUYjdM9SLCmNkYGti/vz53VoPtbUhLCzM/H3p0iUrV65c1qJFi5zztQWqdOnS1tSpU31qTdT1nD59Ol32z852795tWnty5sxpjvsXX3yR7PLaAqQtfnFxcc5p2kqkrcZKWwz1XG3YsME5/+zZs6ZFcfHixT61JGoL1fXr153TlixZYlqoXa8vpN9n+OrVq1atWrWsrl27JructvA1bNjQbVrdunWtF154wfz99ddfm+vp6NGjzvm//PKLKYOj54C3LYmhoaFuy7z55pvWgw8+6NZynR2Qof6LDLUHMjRzkaH+iwy1D3I085Ch/o0ctQcyNGX0DM5kwcHBUrBgQefrUqVKyenTp83f2vqkrUkNGjRwzs+VK5fUq1dPfv31V5+2U65cOSlevHg6ltyeKlWqZFpjtUVowIAB0rNnT/nf//6X7HuqVq0qOXPm9HiO9TwGBgZKWFiYc37RokXNdnw9x9pCpK1IDi1atDDnvXz58tK9e3dZtGiRGScHaaefyy5duphWX30QQUr0QQWubr8GypYta34cqlSpYlonfb0Gateu7fa6c+fOcvXqVXMN9O3bV5YuXSpxcXHiT8jQ7IUMhSJDsw4yNHshQ+FAjmYNZGj2Q45C3SBDeYBcZtMvBFfaRV27mXsrR44c5gJ25el2BO3SjrTTcNbbe/RDOnnyZDNA+cyZM7PkOdZ/TPR2pE8++cSE1YQJE0x5L1y44PW2kfQXx5EjR8wtIPok2pRk1jWgX0h6S9G7774r+fLlk4EDB5pbi3y9ZSkrI0OzFzIUZGjWQoZmL2QoFDmadZCh2Q85CjL0JiqDs7AHHnjAOV6Ig570H3/80bQ0KG0hvHjxohnrxoFxhO4cDYDr16+n+v2VK1c2LTvaMulw7tw584F3PccnT550Cw9vz7G2UjZv3tyMa7N79245fPiwfPPNN6kur905vjh0vJ41a9aYVt+00mvgjz/+MD8O2jqtX/Ku18CJEyfc3uftNaBfGm3btpVZs2bJunXrzDhWP//8s9gBGZr1kaH2QoZmL2Ro1keG2g85mn2QodkDOWovZOgtgS5/Iw0uXbpkBnZ3OHTokDm5d999t9x3332pWqe2CuitC6NGjXKuR0NAbw3o06ePWUZvR8ifP7+MHTvWDC6uIeQ6mDnST0REhDzxxBPmPOiX9r///W/zYfzqq69Svc6KFSuawca1y78OCq6tf2PGjJEyZcqY6apJkyZy5swZc+47depkBo5fuXJlii1YOui8DlyuLUdFihSRL7/80nzZ6S0r8P0zrF8cevy1dVaPrT50QL/UlS7jekuPL/TLXW8J6tatm8yYMcP8M6Etfo0bN5Y6deqYZZo2bSrTpk2ThQsXmgccfPzxx7Jnzx4JDQ1Ndt2aBVpOR07o+/TLRG83ymrIUP9Hhvo3MjRzkaH+jwz1f+Ro5iFD7YEc9W9kqG/oGZxO9EmPeiIdJ3P48OHmb+3Knxb6NNKOHTuaMWJq1aplLm4NKw0Dx0WrF4QGg16AegtBZGRkuuwT3OmYMD169DDh26xZM9Oqq+dCx/JJiwULFpjbVNq0aWOCQVsM9Xw6bkXQlia9LSAqKsrcFrJ161YZOXJkiuvVMWr0ibMaPLoOfRqlXh865hF8/wz/+eef5gmxx44dk5o1a5pbdRw/GzduTPV29RaTZcuWmc+0ftHrl4mOCfTpp586l9GnDo8fP948kbhu3brmnxe9Fr25BubNm2fGKtNxjrT18//+7//SpQU0vZGh/o8M9W9kaOYiQ/0fGer/yNHMQ4baAznq38hQ3wToU+R8fA8AAAAAAAAAIJuhZzAAAAAAAAAA2ACVwQAAAAAAAABgA1QGAwAAAAAAAIANUBkMAAAAAAAAADZAZTAAAAAAAAAA2ACVwQAAAAAAAABgA1QGAwAAAAAAAIANUBkMAAAAAAAAADZAZTD8RsuWzeVf/1qYZdaT3badkoMHD0rXrn+XWrVqSseOHbx+39atW6VatSoSExOT7mWKinpHGjV61Kx/7do1Mm7cWBk6dHC6lu3zz5dK/fph6VRiIOsiQzMWGQr4P3I0Y5GjgH8jQzMWGQpXgW6v4Pf0w7Vs2efm78DAQAkKKiQPPvigtG7dWp58soPkyGGf9gENhddfnyKbNm1xm/6f/yyWfPny+e220xLUWrYVK76Q/PkLeFzmmWd6ykMPPSRjxkRkeHkOHDggs2e/KzNnzpKQkBBzLderFyaWZWX4tmFfZOgtZKhvyFDgJnL0FnLUN+QoQIa6IkN9Q4bCFZXBNtSwYUN59dXXJD4+Qc6dOyfr1/8gU6ZMltWrv5a3344yXyqZIT4+XgICAhJ9gd24ESu5cuW+Y+W4++6779i2stK2U/LHH39Io0aNpHTpMpJVyqOaNm1mrhuVO/edu05gX2Ro8shQz8hQ4BZyNHnkqGfkKHATGZo8MtQzMhSu7NNsBCf9gBUrVlxKlCghVapUkX79+svbb78jP/zwg3z++c1WRqVd7SdMGC+PPtpAwsLqSu/eveS3335zW9e6dd9KeHgXc6tBw4aPyNChQ5zzoqOjJSJijDzyyMNSp04tee65fnLkyOFE3fW//fYbadeujVnHiRMnzK0Vc+bMNu/V7UZGRprld+zYLj16PC21a4dKs2ZNZdKk1+TKlStJ7udHH30oHTq0l7p1a5vlX3nlZbly5bLzdoIXXxwnFy9eNLcV6I+2lHm6tePEieMyZMggsx4tz4gRz8vZs2ed8/V9epvF8uXLzXsffriejBw5Qi5fvrmt2/mybZ23ePGnMnDgAHMM27ZtI7t27ZKjR4+YVjstU7duXeXo0aNu2/jmm7XSuXNHc0xbtWop774bJXFxcUkeq4SEBNMq16zZYxIaGmL2R/+pcC3H//73izkvruW9vZV627Yf5eOP/+Xcrz///NM5X9/fpUtnsx9a5kOHDqW6zLr9wYMHmr+rV69qtuUog+ttJbpf8+a9J48/3sJcN0891UG+/vorSY5el82bNzXl1Ov5woULyS4P+yFDydDbkaG3kKHwBjlKjt6OHL2FHEVKyFAy9HZk6C1kqJcs2MrYsRHWkCGDPM576qknreee6+d83adPb2vQoIHWzz//bB0+fMiaOvV1q0GD+taFC3+Z+evWrbNq1Khmvf32LGv//v3Wr7/+ar333lzn+wcPHmi1bfs3a9u2H828fv36Wk888bgVGxtr5i9d+pkVElLd6tatq7Vjxw7r4MGD1pUrV6wWLZpZYWF1rQUL5ltHjhxx/tSpU8tauPAjUxZdvlOnp6xx4yKc29P36XwH/XvLls3WsWPHrM2bN1lt2rS2Xn75JTMvNva6tXDhQrOdM2dOm5/Lly8lWk98fLzVsWMHq3v3btaePXusn37aZXXu3Mnq2bOHczvvvPO2VbdubWvYsKHWvn37zP42bvyoNWPGdI/H2dttq6pVK1tNmzaxVq780jp06JA1ZMhgq2XL5lbv3s9Y69f/YI57165/t/r37+t8j25f1/3550uto0ePWhs2bDDviYp6J8nr4qOPPjTv+eKLL8x5ePPNN8y50WOttIzt27c114BreV3FxMRYXbv+w5o4cYJzv+Li4qwtW7aY/fjHP8KtrVu3Wvv3/2716PG0Oe+pLbNuX68fXa9jW56u7zlzZltt2vzNHCtdr74nNDTElEM5yhYdHW1e6/mtXr2q9cEH75vj/a9/LbTq1w+zHn64XpLHDvZChpKhnpChZCi8R46So56Qo+QovEOGkqGekKFkqK+oDLaZ5L48RowYbsJebd++zXyYr1+/7rZMq1YtrcWLPzV/a1CMHj3K47o0dPRDqSHv8Ndff1m1a4daq1atNK8dH379YnGlAaoh6Wr8+BetyMgJbtO0jPpBv3btmsfgvd1XX60yX34Oun1PoeC6Hg0x/YI8fvy4c76Gn5Z79+7dzi8P/WK7dOlWoL7xxjQTlknxZttKtzNr1kzn6127dplpS5b8P+c0DfxatWo6X/fp08vtS1wtX77MatKkUZLleeyxxtbcuXPcpoWHd7FeeeVlt38udF+To1+qkydPcpvmCOhNmzY6p3333TozzXHuUlPmNWtWm3UkdX3rtavnZefOnYmupVGjRnr88tDpzz3XP9Hngi8POJChZKgnZCgZCu+Ro+SoJ+QoOQrvkKFkqCdkKBnqK8YMhpM2DjjGatm7d6+5ZaNBg/puy1y/ft05tsvevb9Jp06dknxSpY5VVKNGDee0woULS3BwsJnnkCtXLqlUqVKi91etWtXttZZn3769smLFCrfpetvAsWPH5IEHHki0jk2bNsr7788zty9cunTJjGGk5b969arXg7ofPHhASpYsKaVKlXJOe+CBChIUFGT2o3r16mZa6dKlpUCBW4OwFy9eXM6fPy/pQR8I4FC0aFHzu2LFW9OKFStq9kv38a677jLHaufOnfLee3PdjlNS+67vO336tISG1nKbHhoaataVXh58sJLb8VHnz5+TUqVK+1xmb+itN/revn37uE2/ceOGVK5cOcnz3axZc7dpISE1ZcOG9T5vH/ZDhnraDzI0vZChsANy1NN+kKPphRyFvyNDPe0HGZpeyFD/QmUwnDQMy5S51/ytXxz6AV+w4MNEyxUsGGR+58mTJ83bzJs3r/MLy1X+/PndXmt5OnfuIk8//XSiZV2D3UHHthk0aKCEh/9dhg79pxQqVMiMUaRjJml4pPcTPm8fpF/3ScMvvdftOFa5crlu7+Y0x/b0WA0aNFiaN3cPwfQ6Z+m5HwkJVoaV2TH+1LvvzpESJe5xm3cnH2AA+yBDU48MTRkZCjsgR1OPHE0ZOQp/R4amHhmaMjLUv1AZDGPLls3y++/7pEePHuZ15cpVzKDqOXMGSpkyZZJsGdq8ebN06PBUonnly5c3g4Xv3r3btEgpHbj78OHDHlv9UlKlSmXTynPffeW8Wl4HN9cwHTVqtPNppl99tcptGW3F1NbF5JQv/4CcPHnSDITv+JI6cGC/GYw/Nfvhy7ZTS8+dtp56e6y09fGee+6RnTt3SN26dZ3TtWXP0VLqy34lJMRneJm9oS2++nAFPXeu+5XS+dZr1tXu3T+lW5ngv8hQz8hQMpQMhbfIUc/IUXKUHIU3yFDPyFAylAz1jMpgG4qNjZWzZ89IfHyCnDt3zjxlUm+/aNy4ibRr194sU79+fQkJCTFPchw+fKS5HURvPfj+++9Mt/tq1arJgAED5dlne0vZsmXliSdamzD84YfvpU+fZ6VcuWBp2rSpREZOkIkTIyV//gIyY8ZbJqQee6ypz2Xu3ftZ6dbtH/Laa69Kx44dTUvggQMHZNOmTTJu3IuJli9b9j7z5bVo0SJp0qSJCUJ9iqer0qXLmNamzZs3SaVKD5lWzdtbGPU4VKxYUcaMGS0vvBAh8fFx8sorr0idOnXNMUgtb7adWgMGDDCtqPpl17JlSwkIyGFu29i//3cZOnSYx/f06tXbPNFTj9tDDz1knsD522+/yuuvv+7TtvUfjd27fzYtudoarC24GVXmlOhtPs8800umTp0ilpVgbpvRW2j0S1K/MNu3fzLRe7p1e1q6d+8mCxbMN9fvhg0buKUEiZChN5Ght5ChN5Gh8BY5ehM5egs5ehM5Cm+QoTeRobeQoTeRod6jMtiG1q9fL02aNDbd/HWsHG0RjIgYaz5MjlY37fY/e/ZcmTlzhowfP86Ml1OsWDGpXbuOc5ybevXqyZtvTpe5c2fLBx+8bz6QOt/hlVdekylTJptQ0Fs5dN7s2XNMa5OvdByiBQs+klmzZkqPHt3NeEgadK1atfK4vAbg6NEvyPz578vMmdPNtocNe17Gjh3jXEZbOLt0CZeRI0eYVk79MtRbG1zpcXj77Xdk0qTXpGfP7ub4NGzYUCIixklaeLPt1GrQoKFERb0rs2fPlvnzPzDn+f7775eOHT2PB+UIzYsXL8obb0w1/1BoK+k770SZfwJ8oWE9blyEtG/fVq5duyZffbU6w8rsjSFDhkqRInebf450bCy93rXVsm/ffh6X13+YIiNfkqioKPNl+vDD9aVfv/4yd+6cNJUD/oUMvYkMvYUMvYkMhbfI0ZvI0VvI0ZvIUXiDDL2JDL2FDL2JDPVegD5FzoflAQAAAAAAAADZ0M1mIwAAAAAAAACAX6MyGAAAAAAAAABsgMpgAAAAAAAAALABKoMBAAAAAAAAwAaoDAYAAAAAAAAAG6AyGAAAAAAAAABsgMpgAAAAAAAAALABKoMBAAAAAAAAwAaoDAYAAAAAAAAAG6AyGAAAAAAAAABsgMpgAAAAAAAAABD/9/8BVH6mAjncvUgAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -596,10 +596,10 @@ "id": "2050e0b0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:06:05.220711Z", - "iopub.status.busy": "2026-11-14T08:06:05.220711Z", - "iopub.status.idle": "2026-11-14T08:06:06.221219Z", - "shell.execute_reply": "2026-11-14T08:06:06.221219Z" + "iopub.execute_input": "2026-11-14T15:43:48.272688Z", + "iopub.status.busy": "2026-11-14T15:43:48.272688Z", + "iopub.status.idle": "2026-11-14T15:43:49.335684Z", + "shell.execute_reply": "2026-11-14T15:43:49.335684Z" } }, "outputs": [ diff --git a/docs/examples/tradespace/EvaluateTradeSpace.ipynb b/docs/examples/tradespace/EvaluateTradeSpace.ipynb index 07b7933f..0c6a515d 100644 --- a/docs/examples/tradespace/EvaluateTradeSpace.ipynb +++ b/docs/examples/tradespace/EvaluateTradeSpace.ipynb @@ -35,10 +35,10 @@ "id": "bc7b296c", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:05:20.754477Z", - "iopub.status.busy": "2026-11-14T08:05:20.754477Z", - "iopub.status.idle": "2026-11-14T08:05:22.879382Z", - "shell.execute_reply": "2026-11-14T08:05:22.879382Z" + "iopub.execute_input": "2026-11-14T15:43:03.292530Z", + "iopub.status.busy": "2026-11-14T15:43:03.292530Z", + "iopub.status.idle": "2026-11-14T15:43:05.430329Z", + "shell.execute_reply": "2026-11-14T15:43:05.430329Z" } }, "outputs": [], @@ -84,10 +84,10 @@ "id": "c05d366a", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:05:22.879382Z", - "iopub.status.busy": "2026-11-14T08:05:22.879382Z", - "iopub.status.idle": "2026-11-14T08:05:22.990678Z", - "shell.execute_reply": "2026-11-14T08:05:22.990678Z" + "iopub.execute_input": "2026-11-14T15:43:05.430329Z", + "iopub.status.busy": "2026-11-14T15:43:05.430329Z", + "iopub.status.idle": "2026-11-14T15:43:05.540746Z", + "shell.execute_reply": "2026-11-14T15:43:05.540746Z" } }, "outputs": [ @@ -163,10 +163,10 @@ "id": "374124d4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:05:22.990678Z", - "iopub.status.busy": "2026-11-14T08:05:22.990678Z", - "iopub.status.idle": "2026-11-14T08:05:23.006799Z", - "shell.execute_reply": "2026-11-14T08:05:23.006799Z" + "iopub.execute_input": "2026-11-14T15:43:05.540746Z", + "iopub.status.busy": "2026-11-14T15:43:05.540746Z", + "iopub.status.idle": "2026-11-14T15:43:05.556674Z", + "shell.execute_reply": "2026-11-14T15:43:05.556674Z" } }, "outputs": [], @@ -226,10 +226,10 @@ "id": "8967e528", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:05:23.006799Z", - "iopub.status.busy": "2026-11-14T08:05:23.006799Z", - "iopub.status.idle": "2026-11-14T08:05:23.612875Z", - "shell.execute_reply": "2026-11-14T08:05:23.612875Z" + "iopub.execute_input": "2026-11-14T15:43:05.556674Z", + "iopub.status.busy": "2026-11-14T15:43:05.556674Z", + "iopub.status.idle": "2026-11-14T15:43:06.186322Z", + "shell.execute_reply": "2026-11-14T15:43:06.186322Z" } }, "outputs": [ @@ -376,10 +376,10 @@ "id": "9e23a64a", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:05:23.612875Z", - "iopub.status.busy": "2026-11-14T08:05:23.612875Z", - "iopub.status.idle": "2026-11-14T08:05:23.888781Z", - "shell.execute_reply": "2026-11-14T08:05:23.888781Z" + "iopub.execute_input": "2026-11-14T15:43:06.186322Z", + "iopub.status.busy": "2026-11-14T15:43:06.186322Z", + "iopub.status.idle": "2026-11-14T15:43:06.454940Z", + "shell.execute_reply": "2026-11-14T15:43:06.454940Z" } }, "outputs": [ @@ -522,10 +522,10 @@ "id": "6f877e2d", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:05:23.890781Z", - "iopub.status.busy": "2026-11-14T08:05:23.889781Z", - "iopub.status.idle": "2026-11-14T08:05:24.035704Z", - "shell.execute_reply": "2026-11-14T08:05:24.034695Z" + "iopub.execute_input": "2026-11-14T15:43:06.454940Z", + "iopub.status.busy": "2026-11-14T15:43:06.454940Z", + "iopub.status.idle": "2026-11-14T15:43:06.613586Z", + "shell.execute_reply": "2026-11-14T15:43:06.613586Z" } }, "outputs": [ @@ -582,10 +582,10 @@ "id": "523cddaa", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:05:24.036707Z", - "iopub.status.busy": "2026-11-14T08:05:24.036707Z", - "iopub.status.idle": "2026-11-14T08:05:24.190048Z", - "shell.execute_reply": "2026-11-14T08:05:24.190048Z" + "iopub.execute_input": "2026-11-14T15:43:06.613586Z", + "iopub.status.busy": "2026-11-14T15:43:06.613586Z", + "iopub.status.idle": "2026-11-14T15:43:06.754482Z", + "shell.execute_reply": "2026-11-14T15:43:06.754482Z" } }, "outputs": [ diff --git a/docs/examples/tradespace/ExplainTradeSpace.ipynb b/docs/examples/tradespace/ExplainTradeSpace.ipynb index e94e69a8..955af84b 100644 --- a/docs/examples/tradespace/ExplainTradeSpace.ipynb +++ b/docs/examples/tradespace/ExplainTradeSpace.ipynb @@ -36,10 +36,10 @@ "id": "99a62858", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:05:26.361507Z", - "iopub.status.busy": "2026-11-14T08:05:26.361507Z", - "iopub.status.idle": "2026-11-14T08:05:29.440369Z", - "shell.execute_reply": "2026-11-14T08:05:29.439834Z" + "iopub.execute_input": "2026-11-14T15:43:08.922061Z", + "iopub.status.busy": "2026-11-14T15:43:08.922061Z", + "iopub.status.idle": "2026-11-14T15:43:12.082392Z", + "shell.execute_reply": "2026-11-14T15:43:12.082392Z" } }, "outputs": [], @@ -102,10 +102,10 @@ "id": "7326121b", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:05:29.442416Z", - "iopub.status.busy": "2026-11-14T08:05:29.441905Z", - "iopub.status.idle": "2026-11-14T08:05:29.581444Z", - "shell.execute_reply": "2026-11-14T08:05:29.581444Z" + "iopub.execute_input": "2026-11-14T15:43:12.082392Z", + "iopub.status.busy": "2026-11-14T15:43:12.082392Z", + "iopub.status.idle": "2026-11-14T15:43:12.224209Z", + "shell.execute_reply": "2026-11-14T15:43:12.224209Z" } }, "outputs": [ @@ -157,10 +157,10 @@ "id": "715976e0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:05:29.581444Z", - "iopub.status.busy": "2026-11-14T08:05:29.581444Z", - "iopub.status.idle": "2026-11-14T08:05:29.613359Z", - "shell.execute_reply": "2026-11-14T08:05:29.613359Z" + "iopub.execute_input": "2026-11-14T15:43:12.224209Z", + "iopub.status.busy": "2026-11-14T15:43:12.224209Z", + "iopub.status.idle": "2026-11-14T15:43:12.240256Z", + "shell.execute_reply": "2026-11-14T15:43:12.240256Z" } }, "outputs": [ @@ -232,7 +232,7 @@ " \n", " \n", " 1075\n", - " 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00\n", + " 800 km, 60 deg FOR, SSO: 1 at 09:00, 2 at 15:00\n", " 3.0\n", " 2.0\n", " 28.8\n", @@ -259,7 +259,7 @@ " \n", " \n", " 1081\n", - " 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00\n", + " 800 km, 60 deg FOR, SSO: 2 at 09:00, 2 at 15:00\n", " 4.0\n", " 2.0\n", " 57.6\n", @@ -321,10 +321,10 @@ "1047 800 km, 60 deg FOR, SSO: 2 at 06:00 2.0 1.0 \n", "963 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... 2.0 2.0 \n", "1019 800 km, 60 deg FOR, Walker 75 deg: 1 x 3 (spac... 3.0 1.0 \n", - "1075 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3.0 2.0 \n", + "1075 800 km, 60 deg FOR, SSO: 1 at 09:00, 2 at 15:00 3.0 2.0 \n", "1001 800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac... 3.0 3.0 \n", "1020 800 km, 60 deg FOR, Walker 75 deg: 1 x 4 (spac... 4.0 1.0 \n", - "1081 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4.0 2.0 \n", + "1081 800 km, 60 deg FOR, SSO: 2 at 09:00, 2 at 15:00 4.0 2.0 \n", "758 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... 6.0 3.0 \n", "1045 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... 8.0 4.0 \n", "1035 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... 9.0 3.0 \n", @@ -394,10 +394,10 @@ "id": "92827f66", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:05:29.615364Z", - "iopub.status.busy": "2026-11-14T08:05:29.615364Z", - "iopub.status.idle": "2026-11-14T08:05:29.708263Z", - "shell.execute_reply": "2026-11-14T08:05:29.708263Z" + "iopub.execute_input": "2026-11-14T15:43:12.242261Z", + "iopub.status.busy": "2026-11-14T15:43:12.242261Z", + "iopub.status.idle": "2026-11-14T15:43:12.319088Z", + "shell.execute_reply": "2026-11-14T15:43:12.319088Z" } }, "outputs": [ @@ -447,7 +447,7 @@ " 2.0\n", " \n", " \n", - " 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00\n", + " 800 km, 60 deg FOR, SSO: 2 at 09:00, 2 at 15:00\n", " 57.6\n", " 85.4\n", " 5.9\n", @@ -462,27 +462,27 @@ " sufficient (%) \\\n", "design \n", "800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spaci... 68.2 \n", - "800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 57.6 \n", + "800 km, 60 deg FOR, SSO: 2 at 09:00, 2 at 15:00 57.6 \n", "\n", " accurate (%) \\\n", "design \n", "800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spaci... 26.8 \n", - "800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 85.4 \n", + "800 km, 60 deg FOR, SSO: 2 at 09:00, 2 at 15:00 85.4 \n", "\n", " median revisit (h) \\\n", "design \n", "800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spaci... 0.4 \n", - "800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 5.9 \n", + "800 km, 60 deg FOR, SSO: 2 at 09:00, 2 at 15:00 5.9 \n", "\n", " median longest gap (h) \\\n", "design \n", "800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spaci... 13.8 \n", - "800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 7.6 \n", + "800 km, 60 deg FOR, SSO: 2 at 09:00, 2 at 15:00 7.6 \n", "\n", " median 3-h intervals sampled \n", "design \n", "800 km, 60 deg FOR, Walker 45 deg: 1 x 4 (spaci... 2.0 \n", - "800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4.0 " + "800 km, 60 deg FOR, SSO: 2 at 09:00, 2 at 15:00 4.0 " ] }, "execution_count": 4, @@ -531,16 +531,16 @@ "id": "5555b886", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:05:29.708263Z", - "iopub.status.busy": "2026-11-14T08:05:29.708263Z", - "iopub.status.idle": "2026-11-14T08:05:29.866894Z", - "shell.execute_reply": "2026-11-14T08:05:29.866894Z" + "iopub.execute_input": "2026-11-14T15:43:12.319088Z", + "iopub.status.busy": "2026-11-14T15:43:12.319088Z", + "iopub.status.idle": "2026-11-14T15:43:12.476747Z", + "shell.execute_reply": "2026-11-14T15:43:12.476404Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -598,10 +598,10 @@ "id": "40126ee8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:05:29.866894Z", - "iopub.status.busy": "2026-11-14T08:05:29.866894Z", - "iopub.status.idle": "2026-11-14T08:05:29.899159Z", - "shell.execute_reply": "2026-11-14T08:05:29.899159Z" + "iopub.execute_input": "2026-11-14T15:43:12.477750Z", + "iopub.status.busy": "2026-11-14T15:43:12.477750Z", + "iopub.status.idle": "2026-11-14T15:43:12.508123Z", + "shell.execute_reply": "2026-11-14T15:43:12.508123Z" } }, "outputs": [ @@ -731,10 +731,10 @@ "id": "b1adf213", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:05:29.899159Z", - "iopub.status.busy": "2026-11-14T08:05:29.899159Z", - "iopub.status.idle": "2026-11-14T08:05:29.994743Z", - "shell.execute_reply": "2026-11-14T08:05:29.994743Z" + "iopub.execute_input": "2026-11-14T15:43:12.508123Z", + "iopub.status.busy": "2026-11-14T15:43:12.508123Z", + "iopub.status.idle": "2026-11-14T15:43:12.602035Z", + "shell.execute_reply": "2026-11-14T15:43:12.602035Z" } }, "outputs": [ diff --git a/docs/examples/tradespace/PlanDeployment.ipynb b/docs/examples/tradespace/PlanDeployment.ipynb index 1ab78d9a..de7f0343 100644 --- a/docs/examples/tradespace/PlanDeployment.ipynb +++ b/docs/examples/tradespace/PlanDeployment.ipynb @@ -38,10 +38,10 @@ "id": "6bc87f54", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:06:13.952822Z", - "iopub.status.busy": "2026-11-14T08:06:13.952822Z", - "iopub.status.idle": "2026-11-14T08:06:16.845691Z", - "shell.execute_reply": "2026-11-14T08:06:16.845691Z" + "iopub.execute_input": "2026-11-14T15:43:56.501748Z", + "iopub.status.busy": "2026-11-14T15:43:56.501748Z", + "iopub.status.idle": "2026-11-14T15:43:59.159942Z", + "shell.execute_reply": "2026-11-14T15:43:59.159942Z" } }, "outputs": [ @@ -229,7 +229,7 @@ "id": "14ec3893", "metadata": {}, "source": [ - "The phases of three of these designs over their missions, from the start of development, for the points of the first replicate (`phases_of` gives the metrics of each phase of a design's planned deployment, as the study evaluates them):" + "The phases of three of these designs over their missions, from the start of development, for the points of the first replicate (`mission_of(design).phases()` gives the metrics of each phase of a design's planned deployment, as the study evaluates them):" ] }, { @@ -238,10 +238,10 @@ "id": "c7af361b", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:06:16.845691Z", - "iopub.status.busy": "2026-11-14T08:06:16.845691Z", - "iopub.status.idle": "2026-11-14T08:06:17.352993Z", - "shell.execute_reply": "2026-11-14T08:06:17.352993Z" + "iopub.execute_input": "2026-11-14T15:43:59.159942Z", + "iopub.status.busy": "2026-11-14T15:43:59.159942Z", + "iopub.status.idle": "2026-11-14T15:43:59.716373Z", + "shell.execute_reply": "2026-11-14T15:43:59.716373Z" } }, "outputs": [ @@ -268,7 +268,7 @@ "for color, (satellites, planes) in zip(COLORS, [(4, 1), (4, 2), (6, 2)]):\n", " key = leaders[(leaders.satellites == satellites) & (leaders.planes == planes)].index[0]\n", " (design,) = cost_space.designs_of(summary, [key])\n", - " phases = cost_study.phases_of(design) # the metrics of each phase of the planned deployment, as it evaluates them\n", + " phases = cost_study.mission_of(design).phases() # the metrics of each phase of the planned deployment\n", " edges = [*phases.start, phases.end.iloc[-1]]\n", " ax.stairs(\n", " phases.sufficient,\n", @@ -334,10 +334,10 @@ "id": "eec3e4ab", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:06:17.352993Z", - "iopub.status.busy": "2026-11-14T08:06:17.352993Z", - "iopub.status.idle": "2026-11-14T08:06:17.449071Z", - "shell.execute_reply": "2026-11-14T08:06:17.449071Z" + "iopub.execute_input": "2026-11-14T15:43:59.718378Z", + "iopub.status.busy": "2026-11-14T15:43:59.718378Z", + "iopub.status.idle": "2026-11-14T15:43:59.764094Z", + "shell.execute_reply": "2026-11-14T15:43:59.764094Z" } }, "outputs": [ @@ -392,17 +392,17 @@ " \n", " at once\n", " 62.6\n", - " 77.9\n", - " 91.0\n", + " 77.7\n", + " 90.8\n", " 156.4\n", " 156.4\n", " 156.4\n", " \n", " \n", " first plane\n", - " 4.8\n", - " 10.0\n", - " 73.0\n", + " 5.0\n", + " 8.4\n", + " 71.4\n", " 118.8\n", " 118.8\n", " 118.8\n", @@ -410,17 +410,17 @@ " \n", " decided at launch\n", " 62.6\n", - " 77.9\n", - " 73.0\n", + " 77.7\n", + " 71.4\n", " 156.4\n", " 156.4\n", " 118.8\n", " \n", " \n", " decided a year later\n", - " 49.7\n", - " 62.8\n", - " 73.0\n", + " 49.8\n", + " 62.3\n", + " 71.4\n", " 154.5\n", " 154.5\n", " 118.8\n", @@ -428,8 +428,8 @@ " \n", " measured at launch\n", " 62.6\n", - " 77.9\n", - " 73.0\n", + " 77.7\n", + " 71.4\n", " 156.4\n", " 156.4\n", " 118.8\n", @@ -442,11 +442,11 @@ " accurate mission cost present \\\n", "scenario 1 hour 3 hours 12 hours 1 hour 3 hours \n", "staging \n", - "at once 62.6 77.9 91.0 156.4 156.4 \n", - "first plane 4.8 10.0 73.0 118.8 118.8 \n", - "decided at launch 62.6 77.9 73.0 156.4 156.4 \n", - "decided a year later 49.7 62.8 73.0 154.5 154.5 \n", - "measured at launch 62.6 77.9 73.0 156.4 156.4 \n", + "at once 62.6 77.7 90.8 156.4 156.4 \n", + "first plane 5.0 8.4 71.4 118.8 118.8 \n", + "decided at launch 62.6 77.7 71.4 156.4 156.4 \n", + "decided a year later 49.8 62.3 71.4 154.5 154.5 \n", + "measured at launch 62.6 77.7 71.4 156.4 156.4 \n", "\n", " \n", "scenario 12 hours \n", @@ -489,7 +489,7 @@ "staged_study = phased_study.replace(\n", " space=staging_space, metrics=sample_field, plan=dataclasses.replace(PLAN, stages=stages), scenarios=FIELDS\n", ")\n", - "(four,) = cost_space.designs_of(summary[summary.description == \"800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00\"])\n", + "(four,) = cost_space.designs_of(summary[summary.description == \"800 km, 60 deg FOR, SSO: 2 at 09:00, 2 at 15:00\"])\n", "staged = staged_study.run([staging_space.design(four, staging=option) for option in STAGING])\n", "staged.groupby([\"staging\", \"scenario\"], sort=False)[[\"accurate mission\", \"cost present\"]].mean().unstack(\n", " \"scenario\"\n", @@ -510,16 +510,16 @@ "id": "37d6f8ba", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:06:17.449071Z", - "iopub.status.busy": "2026-11-14T08:06:17.449071Z", - "iopub.status.idle": "2026-11-14T08:06:17.607637Z", - "shell.execute_reply": "2026-11-14T08:06:17.607637Z" + "iopub.execute_input": "2026-11-14T15:43:59.765601Z", + "iopub.status.busy": "2026-11-14T15:43:59.765601Z", + "iopub.status.idle": "2026-11-14T15:43:59.891361Z", + "shell.execute_reply": "2026-11-14T15:43:59.891361Z" } }, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABFcAAAFfCAYAAACLNSM3AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAanlJREFUeJzt3Qm8TPX/x/HPtcuaNVJpkUh2lQhFUVqUVFKW9iitRIu09yNpEVGK9pBSoaLk12ZJVLIkEUUUIvpZ7r3n/3h/+880M+auc5c5M6/n43HdO+fMnDmbOd/5nM/3803xPM8zAAAAAAAA5EqR3L0MAAAAAAAAQnAFAAAAAAAgBgRXAAAAAAAAYkBwBQAAAAAAIAYEVwAAAAAAAGJAcAUAAAAAACAGBFcAAAAAAABiQHAFhcbzPNuxY4f7DQAACg/XZAAAYkNwBYXmr7/+sgoVKtj27dsLe1USXnp6um3c+Iv7jfzH/i447OuCw74uOIWxjwPXZP0uTIl8nrFt/pXI28e2+VMib5uft4/gCgAAAAAAQAwIrgAAAAAAAMSA4AoAAAAAAEAMCK4AAAAAAADEgOAKAAAAAABADAiuAAAAAAAAxIDgCgAAAAAAQAyKxfJiAAD8ZF+aF/y7eNGUQl0XAAAAJE5bj+AKACDhpaZ5pkvtrKU7bO0fe612lRJ2WoPypktuMYIsAAAAvpYaB209gisAgIS/2K7cuNv6Tlxvf+xMC06vUnaTje51iNWtUYoACwAAgE+lxklbj5orAICEprsYkRdb0WNN/zd5FAAAAH7jxUlbj+AKACCh+90qPTTyYhug6Zof2j8XAAAA/rAvjtp6BFcAAAlN/W5jmQ8AAID4tTZO2noEVwAACU0FzWKZDwAAgPhVO07aegRXAAAJS0PwqVJ8lbJFo87XdM1nWGYAAAD/KR5HbT2CKwCAhKZLqSrFR1509VjTCasAAAD4V0qctPUYihkAkNA09J6G4Js9qI4raKZ+t0oP1V0MXWwZhhkAAMC/isVJW4/gCgAg4QUuqrrIBtAVCAAAIDEUi4O2HsEVAEDSIKACAACQuIoXYluP4AoAAEnMS0s18zyzlBRLKUqzAAAA+JdXiO0aWlEAACRx42PP4o8tffM6K1LtUCvZtL2bR5AFAAD4iRcH7RpaTz6ydu1aO/zww23x4sXWuHHjwl4dAICPGyCpv6yyHaNvNm/HluD0XVNGWvm+I61YrToEWAAAgC94cdKuYShmAACSjeft1wBxk3dscdMBAAB8w4uPdg3BlTjy/vvvW+vWra1ixYpWuXJlO+uss2z16tXB+cpakSZNmlhKSoq1a9cuw2XNnTvXjj/+eCtZsqTVqFHDBg0aZKmpqcH5em3//v1t4MCBVqlSJTvooINs6NChYcv4888/7ZprrrHq1atbqVKlrEGDBvbee+8F53/22Wd28sknW+nSpe2QQw5xy9u1a1eG67Rnzx7bsWNH2A8AoODv7ihlNrIBEpy/Y4vt+fqjf9JrkbC4JgMAEoEXR+0agitxRIGJW265xb766iv76KOPrEiRInbeeedZenq6m79gwQL3e/bs2bZx40abOnVq1OX8+uuvduaZZ1qLFi3sm2++sTFjxtj48ePtgQceCHvexIkTrUyZMjZ//nwbNmyY3XfffTZr1iw3T+95xhln2Oeff24vv/yyLVu2zB555BErWrSom6+gT6dOnaxr16727bff2htvvOGCLddff32G2/fwww9bhQoVgj8KyAAACpjnub7ImXHzVQwOCYtrMgAgIXjx066hQ3UcUaAi1PPPP29Vq1Z1gQ1ljehvUVaLMk0yMnr0aNdIGjVqlMtwOeaYY2zDhg12++2325AhQ1zQRho2bGj33HOP+7tOnTru+QrqnHbaaS6Ao2DO8uXL7eijj3bPOeKII8IaZT169LCbbrop+Ponn3zS2rZt64I5ynSJNHjwYBc8CtBdMhpzAFDAUlJckbfMuPkpDFudyLgmAwASQkr8tGvIXIkjq1atsu7du7sgRvny5a127dpu+rp1mUfiIikg0rJlSxdYCWjVqpXt3LnTfvnll+A0BVdCqfvQ5s2b3d9LliyxWrVqBQMrkZQRM2HCBCtbtmzwp2PHji7jZc2aNVFfoy5K2q7QHwBAwVJBN1XPTylfOfr88pX/mU9B24TGNRkAkAhS4qhdQ3Aljpx99tm2detWe/bZZ11XHf3I3r178+X9ihcvHvZYwZhAFyTVUcmMAjWqx6IgTOBHARcFiI488sh8WV8AQN5R9fzIhogeazoAAICflI+Ddg23peLEli1bbOXKlS6woiKxohomoUqUKOF+p6WlZbqsevXq2Ztvvmme5wWzV1Q7pVy5ci4bJTuU1aIslx9++CFq9krTpk1dd6Wjjjoq29sIAIgPunujYQkrPfiuKwKnvshKmdWdncB8AAAAP0iJk3YNrac4ceCBB7paKuPGjXPdc9QVSCP8hKpWrZrLKNGoQgqSqK6JitBF6tu3rz3++ON2ww03uAKzCtqotor6VgfqrWRFtVPatGnj6sA89thjLoiyYsUKF6xRIVvVbznxxBPd8q+88kpXGFfBFhXEVe0WAEB8CzQ0XMNDRd5SUgiqAAAAX0qJg3YN3YLihIIer7/+ui1atMgVr7355ptt+PDhYc8pVqyYKxo7duxYq1mzpp177rlRl3XwwQfbjBkzXEHaRo0a2bXXXmtXXHGF3XXXXTlaJ2W/aMQh1YGpX7++G7Y5kDWjzBYN96zMFmXaaHhoFcvVegEA/EMNj5RixQmsAAAA30spxHZNiqe+I0Ah0MgEyrzZtm2bVaxYsbBXJ6Gpls6mTRusevWa2c5eQu6xvwsO+7rgJMq+3pf+b9fa4kWKWrzu64Lex4Fr8vbt2wu1uG2inGfRsG3+lcjbx7b5UyJvW6zbV5jXeW5TAQCAhJeanm7p5tmMX5faml1b7PAyla3zwQ0sxVKsWAI2TAEASCapcXCdJ7gCAAASvsG1bPtG6zXvRft9z87g9HuXzrCJJ/a0+hVqEGABAMCnUuPkOk9LAgAAJDTdyYpscIkea7pn9JAGAMCv0uPkOk9wBQAAJCz1vVaKcGSDK0DTp/+6NKyPNgAA8Id9cXSdJ7gCAAASmvpexzIfAADErzVxcp0nuAIAABKaitrFMh8AAMSvw+PkOk9wBQAAJCwNw6jRAqqWLBt1vqZrfrwOywwAAPxxnSe4AgAAEpqGYdRoAZENLz3WdM0HAAD+lBIn13mGYgYAAAlNwy9qGMb5HQe6onfqe60UYd3JUoOLYZgBAPCvYnFynSe4AgAAEl6gYaWGVgBdgQAASAzF4uA6T3AFAAAkDQIqAAAkruKFeJ0nDxYAAAAAACAGBFcAAAAAAABiQHAFAAAAAAAgBgRXAAAAAAAAYkBwBQAAAAAAIAYEVwAAAAAAAGJAcAUAAAAAACAGBFcAAAAAAABiQHAFAAAAAAAgBgRXAAAAAAAAYkBwBQAAAAAAIAYEVwAAAAAAAGJAcAUAAAAAACAGBFcAAAAAAABiQHAFAAAAAAAgBgRXAAAAAAAAYkBwBQAAAAAAIAYEVwAAAAAAAGJAcAUAAAAAACAGBFcAAAAAAABiQHAFAAAAAAAgBgRXAAAAAAAAYkBwBQAAAAAAIAYEVwAAAAAAAGJQLJYXA/FoX5oX/Lt40ZRCXRcAAJIV12MAQDIhuIKEkZrmmZpxs5busLV/7LXaVUrYaQ3Km5pzxWjUAQBQILgeAwCSEcEVJExDbuXG3dZ34nr7Y2dacHqVsptsdK9DrG6NUjToAADIZ1yPAQDJiporSAi6QxbZkBM91vR/E5MBAEB+4XoMAEhWBFeQEH26lXoc2ZAL0HTND+37DQAA8hbXYwBAMiO4goSgPt2xzAcAALHjegwASFYEV5AQVCwvlvkAACB2XI8BAMmK4Ap8T8M7ahSCKmWLRp2v6ZrPMJAAAOQfrscAgGRGcAUJQc00jUIQ2aDTY02nGQcAQP7jegwASFYMxYyEoGEdNbzj7EF1XLE89elW6rHukKkhx7CPAADkP67HAIBkRXAFCSPQYFMDLoDUYwAAChbXYwBAMiK4goRDAw4AgMLH9RgAkEyouZIHPM+zq6++2ipVqmQpKSm2ZMkSa9eund10000WDz755BO3Xn/++Wdhr0pC8NJSzUvd534DAIDouF4CAJIJmSt54P3337cJEya4IMYRRxxhVapUsalTp1rx4sVjWq4CIm+99ZZ16dIlz9YVuecah55nexZ/bOmb11mRaodayabt3byUovxXAgBAuF4CAJIRV7g8sHr1aqtRo4addNJJwWnKYsnM3r17rUSJEgWwdsirhmLqL6tsx+ibzduxJTh915SRVr7vSCtWqw4NRgBA0uN6CQBIVnQLilHv3r3thhtusHXr1rlMk9q1a7vpkd2CNP3++++3nj17Wvny5V03IgVYrr/+eheYKVWqlB122GH28MMPB58v5513XthyI61du9bNf/31111wR8tp0KCBzZ07N8N13rJli3Xv3t0OPvhgO+CAA+y4446z1157Lew5Wv/+/fvbwIEDXaDooIMOsqFDh4Y9R92MrrzySqtatarbplNPPdW++eYbS0iet19D0U3escVNBwAAXC8BAMmL4EqMnnjiCbvvvvusVq1atnHjRlu4cGGGz3300UetUaNGtnjxYrv77rvtySeftHfeeccmTZpkK1eutFdeeSUYRAks54UXXshyuTJgwAC79dZb3bJbtmxpZ599tguiRLN7925r1qyZTZ8+3ZYuXeoCPZdddpktWLAg7HkTJ060MmXK2Pz5823YsGFuO2fNmhWc361bN9u8ebPNnDnTFi1aZE2bNrX27dvb1q1bo77vnj17bMeOHWE/frkLp9TmyIZicP6OLbbn64/oUw4A8I38uCZzvQQAJDOCKzGqUKGClStXzooWLeqyO5TFkRFldigAcuSRR7ofZbvUqVPHWrdu7bJW9FsZJRJYTsWKFbNcrigDpmvXrlavXj0bM2aMW6/x48dHfa4yVm677TZr3LixqxGjzJtOnTq5IE+ohg0b2j333OPWURk3zZs3t48++sjN++yzz1wwZvLkyW66nqPgkdZ3ypQpUd9XWTlar8DPIYccYr7gea7PeGbcfM8rsFUCACAW+XJN5noJAEhiBFcKkIIQkV2KNLJQ3bp1XRecDz/8MNfLVrZKQLFixdx7LV++POpz09LSXBcldQdSl5+yZcvaBx984II9kcGVUOq+pEwVUfefnTt3WuXKld3rAz9r1qxxNWiiGTx4sG3fvj34s379evOFlBRXjC8zbn4KQ04CAPwhX67JXC8BAEmMimIFSF1sQqkbjYIR6lYze/Zsu/DCC61Dhw4ZZn7kleHDh7vuTI8//rgLsGi9VB9GNWBCRY52pNou6enp7m8FVhRs0QhJkZS9Ek3JkiXdj9+o8J5GOVAxvmipzinlK7v5FOgDAPhFflyTuV4CAJIZmSuFTIVgL7roInv22WftjTfesDfffDNYs0TBDWWZZMe8efOCf6emproaKOoiFM3nn39u5557rl166aWuBoy6Bv3www85Wm8Fhn777TeXJXPUUUeF/Wgo6kSkUQ7UMAylx5oOAAD+wfUSAJCMuHVQiB577DGX/dGkSRMrUqSIq1+i+iqBzA8Vt1WNk1atWrm7SwceeGCGy3r66add3RMFVEaOHGnbtm2zyy+/POpz9Txlx3zxxRdumVqPTZs2Wf369bO97sqwUVekLl26uGK3Rx99tG3YsMEVydUIR5FdoPxOd9k0fGSlB991xfrUZ1ypzboDF5gPAECy43oJAEhWXOEKkQrhKjCxatUqVxC3RYsWNmPGDBdokREjRtgtt9zislpUhFbDLmfkkUcecT+q4aLsEY1ClFEGyV133WU//fSTdezY0Q3FrNGCFCRRn+vsUhchreudd95pffr0sd9//90Fhtq0aWPVq1e3RBRoELoGoorxpaTQSAQAIALXSwBAMkrxPEq2+5kCLocffrgbglmj//iJhn3UCAXKssmoTgvyhmrlbNq0wapXrxkM3iH/sL8LDvu64LCvC3ZfF/Q+DlyTdaNFXZYLSyKfZ2ybfyXy9rFt/pTI2+bn7eM2AgAAPrAv/d8aXMWLFC3UdQGyg3MWAJBMCK4AABDHUtPTLd08m/HrUluza4sdXqaydT64gaVYihXz0d0cJA/OWQBAMiK44nMqekvPLgBI3C+py7ZvtF7zXrTf9+wMTr936QybeGJPq1+hBl9WEVc4ZwEAyYqrGwAAcUp3/yO/pIoea7pnBNcRXzhnAQDJiuAKAABxWq9C3Soiv6QGaPr0X5eG1bUAChPnLAAgmRFcAQAgTqleRSzzgYLGOQsASFYEVwAAiFMqBBrLfKCgcc4CAJIVwRUAAOKQhq7VCCtVS5aNOl/TNZ8hbhEvOGcBAMmM4AoAAHFKQ9dqhJXIL6t6rOmaD8QTzlkAQLJiKGYAAOKUhqzV0LXzOw50hUJVr0LdKnT3X19SGdIW8YZzFgCQrAiuAAAQxwJfRvXlNIBuFYhnnLMAgGREcAUAAB/gyyn8hnMWAJBMyM0EAAAAAACIAcEVAAAAAACAGBBcAQAAAAAAiAHBFQAAAAAAgBgQXAEAAAAAAIgBwRUAAAAAAIAYEFwBAAAAAACIAcEVAAAAAACAGBBcAQAAAAAAiAHBFQAAAAAAgBgQXAEAAAAAAIgBwRUAAAAAAIAYEFwBAAAAAACIAcEVAAAAAACAGBBcAQAAAAAAiAHBFQAAAAAAgBgQXAEAAAAAAIgBwRUAAAAAAIAYEFwBAAAAAACIAcEVAAAAAACAGBBcAQAAAAAAiAHBFQAAAAAAgBgQXAEAAAAAAIgBwRUAAAAAAIAYFIvlxQAA+Mm+NC/4d/GiKYW6LgAAAEicth7BFQBAwktN80yX2llLd9jaP/Za7Sol7LQG5U2X3GIEWQAAAHwtNQ7aegRXAAAJf7FduXG39Z243v7YmRacXqXsJhvd6xCrW6MUARYAAACfSo2Tth41VwAACU13MSIvtqLHmv5v8igAAAD8xouTth7BFQBAQve7VXpo5MU2QNM1P7R/LgAAAPxhXxy19QiuAAASmvrdxjIfAAAA8WttnLT1CK4AABKaCprFMh8AAADxq3actPUIrgAAEpaG4FOl+Cpli0adr+maz7DMAAAA/lM8jtp6BFcAAAlNl1JVio+86OqxphNWAQAA8K+UOGnrMRQzACChaeg9DcE3e1AdV9BM/W6VHqq7GLrYMgwzAACAfxWLk7YewRUAQMILXFR1kQ2gKxAAAEBiKBYHbT2CKwCApEFABQAAIHEVL8S2XqHXXGnXrp3ddNNNBbq82rVr2+OPPx7T+wwdOtQaN25sftxHeWHt2rWWkpJiS5YsKexVAQDEwEtLNS91n/sNAADgZ14htmsSLnNl6tSpVrx4cfOD3r17259//mlvv/12Ya8KACDJuEaH59mexR9b+uZ1VqTaoVayaXs3L6VowjUPAABAAvPioF2TcK2nSpUqFfYqAAAQ9w2Q1F9W2Y7RN5u3Y0tw+q4pI61835FWrFYdAiwAAMAXvDhp1xRot6Bdu3ZZz549rWzZslajRg0bMWLEfs/Zs2eP3XbbbXbwwQdbmTJl7IQTTrBPPvkk7Dmff/656ypzwAEH2IEHHmgdO3a0bdu2Re1Cs3nzZjv77LOtdOnSdvjhh9srr7yy33sqe+TKK6+0qlWrWvny5e3UU0+1b775Juw5jzzyiFWvXt3KlStnV1xxhe3evTvTbU1LS3PP03vqvevWrWtPPPFEWLeiiRMn2rRp01z3Gv1EbmdGXnrpJWvevLlbl4MOOsguueQSt50BEyZMsIoVK4a9Rtkxeo/Ibk1alrpJVahQwS6++GL766+/gs9JT0+3YcOG2VFHHWUlS5a0Qw891B588MGw5f700092yimnuGPRqFEj+/LLL7O1DQCAQuR5+zVA3OQdW9x0AAAA3/Dio11ToMGVAQMG2Ny5c11A4cMPP3TBhK+//jrsOddff737gv7666/bt99+a926dbNOnTrZqlWr3HzV+Gjfvr3Vr1/fPe+zzz5zwRMFMzLqerN+/XqbM2eOTZkyxUaPHh0WiBC9h6bNnDnTFi1aZE2bNnXvsXXrVjd/0qRJLhjx0EMP2VdffeUCQ1pOZhSYqFWrlk2ePNmWLVtmQ4YMsTvuuMMtSxRAuvDCC922bdy40f2cdNJJ2dqP+/bts/vvv98FgBQ0Uf0TbWdOrV692r3+vffecz86NgoiBQwePNg9vvvuu902vPrqqy7AFOrOO+9026LjcvTRR1v37t0tNTV6/zYFznbs2BH2AwAo+Ls7SpmNbIAE5+/YYnu+/ogaLAmOazIAIBF4cdSuKbCc3507d9r48ePt5ZdfdoELUeaGAhAB69atsxdeeMH9rlmzppumL+7vv/++m67ghjIplLURGtw49thjo77nDz/84AImCxYssBYtWrhpWod69eoFn6PgjOYruKLsDHn00Udd0EHBmKuvvtoVv1UWin7kgQcesNmzZ2eavaK6L/fee2/wsTJYFAxScEVBFWXvKKNFjRtln+TE5ZdfHvz7iCOOsCeffNJtn/axlptdCgApy0UZMHLZZZfZRx995LJTlMGiTJtRo0ZZr1693PwjjzzSWrduHbYMHZ/OnTu7v7W9OhY//vijHXPMMfu938MPPxy2TwAAhcDzXF/kzLj5nldgq4SCxzUZAJAQvPhp1xRY5oqyJPbu3eu6+YTWR1F3mYDvvvvOZaAoA0JBgsCPMir0+tDMlexYvny5FStWzJo1axacpi/9oV1mlP2hoETlypXD3nPNmjXB99RyQtdbWrZsmeX7P/300+691d1Iyxw3bpwLHMVK2TXK1lE3HQVG2rZt66bndNnqDhQIrIgycgJZPdpmBX6y2tcNGzYMe71EZgaFZsJs3749+KOMIgBAAUtJcUXeMuPmh3QlReLhmgwASAgp8dOuiatqdQpyFC1a1AUP9DtUICND2R55/Z4KCkSrdxJZtyQn1K1JWR2qK6NAjIIYw4cPt/nz58dct0Y1ZvSj+jEK3CiooscKXkmRIkXMi4jMqStRpMhRlVSTRdksOdnPocsI1HQJLCOSMoMC2UEAgMKhgm6qnq8ib9FSaFPKV3bzKWib2LgmAwASQUoctWsKLHNFXUr0RTw0uKAitOq6E9CkSROXuaLMBxVRDf0JdJ1RpoS6rmSHslRU/0PBmoCVK1e6ArYBqq/y22+/uQyXyPesUqWKe466EUUGRebNm5fpe6vormqo9O3b122XlhfIhAkoUaJEhrViMrJixQrbsmWLq4Vy8sknu22MzBRRwEXdehSICVDGT07UqVPHBViyu68BAP6i6vlqcITSY00HAADwk/Jx0K4psNtSyjxRzRIVtVUXnGrVqrliqMqyCFB3oB49ergRhZTxoaDE77//7r7gK6ii2h5KYz3uuONc0OLaa691AQoVq1VR2kAwJEBdjlQw9pprrrExY8a4AIpGEgrNyujQoYPLLOnSpYur56J12LBhg02fPt3OO+88V9/lxhtvdAVj9XerVq1cxsj333/v6p1kFpx48cUX7YMPPnD1VjQqz8KFC93fod1yNF8BH+0TjdgTmU0SSV2BtM1PPfWU2/6lS5e64rah1IVJo/eogG7//v1dYEi1VXKiVKlSdvvtt9vAgQPd+2m7dSy03YHaMwAAf9LdGw1LWOnBd10ROPVFVsqs7uwE5gMAAPhBSpy0awp0tCB1i1G2heqFKKih4qih9VBEhWsVXLn11ltdcERBDwUlFFQQBT800pBqpRx//PEuMKLRhxQ4iUbLU3Fc1SU5//zzXYFaBXZCu7LMmDHD2rRpY3369HHL15DEP//8c3BknIsuusiNmKNAg9ZX86677rpMt1UBHb2fXqtgh7JNFBAKddVVV7ltVNBG2SbKdsmKnqdAiUYh0ohJymBRAd5QqmWjwsHaLgWiXnvtNTfaUU5pm3UcNNKRsne0LRnVUwEA+IsaGinFiruGR+mOvYMpswRWAACA36TEQbsmxYsszgEUEA37qGwddQ+Lpb4NsqY6OJs2bbDq1WuGZYshf7C/C04y7et96f92Iy1eJLwuWUFIpn1d2LSvC3ofB67JKm5bvnz5QjtnE/k8Y9v8K5G3j23zp0TeNj9vH7enAACIY6np6ZZuns34damt2bXFDi9T2Tof3MBSLMWK+ajBgeTBOQsASEYEVwAAiOMvqcu2b7Re81603/fsDE6/d+kMm3hiT6tfoQZfVhFXOGcBAMmKqxsAAHFKd/8jv6SKHmu6Z/TsRXzhnAUAJCuCKwAAxCHVq1C3isgvqQGaPv3XpWF1LYDCxDkLAEhmBFcAAIhTqlcRy3ygoHHOAgCSFcEVAADilAqBxjIfKGicswCAZEVwBQCAOKShazXCStWSZaPO13TNL4xhmYFoOGcBAMmM4AoAAHFKQ9dqhJXIL6t6rOmaD8QTzlkAQLJiKGYAAOKUhqzV0LXzOw50hUJVr0LdKnT3X19SGdIW8YZzFgCQrAiuAAAQxwJfRvXlNIBuFYhnnLMAgGREcAUAAB/gyyn8hnMWAJBMyM0EAAAAAACIAcEVAAAAAACAGBBcAQAAAAAAiAHBFQAAAAAAgBgQXAEAAAAAAIgBwRUAAAAAAIAYEFwBAAAAAACIAcEVAAAAAACAGBBcAQAAAAAAiAHBFQAAAAAAgBgQXAEAAAAAAIgBwRUAAAAAAIAYEFwBAAAAAACIAcEVAAAAAACAGBBcAQAAAAAAiAHBFQAAAAAAgBgQXAEAAAAAAIgBwRUAAAAAAIAYEFwBAAAAAACIAcEVAAAAAACAGBBcAQAAAAAAiAHBFQAAAAAAgBgQXAEAAAAAAIgBwRUAAAAAAIAYFIvlxQAA/9uX5gX/Ll40pVDXBQAAAMlhX4K1QQmuAECSSk3zTJe0WUt32No/9lrtKiXstAblTZe2YglwgQMAAED8SU3QNijBFQBI0ovayo27re/E9fbHzrTg9CplN9noXodY3RqlfH1xAwAAgD/boEV82gSl5goAJCHdLYi8qIkea/q/SZoAAABA3vASuA1KcAUAkrB/q9IwIy9qAZqu+aH9YAEAAICCaIOm+bQJSnAFAJKQ+rfGMh8AAADIlzaoZ75EcAUAkpAKh8UyHwAAAMiXNmiK+RLBFQBIMhrqThXZq5QtGnW+pmt+IgyJBwAAAH+1QYv6tAlKcAUAkpCuWarIHnlx02NN9+k1DQAAAHEsJYHboAzFDABJSMMsa6i72YPquMJh6t+qNEzdLdBFjWGYAQAAUBht0PR0fxZdIbgCAEkqEEDRxSyArkAAAADIT8UStA1KcAUAklwiXMwAAADgL8UTrA0ac82Vdu3a2U033ZQ3a5PN5dWuXdsef/zxmN5n6NCh1rhxY0tkeX1sAMDvvLRU81L3ud8AAAAoPF6CtcviLnNl6tSpVrx48cJejaT0ySef2CmnnGLbtm2zihUrFvbqAECecRdtz7M9iz+29M3rrEi1Q61k0/ZuXkrRuLsUAgAAJCwvQdtlcbfmlSpVKuxV8J29e/daiRKZjxdekDzPs7S0NCtWLO5OLwBJegFP/WWV7Rh9s3k7tgSn75oy0sr3HWnFatXx9YUcAAAgkdplluLPQY1ztNa7du2ynj17WtmyZa1GjRo2YsSI/Z6zZ88eu+222+zggw+2MmXK2AknnOAyIkJ9/vnnrsvKAQccYAceeKB17NjRZUtE68qyefNmO/vss6106dJ2+OGH2yuvvLLfe/7555925ZVXWtWqVa18+fJ26qmn2jfffBP2nEceecSqV69u5cqVsyuuuMJ2796d6bYqOKDn6T313nXr1rUnnngi04DCUUcdZY8++mjY9CVLllhKSor9+OOP2VrX1atX27nnnuvWVfu5RYsWNnv27P26Rd1///3uWGgZV199tWXHSy+9ZM2bN3f74KCDDrJLLrnE7V9Zu3aty1oRHROtc+/evd3j9PR0e/jhh4P7olGjRjZlypTgcnV89fyZM2das2bNrGTJkvbZZ59la50AIN953n4XcDd5xxY3HQAAAAXES9x2WY6CKwMGDLC5c+fatGnT7MMPP3Rfqr/++uuw51x//fX25Zdf2uuvv27ffvutdevWzTp16mSrVq0KBhvat29v9evXd8/Tl3AFTxTMiEZf8NevX29z5sxxX+hHjx4dDAgE6D00TV/uFy1aZE2bNnXvsXXrVjd/0qRJrsbKQw89ZF999ZULDGk5mVFAoVatWjZ58mRbtmyZDRkyxO644w63rGgUXLj88svthRdeCJuux23atHGBl+ys686dO+3MM8+0jz76yBYvXuz2nfbPunXrwparII6CHHrO3Xffbdmxb98+F5RRMOftt992AZVAAOWQQw6xN9980/29cuVK27hxYzCYpMDKiy++aM8884x9//33dvPNN9ull17qzoVQgwYNckGs5cuXW8OGDaMG3nbs2BH2AwD5fXdEKaeRF/Dg/B1bbM/XHyVMX18gu7gmAwDitV2Wkh49NhD3vGz666+/vBIlSniTJk0KTtuyZYtXunRp78Ybb3SPf/75Z69o0aLer7/+Gvba9u3be4MHD3Z/d+/e3WvVqlWG79O2bdvg8lauXKkBrr0FCxYE5y9fvtxNGzlypHv86aefeuXLl/d2794dtpwjjzzSGzt2rPu7ZcuWXt++fcPmn3DCCV6jRo28nOjXr5/XtWvXDOdru7X98+fPd4/37t3rValSxZswYUK21zWaY4891nvqqaeCjw877DCvS5cuWa5v6L6MZuHChW5f6tjKnDlz3ONt27YFn6N1PeCAA7wvvvgi7LVXXHGFO5ahr3v77bczXZ977rnHPS/yJ/T9kD/S0tK8DRvWu9/If+zv+NnX6fv2erveG+f9fm3zDH80X89D5jivC05B7OOMrsnbt2/3ClMin2dsm38l8vaxbf7k121Lz0G7zI/bl+3MFXVXUW0PdfMJrY+i7jIB3333nctAOfroo12XlsCPMhz0+tDMlexQBoTqdqirScAxxxwTVmxVWRjK9qhcuXLYe65Zsyb4nlpO6HpLy5Yts3z/p59+2r23uvBomePGjdsvgyRUzZo1rXPnzvb888+7x++++667M6Rsleyuq+arW1W9evXcdmq+1j/yfdW9J6eUKaMsmEMPPdR1DWrbtq2bntk2qTvT33//baeddlrYOiuTJbDO2V2nwYMH2/bt24M/ykgCgHyVkuKKpGXGzU9JrKEAgaxwTQYAxG27zKfytIKfAgNFixZ1X+L1O5S+kItqduT1e6qbT2RdF4llxBt1a1KQQ3VlFIhRMGL48OE2f/78TF+neiqXXXaZjRw50nUJuuiii1xtmeyuq95z1qxZrtuPuhJpf11wwQUusBVK9WxyWi9HtW30o7o1ChgpqKLHkcsOpXWW6dOnuzo6oVRbJSfrpOdHvgYA8pMK1ar6vIqkRUtBTSlf2c2noC2SDddkAEC8tss8nxa0zXZr8sgjj3RDJCu4oMwHURHaH374IZgB0aRJE5e5opoiJ598ctTlqBaH6once++9Wb6nslRSU1NdsEaFXQP1QFQUNkA1S3777TeX4aJCr9EoC0TrrQKwAfPmzcv0vVV096STTrK+ffsGp0VmakSjeikKMowZM8bef/99++9//5ujddX7qg7KeeedFwxuqDZKrFasWGFbtmxxNVFUX0VUfyZUYMSh0Po3qo2jxpcCMYHjDAB+o+rzkcXTdAHXdAAAABSc8gnaLst2cEWZJxo9R0Vt1a2lWrVqduedd1qRIv9GldQdqEePHi6IoYwPBVt+//13F0xRUEVdZpSGetxxx7mgxbXXXuu+0KtYrbrOVKlSJew91eVIBV2vueYaF6xQUEIjCYVmv3To0MFllnTp0sWGDRvm1mHDhg0u00IBCnVVufHGG13AQn+3atXKZW6oMOsRRxyR4fbWqVPHdX354IMP3Cg5Gmln4cKF7u/MKGNH76Xt1DJCux9lZ131mqlTp7ruOyqSq2K1Kq4bKwXEtK+feuopt9+XLl3qituGOuyww9x7vvfeey5IpP2sjB1l06iIrdajdevWLn1YQSCNVNSrV6+Y1w0A8vsuiYb1q/Tgu66IWvrmdS7lVHdGAvMBAAAQH+0yLw++/xaGHOXbqFuMMlL0xV+BAn3RDq2HIuoKo+DKrbfe6oIjCiQoKBHIdlFAQSMNqf7I8ccf74INGn1IgZNotDzVMlHWxPnnn++GHVZgJ0DBgBkzZrgRefr06eOWf/HFF9vPP//shjMWdc1RkGLgwIFufTXvuuuuy3RbFdDR++m1qteirI/QLJbMKAilrjZan1DZWdfHHnvMDYWsrBntZ3XbUcZLrNQNaMKECW70I2WjKIMlcthodftRRpFG/dH6aOQnURBG+0+jBikLSAEvBYSyCjQBQLzQhTqlWHF34S7dsXewKxCBFQAAgIKVkqDtshRVtS3slUg0n376qSvaq+JwgaAJ9qdhHytUqOC6l8VSHwdZU9bRpk0brHr1mmHZZsgf7O+Cw74uOOzrgt3XBb2PA9dkZacqM7WwJPJ5xrb5VyJvH9vmT4m8bX7ePn+HhuKMRgZSN6ihQ4e6bk4EVgAAeWVf+r/1sIoXCS8aD8QjzlkAQDLxTxjIB1577TVXt0QFd1VTBQCAWKWmp9ve9DSb/utSG/XDXPdbX1o1HYhHnLMAgGRE5koeUiFb/QAAkBf0ZXTZ9o3Wa96L9vuencHp9y6dYRNP7Gn1K9SwYj5Kl0Xi45wFACQrrm4AAMSpdPP2+5IqeqzpnlE2DfGFcxYAkKwIrgAAEIfUjWLGr0v3+5IaoOmB7hZAPOCcBQAkM4IrAADEqTW7tsQ0HyhonLMAgGRFcAUAgDh1eJnKMc0HChrnLAAgWRFcAQAgDmno2s4HN7CqJctGna/pms8Qt4gXnLMAgGRGcAUAgDiVYiluhJXIL6t6rOmaD8QTzlkAQLJiKGYAAOKUhqzV0LXzOw50hUJVr0LdKnT3X19SGdIW8YZzFgCQrAiuAAAQxwJfRvXlNIBuFYhnnLMAgGREcAUAAB/gyyn8hnMWAJBMyM0EAAAAAACIAcEVAAAAAACAGBBcAQAAAAAAiAHBFQAAAAAAgBgQXAEAAAAAAIgBwRUAAAAAAIAYEFwBAAAAAACIAcEVAAAAAACAGBBcAQAAAAAAiAHBFQAAAAAAgBgQXAEAAAAAAIgBwRUAAAAAAIAYEFwBAAAAAACIAcEVAAAAAACAGBBcAQAAAAAAiAHBFSSUfWle8CcvTZs2zerVq2eNGze27777zv3+66+/snxdSkqK/fnnn1HnNW/e3D755JMcrcfevXvtrLPOsuOOO8769eu33/z+/ftb7dq13fsuWbIkw+UMHTrUbrrpphy9NwAAAAAgumIZTAd8JTXNM4VTZi3dYWv/2Gu1q5Sw0xqUtxSd5EX1b2yeeeYZGzJkiHXv3t09zixwkZ8WL15sq1atspUrV0adf8EFF9jAgQOtdevWVpjS09Pd7yJFiN8CAAAASHx880FCBFZWbtxtHR5ZZQNe32BPz/7D/dZjTdf8WCgb5NNPP7U77rjDTjrppP0yUhTs6Ny5s7Vo0cIaNmxoo0aNirqcL774wmW8NGjQwPr06WOpqakZvufw4cPt2GOPdRkqPXr0sO3bt9uyZcvc3+vWrXPLefHFF/d7XZs2baxWrVrZ2q6NGzfa2WefbfXr17dTTz3Vtm7d6qanpaXZgAED3Hrq54YbbnAZM9K7d297/PHHg8u47bbbXBaM6HfXrl2tY8eO7nVaPgAAAAAkA4Ir8D2FTvpOXG9/7EwLm67Hmh5rB6Enn3zSdeEZOXKkC5CEUiBC2SwjRoywhQsX2rx582zcuHHu71AKTlx00UX26KOP2tKlS91rvvnmm6jvN3PmTHv++eft888/d12QypQpY4MGDXJBkOeee87q1q3rMmd69uwZ03bNnz/fJkyY4II21apVs7Fjx7rpgfVftGiRe5/Vq1e7bc+OL7/80gV9tMyDDz44pvUDAAAAAL8guAJfU20VdQWKDKwEaLrm53UNlgB1z/n+++/t4osvdtkkymxRLRYFF0KtWLHCihUrZh06dHCPTz/9dDviiCOiLnP27NkuEFOxYkX3+LrrrrNZs2bl+bp36tTJKleu7P5u2bKlC6IE3l8ZKiVLlnTrfNVVV2X7/c8880yrXr16nq8rAAAAAMQzaq7A91RjJZb5sfA8zypVqpSrGizqWpSXz8upUqVKBf8uWrRoht2UQt9fwRZl6wTs3r3bypYtG3wc+jcAAAAAJAsyV+B7Kl4by/xYqItO+fLl7YUXXghO+/HHH4P1SwKOOeYYF7yYM2dOMDskkCkSSdktkyZNsh07drjH6q6jTJeCovdX1x51ZdI6qytS4P2POuooW7Bggft7y5YtNmPGjAJbLwAAAACIV2SuwNeKF01xowJVKbspategKmWLuvl6Xn5QJsd7773nhjVWXRJldVSpUsVeffXVsOeVKFHC3njjDevbt697jorfNmrUKOoyzzjjDFeXRV11NNqOiuSOHj06W+tzzTXX2PTp0+23335zhWXLlSvngj05cfXVV7vAT9OmTd3jdu3aBYdt1jyNSKRhqdWt6cQTT8zRsgEAAAAgEaV46tcAFAJlZlSoUMG2bdsWrC8Sy2hBkUVtFVgZ3esQq1ujVJ4Mx+xnGhp506YNVr16TYZHLgDs74LDvi447OuC3dcFvY8D12SNTqeMzMKSyOcZ2+Zfibx9bJs/JfK2+Xn7yFyB7ylwogDK7EF1XPFa1VhRVyBlrCikkuyBFQD/Ci1unV8ZbQAAAEi+th7BFSSEQABFAZUAvjgBCM1w06WWACwAAEDiiYe2HsEVJBQCKgCy33VwE10HAQAAfC41Ttp6/unABABALuguRuTFVvRY0yk8BgAA4F9enLT1CK4AABK6363SQ6ONJiaarvmh/XMBAADgD/viqK1HcAUAkNDU7zaW+QAAAIhfa+OkrUfNFSQULy3VTKOLp6RYSlFObwDmCprFMh8AAADxq3actPXIXEHCBFW81H225+uP7H8fTHC/3TQFW/LAtGnTrF69eta4cWP77rvv3O+//vory9elpKTYn3/+GXVe8+bN7ZNPPsnReuzdu9fOOussO+6446xfv377zT/99NOtYcOGbv1OPvlkW7x4cdTlDB061G666aYcvTfg1yLXqhRfpWzRqPM1XfMphg0AAOA/xeOorcetffieAiipv6yyHaNvNm/HluD0XVNGWvm+I61YrToxZ7E888wzNmTIEOvevbt7vGTJEisMCpasWrXKVq5cGXX+pEmTrGLFiu7vt956y3r37m3ffPNNAa+lWXp6uvtdpAjxWxQ+XUpVKX7/CvJF3XTCKgAAAP6VEidtPb75wP88b7/Aipu8Y4ubHqv+/fvbp59+anfccYeddNJJ+2WkKNjRuXNna9GihcsaGTVqVNTlfPHFFy6jpEGDBtanTx9LTc04q2b48OF27LHHugyVHj162Pbt223ZsmXu73Xr1rnlvPjii/u9LhBYEb1G65mRjRs32tlnn23169e3U0891bZu3eqmp6Wl2YABA9x66ueGG25wGTOiYM3jjz8eXMZtt93msmBEv7t27WodO3Z0r9Pyr7/+epfx06hRI2vWrJnt3r07y/0N5DUNvach+GYPqmPDL65p/TpUcb/1mGGYAQAA/K1YnLT1yFyB77NW9iz+eL/ASnD+ji2ui1DJpu1znb3y5JNP2rfffuu60XTp0iVsngIRymZ5+eWX7ZhjjrG///7bTjzxRDvhhBNcsCVAwYmLLrrIXnjhBevQoYN9+OGHNmHChKjvN3PmTHv++eftyy+/dMGSq6++2gYNGmRjxoyx5557zq1HZpkzPXv2tDlz5ri/Z8yYkeHz5s+fb4sWLbLKlSvbxRdfbGPHjrXBgwfbuHHjbOHChW5e0aJF7ZxzzrGRI0fa7bffnuW+0joru6Z69eru90cffWTff/+9y2BRsKdECWpboHAELqpKCw2gKxAAAEBiKBYHbT0yV+Bvnmfpm9dl+hQ3X0Vu84G65yh4oOCEskmU2aJaLMoyCbVixQorVqyYC6wEaqMcccQRUZc5e/ZsF4gJZKFcd911NmvWrGyvkzJa1q9fbw888ECmAZFOnTq5wIq0bNnSVq9eHXx/ZaiULFnSrfNVV12V7fc/88wzXWBFtH3Kzrn88stt4sSJtm/fProJodDpIhv4AQAAQGIpXohtPb7p5JIKkWZWrDQvqbuFvrjHm9q1a4d1ESkUKSlWpNqhmT7Fzc+ke0wsPM+zSpUquUySwM+aNWusV69eWb42sy47uXleJK2DMli2bIme1VOqVKng38pQyaibUuj7K9iibJ2AyG4+ZcuWDf5doUIFW7p0qV1yySUuuKQuUz/++GOutgVA/hcEz6sC4AAAAMnYriG4UojULSS0RgZyTl19XJef8pWjzy9fOaYuQVmpW7eulS9f3nX3CVAAIVC/JEBdhhS8CHTXUXZIIFMkkrJbVJh2x44d7rG66yjTJSsK9G3YsCH4+O2333aZKQr+5ITeX9kv6sqkdVZXpMD7H3XUUbZgwQL3t4I2mXU7+v33323Xrl3utQ899JALxkVm9ABI3FHWAAAAkqldk9Q1V5R1oLvwuhsPf9OoQJFFbRVY0fT8pHPnvffec3VQVJdE51OVKlXs1VdfDXueao288cYb1rdvX/cc1WNRkddozjjjDJfxoa466kajjI/Ro0dnuS6qadKtWzf73//+515XtWpVt27KPNG5nl2q8aLAT9OmTd3jdu3aBYdt1rwLLrjAFalVtx/Vl8mIuiapS5G6A2mbW7Vq5bYNQHKMsgYAAJBU7RovF9q2betdf/313o033uhVrFjRq1atmjdu3Dhv586dXu/evb2yZct6Rx55pDdjxoyw13333Xdep06dvDJlyrjXXHrppd7vv/8enD9z5kyvVatWXoUKFbxKlSp5nTt39n788cfg/D179nj9+vXzDjroIK9kyZLeoYce6j300ENu3po1a/Tt0Vu8eHHw+du2bXPT5syZ4x7rtx5rvZo2beoVL17cTUtLS3PLqV27tleqVCmvYcOG3uTJk8PWffr06V6dOnXc/Hbt2nkvvPCCW5beIyMjRozwGjRo4B1wwAFerVq1vOuuu87766+/wtYl9Oeee+6JuhxNb9SoUfDxggULvA4dOniVK1f2ypcv77Vp08ZbtGhRcH5O9sXs2bO9Zs2aeaVLl/ZatmzprVixIuy933nnHa958+Zuf+v9unTpEpx32GGHeQ8++KDXp08fd8wPOeQQb+zYsV52bd++Pct9mF3pqfu89H17vf8teN/b9d4499tNS90X87ITgc7xDRvWu9/If+zvgsO+zh19Xv4xsKP3+7XN9/vR9GifnezrglMY+zhwTdbvwpTI5xnb5l+JvH1smz8l8rblZvty067JD7nuFqQClbpDry4CGqpVRTd111wFPb/++mvXFeCyyy5zo6cEuixouNcmTZrYV199Ze+//75t2rTJLrzwwuAy1YXglltucfM1yojuvp933nmWnp4eHLXlnXfecV0mVEj0lVdecV0NckojrzzyyCO2fPlylxXw8MMPu24QzzzzjCtOevPNN9ull15qc+fODd6BP//8892wtaqpceWVV7plZEXrr3XWMrW/Pv74Yxs4cKCbp/2keiXqUqIha/WjYW2zQwVTVU/js88+s3nz5lmdOnVcIVFNz6k777zTRowY4fa5sjBUfDRg+vTpbv9r2YGRX44//viw1+u1zZs3d/OVlaHzQMcmmj179riuLqE/eUWRyJRixV0XoNIdewe7AnHnFQByN8oa3YMSW35ekwEASMZ2Ta6/eapLw1133eX+1vCtClYo2KJuADJkyBA3dKyGsFXXgVGjRrnAimovBGi42UMOOcR++OEHO/roo61r165h76H56tqgOg0NGjSwdevWuUBC69atXVeHww47LFfrft9999lpp50WbFxonVQDQ90wRN0dFLhQrYu2bdu67TjyyCNdICFQZ+O7776z//znP5m+T6ArhSgIpNFbrr32WtfFQ91EVPBT23HQQQflaP0VpAqloXNVu0XBoLPOOitHy3rwwQfdNooCRp07d3ZFSlXsVPM0Cs69994bfH5kVxYFXhRUEY1Mo64xqiuifRRJQazQZeUHgikAEN+jrCE+FMQ1GQCAZGrX5DpzRRkfoSONqHDmcccdF5wWGI518+bN7vc333zjvnRrNJHAj4p8SqCw56pVq6x79+4uuKGMjkBWioIqouFhlTmiL+79+/e3Dz/8MFfrrkyL0OKjyq5RsCV03ZTJElgvZbiccMIJYcsIBGIyo4BN+/bt7eCDD7Zy5cq5TB4VAQ1k8+SWMn4UxFKgSQEa7audO3cG91Nuj2ONGjXCjpn2tdY/u68PBIoCr4+kIJzqggR+lBEEAEiuUdYQH7gmAwASQkr8tGtyfZu/ePHiYY/1xTp0WmD41kCXHn35V7eaaNkegS/1mq9slGeffdZq1qzpXquMFY1aIiqwqWFuZ86c6QIX6lKkkU2mTJniuuBIaOFOFdKMpkyZMsG/tV6BLjAKgoQqWbKk5dbatWtdFom6ySgDRCO2KBvmiiuucNtzwAEH5HrZ6hKkIM0TTzzh9pfWU8GewH7Kyb7I7JiVLl06V+dB4PWRtJ6x7FMAQN6NsqYib9FSaPN7lDXEB67JAIBEkBJH7ZoCG4pZgRHVHlE2ioZzDf1RsEPBAtXqUFcjZUtoNJJt27bttxxlaVx00UUuAKPRV95880037K26D4lqlwQo8yIr9evXd40LZX1Erpe6LInWJTD8bIBqnWRm0aJFLsigrkTqFqVuT6HD5Iq6BmkUlZz6/PPPXeaOuuQce+yxbv3/+OOP4Pzc7otoWSmqswIASDyqnh85jH1BjLIGAACQiO2aArst1a9fPxcQUbcfFXVVJoe65Lz++uv23HPP2YEHHui6Fql+iDJZFOyILBr72GOPuXmq3aLsjMmTJ7tuKKo3oscKYqj2y+GHH+66pgRqwmRG3XVUSFZFbBUMUT0XpccqgKFAjrJEVCdFQZIBAwa4YrYKnEyYMCHT5So4o2yRp556ymXkaHkqmBtKgSZlziiAoVomymbJTkaLugO99NJLrnuTCtBpvUKzTPR3bvZFpHvuuccFulRvRrVXUlNTbcaMGa62CgDAv3T3RsMSVnrwXVcETn2RlTKrOzuB+QAAAH6QEiftmgLLXFE3HwUYlKmhkYRUn0UFXwOBEf0o0KLAhboCKdgxfPjw/QIhw4YNc0GFFi1auK43+rIf6AajArgKADRr1swtWwVks+P++++3u+++2xV3U5ZKp06dXDchBSbk0EMPdRkyb7/9tguCKEgSWpg3Gj1PwSB1g9L2aGQjLT+URgxS4EaZOMo20bZlx/jx411Wj7KBVMdFWSzVqlULe05u90Wodu3auQCWRmhq3LixK6QbmcETb/alpwV/8tK0adPcuaH9oGLG+p2d0ZnUTUojZUWj8/iTTz7J0Xqo65e6m+n/jwKWkXQuKGin9w3NVlKR4j59rnB1jnRuqsaQgpvRKHDYpUuXHK0XAP9hlDUAAJAoUuKgXZOi8ZgL7N2AEMq6UUFeBYoUZItFanq6pZtnM35damt2bbHDy1S2zgc3sBRLsWL/H3yLxRlnnGE9e/Z0mVc5oSBHRtun4Mqjjz7qgljZNX/+fLceGQ13/d///tcVhFYGloKBCgKJiihPnTrFunfv4QpQa/Qu1SqKFtxRcEWv1U9+UZBV65GolAW3adMGq169ZjD4i/zBvi447OuC3dcFvY8D12Rl7ypzt7Ak8nnGtvlXIm8f2+ZPibxtft4+/6wpkElgZdn2jXbCB8Ps+kWTbMSKj9zv4z8Y5qZrfiyUDfLpp5/aHXfc4bKNIjNSNMqVhrBWNpXq1ChwEc0XX3zhgh3KZOrTp4/LLMqIsrZUT0cZKj169HCNXQ1Jrr/VZU7L0YhWkdq0aWO1atXab7qG1m7f/tRg0WJ1G1PmV0bUXU2BJL2/gkA//fRTpusmQ4cODRt+XPtBI3wFAjannHKKG25dr1MGlLKpAtlA+vn5558zXB8A+ZeZB+QXzlkAQDIhuALfU8ZKr3kv2u97/hn5KUCPNd2z2JKznnzySRdgGDlypAuQRGZgKAihmjwLFy50hY5VN0h/R3bnUfcvZaosXbrUvUbDk0ej0bDUrUvd6NQFSQWfVX9IxZdVn0hDkavLjzJYcksjTZ177rkZztf6q+ub3l8jcgVG+cpo3bKbdRNYpronaV98/fXXblu0XwPDtwMIpwDx3vQ0m/7rUhv1w1z3W19WYw0cA/mFcxYAkIzoWA1fU2NNXYEiAysBmq5GnboIFS+S991Q1D1Ho2Cp4G+AarEoy0SZLAErVqywYsWKuUCFqO6Quu9Eo2HGFYgJdCXScN7dunXLs3VWgEP1VjIbCUpDewdqDulvFWaOdd2U9aPAkCjlXIWZL730UrcvlPkTLeMGSHaBzLzIAPK9S2fYxBN7Wv0KNfKk6yOQVzhnAQDJiqsbfE81VmKZHwuVLNLIV8q+CPysWbPGjTKVlUAXnbx6XnYow2bq1KkuAyWzkanUjShAtVEy6sIUum4KHoUOLa4iuqHKli0btkxl+agbkUazUjcldb0CULCZeUBe45wFACQrgivwPRWvjWV+LJSJoSyMF154IThNWSFbt24Ne566wShAMWfOnGAGyOrVq6MuU9ktkyZNcsUFZezYsS67I1Zjx45zI3LNmjUr1wWEM1s3DT/+1VdfuQCLCuhqhK2MKLtn06ZNdvLJJ7uRulSAd/HixbncMiC5M/OoZ4F4wTkLAEhmdAuCr6mrj7r8KN04WmOuasmy+dYlKJCt8d5777kMDNVkUWChSpUq9uqrr4Y9r0SJEvbGG29Y37593XPUZUhDImc0MpHqsqg7jqpjq0ju6NGjs7U+11xzjRtG/LfffrOOHTu64csV7Pnll1/s3nvvd12RVFhWSpYs6eqg5ERm63b++ee7obtVpFZdfJo0aeKCLNGoCO4FF1xgu3btctkv6iKUnWwfINkUZmYekBucswCAZMVQzPD9UMwZ9e9WYIX+3f4ezsyv2N8FJ5H3te7u6y6/Rj/LyKhmF+ZrADlZ9nW88etQzHlxzibyeca2+Vcibx/b5k+JvG1+3j4yV+B7CpwogDK/40CXjqy7YuoKpMZbiqUkfWAFgD8VdmYekFOcswCAZMa3TiQEBVBK/H+j7vqj2wYbbwRWAPiZAsTKwNOX0lCBzDzNB+IJ5ywAIFmRuYKEwt0wAImEzDz4DecsACBZEVwBACCOBb6M6stpAIFkxDPOWQBAMiK4AgCAD/DlFH7DOQsASCbkZgIAAAAAAMSA4AoAAAAAAEAMCK4AAAAAAADEgOAKAAAAAABADAiuAAAAAAAAxIDRglBoPM9zv3fs2GFF/n/YRuSP9PR0++uvv6x0afZ1QWB/Fxz2dcFhXxfsvtY+LleunKWkpBT4NbkwJfJ5xrb5VyJvH9vmT4m8bfG8fVldlwmuoNBs2bLF/T7ssMMKe1UAAIg7mzdvtqpVqxbIe6kRK4ccckiBvB8AAH6zfft2K1++fIbzCa6g0FSqVMn9XrdunVWoUKGwVyeh6U6kGszr16/P9AMBeYP9XXDY1wWHfV3w+7pEiRIF9p41a9Z0x7Ygs2WS7Txj2/wrkbePbfOnRN62eN4+XSMzQ3AFhSaQ4qXASjz9p0lk2s/s64LD/i447OuCw74uOAUZ5NA1uVatWhYvEvk8Y9v8K5G3j23zp0TeNj9uX/x0YAIAAAAAAPAhgisAAAAAAAAxILiCQlOyZEm755573G/kL/Z1wWJ/Fxz2dcFhXxecZN7XibztbJt/JfL2sW3+lMjb5uftS/ECY+8BAAAAAAAgx8hcAQAAAAAAiAHBFQAAAAAAgBgQXAEAAAAAAIgBwRUAAAAAAIAYEFxBoXj66aetdu3aVqpUKTvhhBNswYIFhb1Kvvfwww9bixYtrFy5clatWjXr0qWLrVy5Muw5u3fvtn79+lnlypWtbNmy1rVrV9u0aVOhrXOieOSRRywlJcVuuumm4DT2dd769ddf7dJLL3X7s3Tp0nbcccfZV199FZyv2uxDhgyxGjVquPkdOnSwVatWFeo6+1FaWprdfffddvjhh7v9eOSRR9r999/v9m8A+zr3/vvf/9rZZ59tNWvWdJ8Zb7/9dtj87OzbrVu3Wo8ePax8+fJWsWJFu+KKK2znzp3m1+3et2+f3X777e7/dJkyZdxzevbsaRs2bPDNdufF9qlNpNeG/ujaEu/n7NChQ+2YY45x23bggQe6c3b+/Pm+OHZ5sW1+PW6hrr32Wvecxx9/3BfHLa+2z6/Hrnfv3vutd6dOnXxx7P6bB9sWr8ctgOAKCtwbb7xht9xyixte6+uvv7ZGjRpZx44dbfPmzYW9ar42d+5c92V+3rx5NmvWLNegO/30023Xrl3B59x888327rvv2uTJk93z1bg7//zzC3W9/W7hwoU2duxYa9iwYdh09nXe2bZtm7Vq1cqKFy9uM2fOtGXLltmIESNcYzdg2LBh9uSTT9ozzzzjGr9qDOtzRUEuZN9//vMfGzNmjI0aNcqWL1/uHmvfPvXUU8HnsK9zT5/HuubpBkM02dm3ajB///337nP+vffec43Vq6++2vy63X///bdrCyiop99Tp051NwbOOeecsOfF83bnxfbJfffdZxs3bgz+3HDDDRbv5+zRRx/tPi++++47++yzz9wXH7U9fv/997g/dnmxbX49bgFvvfWWazfqy26keD1uebV9fj52CjiErvdrr73mi2O3Kw+2LV6PW5CGYgYK0vHHH+/169cv+DgtLc2rWbOm9/DDDxfqeiWazZs361azN3fuXPf4zz//9IoXL+5Nnjw5+Jzly5e753z55ZeFuKb+9ddff3l16tTxZs2a5bVt29a78cYb3XT2dd66/fbbvdatW2c4Pz093TvooIO84cOHB6fpGJQsWdJ77bXXCmgtE0Pnzp29yy+/PGza+eef7/Xo0cP9zb7OO/o8eOutt4KPs7Nvly1b5l63cOHC4HNmzpzppaSkeL/++qvnx+2OZsGCBe55P//8s++2OzfbJ4cddpg3cuRIL55lZ9u2b9/unjd79mxfHbvcbJvfj9svv/ziHXzwwd7SpUv32w6/HLfcbp+fj12vXr28c889N8PX+OXYWS62zQ/HjcwVFKi9e/faokWLXGplQJEiRdzjL7/8slDXLdFs377d/a5UqZL7rf2ubJbQfa9010MPPZR9n0vKFOrcuXPYPhX2dd565513rHnz5tatWzfX5a1Jkyb27LPPBuevWbPGfvvtt7D9XaFCBdflkP2dMyeddJJ99NFH9sMPP7jH33zzjbtje8YZZ7jH7Ov8k519q99K8db/hwA9X9fRyO4Kfr9+KdVb25qI2x25fQFKbVfXR33GDR8+3FJTU81vbbxx48a581Z3pxPp2EXbNj8ft/T0dLvssstswIABduyxx+433+/HLavt8/Oxk08++cS1h+rWrWvXXXedbdmyJWGO3SeZbJsfjluxwl4BJJc//vjD9emvXr162HQ9XrFiRaGtV6LRRUX1P9SVokGDBm6aGu0lSpTYrzGnfa95yJnXX3/dpXirW1Ak9nXe+umnn1xXFXUnvOOOO9w+79+/v9vHvXr1Cu7TaJ8r7O+cGTRokO3YscMFA4sWLeo+rx988EGXYizs6/yTnX2r32p0hipWrJgLoifK/lcXKNUo6d69u6sXkGjbHW37RJ9pTZs2ddv0xRdf2ODBg126+2OPPWbxTt0OLr74YtcFSvWC1BWhSpUqCXHsMts2Px83dfnUcdD6R+P345bV9vn52KnbjLqZqzba6tWrXbtIN0AUVNF128/HrlMW2+aH40ZwBUjQjIqlS5e6O87Ie+vXr7cbb7zRNbJUlBn5HyzUHZiHHnrIPdadCp3fqkuh4AryzqRJk+yVV16xV1991d3tW7JkiQvUqr86+xr5TRl/F154oSvsq4BqMm2fgscBquGl4PE111zjitWXLFnS4tkpp5ziPit0A01ZhdpG3SGP/ILnR1ltmx+Pm7Jrn3jiCXeDSBlUiSa72+fHYycK9gWoULbWXcXnlfHRvn1787OLs7Ft8X7c6BaEAqVovyKPkaOm6PFBBx1UaOuVSK6//np3p2XOnDlWq1at4HTtX6W1/vnnn2HPZ9/n7sKtAsyKnOtugH5UtFaFKPW37jSzr/OO7hbWr18/bFq9evVs3bp17u/APuVzJXZKoVb2iho4atgorVrFmdVoEfZ1/snOvtXvyOLvSofWyBB+3/+BwMPPP//sAtehWR2JsN2ZbV806g6mbVy7dq3FOxVePuqoo+zEE0+08ePHu+ugfifCscts2/x63D799FN3TNRVOdCG0Xl56623uqK9fj9u2dk+vx67aI444gj3/erHH3/0/bHLatv8cNwIrqBAKbrYrFkz16c/9K60Hrds2bJQ183vdCdMgRVVRv/4449dSl0o7XeNthK67zVigb6gsu9zRtFzjR6gu1mBH2VWqOtE4G/2dd5R97bIYcVVE+Swww5zf+tcV4MhdH+ra4vuLrK/c0ap7+qXHUoBcX1OC/s6/2Rn3+q3grYK8Abo817HRw1MvwoEHjTs9OzZs11f+lB+3+6sti8aXUv0f9GP2R86Lnv27EmIY5fZtvn1uClo/u2334a1YZSdqOD6Bx984Pvjlp3t8+uxi+aXX35xdUl0I8rvxy6rbfPDcaNbEAqc0rmUXq4voMcff7wbd15Dc/Xp06ewV833XYGUyj9t2jQrV65csF+liq+VLl3a/dY499r/6qeou2Yaukwfwrojg+zT/g3Usgm9u6UGc2A6+zrvKHNChVbVLUhfUBYsWOAKC+pHlParrisPPPCA1alTx31J1bCnakx16dKlsFffV84++2xXY0V3/NQtaPHixa4f8+WXX+7ms69js3PnzrA7cCpiq4ahPie0z7Pat8rYUp/0q666ynWL05d2BdWVaZTRUKPxvt1qNF9wwQUuhV9Zl6rzE7h+ab5uysT7dse6faonoCCauqDo+qLH+ty79NJLw4acj7dt0zVPnxcaVlrbqa4zGmL1119/dQXIJZ6PXazb5tfjps+ayACfbggpuKsiovF+3PJi+/x67PRz7733WteuXd32qC7JwIEDXXZVx44d4/7Y7Yxx2+L5uAUV9nBFSE5PPfWUd+ihh3olSpRwQzPPmzevsFfJ9/TfOdrPCy+8EHzO//73P69v377egQce6B1wwAHeeeed523cuLFQ1ztRhA7FLOzrvPXuu+96DRo0cMPSHnPMMd64cePC5msY27vvvturXr26e0779u29lStXFtr6+tWOHTvceazP51KlSnlHHHGEd+edd3p79uwJPod9nXtz5syJ+jmt4Sezu2+3bNnide/e3StbtqxXvnx5r0+fPm5YeL9u95o1azK8ful1ftjuWLdv0aJF3gknnOBVqFDB/b+rV6+e99BDD3m7d++O623TdU7Xtpo1a7r2XI0aNbxzzjnHDTUdKl6PXazb5tfjlt3hbeP1uOXF9vn12P3999/e6aef7lWtWtUrXry4266rrrrK++2333xx7ObEuG3xfNwCUvRPYQd4AAAAAAAA/IqaKwAAAAAAADEguAIAAAAAABADgisAAAAAAAAxILgCAAAAAAAQA4IrAAAAAAAAMSC4AgAAAAAAEAOCKwAAAAAAADEguAIAAAAAABADgiuAj7399lvWsuUJhb0aSaF37172yCMPW6L59ddfrUGD+rZixXJL9v1z5513WP/+11s8ePrpUda163m++oxYs2aNtW17su3atSvXy1i9+kdr3/4U+/vvv/N03QCgIDz11JM2dOg9MS1jwYIF7rq8Y8eOqJ/jkdeHeLp2ZWby5EnWvv2pdtxxx9pLL72Yb22UyPbI6ad3yPb75dYbb7xu/fr1zdf3gD8QXAEKkS6Iumjop3HjhnbGGR1tzJjRlpqamq3Xd+p0hr333oyk+xIci2TffuRdQCk/9enTx8aPfyHm5eTmMyK3Hn98pF1ySQ8rU6ZMcD/36nWZtWjRzP3W41B9+15ns2Z9GDbtyCOPsoYNG9mLL04skHUGkkGsbY3CEhlkiPfrxR9//G4vv/ySXX311TG9Z5Mmje2TT+ZauXLlsvX8QYMG2wMPPGTxbOfOnfbggw/YFVdcYR9//IldcEE3SyTnn3++LV++zBYt+qqwVwWFjOAKUMhat27tLqIzZsy0Xr362OjRT9sLLzyfrdeWKlXKKleunO/r6Af79u0r7FVAnPE8L+6/PGTkgAPKWMWKFWNeTkF9RmzcuMHmzv3EunT5927q8OHDrFq16jZlyptWpUpVe/TR4cF5M2fOtCJFithpp52+37K0DN0F9OuxA/ze1ti3b2+Br18iePPNN61x4yZWs+bBMS2nePES7jMzJSUlW89XEKZ8+fIWzzZu3Og+09u0aWtVq1a10qVLm1+kpaVZenp6lsfszDM72yuvvFxg64X4RHAFKGQlSvxzEdXF+OKLL7YTT2xpn3wyx83bvn27DR48yE466URr3rypXXvt1fbzz2uDr80oVfSdd95xaZAnnni83XbbrcE0fd29+uqrhe7OSuAulu7K6H1uv32AnXxyK2vWrImdeWYne+utqRmu82effWqXXXape+9WrVq6O9Dr1q0Le85vv/1mAwbc5tZdd64vvLCbffvtN8H52saLLrrQmjZtbK1bn2T9+98QnKf1+uij2WHL03tpe0PvJOkLWu/ePd0ypk9/z/7880/3nqee2s7tr/POO9dmzJgeXEZG2y+rVq1y+1fr2qbNyTZo0O22bdu2qNuvO35dupyz33Tte6UER5PVPn7ssRHWufMZbr07dTrdLSc0YBQ4tlOnvmkdOpzq1vP+++9zF/3nnx/vumO0adPaxo59Jux9tY2vv/662za9r5b94YcfWGay2hfqsqHzUvPbtWtjEyZkL8NC69GpU0d35/Sss85052nAwIED7NZbbwl7vrZf58a0adPcYzVunn12nHXseJrblvPPPy9sWwJ3OT/99L924YUXWJMmjezrr7/ebz30ernggq7u+cpmCqUvHNoundsPPHB/2HHYu3evCxroHNP2d+9+kXvfzOg9Jk16w/0/0fE9++yzbMmSJbZu3c/uvbWcHj0uCfs/FJn2rfe4+OKL3HP1f+HSS3vYhg3/nLsrVqywPn162/HHN7cTTmjhtn3p0qUZdgvK7DgE1nfKlCnu/6TWV+fqnDkfZ7qN77//vtWte4xVr149OO2nn1bbueeea4cdVtu6dOniHovuQj/11BN25513RV3WSSe1dP9f9H8VQN7IrK0R6Fai68cpp7S1s87qHPxCfOutN7vPEF3Lb7ihX1gGWmafS/Lxxx9Zt25d3TVa1x4FdEKDppl91uh9Lr+8t/tb763naj0zos96fZ5qOXr+1Vdf5T5HAp/bDz30oLtGal3Ufvnuu++ydX3O6noRaubMGdauXbuwaXr+Qw894DJmtV66pk6ZMtldR++66w73ua1MIl23cpuxE9ktKKvtDSx/3rwvXdtM+0zXIHXtDMjsupJRgF3nh84FPV/nzR9//BG8Dqk9JjoPQttekb777lu74ILz3Xpr3ZYv3z9jaOHChe680zVe1+qRIx/LUTB+4sQJbn20ruqmpLbU33//2501cN3UuXjOOWe5ddH/hazO93btTrE5c+bY7t27s70uSDwEV4A4U6pUyeCXOV14v/9+qT311Ch7+eVXzfPMrrvu2kyzNNavX+8aNE8/Pcaefnq0+4Ly3HPPBlNHGzVq7NIxdQdLPwcddJCNGvWUrV692saMGWvvvPOe3X33EDvwwAMzfI///e9/1rNnL3vjjUk2fvzz7g70jTf2D0b2dZFSg2Lz5k02atTT9uabU+3yyy+39HTPzZ87d657/sknn2yTJ79pzz33vB133HE53lePP/6Y9ehxmVvnVq1a2549e6x+/fo2evQYe+utaW47FQTQxTqz7VcD5oor+tgxx9SzN96YbGPHjrUtW7bs92U/4LzzzreffvoprLGidNAffvgh7M59qKz2sbpSKK132rR33Xqq8RXZR1jHVoGtsWPH2fDhj7pAi76wK5A1YcKLdvPNt7igTGgQ65/3ftI6dDjd3nzzLevc+SwXgNK6RJOdfTFixKPuvNJ5OW7cc66ho+3PzOzZs+2RRx6y3r1729tvv2Pdul1od999py1YMN/N13op8yG0gfP555+7RkqHDh3cYwVWFAgYMuQet4yePXu6wI/eP9TIkSPtpptucfu5bt2j91uX1157w/1+7rnx7hx44okngvPUeNJ+fv75Cfbggw/btGlvu58ApTV/8803bv9rf55+esf9gp7R6EvLOeecY1OmTLXDDz/cNeTvvXeoXXXVVfb665OUZ+Ma4NGo0Xjjjfry0dy9pz4LunXrFryrOWjQQBfU0HImTZpsV1xxpRUrVixXxyE0gNipUyebOvUtO/nkNnb77QNt+/Y/M9y+r79eZMcee2zYNAVbvvzyS/e58MUXX9jRR9cNnj/du19iNWrUyPAO4DHHHGOLFi3KdJ8CyJu2hsybN8/Wrl1rzz77nGs7aN4111zlsugmTnzJXnrpFTvggAPc550yW7L6XFL3iDvuGGyXXnqZu64NGTLUfZaOGzc2W581ujaPHPnPZ7O6NuqzWtfGaNRl58orL7cjjzzSrceLL77kghyBNok+c2bPnmUPPviQTZ48xQ499FC3bYHPtMyuz5ldL0JpWVpG5Oeg6AaBlvfaa69bjx493Jd5BR+U5aL1OemkVq6torZVXshqewOefPIJGzBgoGvLFStW1O6++9+Ad06uK9rPN9xwvQtSqS2ic2j9+l/czb1A91Ttv8D+DLS9Iun6r7olOo56z759+4VlPMqmTZusb99rrUGDBu6807FSWyjyxlJm1GYdPPgOdw186KGH3PVvxIgRYc/RsRg/frzde+/97nkVKlTI9HwXHXvd8Pr223/anEhSHoBCc8cdg70bbujn/k5PT/e++OJzr0mTRt7w4cO8tWvXeMceW8/7+uuvg8/ftm2b16xZE+/992e6x2+9NdU78cTjg/NHjXrKa968qbdz587gtEcfHe51735R8HGvXj29hx9+KGw9+vXr69155x253o6tW7e6df3hhx/c40mT3vCOP7659+ef26I+/5JLunsDBw7IcHla1uzZs8KmaTu1vfLLL7+457z44otZrtt1113rDRv2n0y3/5lnxnhXXXVl2LSNGze691izZk3U11177dXefffdG3z84IMPeL1798pwPXK6j59/frzXrdsFmR7bq6++yjv99A5eWlpacNpZZ53pPfvsuOBjbcO99w4NW7bOh8C6B/bl8uXLsrUvdu3a6TVu3DB4DoqOs87LyP0aqkePS7x77hkSNu2WW27yrr32Gvf3vn37vNatT/KmTZsWnD9gwG3erbfe4v7es2eP2/7FixeHLePuu+9yz5P58+e79fzoo9kZrke0bQ79/3jaae291NTUsHUMrMOGDb96DRs28DZt2hT2uiuu6OONHPlYhu+n93ryySeCj5csWeKmvfnmlOC06dOne02bNg473uef3yW4f/X8BQsWRF2+/q+9/fZbUedFfkZkdRyire+uXbvctE8//W+G26h1HTNmdNi03377zf3/a9/+FPdbjxcuXOhdeGE3t016344dT/OGDr3H27t3T9hr+/e/wbvzzsEZvh+AvGlrBOa3adM67P/hO+9Mc9cTPT9A8/VZ/9lnn2X5uaTPxXHjxoZN0zLbtWuT7c+awGf69u3bM90+XQMuvbRH1HlaZqNGx3nvvfduyHbs9U45pa03fvxzWV6fM7peRNJ8PW/Dhg1h09V2uOyyf9dN1xddywYNuj047fffN7vX6toQbbujtfUC14fI45ud7Q0s/8svvwg+Z+7cT9y03bt3Z3ldifT555+7a2Potv/44yq3vG+//TZs/2h/ZkRtx1atWgbXQV5//bWw/f/44yP3Oy9fe+1Vr0WLZsG2UGR7Tdf1F1+cmOH7fvDB++59A7S//3nP5cFpWZ3vAS1bnpDt/YbEFD0ECaDAKItDKYa6C6QaEeqzqWj9/Pnz3F2Chg0bBp+rGgy1a9d2WRMZqVmzZrCgpKhv69atWzNdh4suushuvvkml32gOyinntremjRpkuHzdZd+1KhRLiNE3UUCd4eUFlqnTh2XTlqvXj2rUCF6zYiVK1fYBRdcYLGKvEOkOwbKbvjgg/fd3Q3dedNP6dKlMl2O1kd3LnQcIq1fv87t80hdu3azIUPusoEDb7ciRVJc96OBAwfleh+ri5P66ur9lC6sbSlbtmymx1a1NHQHRj+h0yKPt7J1Ih/rGOVmXyiTRPs09LzUcY62j0KpS4ju8oRq3LipvfLKS+5vnesdO3Zy3buU4aF9oJRcZYiIutDoTtJVV10Rtgyti861UMce28BySwVVixYtGnysNHp1k5Iffljljou6b0WuQ0bnesDRR/+bQROogVKnzr/TqlSp7DKvVPQv8rhr2epWozuPLVue5NL5dadX/7dFWWT33DPE3n33HTdP2TS6U5mb4xBtfXW3Wuu0ZUvGnyNad3U7CKW7nsoiC01V1zYoI0gZUboj/u67092d8EmTJlmPHpeG3VX/3/9IrQbyu60RoM8jZY0FrFy50nVVVLeQyP/ryu5r1apVpp9Lev3ixYvDMlXUVtDr9VkeqLmR08+ajDJX9LkXjdZV2xx6vS1evLg1aHBcsC2V0zZQNLt373G/S5Ysud+8QNae6PqitpzaSgGVK1dxv7du3WKxys72RluvwHHTOtSoUTPH1xVlooRmI+paqjowes/sZibruVqn0H0Y2X7Rcxo1ahSWMaIMILUZNm36za17Vr788guX0a1uULrm6roeeV5qn9WtWzfb1+HQOmdcu5IbwRWgkLVocbwNGTLEfZBXrVotw7TL7Ip8vS5AWRXiUiruhx/Odn1+lb6v9NqLL+7u0kWjuf76fu4CNnTovW6dPS/dunQ5N5hirC9GmYnW+IhcZ3WBChWtP+0BB5Ter1aG6qncfvsg11DU/EceeSTLYre6KKuv7C237N8NSF+uo1HKsY6ZasPot9bv9NP3L86ZnX2s+htKwVVDV92bypUr64It6hec1bEtXjzyfMn6eMeyLyJr6+QldQ3q06eX64akxo/OE+2PwHrJ6NHPWPXq1cJeF/qFQGIplBe5P0P//2gd1DCeNGmKFS0a3qtWXwoyE3rsAo3C8Pf6Z1pGx05dxhR8+Oyzz+z992e6miXPPjveNTL79bve7bv//neuffrpp65ey/DhI4LdqXIj2rmm/+cZqVjxwCzrA+hLlr64KCg6dOgQu+GG/u7/TocOp9n8+fPDgitKLz/kkOgNeQB539aIvJ7q807dbP/zn2H7LevAAytl+bmk1+uzKdrnUGgbIKefNdHoC20sctoGiubAA/8JsOtzsFKlf/ZP5tfu4mGPJZZrd25Euy4Fum/nx3UlHqjWi7oeXXTRxda//02uu4+6tQ4Zcvf/34wrHTynIgsKZ3a+h167KlXKuFs9Eh81V4BCpgbNoYce5oIVoRe6I444wn1hD+27qYKt6hOt/qi5pQt6enraftPVGDj33C6uIaXghGp+RKN1ULT/mmuucZF7rUvklyrdeVBmREY1GjRf/bszooabhjQMzZTJTl9k3SU75ZRT7eyzz3E1G2rVOmS/WhjRtr9evfq2evWPrtCfjkXoT0ZfmnWstL/eeust93PGGWdk2cDLaB8vWbLYHf9rrvmnH7EKgG7YsMHySmQNFj3W+RVNVvvi0EMPcdseel6qMfHzzz9nug5HHHGkOz6hliz52k0P0J023f1So0UZLLpTFmiA6i6YMiNUVC5yvTKq3ZGRwDLT0nLWkFWGjO5w6c5e5DpkFITLSzo2V111tb3yyqvurqf2UYAyh3SnUX3dFawIFH/OzXHI3brVCxasjUa1CJTddf31NwT3fSBgqt+R/ydXrfrR1f0BkL9tjYwosKLP9UqVKu/3eRc6RHBGn0uarrZC5Gv1E5ptmZ3P6qyCDsp+UYA2mkMOOcQtJ/RzT1+iVc8utC2V0fU5u9cLBYOVdaPrZ2HK7vZmR06uK6r9putzgPaD2oY5eU+1S374YaXLIsmo/aLnqO6Zsq8C1IZSVm/16vvXcYm0bNn37nxS4ExBEW3j77//296M5Tqsm09ad65dyY3gChCn9AX71FNPdXd4FVVXsELZDdWqVXMBhNw6+OCD7dtvv3PR+0CXHhVzUxFcdb348cdVLn04oy/fSvNUSuvkyZPd89V9adiw8DtbZ555plWpUsWNAKAK/kpTnTXrQ5ehIddd19dV1Q8UkVMh2PHjnwu+/oQTTrBXX33FpeiqOv19992brcbgYYcd5jIe1KjQclUwVFkQWW2/imsqQDBw4G2uSK0ukJ9//pkrKKwv0xnp2rWr60Kj56rIbWYy28da799+22gzZsxw763sm8jRkmKhEXVU8E2BOa2HtvGSSy6J+tys9oW6cpx/fldXME/HXl1mNC+rISP79OnjGmYaqUYBL2XlqLhq7959wp6nVHWNrKNCqGeddVZwuhpOeu6wYY+4oohar2XLlrmuVKEFZ7NDjWgFwlQcWKMZ/PXXX9l6nRphupOnIo2zZs2yX375xXWNU1c0Hc/8ovfRaAj6/6ORCVToV1961KBVNy0V2VUhXs3T/7elS7/L8P9vdo9DTqmLwJIl30T9/6JG8L333uO6zQWClQqkaZQQ/T99551pLq07QP83VQy7ZcsTY1onALmnzzoVYVWhUhWn1eeQPmc0Co2+SGf2uSTXXXed61KiEYJ0zfsnwDrDFVHNLnWF1bVFxc7V3TW04HmoK6+82n3uqVCsuiOp64g+43SN12eOshR0zdJnvr70Dx16j7tho2tZVtfn7F4vFDDSDadoI9QVpOxsb1Zyel1p2bKlCzSojarrsq6LgwcPtubNW7gbRtnVuXNnd7zVHUnrrayZyNEIlVGk80/noY7zPwM4jHJBoOwE7RQEU0D/lVdecW1TFclXmyMrWZ3vora6bupl1H0KyYFuQUAcu//+B93wfUph1J2HZs2a25gxz4Slk+aUvkTdeedgO/fcs90F9IMPZrnlPf74SJctoXTdZs2aufTPaHTxUh2Mhx9+yHUFql37cFd1Xd05QrtpjBv3rA0fPtxVddcXLl2A7rrrn0r0xx9/vI0YMdLGjh3jgiq626NtC9AdhbvuutN69rzMBZM0QoAu2FlRNs0vv6x3fWJLlSrtakuo7/TOnX9luv0KuLz00sv22GOPudeqNoTu7rVu3TrTi7UCYI0bN3bBiIYN/00LjSazfaxg2WWX9XSjxei927Rpa9dee51rlOYFpfeqm5GGFVb/4GHDhrtMkGi0v7PaF7fddptL+Vb3MDXkevXqbX/9tTPTdWjfvoMNGnSHayhptJpatWq581vnQmSDXt1H1Khu0qRp2Dx1I1FWk/pKq1GkQF/gLlJOKFCndXnmmdGuUda0aTObMGFitl77wAMPulEJHn10mKvroy8fOvZt24YPv5mX1LDXHeB33rnRZY7pGKqBeeGFF1paWqqbdscdg1wgUeujtG0d81iOQ061bn2yG21CQ3sGunIFTJ48ydUUCB2iVF3gNGLSJZdc7M4tBfUClOGi7kPKngJQONQ9YuLEF9214KabbrRdu3ZZtWrV7cQTT3TXbF0/M/pcEn0OaNShMWPG2PPPj3efuxoprWvX7NdbU90mfZbpS63aBOecc64bASda4Fsj1z3xxOPWvftF7jPzuOMauhs9opH0dCNFI/JoO1SXa+zYZ12XkKyuzzm5XuiGiwIZt956W7azc/JDVtubFXV7zcl1RQERjR6ogEevXpe5bdfn+uDBd+ZovXXzZtSo0XbffUPd0NfKern55lvt5ptvjKjl9YwLHk2Zcp7bJgWNlPmbHcpqVq2855/X+TLStT1vvPFmt625vQ4HKHiYF/UE4W8pqmpb2CsBAH70T1HATu4CqwBDPGrQoL498cST7ks1kJ9ee+1VmzNnjgus5paGeD3zzDPsP/8Zbk2bhgfXACDe2wTdu19sPXv2dFmYSB7KeLr88stt+vQZYd3mkHzIXAGAXFCKsro2KU24S5fzCnt1gELXrduFro+97pSGjmqVE+qzr0wkAisA/EYZHEOHDnUjyyG5qG7Lww8/TGAFZK4AQG4zQpQqqy5L6soSr8hcAQAAAPIfwRUAAAAAAIAYMFoQAAAAAABADAiuAAAAAAAAxIDgCgAAAAAAQAwIrgAAAAAAAMSA4AoAAAAAAEAMCK4AAAAAAADEgOAKAAAAAABADAiuAAAAAAAAWO79H7wKrZmSQHlAAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -553,11 +553,11 @@ "id": "9d9352fa", "metadata": {}, "source": [ - "Deciding at the first launch is worth the most. Where the field varies within hours, the second plane is produced and launched as if it were deployed at once: 63% and 78% of the points are accurately sampled on average over the mission, for 156 million dollars. Where the field varies slowly, the second plane is not deployed, which saves 38 million dollars (24%) for 18 points of the mean (73% against 91%): a trade that the rule makes, and that a mission might not.\n", + "Deciding at the first launch is worth the most. Where the field varies within hours, the second plane is produced and launched as if it were deployed at once: 63% and 78% of the points are accurately sampled on average over the mission, for 156 million dollars. Where the field varies slowly, the second plane is not deployed, which saves 38 million dollars (24%) for 19 points of the mean (71% against 91%): a trade that the rule makes, and that a mission might not.\n", "\n", - "Deciding a year later costs the fields that need the second plane 13 to 15 points of the mean (50% and 63%), as the first plane flies alone a year longer, and saves only 2 million dollars, by discounting the later production. The earlier the need is known, the more staging saves, at less loss.\n", + "Deciding a year later costs the fields that need the second plane 13 to 15 points of the mean (50% and 62%), as the first plane flies alone a year longer, and saves only 2 million dollars, by discounting the later production. The earlier the need is known, the more staging saves, at less loss.\n", "\n", - "The rule that measures makes the same choices as the rule that reads the field, in every field. The first plane alone samples 5% and 10% of the points accurately where the field varies within hours, so the second plane is deployed, and 73% where it varies over 12 hours, so it is not. A mission knows what its satellites achieve, not the field, so this is a rule it could follow." + "The rule that measures makes the same choices as the rule that reads the field, in every field. The first plane alone samples 5% and 8% of the points accurately where the field varies within hours, so the second plane is deployed, and 71% where it varies over 12 hours, so it is not. A mission knows what its satellites achieve, not the field, so this is a rule it could follow." ] }, { diff --git a/docs/examples/tradespace/PlanForFailures.ipynb b/docs/examples/tradespace/PlanForFailures.ipynb index 37a6f37c..f4b457a9 100644 --- a/docs/examples/tradespace/PlanForFailures.ipynb +++ b/docs/examples/tradespace/PlanForFailures.ipynb @@ -35,10 +35,10 @@ "id": "e20ee309", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:06:19.762215Z", - "iopub.status.busy": "2026-11-14T08:06:19.762215Z", - "iopub.status.idle": "2026-11-14T08:06:21.582005Z", - "shell.execute_reply": "2026-11-14T08:06:21.582005Z" + "iopub.execute_input": "2026-11-14T15:44:01.748712Z", + "iopub.status.busy": "2026-11-14T15:44:01.748712Z", + "iopub.status.idle": "2026-11-14T15:44:03.435885Z", + "shell.execute_reply": "2026-11-14T15:44:03.435885Z" } }, "outputs": [ @@ -74,10 +74,10 @@ "id": "7c437e44", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:06:21.582005Z", - "iopub.status.busy": "2026-11-14T08:06:21.582005Z", - "iopub.status.idle": "2026-11-14T08:06:22.072799Z", - "shell.execute_reply": "2026-11-14T08:06:22.072799Z" + "iopub.execute_input": "2026-11-14T15:44:03.435885Z", + "iopub.status.busy": "2026-11-14T15:44:03.435885Z", + "iopub.status.idle": "2026-11-14T15:44:03.892354Z", + "shell.execute_reply": "2026-11-14T15:44:03.892354Z" } }, "outputs": [ @@ -130,7 +130,7 @@ "* **spare on ground**: store a spare, which is launched at the next opportunity;\n", "* **spares in orbit and on ground**: both.\n", "\n", - "A spare that is used is produced again. The policy is a decision of each design: `policy_space` declares whether to restore failed satellites, and the numbers of spares in each plane and on the ground (none or one of each). `space.extend` adds the policy to the design space, with the seed of the failures (`failure_seed`, drawn for each replicate).\n", + "The policy is a decision of each design: `policy_space` declares whether to restore failed satellites, the numbers of spares in each plane and on the ground (none or one of each), and the policy's other fields (here, half a year of procurement, and a spare produced again once it is used). `space.extend` adds the policy to the design space, with the seed of the failures (`failure_seed`, drawn for each replicate).\n", "\n", "`Failures` simulate 20 histories of the failures of each replicate, restored by the design's policy. The study evaluates each history by the phases in which its satellites operate, and gives the means over the histories and their quantiles: here, the share accurately sampled in the worst 10% of the histories (`accurate mission histories p10`), and the cost at 70% confidence (`cost histories p70`). The designs are the efficient designs by accuracy of `ExplainTradeSpace`, each with each policy." ] @@ -141,10 +141,10 @@ "id": "35efa3e2", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:06:22.072799Z", - "iopub.status.busy": "2026-11-14T08:06:22.072799Z", - "iopub.status.idle": "2026-11-14T08:06:23.178781Z", - "shell.execute_reply": "2026-11-14T08:06:23.178781Z" + "iopub.execute_input": "2026-11-14T15:44:03.892354Z", + "iopub.status.busy": "2026-11-14T15:44:03.892354Z", + "iopub.status.idle": "2026-11-14T15:44:04.886661Z", + "shell.execute_reply": "2026-11-14T15:44:04.886661Z" } }, "outputs": [ @@ -163,7 +163,6 @@ "from tatc.tradespace import (\n", " Failures,\n", " Integer,\n", - " RestorationPolicy,\n", " Uncertain,\n", " aggregate,\n", " pareto_front,\n", @@ -174,11 +173,11 @@ "summary = summarize(cost_study.run(), ACCURACY)\n", "efficient = summary[summary.pareto]\n", "\n", - "POLICY = policy_space(orbit_spares=Integer(0, 1), ground_spares=Integer(0, 1), replenish=True)\n", + "# the policy of each design: its spares, and its other fields (half a year of procurement, and spares produced again)\n", + "POLICY = policy_space(orbit_spares=Integer(0, 1), ground_spares=Integer(0, 1), replenish=True, procurement_years=0.5)\n", "failure_space = cost_space.extend(failure_seed=Uncertain.seed(), policy=POLICY)\n", "FAILURES = Failures(\n", " FAILURE_MODEL,\n", - " RestorationPolicy(procurement_years=0.5, replenish=True), # the policy of each design starts from this one\n", " histories=20,\n", " seed=\"failure_seed\",\n", " quantiles={\"accurate mission\": 0.1, \"cost\": 0.7},\n", @@ -213,10 +212,10 @@ "id": "4c9a47e8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:06:23.178781Z", - "iopub.status.busy": "2026-11-14T08:06:23.178781Z", - "iopub.status.idle": "2026-11-14T08:06:23.226105Z", - "shell.execute_reply": "2026-11-14T08:06:23.226105Z" + "iopub.execute_input": "2026-11-14T15:44:04.886661Z", + "iopub.status.busy": "2026-11-14T15:44:04.886661Z", + "iopub.status.idle": "2026-11-14T15:44:04.934016Z", + "shell.execute_reply": "2026-11-14T15:44:04.934016Z" } }, "outputs": [ @@ -290,34 +289,34 @@ " 206.4\n", " \n", " \n", - " 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00\n", + " 800 km, 60 deg FOR, SSO: 2 at 09:00, 2 at 15:00\n", " 85.4\n", " degrade\n", - " 50.7\n", - " 10.8\n", + " 50.6\n", + " 11.4\n", " 170.4\n", " \n", " \n", " produce\n", - " 68.5\n", - " 56.2\n", + " 68.3\n", + " 56.3\n", " 218.3\n", " \n", " \n", " spare in orbit\n", - " 68.8\n", - " 61.3\n", + " 68.4\n", + " 60.5\n", " 246.8\n", " \n", " \n", " spare on ground\n", - " 72.5\n", - " 62.2\n", + " 72.3\n", + " 62.1\n", " 235.4\n", " \n", " \n", " spares in orbit and on ground\n", - " 69.3\n", + " 69.0\n", " 63.1\n", " 260.7\n", " \n", @@ -397,11 +396,11 @@ " spare in orbit 28.2 \n", " spare on ground 28.9 \n", " spares in orbit and on ground 28.5 \n", - "800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 85.4 degrade 50.7 \n", - " produce 68.5 \n", - " spare in orbit 68.8 \n", - " spare on ground 72.5 \n", - " spares in orbit and on ground 69.3 \n", + "800 km, 60 deg FOR, SSO: 2 at 09:00, 2 at 15:00 85.4 degrade 50.6 \n", + " produce 68.3 \n", + " spare in orbit 68.4 \n", + " spare on ground 72.3 \n", + " spares in orbit and on ground 69.0 \n", "700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spaci... 96.4 degrade 64.2 \n", " produce 78.0 \n", " spare in orbit 74.2 \n", @@ -420,10 +419,10 @@ " spare in orbit 25.1 \n", " spare on ground 25.6 \n", " spares in orbit and on ground 25.6 \n", - "800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 85.4 degrade 10.8 \n", - " produce 56.2 \n", - " spare in orbit 61.3 \n", - " spare on ground 62.2 \n", + "800 km, 60 deg FOR, SSO: 2 at 09:00, 2 at 15:00 85.4 degrade 11.4 \n", + " produce 56.3 \n", + " spare in orbit 60.5 \n", + " spare on ground 62.1 \n", " spares in orbit and on ground 63.1 \n", "700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spaci... 96.4 degrade 38.9 \n", " produce 70.1 \n", @@ -443,7 +442,7 @@ " spare in orbit 192.7 \n", " spare on ground 175.2 \n", " spares in orbit and on ground 206.4 \n", - "800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 85.4 degrade 170.4 \n", + "800 km, 60 deg FOR, SSO: 2 at 09:00, 2 at 15:00 85.4 degrade 170.4 \n", " produce 218.3 \n", " spare in orbit 246.8 \n", " spare on ground 235.4 \n", @@ -533,10 +532,10 @@ "id": "a41c39e2", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:06:23.227869Z", - "iopub.status.busy": "2026-11-14T08:06:23.227869Z", - "iopub.status.idle": "2026-11-14T08:06:23.241957Z", - "shell.execute_reply": "2026-11-14T08:06:23.241957Z" + "iopub.execute_input": "2026-11-14T15:44:04.934016Z", + "iopub.status.busy": "2026-11-14T15:44:04.934016Z", + "iopub.status.idle": "2026-11-14T15:44:04.949712Z", + "shell.execute_reply": "2026-11-14T15:44:04.949712Z" } }, "outputs": [ @@ -634,12 +633,20 @@ " 175.2\n", " \n", " \n", - " c8774dd43adf\n", - " 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00\n", + " 77d5dc1d8f4f\n", + " 800 km, 60 deg FOR, SSO: 1 at 09:00, 2 at 15:00\n", " produce\n", - " 47.3\n", - " 38.5\n", - " 198.1\n", + " 46.4\n", + " 35.9\n", + " 193.5\n", + " \n", + " \n", + " 525acda84c60\n", + " 800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac...\n", + " produce\n", + " 44.9\n", + " 37.7\n", + " 201.0\n", " \n", " \n", " 3a902b976460\n", @@ -650,27 +657,35 @@ " 209.5\n", " \n", " \n", - " 669760831f64\n", - " 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00\n", + " d1a143db2a62\n", + " 800 km, 60 deg FOR, SSO: 1 at 09:00, 2 at 15:00\n", " spare on ground\n", - " 51.7\n", - " 44.9\n", - " 212.4\n", + " 50.2\n", + " 40.9\n", + " 211.7\n", " \n", " \n", - " dc951db700b1\n", - " 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00\n", + " 7b247cdf0711\n", + " 800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac...\n", + " spare on ground\n", + " 48.1\n", + " 42.4\n", + " 216.8\n", + " \n", + " \n", + " 170ca99f7e10\n", + " 800 km, 60 deg FOR, SSO: 2 at 09:00, 2 at 15:00\n", " produce\n", - " 68.5\n", - " 56.2\n", + " 68.3\n", + " 56.3\n", " 218.3\n", " \n", " \n", - " 0a25f2a2d87c\n", - " 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00\n", + " e84f662c5ca8\n", + " 800 km, 60 deg FOR, SSO: 2 at 09:00, 2 at 15:00\n", " spare on ground\n", - " 72.5\n", - " 62.2\n", + " 72.3\n", + " 62.1\n", " 235.4\n", " \n", " \n", @@ -727,11 +742,13 @@ "8aca273a3613 800 km, 60 deg FOR, SSO: 2 at 06:00 \n", "ad99c42082ab 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", "cc2e14e787ff 800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spac... \n", - "c8774dd43adf 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 \n", + "77d5dc1d8f4f 800 km, 60 deg FOR, SSO: 1 at 09:00, 2 at 15:00 \n", + "525acda84c60 800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac... \n", "3a902b976460 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", - "669760831f64 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 \n", - "dc951db700b1 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 \n", - "0a25f2a2d87c 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 \n", + "d1a143db2a62 800 km, 60 deg FOR, SSO: 1 at 09:00, 2 at 15:00 \n", + "7b247cdf0711 800 km, 60 deg FOR, Walker 60 deg: 3 x 1 (spac... \n", + "170ca99f7e10 800 km, 60 deg FOR, SSO: 2 at 09:00, 2 at 15:00 \n", + "e84f662c5ca8 800 km, 60 deg FOR, SSO: 2 at 09:00, 2 at 15:00 \n", "46932f795a5a 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", "6e4564d2ae2c 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", "570a452fdb8f 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... \n", @@ -747,11 +764,13 @@ "8aca273a3613 produce 9.2 7.3 153.4 \n", "ad99c42082ab produce 26.1 19.5 159.4 \n", "cc2e14e787ff spare on ground 28.9 25.6 175.2 \n", - "c8774dd43adf produce 47.3 38.5 198.1 \n", + "77d5dc1d8f4f produce 46.4 35.9 193.5 \n", + "525acda84c60 produce 44.9 37.7 201.0 \n", "3a902b976460 degrade 64.2 38.9 209.5 \n", - "669760831f64 spare on ground 51.7 44.9 212.4 \n", - "dc951db700b1 produce 68.5 56.2 218.3 \n", - "0a25f2a2d87c spare on ground 72.5 62.2 235.4 \n", + "d1a143db2a62 spare on ground 50.2 40.9 211.7 \n", + "7b247cdf0711 spare on ground 48.1 42.4 216.8 \n", + "170ca99f7e10 produce 68.3 56.3 218.3 \n", + "e84f662c5ca8 spare on ground 72.3 62.1 235.4 \n", "46932f795a5a degrade 79.5 69.0 253.5 \n", "6e4564d2ae2c produce 78.0 70.1 278.8 \n", "570a452fdb8f spare on ground 79.6 71.5 294.4 \n", @@ -783,16 +802,16 @@ "id": "58d5e989", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:06:23.241957Z", - "iopub.status.busy": "2026-11-14T08:06:23.241957Z", - "iopub.status.idle": "2026-11-14T08:06:23.605760Z", - "shell.execute_reply": "2026-11-14T08:06:23.605760Z" + "iopub.execute_input": "2026-11-14T15:44:04.949712Z", + "iopub.status.busy": "2026-11-14T15:44:04.949712Z", + "iopub.status.idle": "2026-11-14T15:44:05.297133Z", + "shell.execute_reply": "2026-11-14T15:44:05.297133Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -843,10 +862,10 @@ "id": "c687c0ed", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:06:23.605760Z", - "iopub.status.busy": "2026-11-14T08:06:23.605760Z", - "iopub.status.idle": "2026-11-14T08:06:23.874510Z", - "shell.execute_reply": "2026-11-14T08:06:23.874510Z" + "iopub.execute_input": "2026-11-14T15:44:05.297133Z", + "iopub.status.busy": "2026-11-14T15:44:05.297133Z", + "iopub.status.idle": "2026-11-14T15:44:05.595246Z", + "shell.execute_reply": "2026-11-14T15:44:05.595246Z" } }, "outputs": [ @@ -854,7 +873,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "1700 evaluations in 0 s\n" + "1900 evaluations in 0 s\n" ] }, { @@ -898,30 +917,30 @@ " \n", " \n", " points_seed\n", - " 92.4\n", - " 30.4\n", + " 88.7\n", + " 35.9\n", " 0.0\n", - " 6.4\n", - " 3.3\n", + " 8.6\n", + " 4.6\n", " 0.0\n", " \n", " \n", " cost_growth\n", " 0.0\n", " 0.0\n", - " 81.8\n", + " 78.6\n", " 0.0\n", " 0.0\n", " 19.0\n", " \n", " \n", " failure_seed\n", - " 3.6\n", - " 67.0\n", - " 35.8\n", + " 3.7\n", + " 65.4\n", + " 37.3\n", " 0.7\n", - " 6.5\n", - " 7.1\n", + " 6.9\n", + " 7.6\n", " \n", " \n", "\n", @@ -930,21 +949,21 @@ "text/plain": [ " accurate mission accurate mission histories p10 \\\n", "parameter \n", - "points_seed 92.4 30.4 \n", + "points_seed 88.7 35.9 \n", "cost_growth 0.0 0.0 \n", - "failure_seed 3.6 67.0 \n", + "failure_seed 3.7 65.4 \n", "\n", " cost histories p70 accurate mission se \\\n", "parameter \n", - "points_seed 0.0 6.4 \n", - "cost_growth 81.8 0.0 \n", - "failure_seed 35.8 0.7 \n", + "points_seed 0.0 8.6 \n", + "cost_growth 78.6 0.0 \n", + "failure_seed 37.3 0.7 \n", "\n", " accurate mission histories p10 se cost histories p70 se \n", "parameter \n", - "points_seed 3.3 0.0 \n", + "points_seed 4.6 0.0 \n", "cost_growth 0.0 19.0 \n", - "failure_seed 6.5 7.1 " + "failure_seed 6.9 7.6 " ] }, "execution_count": 7, @@ -979,16 +998,16 @@ "id": "608307dd", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:06:23.874510Z", - "iopub.status.busy": "2026-11-14T08:06:23.874510Z", - "iopub.status.idle": "2026-11-14T08:06:23.953804Z", - "shell.execute_reply": "2026-11-14T08:06:23.953804Z" + "iopub.execute_input": "2026-11-14T15:44:05.595246Z", + "iopub.status.busy": "2026-11-14T15:44:05.595246Z", + "iopub.status.idle": "2026-11-14T15:44:05.674082Z", + "shell.execute_reply": "2026-11-14T15:44:05.674082Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1022,9 +1041,9 @@ "id": "da3c8d4e", "metadata": {}, "source": [ - "The sample of points spreads the mean shares accurately sampled (92% of their variance between replicates), and the failures hardly do (4%), as each replicate averages 20 histories. The share in the worst 10% of the histories is spread mostly by the failures (67%, and 30% by the points), as a quantile of 20 histories is a noisy estimate. Both are noise of the estimates, with different remedies: more points would sharpen the means, and more histories the worst 10%, which is cheap.\n", + "The sample of points spreads the mean shares accurately sampled (89% of their variance between replicates), and the failures hardly do (4%), as each replicate averages 20 histories. The share in the worst 10% of the histories is spread mostly by the failures (65%, and 36% by the points), as a quantile of 20 histories is a noisy estimate. Both are noise of the estimates, with different remedies: more points would sharpen the means, and more histories the worst 10%, which is cheap.\n", "\n", - "The cost at 70% confidence is spread by the growth of the cost of development (82%), a risk of the mission, and by the failures (36%), which cost replacements and spares. These shares are the least certain, with standard errors of 19 and 7 points. The total shares of each objective sum to about 100% within their errors, so the parameters hardly interact." + "The cost at 70% confidence is spread by the growth of the cost of development (79%), a risk of the mission, and by the failures (37%), which cost replacements and spares. These shares are the least certain, with standard errors of 19 and 8 points. The total shares of each objective sum to about 100% within their errors, so the parameters hardly interact." ] }, { @@ -1041,10 +1060,10 @@ "id": "d53fe0cc", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:06:23.953804Z", - "iopub.status.busy": "2026-11-14T08:06:23.953804Z", - "iopub.status.idle": "2026-11-14T08:06:24.207649Z", - "shell.execute_reply": "2026-11-14T08:06:24.207649Z" + "iopub.execute_input": "2026-11-14T15:44:05.674082Z", + "iopub.status.busy": "2026-11-14T15:44:05.674082Z", + "iopub.status.idle": "2026-11-14T15:44:05.958791Z", + "shell.execute_reply": "2026-11-14T15:44:05.958791Z" } }, "outputs": [ @@ -1089,11 +1108,11 @@ " \n", " \n", " points_seed\n", - " 92.1\n", - " 30.4\n", + " 95.8\n", + " 42.7\n", " 0.0\n", - " 6.4\n", - " 4.5\n", + " 9.7\n", + " 7.2\n", " 0.0\n", " \n", " \n", @@ -1107,12 +1126,12 @@ " \n", " \n", " failure_seed\n", - " 2.9\n", - " 73.0\n", - " 105.8\n", + " 2.5\n", + " 72.6\n", + " 106.0\n", " 0.5\n", - " 6.5\n", - " 4.7\n", + " 8.6\n", + " 4.4\n", " \n", " \n", "\n", @@ -1121,21 +1140,21 @@ "text/plain": [ " accurate mission accurate mission histories p10 \\\n", "parameter \n", - "points_seed 92.1 30.4 \n", + "points_seed 95.8 42.7 \n", "cost_growth 0.0 0.0 \n", - "failure_seed 2.9 73.0 \n", + "failure_seed 2.5 72.6 \n", "\n", " cost histories p70 accurate mission se \\\n", "parameter \n", - "points_seed 0.0 6.4 \n", + "points_seed 0.0 9.7 \n", "cost_growth 0.0 0.0 \n", - "failure_seed 105.8 0.5 \n", + "failure_seed 106.0 0.5 \n", "\n", " accurate mission histories p10 se cost histories p70 se \n", "parameter \n", - "points_seed 4.5 0.0 \n", + "points_seed 7.2 0.0 \n", "cost_growth 0.0 0.0 \n", - "failure_seed 6.5 4.7 " + "failure_seed 8.6 4.4 " ] }, "execution_count": 9, @@ -1153,7 +1172,7 @@ "id": "a7a0fb65", "metadata": {}, "source": [ - "The growth of the cost of development cancels in every difference. All of these designs fly the same imager, whose development grows alike for each, so the growth is a risk of each mission but not a reason to prefer one design to another; the failures alone spread the differences of their costs. The shares differ by what spreads them: the sample of points for the means (92%), and mostly the histories for the worst 10% (73%). More points would settle the order of neighbors by their means, and more histories their order by the worst 10% and by cost." + "The growth of the cost of development cancels in every difference. All of these designs fly the same imager, whose development grows alike for each, so the growth is a risk of each mission but not a reason to prefer one design to another; the failures alone spread the differences of their costs. The shares differ by what spreads them: the sample of points for the means (96%), and mostly the histories for the worst 10% (73%). More points would settle the order of neighbors by their means, and more histories their order by the worst 10% and by cost." ] }, { @@ -1177,9 +1196,9 @@ "source": [ "## Notes\n", "\n", - "* Simulating failures is cheap, but evaluating each phase's satellites is not, and most phases repeat the same sets of satellites. The histories of a replicate are therefore evaluated together, with a cache that evaluates each set of satellites once (`evaluate_missions`, `PhaseCache`).\n", + "* Simulating failures is cheap, but evaluating each phase's satellites is not, and most phases repeat the same sets of satellites. The histories of a replicate are therefore evaluated together, with a cache that evaluates each set of satellites once (`evaluate_histories`, `PhaseCache`).\n", "* The histories are stratified: each satellite's life and each launch is drawn from its own stratum of its distribution, which estimates means several times more precisely than independent histories (`Deployment.simulate_many`).\n", - "* Without restoration (degrading), satellites fail independently, so the mean share over the failures is computed exactly, from the probability that each set of satellites operates (`expected_missions`); its worst 10% and its cost still come from the histories.\n", + "* Without restoration (degrading), satellites fail independently, so the mean share over the failures is computed exactly, from the probability that each set of satellites operates (`exact_expectations`); its worst 10% and its cost still come from the histories.\n", "* A design life does not retire a satellite, and a replacement whose launch fails is not flown again (see `DeploymentSchedule`)." ] } diff --git a/docs/examples/tradespace/RankUncertainDesigns.ipynb b/docs/examples/tradespace/RankUncertainDesigns.ipynb index 80885c28..ba01f6ca 100644 --- a/docs/examples/tradespace/RankUncertainDesigns.ipynb +++ b/docs/examples/tradespace/RankUncertainDesigns.ipynb @@ -25,10 +25,10 @@ "id": "cc653395", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:05:39.675555Z", - "iopub.status.busy": "2026-11-14T08:05:39.673497Z", - "iopub.status.idle": "2026-11-14T08:05:42.202106Z", - "shell.execute_reply": "2026-11-14T08:05:42.202106Z" + "iopub.execute_input": "2026-11-14T15:43:22.553883Z", + "iopub.status.busy": "2026-11-14T15:43:22.553883Z", + "iopub.status.idle": "2026-11-14T15:43:24.983545Z", + "shell.execute_reply": "2026-11-14T15:43:24.983545Z" } }, "outputs": [ @@ -63,10 +63,10 @@ "id": "4aef9718", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:05:42.204110Z", - "iopub.status.busy": "2026-11-14T08:05:42.204110Z", - "iopub.status.idle": "2026-11-14T08:05:43.433591Z", - "shell.execute_reply": "2026-11-14T08:05:43.433591Z" + "iopub.execute_input": "2026-11-14T15:43:24.985548Z", + "iopub.status.busy": "2026-11-14T15:43:24.985548Z", + "iopub.status.idle": "2026-11-14T15:43:26.232628Z", + "shell.execute_reply": "2026-11-14T15:43:26.232628Z" } }, "outputs": [ @@ -303,10 +303,10 @@ "id": "19cf5721", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:05:43.433591Z", - "iopub.status.busy": "2026-11-14T08:05:43.433591Z", - "iopub.status.idle": "2026-11-14T08:05:43.877032Z", - "shell.execute_reply": "2026-11-14T08:05:43.877032Z" + "iopub.execute_input": "2026-11-14T15:43:26.234633Z", + "iopub.status.busy": "2026-11-14T15:43:26.234633Z", + "iopub.status.idle": "2026-11-14T15:43:26.673639Z", + "shell.execute_reply": "2026-11-14T15:43:26.673639Z" } }, "outputs": [ @@ -374,10 +374,10 @@ "id": "104737eb", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:05:43.877032Z", - "iopub.status.busy": "2026-11-14T08:05:43.877032Z", - "iopub.status.idle": "2026-11-14T08:05:57.168871Z", - "shell.execute_reply": "2026-11-14T08:05:57.168871Z" + "iopub.execute_input": "2026-11-14T15:43:26.675397Z", + "iopub.status.busy": "2026-11-14T15:43:26.675397Z", + "iopub.status.idle": "2026-11-14T15:43:40.110219Z", + "shell.execute_reply": "2026-11-14T15:43:40.110219Z" } }, "outputs": [ @@ -505,9 +505,9 @@ "source": [ "from tatc.tradespace import Criteria, refine\n", "\n", - "CRITERIA = Criteria(OBJECTIVES, tolerance={\"sufficient\": 1.0}) # percentage points that do not matter\n", + "CRITERIA = Criteria(OBJECTIVES, tolerances={\"sufficient\": 1.0}) # percentage points that do not matter\n", "refinement = refine(study, CRITERIA, results, step=5, max_replicates=40, n_resamples=1000)\n", - "added = len(refinement.results) - len(results)\n", + "added = refinement.evaluations\n", "print(f\"{added} evaluations added, {added / (len(designs) * 35):.1%} of those of 40 replicates of every design\")\n", "refinement.history" ] @@ -518,10 +518,10 @@ "id": "355e4987", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:05:57.168871Z", - "iopub.status.busy": "2026-11-14T08:05:57.168871Z", - "iopub.status.idle": "2026-11-14T08:05:57.312415Z", - "shell.execute_reply": "2026-11-14T08:05:57.312415Z" + "iopub.execute_input": "2026-11-14T15:43:40.110219Z", + "iopub.status.busy": "2026-11-14T15:43:40.110219Z", + "iopub.status.idle": "2026-11-14T15:43:40.283707Z", + "shell.execute_reply": "2026-11-14T15:43:40.283707Z" } }, "outputs": [ @@ -1017,10 +1017,10 @@ "id": "807da56f", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:05:57.312415Z", - "iopub.status.busy": "2026-11-14T08:05:57.312415Z", - "iopub.status.idle": "2026-11-14T08:05:57.407951Z", - "shell.execute_reply": "2026-11-14T08:05:57.407951Z" + "iopub.execute_input": "2026-11-14T15:43:40.286945Z", + "iopub.status.busy": "2026-11-14T15:43:40.286945Z", + "iopub.status.idle": "2026-11-14T15:43:40.378440Z", + "shell.execute_reply": "2026-11-14T15:43:40.378440Z" } }, "outputs": [ @@ -1183,10 +1183,10 @@ "id": "99289e48", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:05:57.407951Z", - "iopub.status.busy": "2026-11-14T08:05:57.407951Z", - "iopub.status.idle": "2026-11-14T08:05:57.535610Z", - "shell.execute_reply": "2026-11-14T08:05:57.535610Z" + "iopub.execute_input": "2026-11-14T15:43:40.378440Z", + "iopub.status.busy": "2026-11-14T15:43:40.378440Z", + "iopub.status.idle": "2026-11-14T15:43:40.457984Z", + "shell.execute_reply": "2026-11-14T15:43:40.457984Z" } }, "outputs": [ @@ -1251,10 +1251,10 @@ "id": "419f7f85", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:05:57.535610Z", - "iopub.status.busy": "2026-11-14T08:05:57.535610Z", - "iopub.status.idle": "2026-11-14T08:05:58.648984Z", - "shell.execute_reply": "2026-11-14T08:05:58.648984Z" + "iopub.execute_input": "2026-11-14T15:43:40.457984Z", + "iopub.status.busy": "2026-11-14T15:43:40.457984Z", + "iopub.status.idle": "2026-11-14T15:43:41.777398Z", + "shell.execute_reply": "2026-11-14T15:43:41.777398Z" } }, "outputs": [ @@ -1392,10 +1392,10 @@ "id": "da41d282", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:05:58.648984Z", - "iopub.status.busy": "2026-11-14T08:05:58.648984Z", - "iopub.status.idle": "2026-11-14T08:05:58.745115Z", - "shell.execute_reply": "2026-11-14T08:05:58.745115Z" + "iopub.execute_input": "2026-11-14T15:43:41.777398Z", + "iopub.status.busy": "2026-11-14T15:43:41.777398Z", + "iopub.status.idle": "2026-11-14T15:43:41.888212Z", + "shell.execute_reply": "2026-11-14T15:43:41.888212Z" } }, "outputs": [ diff --git a/docs/examples/tradespace/SearchTradeSpace.ipynb b/docs/examples/tradespace/SearchTradeSpace.ipynb index d8a1a025..35da1428 100644 --- a/docs/examples/tradespace/SearchTradeSpace.ipynb +++ b/docs/examples/tradespace/SearchTradeSpace.ipynb @@ -34,10 +34,10 @@ "id": "01692fbc", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:05:32.143944Z", - "iopub.status.busy": "2026-11-14T08:05:32.143944Z", - "iopub.status.idle": "2026-11-14T08:05:34.609205Z", - "shell.execute_reply": "2026-11-14T08:05:34.609205Z" + "iopub.execute_input": "2026-11-14T15:43:14.742854Z", + "iopub.status.busy": "2026-11-14T15:43:14.741854Z", + "iopub.status.idle": "2026-11-14T15:43:17.184511Z", + "shell.execute_reply": "2026-11-14T15:43:17.184511Z" } }, "outputs": [ @@ -79,10 +79,10 @@ "id": "35495471", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:05:34.611199Z", - "iopub.status.busy": "2026-11-14T08:05:34.611199Z", - "iopub.status.idle": "2026-11-14T08:05:35.148670Z", - "shell.execute_reply": "2026-11-14T08:05:35.147665Z" + "iopub.execute_input": "2026-11-14T15:43:17.184511Z", + "iopub.status.busy": "2026-11-14T15:43:17.184511Z", + "iopub.status.idle": "2026-11-14T15:43:17.753797Z", + "shell.execute_reply": "2026-11-14T15:43:17.753797Z" } }, "outputs": [ @@ -199,7 +199,7 @@ "rows = []\n", "for hours, keep in [(12, 0.05), (12, 0.1), (6, 0.05), (6, 0.2)]:\n", " screening = screen([cheap_study(hours), study], OBJECTIVES, designs, keep=keep)\n", - " days = screening.results.stage.map({0: hours / 24, 1: 1.0}) # of each analysis, by the cheap or the full study\n", + " days = screening.history.stage.map({0: hours / 24, 1: 1.0}) # of each analysis, by the cheap or the full study\n", " kept = {d.key for d in screening.designs}\n", " rows.append(\n", " {\n", @@ -208,7 +208,7 @@ " \"designs kept\": len(kept),\n", " \"efficient designs kept\": f\"{len(true_front & kept)} of {len(true_front)}\",\n", " \"hypervolume (%)\": 100 * hypervolume(screening.summary, OBJECTIVES, REFERENCE) / true_hypervolume,\n", - " \"cost (%)\": 100 * (screening.results.satellites * days).sum() / full_cost,\n", + " \"cost (%)\": 100 * (screening.history.satellites * days).sum() / full_cost,\n", " }\n", " )\n", "pd.DataFrame(rows).round(1)" @@ -245,10 +245,10 @@ "id": "01e8217c", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:05:35.149669Z", - "iopub.status.busy": "2026-11-14T08:05:35.149669Z", - "iopub.status.idle": "2026-11-14T08:05:36.804151Z", - "shell.execute_reply": "2026-11-14T08:05:36.804151Z" + "iopub.execute_input": "2026-11-14T15:43:17.753797Z", + "iopub.status.busy": "2026-11-14T15:43:17.753797Z", + "iopub.status.idle": "2026-11-14T15:43:19.561285Z", + "shell.execute_reply": "2026-11-14T15:43:19.561285Z" } }, "outputs": [ @@ -347,10 +347,10 @@ "id": "ce572cad", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:05:36.804151Z", - "iopub.status.busy": "2026-11-14T08:05:36.804151Z", - "iopub.status.idle": "2026-11-14T08:05:37.294696Z", - "shell.execute_reply": "2026-11-14T08:05:37.294696Z" + "iopub.execute_input": "2026-11-14T15:43:19.561285Z", + "iopub.status.busy": "2026-11-14T15:43:19.561285Z", + "iopub.status.idle": "2026-11-14T15:43:20.050928Z", + "shell.execute_reply": "2026-11-14T15:43:20.050928Z" } }, "outputs": [ @@ -394,10 +394,10 @@ "id": "d8c9d612", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:05:37.297375Z", - "iopub.status.busy": "2026-11-14T08:05:37.295717Z", - "iopub.status.idle": "2026-11-14T08:05:37.531094Z", - "shell.execute_reply": "2026-11-14T08:05:37.531094Z" + "iopub.execute_input": "2026-11-14T15:43:20.050928Z", + "iopub.status.busy": "2026-11-14T15:43:20.050928Z", + "iopub.status.idle": "2026-11-14T15:43:20.303984Z", + "shell.execute_reply": "2026-11-14T15:43:20.303984Z" } }, "outputs": [ diff --git a/docs/examples/tradespace/TradeCostAndUtility.ipynb b/docs/examples/tradespace/TradeCostAndUtility.ipynb index 50892592..5b9f3a2b 100644 --- a/docs/examples/tradespace/TradeCostAndUtility.ipynb +++ b/docs/examples/tradespace/TradeCostAndUtility.ipynb @@ -40,10 +40,10 @@ "id": "216ec565", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:06:08.329801Z", - "iopub.status.busy": "2026-11-14T08:06:08.329801Z", - "iopub.status.idle": "2026-11-14T08:06:10.901833Z", - "shell.execute_reply": "2026-11-14T08:06:10.901833Z" + "iopub.execute_input": "2026-11-14T15:43:51.170741Z", + "iopub.status.busy": "2026-11-14T15:43:51.170741Z", + "iopub.status.idle": "2026-11-14T15:43:53.762661Z", + "shell.execute_reply": "2026-11-14T15:43:53.762661Z" } }, "outputs": [ @@ -224,10 +224,10 @@ "id": "80fc3006", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:06:10.901833Z", - "iopub.status.busy": "2026-11-14T08:06:10.901833Z", - "iopub.status.idle": "2026-11-14T08:06:11.391367Z", - "shell.execute_reply": "2026-11-14T08:06:11.391367Z" + "iopub.execute_input": "2026-11-14T15:43:53.762661Z", + "iopub.status.busy": "2026-11-14T15:43:53.762661Z", + "iopub.status.idle": "2026-11-14T15:43:54.255400Z", + "shell.execute_reply": "2026-11-14T15:43:54.255400Z" } }, "outputs": [ @@ -240,7 +240,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -287,10 +287,10 @@ "id": "c732c5b8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:06:11.391367Z", - "iopub.status.busy": "2026-11-14T08:06:11.391367Z", - "iopub.status.idle": "2026-11-14T08:06:11.407002Z", - "shell.execute_reply": "2026-11-14T08:06:11.407002Z" + "iopub.execute_input": "2026-11-14T15:43:54.255400Z", + "iopub.status.busy": "2026-11-14T15:43:54.255400Z", + "iopub.status.idle": "2026-11-14T15:43:54.271836Z", + "shell.execute_reply": "2026-11-14T15:43:54.271836Z" } }, "outputs": [ @@ -503,16 +503,16 @@ "id": "ae075375", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:06:11.407002Z", - "iopub.status.busy": "2026-11-14T08:06:11.407002Z", - "iopub.status.idle": "2026-11-14T08:06:11.771508Z", - "shell.execute_reply": "2026-11-14T08:06:11.771508Z" + "iopub.execute_input": "2026-11-14T15:43:54.273566Z", + "iopub.status.busy": "2026-11-14T15:43:54.273566Z", + "iopub.status.idle": "2026-11-14T15:43:54.636789Z", + "shell.execute_reply": "2026-11-14T15:43:54.636280Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -564,10 +564,10 @@ "id": "ab147572", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T08:06:11.771508Z", - "iopub.status.busy": "2026-11-14T08:06:11.771508Z", - "iopub.status.idle": "2026-11-14T08:06:11.787515Z", - "shell.execute_reply": "2026-11-14T08:06:11.787515Z" + "iopub.execute_input": "2026-11-14T15:43:54.638453Z", + "iopub.status.busy": "2026-11-14T15:43:54.638453Z", + "iopub.status.idle": "2026-11-14T15:43:54.652143Z", + "shell.execute_reply": "2026-11-14T15:43:54.652143Z" } }, "outputs": [ @@ -626,26 +626,39 @@ " \n", " \n", " \n", - " d7161d3cbaa7\n", - " 800 km, 60 deg FOR, SSO: 1 at 12:00, 2 at 18:00\n", + " aa335914661d\n", + " 800 km, 30 deg FOR, SSO: 1 at 09:00, 2 at 15:00\n", " 3\n", " 2\n", - " 29.2\n", - " 57.0\n", - " 156.65\n", - " 0.44\n", + " 6.6\n", + " 15.4\n", + " 117.10\n", + " 0.14\n", + " True\n", + " 0.23\n", + " False\n", + " \n", + " \n", + " d724deb26c78\n", + " 800 km, 30 deg FOR, SSO: 1 at 12:00, 2 at 18:00\n", + " 3\n", + " 2\n", + " 4.4\n", + " 16.2\n", + " 117.10\n", + " 0.13\n", " False\n", - " 0.64\n", + " 0.24\n", " True\n", " \n", " \n", - " d5bff0394d77\n", - " 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00\n", + " 87addc291d43\n", + " 800 km, 60 deg FOR, SSO: 1 at 09:00, 2 at 15:00\n", " 3\n", " 2\n", " 28.8\n", " 60.6\n", - " 156.90\n", + " 156.65\n", " 0.45\n", " False\n", " 0.66\n", @@ -665,8 +678,8 @@ " False\n", " \n", " \n", - " dfd5eb7d33d2\n", - " 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00\n", + " 904a205f7cd9\n", + " 800 km, 60 deg FOR, SSO: 2 at 09:00, 2 at 15:00\n", " 4\n", " 2\n", " 57.6\n", @@ -710,37 +723,41 @@ "text/plain": [ " description satellites \\\n", "design \n", - "d7161d3cbaa7 800 km, 60 deg FOR, SSO: 1 at 12:00, 2 at 18:00 3 \n", - "d5bff0394d77 800 km, 60 deg FOR, SSO: 2 at 15:00, 1 at 09:00 3 \n", + "aa335914661d 800 km, 30 deg FOR, SSO: 1 at 09:00, 2 at 15:00 3 \n", + "d724deb26c78 800 km, 30 deg FOR, SSO: 1 at 12:00, 2 at 18:00 3 \n", + "87addc291d43 800 km, 60 deg FOR, SSO: 1 at 09:00, 2 at 15:00 3 \n", "6ba50f2632cd 800 km, 60 deg FOR, Walker 45 deg: 2 x 2 (spac... 4 \n", - "dfd5eb7d33d2 800 km, 60 deg FOR, SSO: 2 at 15:00, 2 at 09:00 4 \n", + "904a205f7cd9 800 km, 60 deg FOR, SSO: 2 at 09:00, 2 at 15:00 4 \n", "7d5b745cf8f6 800 km, 60 deg FOR, Walker 45 deg: 4 x 1 (spac... 4 \n", "64cf6542c326 800 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spac... 6 \n", "\n", " planes sufficient accurate cost p70 utility (sufficiency) \\\n", "design \n", - "d7161d3cbaa7 2 29.2 57.0 156.65 0.44 \n", - "d5bff0394d77 2 28.8 60.6 156.90 0.45 \n", + "aa335914661d 2 6.6 15.4 117.10 0.14 \n", + "d724deb26c78 2 4.4 16.2 117.10 0.13 \n", + "87addc291d43 2 28.8 60.6 156.65 0.45 \n", "6ba50f2632cd 2 69.6 65.4 173.73 0.74 \n", - "dfd5eb7d33d2 2 57.6 85.4 173.73 0.69 \n", + "904a205f7cd9 2 57.6 85.4 173.73 0.69 \n", "7d5b745cf8f6 4 68.6 71.2 188.73 0.74 \n", "64cf6542c326 3 90.2 95.8 213.53 0.93 \n", "\n", " efficient (sufficiency) utility (accuracy) \\\n", "design \n", - "d7161d3cbaa7 False 0.64 \n", - "d5bff0394d77 False 0.66 \n", + "aa335914661d True 0.23 \n", + "d724deb26c78 False 0.24 \n", + "87addc291d43 False 0.66 \n", "6ba50f2632cd True 0.80 \n", - "dfd5eb7d33d2 False 0.84 \n", + "904a205f7cd9 False 0.84 \n", "7d5b745cf8f6 True 0.82 \n", "64cf6542c326 False 0.96 \n", "\n", " efficient (accuracy) \n", "design \n", - "d7161d3cbaa7 True \n", - "d5bff0394d77 True \n", + "aa335914661d False \n", + "d724deb26c78 True \n", + "87addc291d43 True \n", "6ba50f2632cd False \n", - "dfd5eb7d33d2 True \n", + "904a205f7cd9 True \n", "7d5b745cf8f6 False \n", "64cf6542c326 True " ] @@ -766,7 +783,7 @@ "id": "ed863e18", "metadata": {}, "source": [ - "Within the budget, the stakeholders agree: every design efficient for either of them up to 150 million dollars is efficient for both, as more satellites in more planes buy both shares. Beyond the budget, they part. For 174 million dollars at 70% confidence, the stakeholder of sufficiency prefers four satellites in two Walker planes (70% of the points sufficiently sampled, and 65% accurately), and the stakeholder of accuracy four satellites in two sun-synchronous planes crossing at 09:00 and 15:00 (58% and 85%), whose planes spread the samples over the day. The stakeholder of accuracy also finds three satellites in two sun-synchronous planes efficient for 157 million, and six satellites in three Walker planes for 214 million, which the stakeholder of sufficiency passes over." + "Within the budget, the stakeholders nearly agree, as more satellites in more planes buy both shares: they part only on two designs of three satellites in two sun-synchronous planes with a 30-degree field of regard, which cost the same (117 million dollars), of which the stakeholder of sufficiency prefers the planes crossing at 09:00 and 15:00 and the stakeholder of accuracy those crossing at 12:00 and 18:00. Beyond the budget, they part more. For 174 million dollars at 70% confidence, the stakeholder of sufficiency prefers four satellites in two Walker planes (70% of the points sufficiently sampled, and 65% accurately), and the stakeholder of accuracy four satellites in two sun-synchronous planes crossing at 09:00 and 15:00 (58% and 85%), whose planes spread the samples over the day. The stakeholder of accuracy also finds three satellites in two sun-synchronous planes efficient for 157 million, and six satellites in three Walker planes for 214 million, which the stakeholder of sufficiency passes over." ] }, { diff --git a/docs/examples/tradespace/trade_space_example.py b/docs/examples/tradespace/trade_space_example.py index 775a51b1..b5ad9124 100644 --- a/docs/examples/tradespace/trade_space_example.py +++ b/docs/examples/tradespace/trade_space_example.py @@ -32,10 +32,10 @@ Uncertain, build_constellation, count_satellites, + layout_of, sso_planes_space, walker_space, ) -from tatc.tradespace.constellations import layout_of # EvaluateTradeSpace: the design space, and the study of sufficient sampling diff --git a/src/tatc/tradespace/__init__.py b/src/tatc/tradespace/__init__.py index 3716b42c..e3f7336f 100644 --- a/src/tatc/tradespace/__init__.py +++ b/src/tatc/tradespace/__init__.py @@ -26,6 +26,7 @@ build_constellation, count_planes, count_satellites, + layout_of, mog_space, planes_space, soc_space, @@ -41,20 +42,7 @@ Triangular, risk_space, ) -from .criteria import ( - Across, - Criteria, - Maximum, - Mean, - Minimum, - Probability, - Quantile, - Requirement, - StandardDeviation, - StandardError, - aggregate, - summarize, -) +from .criteria import Across, Criteria, Requirement from .deployment import DeploymentSchedule, Stage from .failures import ( Bathtub, @@ -76,15 +64,10 @@ Repeat, Uncertain, ) -from .observations import Failures, MissionPlan, ObservationStudy, Observations, Targets +from .observations import ObservationStudy, Observations, Targets from .optimization import optimize_optuna, optimize_pymoo -from .pareto import ( - hypervolume, - hypervolume_progress, - pareto_front, - pareto_probability, - pareto_ranks, -) +from .pareto import hypervolume, hypervolume_progress, pareto_front, pareto_ranks +from .plans import Failures, MissionPlan from .plotting import ( COLORS, GRAY, @@ -102,8 +85,18 @@ from .screening import screen from .sensitivity import main_effects, sensitivity from .space import Design, DesignSpace +from .statistics import ( + Maximum, + Mean, + Minimum, + Probability, + Quantile, + StandardDeviation, + StandardError, +) from .store import ResultStore from .study import Study +from .summary import aggregate, pareto_probability, summarize from .utility import ExponentialUtility, LinearUtility, PiecewiseUtility, Utility __all__ = [ @@ -122,6 +115,7 @@ "build_constellation", "count_planes", "count_satellites", + "layout_of", "mog_space", "planes_space", "policy_space", diff --git a/src/tatc/tradespace/alerts.py b/src/tatc/tradespace/alerts.py new file mode 100644 index 00000000..d971c2a2 --- /dev/null +++ b/src/tatc/tradespace/alerts.py @@ -0,0 +1,38 @@ +""" +Warnings of trade studies, which point at the call into the trade space +module that leads to them (rather than at the module's own code), however +deep within the module they are given. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +import sys +import warnings + +_PACKAGE = __name__.rpartition(".")[0] +"""The name of the package whose frames a warning skips.""" + + +def _warn(message: str, category: type[Warning] = UserWarning) -> None: + """ + Gives a warning at the first frame of the stack outside the package + (the user's call into it), as `warnings.warn` would with the stack level + of that frame. + + Args: + message (str): The message. + category (type[Warning]): The category of the warning. + """ + level, frame = 2, sys._getframe(1) # pylint: disable=protected-access + while frame is not None and _is_package(frame.f_globals.get("__name__")): + frame, level = frame.f_back, level + 1 + warnings.warn(message, category, stacklevel=level) + + +def _is_package(module: object) -> bool: + """Whether a module name is of the package (or the package itself).""" + return isinstance(module, str) and ( + module == _PACKAGE or module.startswith(_PACKAGE + ".") + ) diff --git a/src/tatc/tradespace/attribution.py b/src/tatc/tradespace/attribution.py index 186321a6..26cd6e6d 100644 --- a/src/tatc/tradespace/attribution.py +++ b/src/tatc/tradespace/attribution.py @@ -16,9 +16,11 @@ import numpy as np import pandas as pd -from .criteria import _names, _resamples -from .space import Design, DesignSpace, _check_uncertain, _designs, _generic +from .space import Design, DesignSpace, _designs +from .statistics import _names from .study import Study +from .summary import _resamples +from .walks import _generic _SHARES = ("first", "total") """The shares of variance of a parameter (see `attribute_variance`).""" @@ -28,7 +30,10 @@ class Attribution: """ The attribution of the variance of the metrics of designs between their - replicates to their uncertain parameters (see `attribute_variance`). + replicates to their uncertain parameters (see `attribute_variance`): as + the outcomes of other steps of a trade study (see `Refinement`), its + `results`, its `summary` (of the shares of the parameters over every + design), and the `designs` attributed. """ results: pd.DataFrame @@ -263,7 +268,7 @@ def _groups_of( if not groups: raise ValueError("no parameters to attribute variance to") paths = [path for group in groups.values() for path in group] - _check_uncertain(space, paths) + space.check_uncertain(paths) repeated = sorted({path for path in paths if paths.count(path) > 1}) if repeated: raise ValueError(f"parameters in more than one group: {repeated}") diff --git a/src/tatc/tradespace/cache.py b/src/tatc/tradespace/cache.py index c4b6c400..764428e8 100644 --- a/src/tatc/tradespace/cache.py +++ b/src/tatc/tradespace/cache.py @@ -19,7 +19,6 @@ import shutil import tempfile import time -import warnings from collections.abc import Callable, Iterable from pathlib import Path from typing import Any @@ -27,7 +26,12 @@ import pandas as pd from ..schemas import Satellite -from .fingerprint import _fingerprint_of, _with_other_code, get_definition +from .fingerprint import ( + _fingerprint_of, + _warn_other_code, + _with_other_code, + get_definition, +) from .hashing import _canonical, _digest @@ -96,17 +100,18 @@ class SatelliteCache: a `namespace`, which must identify what the fingerprint cannot see (data the function reads, such as from files, and the code of other modules it calls, other than TAT-C's: change it whenever these change), and by the - satellite, in a folder of - each namespace (by a hash of it, with the namespace in `namespace.txt`), - and in it a folder of each fingerprint (with the definition in - `definition.json`). A cache warns if its namespace has results only of - the same function with other code (of the function, of TAT-C, or of - Python: the same values but for code, as a study warns of its store, see - `Study`), which it does not reuse, with the differences from the latest - (see `compare_definitions`), and removes them with `prune` (see - `Observations.prune` for the caches of the observations of a study). A result that cannot be read (such as one - written with other versions of the libraries of its data) is computed - again. + satellite, in a folder of each namespace (by a hash of it, with the + namespace in `namespace.txt`), and in it a folder of each fingerprint + (with the definition in `definition.json`). + + A cache warns if its namespace has results only of the same function + with other code (of the function, of TAT-C, or of Python: the same values + but for code, as a study warns of its store, see `Study`), which it does + not reuse, with the differences from the latest (see + `compare_definitions`), and removes them with `prune` (see + `Observations.prune` for the caches of the observations of a study). A + result that cannot be read (such as one written with other versions of + the libraries of its data) is computed again. Args: function (Callable): The analysis of one satellite. @@ -144,7 +149,7 @@ def __init__( _write(self._folder.parent / "namespace.txt", namespace.encode()) _write(self._folder / "definition.json", _canonical(definition).encode()) self._definition = definition - self._warn_other_definitions(definition) + self._warn_other_definitions() @property def folder(self) -> Path | None: @@ -158,35 +163,34 @@ def __getstate__(self) -> dict: state["_memory"], state["_unreadable"] = {}, set() return state - def _others(self) -> list[Path]: + def _stale(self) -> dict[Path, int]: """ - Gets the folders of the results of the namespace by other definitions - of the function (that hold results), the latest last. + Gets the folders of the results of the namespace by the function with + other code (the same values but for code, see `_with_other_code`), + the latest first, and their numbers of results (including folders of + definitions without results). """ folders = [ folder for folder in self._folder.parent.iterdir() - if folder.is_dir() - and folder != self._folder - and next(folder.glob("*.pkl"), None) is not None + if folder.is_dir() and folder != self._folder ] - return sorted(folders, key=lambda folder: folder.stat().st_mtime) - - def _warn_other_definitions(self, definition: dict) -> None: + folders.sort(key=lambda folder: folder.stat().st_mtime, reverse=True) + others = {folder: _read_definition(folder) for folder in folders} + return { + folder: sum(1 for _ in folder.glob("*.pkl")) + for folder in _with_other_code(self._definition, others) + } + + def _warn_other_definitions(self) -> None: """ Warns if the namespace has results only of the function with other - code (see `_with_other_code`), with the differences from the latest, - once (of the caches of the definition, such as those of parallel - workers). + code (see `_stale`), with the differences from the latest, once (of + the caches of the definition, such as those of parallel workers). """ if next(self._folder.glob("*.pkl"), None) is not None: return - others = self._others() - stale = [ - folder - for folder in reversed(others) - if _with_other_code(definition, [_read_definition(folder)]) is not None - ] + stale = {folder: count for folder, count in self._stale().items() if count} if not stale: return try: @@ -195,15 +199,12 @@ def _warn_other_definitions(self, definition: dict) -> None: pass except FileExistsError: return - count = sum(1 for folder in stale for _ in folder.glob("*.pkl")) - differences = _with_other_code(definition, [_read_definition(stale[0])]) - warnings.warn( - f"the cache in {self.directory} has {count} results of namespace " - + f"{self.namespace!r} by its function with other code, which are not " - + "reused (prune removes them: Observations.prune for the observations " - + "of a study); the latest differs in: " - + "; ".join(differences or []), - stacklevel=3, + _warn_other_code( + f"the cache in {self.directory} has {sum(stale.values())} results of " + + f"namespace {self.namespace!r} by its function", + "prune removes them: Observations.prune for the observations of a study", + _read_definition(next(iter(stale))), + self._definition, ) def prune(self) -> int: @@ -218,16 +219,10 @@ def prune(self) -> int: """ if self._folder is None: return 0 - removed = 0 - for folder in self._folder.parent.iterdir(): - if not folder.is_dir() or folder == self._folder: - continue - other = _read_definition(folder) - if _with_other_code(self._definition, [other]) is None: - continue # of another function - removed += sum(1 for _ in folder.glob("*.pkl")) + stale = self._stale() + for folder in stale: shutil.rmtree(folder, ignore_errors=True) - return removed + return sum(stale.values()) def _path(self, key: str) -> Path: return self._folder / f"{key}.pkl" diff --git a/src/tatc/tradespace/comparison.py b/src/tatc/tradespace/comparison.py index 66da55a0..520d2797 100644 --- a/src/tatc/tradespace/comparison.py +++ b/src/tatc/tradespace/comparison.py @@ -23,8 +23,8 @@ import numpy as np import pandas as pd -from .criteria import _get_matrices, _groups from .space import Design, _keys_of +from .summary import _get_matrices, _groups def exceedance( @@ -98,7 +98,9 @@ def exceedance( continue if "feasible" in group: group = group[group["feasible"].astype(bool)] - _, _, matrices = _get_matrices(group, [metric], index) + _, _, matrices = _get_matrices( + group, [metric], index, hint="give the columns that separate them as `by`" + ) values = matrices[metric] valid = ~np.isnan(values) if keys is None: diff --git a/src/tatc/tradespace/confirmation.py b/src/tatc/tradespace/confirmation.py index ed0c05e2..ba4d2fc0 100644 --- a/src/tatc/tradespace/confirmation.py +++ b/src/tatc/tradespace/confirmation.py @@ -13,19 +13,22 @@ import numpy as np import pandas as pd -from .criteria import Criteria, _as_criteria, aggregate +from .criteria import Criteria, _as_criteria from .space import Design, _designs from .study import Study +from .summary import _FEASIBLE, _JUDGMENT, aggregate @dataclass class Confirmation: """ - The outcome of a confirmation (see `confirm`): its `results`, the - `summary` of its designs, and the `designs` themselves, as the outcomes of - other steps of a trade study (see `Refinement`). Its results are only - those of the new replicates, which judge the designs without the - optimism of their selection. + The outcome of a confirmation (see `confirm`): as the outcomes of other + steps of a trade study (see `Refinement`), its `results`, the `summary` + of its designs, the `designs` it selects for a next step (those it + confirmed), and its `criteria`. Its results are only those of the new + replicates, which judge the designs without the optimism of their + selection: the designs still efficient by them are those of + `summary.pareto`. """ results: pd.DataFrame @@ -38,13 +41,15 @@ class Confirmation: optimism of the selection in each objective (` optimism`: by how much the selecting replicates made the design look better than the new replicates do, in its units, positive if they did), the number of - new `replicates`, the `violation` of the requirements, and whether the - design meets them (`meets_requirements`) and is efficient among the - confirmed designs that do (`pareto`), by the new replicates.""" + new feasible `replicates`, the share of the new replicates that are + `feasible`, the `violation` of the requirements, and whether the design + meets them (`meets_requirements`) and is efficient among the confirmed + designs that do (`pareto`), by the new replicates.""" criteria: Criteria """Criteria: The criteria of the confirmation.""" designs: list[Design] = field(default_factory=list) - """list[Design]: The confirmed designs.""" + """list[Design]: The confirmed designs (every design evaluated with new + replicates).""" @property def optimism(self) -> pd.Series: @@ -71,7 +76,9 @@ def confirm( ) -> Confirmation: """ Confirms selected designs (by default, the Pareto front of the results, - or the best designs of an optimizer) with new replicates. + or the designs that another step selects, such as the efficient designs + of a refinement or a search, see `Refinement.designs`) with new + replicates. Designs selected for their outcomes in some replicates are selected in part for the luck of those replicates: among many designs, the best @@ -94,7 +101,8 @@ def confirm( or search. designs (Sequence[Design | str] | pandas.DataFrame | None): The selected designs (designs, their keys, or a data frame of them, - such as rows of a summary), or `None` for those efficient by + such as rows of a summary, or the `designs` of another step), + or `None` for those efficient by the criteria over every replicate of the results (see `aggregate` and `pareto_front`). replicates (int | None): The number of new replicates, or `None` for @@ -115,7 +123,7 @@ def confirm( keys = {design.key for design in designs} start = int(results["replicate"].max()) + 1 if len(results) > 0 else 0 fresh = study.run(designs, replicate_indices=range(start, start + count)) - names = criteria.names + names = [name for name in criteria.names if name != _FEASIBLE] columns = ["design", *criteria.by] confirmed = aggregate(fresh, criteria) selected = aggregate( @@ -131,7 +139,7 @@ def confirm( summary[f"{name} optimism"] = sign * ( summary[f"{name} selected"] - summary[name] ) - status = ["replicates", "violation", "meets_requirements", "pareto"] + status = ["replicates", _FEASIBLE, *_JUDGMENT] values = [c for c in confirmed.columns if c not in {*columns, *names, *status}] summary = summary[ [ diff --git a/src/tatc/tradespace/constellations.py b/src/tatc/tradespace/constellations.py index d181970e..e77157c4 100644 --- a/src/tatc/tradespace/constellations.py +++ b/src/tatc/tradespace/constellations.py @@ -73,15 +73,15 @@ def build(d): from .values import ChoiceValues, RepeatValues, Scope, Values WALKER = "walker" -"""The kind of the layouts of `walker_space`.""" +"""The pattern of the layouts of `walker_space`.""" SSO_PLANES = "sso planes" -"""The kind of the layouts of `sso_planes_space`.""" +"""The pattern of the layouts of `sso_planes_space`.""" PLANES = "planes" -"""The kind of the layouts of `planes_space`.""" +"""The pattern of the layouts of `planes_space`.""" SOC = "soc" -"""The kind of the layouts of `soc_space`.""" +"""The pattern of the layouts of `soc_space`.""" MOG = "mog" -"""The kind of the layouts of `mog_space`.""" +"""The pattern of the layouts of `mog_space`.""" def _node(value: Any, default: Any) -> Any: @@ -147,7 +147,7 @@ def walker_space( DesignSpace: the fragment """ children = { - "kind": Fixed(WALKER), + "pattern": Fixed(WALKER), "configuration": configuration, "inclination": _node(inclination, Real(30, 90, step=15)), "planes": _node(planes, Integer(1, 6)), @@ -275,7 +275,7 @@ def sso_planes_space( true_anomaly=Derived(_plane_true_anomaly), ) children = { - "kind": Fixed(SSO_PLANES), + "pattern": Fixed(SSO_PLANES), "ascending": ascending, "repeat_ground_track": repeat_ground_track, "planes": Repeat(plane, count=_node(planes, Integer(1, 3)), ordered=ordered), @@ -349,7 +349,7 @@ def planes_space( true_anomaly=Derived(_plane_true_anomaly), ) children = { - "kind": Fixed(PLANES), + "pattern": Fixed(PLANES), "repeat_ground_track": repeat_ground_track, "planes": Repeat(plane, count=_node(planes, Integer(1, 3)), ordered=ordered), } @@ -460,7 +460,7 @@ def soc_space( DesignSpace: the fragment """ children = { - "kind": Fixed(SOC), + "pattern": Fixed(SOC), "inclination": _node(inclination, Real(30, 90, step=15)), "swath_width": swath_width, "packing_distance": packing_distance, @@ -528,7 +528,7 @@ def mog_space( DesignSpace: the fragment """ children = { - "kind": Fixed(MOG), + "pattern": Fixed(MOG), "inclination": _node(inclination, Real(30, 90, step=15)), "node": node, "satellites": _node(satellites, Integer(2, 6)), @@ -555,7 +555,8 @@ class Plane: values: Any = None """Any: The values of the plane in a design (such as those of each plane of `sso_planes_space`), or `None` (as for the planes of a Walker - constellation), as given to the `order` of a `DeploymentSchedule`.""" + constellation), as given to the `order` and `launch_mass_capacity` of a + `DeploymentSchedule` (functions of the index and values of a plane).""" class Layout: @@ -1025,14 +1026,15 @@ def _unrealized(self) -> bool: return any(layout._unrealized() for layout in self.layouts) -_KINDS = { +_PATTERNS = { WALKER: WalkerLayout, SSO_PLANES: SSOPlanesLayout, PLANES: PlanesLayout, SOC: SOCLayout, MOG: MOGLayout, } -"""The layouts of the kinds of the fragments of design spaces.""" +"""The layouts of the patterns of the fragments of design spaces (their +values `pattern`).""" def layout_of(layout: Any) -> Layout: @@ -1057,13 +1059,13 @@ def layout_of(layout: Any) -> Layout: return Layouts(list(layout)) if isinstance(layout, ChoiceValues): layout = layout.value - kind = getattr(layout, "kind", None) - if not isinstance(kind, str) or kind not in _KINDS: + pattern = getattr(layout, "pattern", None) + if not isinstance(pattern, str) or pattern not in _PATTERNS: raise ValueError( "a layout must be the values of walker_space, sso_planes_space, " + "planes_space, soc_space, or mog_space, or a Layout" ) - return _KINDS[kind](layout) + return _PATTERNS[pattern](layout) def count_satellites(layout: Any) -> int: @@ -1264,6 +1266,13 @@ def remove_failures( random numbers, the satellite at the same position fails in the same replicate of every design. + It is a snapshot, for the build function of any study: the constellation + with some of its satellites missing, without a deployment or the time of + a mission. The failures of an `ObservationStudy` with a `MissionPlan` + (see `Failures`) are those over a mission instead: the lives of + satellites, the failures of launches, and their restoration, averaged + over the phases of the mission. + Args: satellites (Sequence[Satellite]): The satellites, in the order they are built. diff --git a/src/tatc/tradespace/cost.py b/src/tatc/tradespace/cost.py index 6d524875..72b71d7f 100644 --- a/src/tatc/tradespace/cost.py +++ b/src/tatc/tradespace/cost.py @@ -237,7 +237,9 @@ class SatelliteCost: first_unit (float): The recurring cost of the first unit (besides that of its components). learning_rate (float): The learning rate, in (0, 1]. - mass (float | None): The mass (kg), for launches priced by mass. + mass (float | None): The mass (kg), for launches priced by mass + (and of a `MissionPlan`, limited in mass) if the deployment + does not give one (see `CostModel.estimate`). components (Sequence[Component]): The components, if any, of distinct names. block_size (int | None): The units of each block of production, or @@ -402,8 +404,8 @@ class CostEstimate: operations: float = 0.0 """float: The cost of operations.""" units: dict[Any, int] = field(default_factory=dict) - """dict: The units built of each type of satellite, by kind (`None` for - the satellites of a deployment of one type without a kind), including + """dict: The units built of each type of satellite, by type (`None` for + the satellites of a deployment of one type without a type), including replacements and spares, and those in production at the end of a sustained mission.""" launches: int = 0 @@ -414,7 +416,7 @@ class CostEstimate: present: dict[str, float] = field(default_factory=dict) """dict: The present value of each element.""" blocks: dict[Any, int] = field(default_factory=dict) - """dict: The blocks of production of each type of satellite, by kind + """dict: The blocks of production of each type of satellite, by type (see `units` and `SatelliteCost.block_size`).""" @property @@ -477,7 +479,7 @@ def metrics(self, prefix: str = "cost") -> dict[str, float]: Growth = float | Mapping[str, float | Mapping[Any, float]] """Growth factors of costs: one for every element, or by element (see `ELEMENTS`, others 1), and of development, production, and launches, by -type of satellite (a mapping of each kind to its factor).""" +type of satellite (a mapping of each type to its factor).""" @dataclass(frozen=True) @@ -502,7 +504,7 @@ class CostModel: Args: satellites (SatelliteCost | Mapping[Any, SatelliteCost]): The cost of - the satellites, or of each type of satellite (by kind). The + the satellites, or of each type of satellite (by type). The components of the same name of different types must be the same (equal costs and growth). launch (LaunchCost): The cost of launches. @@ -556,8 +558,7 @@ def satellite_cost_of(self, kind: Any = None) -> SatelliteCost: Gets the cost of a type of satellite. Args: - kind (Any): The type (its kind), or `None` for a model of one - type. + kind (Any): The type, or `None` for a model of one type. Returns: SatelliteCost: the cost @@ -565,11 +566,11 @@ def satellite_cost_of(self, kind: Any = None) -> SatelliteCost: if isinstance(self.satellites, SatelliteCost): return self.satellites if kind is None: - raise ValueError("a model of several types of satellites needs a kind") + raise ValueError("a model of several types of satellites needs a type") return _per_type(self.satellites, kind, "cost") def _types(self) -> list[tuple[Any, SatelliteCost]]: - """Gets the types of satellites: the kind of each, and its cost.""" + """Gets the types of satellites: each type, and its cost.""" if isinstance(self.satellites, SatelliteCost): return [(None, self.satellites)] return list(self.satellites.items()) @@ -680,6 +681,13 @@ def estimate( block of production after the first (see `SatelliteCost.block_size`) develops its type again (a share of its development), dated over the type's development just before the production of its first unit. + Every type of satellite of the deployment is developed, including a + type whose planes are all staged (see `Stage`) and whose stages are + never deployed: its development is the cost of the option to deploy + them. Launches priced by mass (see `LaunchCost.per_kg`) take the + masses of the satellites of the deployment (see + `DeploymentSchedule.plan`), which also limit the satellites of a + launch, or else those of the cost model (`SatelliteCost.mass`). The costs of a sustained constellation (see `DeploymentSchedule`), such as of an operational program over the period of a study, are @@ -713,7 +721,7 @@ def estimate( growth (float | Mapping): A growth factor of the cost, or of each element (`"development"`, `"production"`, `"launch"`, or `"operations"`; others 1), and of development, production, and - launches, of each kind of satellite (a mapping of each kind of + launches, of each type of satellite (a mapping of each type of the deployment to its factor). Returns: @@ -721,16 +729,19 @@ def estimate( Raises: ValueError: if growth names an unknown element, is of operations - by type of satellite, or lacks a kind of the deployment. + by type of satellite, or lacks a type of the deployment, or if + launches priced by mass lack the mass of a type. """ factors = _get_growth(growth) history = ( deployment.planned() if isinstance(deployment, Deployment) else deployment ) - if self.launch.per_kg > 0 and any( - self.satellite_cost_of(kind).mass is None for kind in history.development - ): - raise ValueError("launches priced by mass require masses") + masses = {kind: self._mass_of(history, kind) for kind in history.development} + if self.launch.per_kg > 0 and any(mass is None for mass in masses.values()): + raise ValueError( + "launches priced by mass require masses (of the deployment, see " + + "DeploymentSchedule.plan, or of the cost model, see SatelliteCost.mass)" + ) # the costs of a sustained constellation are those incurred by the end until = history.end if history.schedule.sustained else math.inf flows: list[tuple[float, str, float]] = [] @@ -749,7 +760,7 @@ def add( kind: self.satellite_cost_of(kind).blocks(units) for kind, units in begun.items() } - estimate.launches = self._add_launches(history, add) + estimate.launches = self._add_launches(history, masses, add) self._add_operations(history, add) flows = [flow for flow in flows if flow[2] != 0] estimate.flows = sorted(flows, key=lambda flow: (flow[0], flow[1])) @@ -836,12 +847,25 @@ def _add_production( ) return begun - def _add_launches(self, history: MissionHistory, add: Callable[..., None]) -> int: + def _mass_of(self, history: MissionHistory, kind: Any) -> float | None: + """ + Gets the mass of a type of satellite: that of the deployment (see + `DeploymentSchedule.plan`), or else of its cost (if any). + """ + mass = history.masses.get(kind) + return self.satellite_cost_of(kind).mass if mass is None else mass + + def _add_launches( + self, + history: MissionHistory, + masses: Mapping[Any, float | None], + add: Callable[..., None], + ) -> int: """Adds the price of each launch when it flies, returning the launches.""" for launch in history.launches: - cost = self.satellite_cost_of(launch.kind) + mass = masses.get(launch.kind) or 0.0 price = self.launch.per_launch + launch.satellites * ( - self.launch.per_satellite + self.launch.per_kg * (cost.mass or 0.0) + self.launch.per_satellite + self.launch.per_kg * mass ) add("launch", [(launch.time, price)], launch.kind) return len(history.launches) @@ -862,7 +886,7 @@ def _add_operations( def _get_growth(growth: Growth) -> dict[str, float | dict[Any, float]]: """ - Gets the growth factor of each element of cost (or a mapping of each kind + Gets the growth factor of each element of cost (or a mapping of each type of satellite to its factor). """ if not isinstance(growth, Mapping): @@ -886,12 +910,12 @@ def _get_factor( factors: Mapping[str, float | Mapping[Any, float]], element: str, kind: Any ) -> float: """ - Gets the growth factor of an element of the cost of a kind of satellite + Gets the growth factor of an element of the cost of a type of satellite (`None` for costs of no type). """ factor = factors[element] if isinstance(factor, Mapping) and kind is None: - raise ValueError(f"growth of {element} by type of satellite needs kinds") + raise ValueError(f"growth of {element} by type of satellite needs types") return _per_type(factor, kind, f"growth of {element}") diff --git a/src/tatc/tradespace/criteria.py b/src/tatc/tradespace/criteria.py index 13222bd4..20fab445 100644 --- a/src/tatc/tradespace/criteria.py +++ b/src/tatc/tradespace/criteria.py @@ -1,339 +1,39 @@ """ -Criteria of designs over their replicates: statistics of the metrics of -their evaluations (such as a mean, a quantile, or the probability of meeting -a threshold), requirements on these statistics, and the criteria by which -designs are judged (objectives, requirements, and tolerances). - -The outcomes of a design are uncertain if its replicates differ (see -`Uncertain`), and a statistic over the replicates states how a design is -judged: by its mean, by a pessimistic quantile, or by how reliably it meets -a threshold. A requirement on a statistic is an output constraint, which a -design meets or violates (by an amount) once it is evaluated, as opposed to -the constraints of a design space, which are known before. +Criteria by which designs are judged from the statistics of the metrics of +their evaluations over their replicates (see `Statistic`): objectives to +minimize or maximize, requirements on statistics, the tolerances of the +objectives, and the rules that combine the statistics of a design across +groups of its results (such as scenarios). + +A requirement on a statistic is an output constraint, which a design meets +or violates (by an amount) once it is evaluated, as opposed to the +constraints of a design space, which are known before. @author: Paul T. Grogan """ from __future__ import annotations -import operator as op -from collections.abc import Iterator, Mapping, Sequence -from dataclasses import dataclass, field, replace +from collections.abc import Mapping, Sequence +from dataclasses import dataclass, field from typing import Any import numpy as np -import pandas as pd - -from .dominance import _efficient -from .study import _STATUS_COLUMNS -_OPERATORS = {">=": op.ge, ">": op.gt, "<=": op.le, "<": op.lt} +from .statistics import _OPERATORS, Mean, Statistic, _named_statistics _DIRECTIONS = ("min", "max") -def _names(value: str | Sequence[str]) -> list[str]: - """Gets names given as a name or a sequence of names.""" - return [value] if isinstance(value, str) else list(value) - - -def _as_statistic(name: str, value: Any) -> Statistic: - """ - Gets a statistic given by name: a statistic, or the mean of a metric - given as a string or a metric computed from others (such as a - `Utility`). - """ - if isinstance(value, str) or _is_derived(value): - return Mean(value) - if not isinstance(value, Statistic): - raise TypeError(f"statistic {name!r} is not a Statistic") - return value - - -def _named_statistics(statistics: Any) -> dict[str, Statistic]: - """ - Gets statistics by name: of a mapping of names to statistics (or metrics, - whose means they are), or of a sequence of statistics (or metrics), named - by their conventional names (see `Statistic.name`). - """ - if statistics is None: - return {} - if isinstance(statistics, Mapping): - return {name: _as_statistic(name, value) for name, value in statistics.items()} - if isinstance(statistics, (str, Statistic)) or _is_derived(statistics): - statistics = [statistics] - named: dict[str, Statistic] = {} - for item in statistics: - statistic = _as_statistic(str(item), item) - if statistic.name in named and named[statistic.name] != statistic: - raise ValueError(f"statistics of the same name: {statistic.name!r}") - named[statistic.name] = statistic - return named - - -def _is_derived(metric: Any) -> bool: - """ - Whether a metric is computed from others in each replicate (such as a - `Utility`): an object with the `columns` it needs and an `evaluate` - method of their values. - """ - return ( - not isinstance(metric, (str, Statistic)) - and hasattr(metric, "columns") - and callable(getattr(metric, "evaluate", None)) - ) - - -class Statistic: - """ - Base class of statistics of a metric over the replicates of each design: - a column of the results of a study, or a metric computed from others in - each replicate (such as a `Utility`, whose mean is the expected utility). - - Args: - column (str | Utility): The metric. - """ - - def __init__(self, column: Any): - self.column = column - - @property - def metric(self) -> str: - """str: The name of the statistic's metric: its column, or `"utility"` - of a metric computed from others.""" - return "utility" if _is_derived(self.column) else str(self.column) - - @property - def name(self) -> str: - """str: The conventional name of the statistic (the suffixes of which - are those of `summarize` and `summarize_missions`): such as `cost` - (a mean), `cost std`, `cost se`, `cost min`, `cost max`, `cost p70` - (a quantile), or `P(cost <= 150)`, by which criteria name the - statistics given without names.""" - return self.metric - - @property - def columns(self) -> tuple[str, ...]: - """tuple[str, ...]: The columns of the results that the statistic - needs: its metric, or those its metric is computed from.""" - if _is_derived(self.column): - return tuple(self.column.columns) - return (self.column,) - - def values_of(self, matrices: Mapping[str, np.ndarray]) -> np.ndarray: - """ - Gets the values of the statistic's metric in each replicate of each - design, from those of the columns of the results. - - Args: - matrices (Mapping[str, numpy.ndarray]): The values of each column - (shape (designs, replicates)). - - Returns: - numpy.ndarray: the values of the metric (shape (designs, - replicates)) - """ - if _is_derived(self.column): - values = {name: matrices[name] for name in self.columns} - return np.asarray(self.column.evaluate(values), dtype=float) - return matrices[self.column] - - def reduce(self, values: np.ndarray) -> np.ndarray: - """ - Computes the statistic of each design (row) from its values in its - replicates (columns), ignoring missing values (`NaN`). - - Args: - values (numpy.ndarray): The values (shape (designs, replicates)). - - Returns: - numpy.ndarray: the statistic of each design (`NaN` without values) - """ - raise NotImplementedError - - def __eq__(self, other: object) -> bool: - return type(self) is type(other) and vars(self) == vars(other) - - def __hash__(self) -> int: - return hash((type(self), tuple(sorted(vars(self).items())))) - - def __repr__(self) -> str: - return f"{type(self).__name__}({self.column!r})" - - -def _all_nan(values: np.ndarray) -> np.ndarray: - return np.all(np.isnan(values), axis=1) - - -def _nan_reduce(function, values: np.ndarray) -> np.ndarray: - """ - Applies a nan-aware reduction along replicates, giving `NaN` (without a - warning) for designs without values. - """ - result = np.full(values.shape[0], np.nan) - valid = ~_all_nan(values) - if np.any(valid): - result[valid] = function(values[valid], axis=1) - return result - - -class Mean(Statistic): - """ - The mean of a metric over the replicates. - """ - - def reduce(self, values: np.ndarray) -> np.ndarray: - return _nan_reduce(np.nanmean, values) - - -class StandardDeviation(Statistic): - """ - The (sample) standard deviation of a metric over the replicates, a - measure of how much a design's outcome depends on its uncertain - parameters (`NaN` with fewer than two replicates). - """ - - @property - def name(self) -> str: - return f"{self.metric} std" - - def reduce(self, values: np.ndarray) -> np.ndarray: - counts = np.sum(~np.isnan(values), axis=1) - result = np.full(values.shape[0], np.nan) - valid = counts > 1 - if np.any(valid): - result[valid] = np.nanstd(values[valid], axis=1, ddof=1) - return result - - -class StandardError(Statistic): - """ - The standard error of the mean of a metric over the replicates: its - standard deviation over the square root of the number of replicates, a - measure of the uncertainty of the mean (`NaN` with fewer than two - replicates). - """ - - @property - def name(self) -> str: - return f"{self.metric} se" - - def reduce(self, values: np.ndarray) -> np.ndarray: - counts = np.sum(~np.isnan(values), axis=1) - deviation = StandardDeviation(self.column).reduce(values) - return deviation / np.sqrt(np.maximum(counts, 1)) - - -class Minimum(Statistic): - """ - The least value of a metric over the replicates (the worst case of a - metric to maximize). - """ - - @property - def name(self) -> str: - return f"{self.metric} min" - - def reduce(self, values: np.ndarray) -> np.ndarray: - return _nan_reduce(np.nanmin, values) - - -class Maximum(Statistic): - """ - The greatest value of a metric over the replicates (the worst case of a - metric to minimize). - """ - - @property - def name(self) -> str: - return f"{self.metric} max" - - def reduce(self, values: np.ndarray) -> np.ndarray: - return _nan_reduce(np.nanmax, values) - - -class Quantile(Statistic): - """ - A quantile of a metric over the replicates: for example, the 0.1 - quantile of a metric to maximize is a value that the design exceeds in - 90% of the replicates (by linear interpolation between them). - - Args: - column (str | Utility): The metric. - q (float): The quantile, between 0 and 1. - """ - - def __init__(self, column: str, q: float): - super().__init__(column) - if not 0 <= q <= 1: - raise ValueError("q must be between 0 and 1") - self.q = q - - def reduce(self, values: np.ndarray) -> np.ndarray: - # numpy's nanquantile, vectorized: sort each row (missing values - # last), and interpolate linearly between the values around the - # quantile's position among each row's values - ordered = np.sort(values, axis=1) - counts = np.sum(~np.isnan(values), axis=1) - position = self.q * np.maximum(counts - 1, 0) - below = np.floor(position).astype(int) - above = np.minimum(below + 1, np.maximum(counts - 1, 0)) - rows = np.arange(len(values)) - weight = position - below - with np.errstate(invalid="ignore"): - result = (1 - weight) * ordered[rows, below] + weight * ordered[rows, above] - result[weight == 0] = ordered[rows, below][weight == 0] - result[counts == 0] = np.nan - return result - - @property - def name(self) -> str: - return f"{self.metric} p{100 * self.q:g}" - - def __repr__(self) -> str: - return f"Quantile({self.column!r}, {self.q!r})" - - -class Probability(Statistic): - """ - The probability that a metric meets a threshold: the share (0 to 1) of - the replicates in which it does, such as the reliability of a design. - - Args: - column (str | Utility): The metric. - operator (str): The comparison: `">="`, `">"`, `"<="`, or `"<"`. - threshold (float): The threshold. - """ - - def __init__(self, column: str, operator: str, threshold: float): - super().__init__(column) - if operator not in _OPERATORS: - raise ValueError(f"operator must be one of {list(_OPERATORS)}") - self.operator, self.threshold = operator, threshold - - def reduce(self, values: np.ndarray) -> np.ndarray: - valid = ~np.isnan(values) - with np.errstate(invalid="ignore"): - met = _OPERATORS[self.operator](values, self.threshold) & valid - counts = valid.sum(axis=1) - result = np.full(values.shape[0], np.nan) - result[counts > 0] = met.sum(axis=1)[counts > 0] / counts[counts > 0] - return result - - @property - def name(self) -> str: - return f"P({self.metric} {self.operator} {self.threshold:g})" - - def __repr__(self) -> str: - return f"Probability({self.column!r}, {self.operator!r}, {self.threshold!r})" - - @dataclass(frozen=True) class Requirement: """ A requirement on a statistic of a design (by its name in the statistics of criteria, see `Criteria`, or a metric, whose mean it then is): for - example, `Requirement("sufficient p10", ">=", 80)`. + example, `Requirement("sufficient p10", ">=", 80)`, or + `Requirement("feasible", ">=", 1)`, which requires every replicate of a + design to be feasible (`feasible` is the share of its replicates that + are, see `aggregate`). A design that does not meet it violates it by the difference between the statistic and the value, relative to a `scale`: by default the magnitude @@ -441,7 +141,10 @@ class Across: rule asks for their worst. Requirements and tolerances apply to the combined statistics. A design is judged only if it has feasible results in every group of the results (in each group of - the criteria's `by`). + the criteria's `by`). Statistics of the feasibility of replicates (such + as `feasible`, the share of a design's replicates that are feasible, see + `aggregate`) are not combined: they are over the evaluations of every + group together. Combining the statistics of the groups (such as the worst of the means) differs from a statistic of the worst group of each replicate (the mean @@ -503,19 +206,19 @@ def weights_of(self, groups: Sequence[Any]) -> np.ndarray: def _get_tolerances( - objectives: Mapping[str, str], tolerance: Mapping[str, Tolerance] + objectives: Mapping[str, str], tolerances: Mapping[str, Tolerance] ) -> np.ndarray: """ Gets the tolerances of the objectives (zero if not given): their absolute values (first row) and their shares of the values of the objectives (second row). """ - unknown = set(tolerance) - set(objectives) + unknown = set(tolerances) - set(objectives) if unknown: raise ValueError(f"tolerances of names that are not objectives: {unknown}") values = np.zeros((2, len(objectives))) for i, name in enumerate(objectives): - value = tolerance.get(name, 0.0) + value = tolerances.get(name, 0.0) if isinstance(value, str): if not value.strip().endswith("%"): raise ValueError( @@ -544,7 +247,7 @@ class Criteria: {"cost p70": "min", "coverage": "max"}, statistics=[Quantile("cost", 0.7)], # named cost p70 requirements=[Requirement("cost p70", "<=", 150)], - tolerance={"coverage": 1.0}, + tolerances={"coverage": 1.0}, ) summary = aggregate(results, criteria) front = summary[summary.pareto] @@ -555,6 +258,12 @@ class Criteria: them is as good in every objective and better in at least one, by more than the tolerances (see `pareto_front`). + Designs are judged by their feasible replicates. The share of a design's + replicates that are feasible is the statistic `feasible` (see + `aggregate`), which requirements may name, such as + `Requirement("feasible", ">=", 1)` of designs feasible in every + replicate. Designs without a feasible replicate are not judged. + Designs evaluated in several groups of a column (such as the scenarios of a study, see `Study`) are judged in each group with criteria `by` the column, or once with criteria `across` it (see `Across`), which combine @@ -578,7 +287,7 @@ class Criteria: names (see `Statistic.name`, such as `cost p70` of `Quantile("cost", 0.7)`). requirements (Sequence[Requirement]): Requirements on statistics. - tolerance (Mapping[str, float | str]): The tolerances of objectives + tolerances (Mapping[str, float | str]): The tolerances of objectives (by name, zero if not given): values in their units, or percentages of their values (such as `"5%"`). by (Sequence[str] | str): The columns that group the records of an @@ -594,7 +303,7 @@ class Criteria: default_factory=dict ) requirements: Sequence[Requirement] = () - tolerance: Mapping[str, Tolerance] = field(default_factory=dict) + tolerances: Mapping[str, Tolerance] = field(default_factory=dict) by: Sequence[str] | str = () across: Across | None = None @@ -614,13 +323,13 @@ def __post_init__(self): for requirement in requirements: if not isinstance(requirement, Requirement): raise TypeError(f"{requirement!r} is not a Requirement") - tolerance = dict(self.tolerance) - _get_tolerances(objectives, tolerance) # checks the tolerances + tolerances = dict(self.tolerances) + _get_tolerances(objectives, tolerances) # checks the tolerances by = (self.by,) if isinstance(self.by, str) else tuple(self.by) object.__setattr__(self, "objectives", objectives) object.__setattr__(self, "statistics", statistics) object.__setattr__(self, "requirements", requirements) - object.__setattr__(self, "tolerance", tolerance) + object.__setattr__(self, "tolerances", tolerances) object.__setattr__(self, "by", by) if self.across is not None: if not isinstance(self.across, Across): @@ -683,76 +392,6 @@ def _as_criteria(criteria: Criteria | Mapping[str, str]) -> Criteria: ) -def _resamples(count: int, n_resamples: int, seed: Any) -> np.ndarray: - """ - Gets the replicates of each resample of a bootstrap: a row per resample of - `count` replicates (their positions) drawn with replacement, from a seed - (or a random number generator, which draws them). - """ - if n_resamples < 2: - raise ValueError("n_resamples must be at least 2") - return np.random.default_rng(seed).integers(count, size=(n_resamples, count)) - - -def _bootstrap_error(sums: np.ndarray, squares: np.ndarray, n: int) -> np.ndarray: - """ - Gets the standard errors of statistics from the sums of their values (and - of their squares) over `n` resamples of a bootstrap: their standard - deviations over the resamples. - """ - mean = sums / n - return np.sqrt(np.maximum(squares - n * mean**2, 0.0) / max(n - 1, 1)) - - -def _violation_of( - values: Mapping[str, Any], requirements: Sequence[Requirement], count: int -) -> np.ndarray: - """ - Gets the total violation of requirements by `count` designs, from the - values of their statistics (by name, such as the columns of a summary; - `NaN` where a statistic is missing). - """ - violation = np.zeros(count) - for requirement in requirements: - statistic = np.asarray(values[requirement.name], dtype=float) - violation = violation + requirement.violation(statistic) - return violation - - -def _judge( - frame: pd.DataFrame, - values: Mapping[str, np.ndarray], - violation: np.ndarray, - criteria: Criteria, -) -> None: - """ - Adds the judgment of designs by criteria to the rows of a summary of - them, from the values of their statistics and the violation of the - criteria's requirements: the `violation`, whether each design meets the - requirements (`meets_requirements`), and whether it is efficient among - those that do (`pareto`). - """ - meets = violation == 0 - tolerances = _get_tolerances(criteria.objectives, criteria.tolerance) - frame["violation"] = violation - frame["meets_requirements"] = meets - frame["pareto"] = _efficient(_costs_of(values, criteria), meets, tolerances) - - -def _costs_of(values: Mapping[str, Any], criteria: Criteria) -> np.ndarray: - """ - Gets the objectives of criteria as costs (to minimize), from the values of - their statistics (by name, such as the columns of a summary): maximized - objectives are negated (missing values are `NaN`). - """ - columns = [ - np.asarray(values[name], dtype=float) * sign - for name, sign in zip(criteria.objectives, _signs(criteria)) - ] - count = len(columns[0]) if columns else 0 - return np.column_stack(columns) if count else np.empty((0, len(columns))) - - def _resolve(criteria: Criteria) -> dict[str, Statistic]: """ Gets the statistic of each name of criteria. @@ -772,103 +411,33 @@ def _signs(criteria: Criteria) -> np.ndarray: ) -def _groups(frame: pd.DataFrame, by: Sequence[str]) -> Iterator[tuple[tuple, Any]]: - """ - Iterates over the groups of a data frame by columns (or the frame, if - none): the values of the columns, and the positions of the group's rows. - """ - if not by: - yield (), np.arange(len(frame)) - return - missing = [column for column in by if column not in frame.columns] - if missing: - raise ValueError(f"no columns {missing} to group by") - for key, positions in frame.groupby(list(by), sort=False).indices.items(): - yield (key if isinstance(key, tuple) else (key,)), positions - - -def _check_summary(summary: pd.DataFrame, by: Sequence[str] = ()) -> None: - """ - Checks that a data frame is a summary of designs (a row per design, in - each group of the columns `by`), not the results of a study (a row per - replicate), which the functions of summaries would judge as if each - replicate were a design. - """ - if "design" in summary.columns: - keys = summary[["design", *(c for c in by if c in summary.columns)]] - elif summary.index.name == "design" and not by: - keys = summary.index.to_frame() - else: - return - if keys.duplicated().any(): - raise ValueError( - "the data frame has several rows of a design: summarize the results " - + "of a study (a row per replicate) first, with a row per design (see " - + "aggregate), or judge designs in groups (see Criteria's `by`)" - ) - - -def _get_matrices( - group: pd.DataFrame, - columns: Sequence[str], - designs: pd.Index | None = None, - replicates: pd.Index | None = None, -) -> tuple[pd.Index, pd.Index, dict[str, np.ndarray]]: +def _costs_of(values: Mapping[str, Any], criteria: Criteria) -> np.ndarray: """ - Gets the values of metrics of each design (rows) in each replicate - (columns) of the results of a group, which must have one record per - evaluation (a design in a replicate): of the designs and replicates of - the group, or of those given (`NaN` without a record). + Gets the objectives of criteria as costs (to minimize), from the values of + their statistics (by name, such as the columns of a summary): maximized + objectives are negated (missing values are `NaN`). """ - missing = [column for column in columns if column not in group.columns] - if missing: - raise ValueError(f"metrics that are not in the results: {missing}") - keys = ["design", "replicate"] - if group.duplicated(keys).any(): - candidates = [ - column - for column in group.columns - if column not in (*_STATUS_COLUMNS, *columns) - ] - counts = group.groupby(keys)[candidates].nunique(dropna=False).max() - varying = list(counts.index[counts > 1]) - raise ValueError( - "the results have several records of an evaluation (a design in a " - + "replicate): give the columns that separate them as `by` (of the " - + "criteria), or combine their groups `across` (see Across)" - + (f", such as {varying}" if varying else "") - ) - if designs is None: - designs = pd.Index(group["design"].drop_duplicates()) - if replicates is None: - replicates = pd.Index(sorted(group["replicate"].unique())) - matrices = {} - for column in columns: - table = group.pivot(index="design", columns="replicate", values=column) - matrices[column] = table.reindex(index=designs, columns=replicates).to_numpy( - dtype=float - ) - return designs, replicates, matrices + columns = [ + np.asarray(values[name], dtype=float) * sign + for name, sign in zip(criteria.objectives, _signs(criteria)) + ] + count = len(columns[0]) if columns else 0 + return np.column_stack(columns) if count else np.empty((0, len(columns))) -def _evaluate( - statistics: Mapping[str, Statistic], - requirements: Sequence[Requirement], - matrices: Mapping[str, np.ndarray], - columns: np.ndarray | None = None, -) -> tuple[dict[str, np.ndarray], np.ndarray]: +def _violation_of( + values: Mapping[str, Any], requirements: Sequence[Requirement], count: int +) -> np.ndarray: """ - Computes statistics (of the replicates `columns` of the matrices, or all) - and the total violation of the requirements of each design. + Gets the total violation of requirements by `count` designs, from the + values of their statistics (by name, such as the columns of a summary; + `NaN` where a statistic is missing). """ - values = {} - for name, statistic in statistics.items(): - matrix = statistic.values_of(matrices) - values[name] = statistic.reduce( - matrix if columns is None else matrix[:, columns] - ) - n = len(next(iter(matrices.values()))) if matrices else 0 - return values, _violation_of(values, requirements, n) + violation = np.zeros(count) + for requirement in requirements: + statistic = np.asarray(values[requirement.name], dtype=float) + violation = violation + requirement.violation(statistic) + return violation def _combiners(criteria: Criteria) -> dict[str, str]: @@ -905,380 +474,3 @@ def _combiners(criteria: Criteria) -> dict[str, str]: else: combiners[name] = next(iter(worst[name])) return combiners - - -def _across_groups(results: pd.DataFrame, across: Across | None) -> list | None: - """ - Gets the groups of results (values of a column, in order) across which - criteria combine statistics, if any. - """ - if across is None: - return None - if across.column not in results.columns: - raise ValueError( - f"the results have no column {across.column!r} to combine across " - + "(such as the scenarios of a study, see Study)" - ) - return list(pd.unique(results[across.column])) - - -class _Statistics: - """ - The statistics of the designs of the feasible results of a group (of the - criteria's `by`), over every replicate or some of them (see `evaluate`), - from the values of their metrics in each replicate: in each group of a - column, combined across the groups (see `Across`), if any. Designs - without results in every group are left out. - - Args: - results (pandas.DataFrame): The feasible results of a group. - statistics (Mapping[str, Statistic]): The statistics, by name. - requirements (Sequence[Requirement]): The requirements. - across (Across | None): The rule that combines the groups of a - column, if any. - combiners (Mapping[str, str] | None): How each statistic is combined - (see `_combiners`), with a rule. - groups (Sequence | None): The groups of the column (of every result), - with a rule. - """ - - def __init__( - self, - results: pd.DataFrame, - statistics: Mapping[str, Statistic], - requirements: Sequence[Requirement] = (), - across: Across | None = None, - combiners: Mapping[str, str] | None = None, - groups: Sequence | None = None, - ): - self.statistics, self.requirements = statistics, requirements - self.combiners = combiners - metrics = sorted( - { - column - for statistic in statistics.values() - for column in statistic.columns - } - ) - if across is None: - self.designs, self.replicates, matrices = _get_matrices(results, metrics) - self.matrices = [matrices] - self.counts = ( - results.groupby("design")["replicate"] - .nunique() - .reindex(self.designs) - .to_numpy() - ) - return - self.weights = ( - across.weights_of(groups) if "mean" in combiners.values() else None - ) - parts = [ - results[(results[across.column] == group).to_numpy()] for group in groups - ] - complete = set.intersection(*(set(part["design"]) for part in parts)) - designs = results["design"].drop_duplicates() - self.designs = pd.Index(designs[designs.isin(complete)]) - self.replicates = pd.Index(sorted(results["replicate"].unique())) - self.matrices = [ - _get_matrices(part, metrics, self.designs, self.replicates)[2] - for part in parts - ] - self.counts = ( - results.groupby(["design", across.column])["replicate"] - .nunique() - .groupby(level="design") - .min() - .reindex(self.designs) - .to_numpy() - ) - - def evaluate( - self, columns: np.ndarray | None = None - ) -> tuple[dict[str, np.ndarray], np.ndarray]: - """ - Computes the statistics of each design (of the replicates `columns` - of the matrices, or all) and the total violation of the requirements. - """ - if self.combiners is None: - return _evaluate( - self.statistics, self.requirements, self.matrices[0], columns - ) - parts = [_evaluate(self.statistics, (), m, columns)[0] for m in self.matrices] - values = {} - for name in self.statistics: - stacked = np.vstack([part[name] for part in parts]) - how = self.combiners[name] - if how == "max": - values[name] = stacked.max(axis=0) - elif how == "min": - values[name] = stacked.min(axis=0) - else: - values[name] = self.weights @ stacked - return values, _violation_of(values, self.requirements, len(self.designs)) - - -def _design_columns(results: pd.DataFrame, excluded: set[str]) -> list[str]: - """ - Gets the columns of the values of designs: those (other than `excluded`) - that are the same in every record of each design. - """ - candidates = [column for column in results.columns if column not in excluded] - if not candidates or len(results) == 0: - return [] - constant = results.groupby("design")[candidates].nunique(dropna=False) - return [column for column in candidates if (constant[column] <= 1).all()] - - -def _value_columns( - feasible: pd.DataFrame, - statistics: Mapping[str, Statistic], - by: Sequence[str], - across: Across | None, - design_columns: Sequence[str] | None, -) -> list[str]: - """ - Gets the columns of the values of designs that a summary keeps: those - given, or those that are the same in every record of each design (but - the metrics of the statistics, the columns of groups, and status - columns). - """ - combined = [] if across is None else [across.column] - if design_columns is None: - metrics = { - column for statistic in statistics.values() for column in statistic.columns - } - design_columns = _design_columns( - feasible, {*_STATUS_COLUMNS, *metrics, *by, *combined} - ) - return [ - c for c in design_columns if c not in statistics and c not in (*by, *combined) - ] - - -def _with_values( - frame: pd.DataFrame, group: pd.DataFrame, designs: Any, columns: Sequence[str] -) -> None: - """ - Adds the values of designs (columns of the first record of each design of - a group of results) to the rows of a summary of the designs. - """ - first = group.drop_duplicates("design").set_index("design") - for column in columns: - frame[column] = first.loc[designs, column].to_numpy() - - -def _summary_groups( - results: pd.DataFrame, - statistics: Mapping[str, Statistic], - by: Sequence[str], - requirements: Sequence[Requirement] = (), - across: Across | None = None, - combiners: Mapping[str, str] | None = None, - design_columns: Sequence[str] | None = None, -) -> Iterator[tuple[pd.DataFrame, _Statistics]]: - """ - Iterates over the groups (of the columns `by`) of the feasible results of - a study, for summaries of their designs: a data frame of the designs of - each group (`design`, the values of `by`, and the values of the designs, - see `aggregate`), and their statistics (see `_Statistics`). - """ - feasible = results[results["feasible"]] if "feasible" in results else results - groups = _across_groups(results, across) - columns = _value_columns(feasible, statistics, by, across, design_columns) - for key, positions in _groups(feasible, by): - group = feasible.iloc[positions] - table = _Statistics(group, statistics, requirements, across, combiners, groups) - frame = pd.DataFrame({"design": table.designs}) - for name, value in zip(by, key): - frame[name] = value - _with_values(frame, group, table.designs, columns) - yield frame, table - - -def _criteria_of( - criteria: Criteria | Mapping[str, str] | Sequence[str] | str, - statistics: Mapping[str, Statistic | str] | Sequence[str] | None, - by: Sequence[str] | str, -) -> tuple[Criteria | None, dict[str, Statistic], tuple[str, ...]]: - """ - Gets the criteria (if any) of the arguments of `aggregate`, the - statistics to compute (by name), and the columns that group records. - """ - by = (by,) if isinstance(by, str) else tuple(by) - extra = _named_statistics(statistics) - if isinstance(criteria, Mapping) and not set(criteria.values()) <= {"min", "max"}: - raise ValueError( - "a mapping of criteria gives the directions of objectives ('min' or " - + "'max'): give statistics by name as `statistics`" - ) - if isinstance(criteria, (Criteria, Mapping)): - if by and isinstance(criteria, Criteria): - raise ValueError( - "criteria group records by their own `by`: give it to the criteria" - ) - judged = _as_criteria(criteria) - if by: - judged = replace(judged, by=by) - if extra: - clashes = sorted( - name - for name in extra - if name in judged.names and judged.statistic(name) != extra[name] - ) - if clashes: - raise ValueError( - f"statistics that the criteria name otherwise: {clashes}" - ) - judged = replace(judged, statistics={**judged.statistics, **extra}) - return judged, _resolve(judged), judged.by - metrics = [criteria] if isinstance(criteria, str) else list(criteria) - resolved: dict[str, Statistic] = {name: Mean(name) for name in metrics} - resolved.update(extra) - if not resolved: - raise ValueError( - "give criteria, the metrics whose means to compute, or statistics" - ) - return None, resolved, by - - -def aggregate( - results: pd.DataFrame, - criteria: Criteria | Mapping[str, str] | Sequence[str] | str = (), - *, - statistics: Mapping[str, Statistic | str] | Sequence | None = None, - by: Sequence[str] | str = (), - design_columns: Sequence[str] | None = None, -) -> pd.DataFrame: - """ - Aggregates the feasible results of a study (see `Study.run`, a row per - replicate) into a summary of its designs (a row per design, and per - group of the columns `by`, such as a sensor): statistics over the - replicates of each design, the number of `replicates`, and the values of - the design (see `Design.flat`), from which `DesignSpace.designs_of` - rebuilds the designs. - - The statistics are those of criteria (see `Criteria`, or a mapping of - objectives to their directions, which are the means of the metrics of - their names), or the means of metrics (a list of their names), and other - `statistics`, by name (a statistic, or a metric given as a string, whose - mean it is), or a list of statistics (or metrics), named by their - conventional names (see `Statistic.name`):: - - aggregate(results, {"satellites": "min", "sufficient": "max"}) - aggregate(results, ["sufficient", "accurate"]) - aggregate(results, statistics=[Quantile("cost", 0.7)]) # cost p70 - aggregate(results, COST, statistics=["cost development"]) - - With criteria, the summary also gives the `violation` of their - requirements (the sum of the violations, see `Requirement`, 0 if the - design meets them all), whether the design meets them - (`meets_requirements`), and whether it is efficient among the designs - that do (`pareto`, see `pareto_front`, in each group of the criteria's - `by`; a design with a missing objective, `NaN`, is not). Criteria - `across` a column combine the statistics of each design across its - groups (see `Across`), of which `replicates` is the fewest of any group. - - The results must have one record per evaluation (a design in a - replicate) in each group (and in each group of the column of the - criteria's `across`). - - Args: - results (pandas.DataFrame): The results. - criteria (Criteria | Mapping[str, str] | Sequence[str] | str): The - criteria (or objectives and their directions), or the metrics - whose means to compute. - statistics (Mapping[str, Statistic | str] | Sequence | None): Other - statistics, by name, or a sequence of statistics (or metrics, - whose means they are), named by their conventional names. - by (Sequence[str] | str): The columns that group records of an - evaluation (those of the criteria, if they have any). - design_columns (Sequence[str] | None): The columns of the values of - designs, or `None` for those that are the same in every - replicate of a design (except the metrics). - - Returns: - pandas.DataFrame: a row per design (and group) - """ - judged, resolved, by = _criteria_of(criteria, statistics, by) - across, combiners, requirements = None, None, () - if judged is not None: - requirements, across = judged.requirements, judged.across - combiners = None if across is None else _combiners(judged) - frames = [] - for frame, table in _summary_groups( - results, resolved, by, requirements, across, combiners, design_columns - ): - values, violation = table.evaluate() - for name, value in values.items(): - frame[name] = value - frame["replicates"] = table.counts - if judged is not None: - _judge(frame, values, violation, judged) - frames.append(frame) - if not frames: - status = ["violation", "meets_requirements", "pareto"] if judged else [] - return pd.DataFrame(columns=["design", *by, *resolved, "replicates", *status]) - return pd.concat(frames, ignore_index=True) - - -def summarize( - results: pd.DataFrame, - criteria: Criteria | Mapping[str, str] | Sequence[str] | str = (), - *, - statistics: Mapping[str, Statistic | str] | Sequence | None = None, - by: Sequence[str] | str = (), - design_columns: Sequence[str] | None = None, -) -> pd.DataFrame: - """ - Summarizes the feasible results of a study over their replicates (see - `aggregate`), with the spread of the means of metrics: for each design - (and each group of the columns `by`, such as a sensor), the statistics - of criteria (or the means of a list of metrics) and of other - `statistics`, the standard deviation (` std`) and standard error - (` se`) between replicates of each that is the mean of a metric, - the number of replicates (`replicates`), and the values of the design. - Of criteria (or a mapping of objectives to their directions), the - summary is theirs (see `aggregate`: the violation of their requirements, - and whether each design is efficient, `pareto`):: - - summary = summarize(results, {"satellites": "min", "sufficient": "max"}) - front = summary[summary.pareto] - summarize(results, ACCURACY, statistics=["sufficient"]) # and its mean - - Args: - results (pandas.DataFrame): The results (see `Study.run`). - criteria (Criteria | Mapping[str, str] | Sequence[str] | str): The - criteria (or objectives and their directions), or the metrics - whose means to summarize. - statistics (Mapping[str, Statistic | str] | Sequence | None): Other - statistics (see `aggregate`). - by (Sequence[str] | str): Other columns that group records of an - evaluation (those of criteria, if they have any). - design_columns (Sequence[str] | None): The columns of the values of - designs, or `None` for those that are the same in every - replicate of a design (except the metrics). - - Returns: - pandas.DataFrame: the summary, a row per design (and group) - """ - judged, resolved, by = _criteria_of(criteria, statistics, by) - summarized: dict[str, Statistic] = {} - spread: dict[str, Statistic] = {} - for name, statistic in resolved.items(): - summarized[name] = statistic - if type(statistic) is Mean and isinstance(statistic.column, str): - spread[f"{name} std"] = StandardDeviation(statistic.column) - spread[f"{name} se"] = StandardError(statistic.column) - summarized.update( - { - f"{name} std": spread[f"{name} std"], - f"{name} se": spread[f"{name} se"], - } - ) - if judged is None: - # each mean of a metric followed by its spread - return aggregate( - results, statistics=summarized, by=by, design_columns=design_columns - ) - return aggregate(results, judged, statistics=spread, design_columns=design_columns) diff --git a/src/tatc/tradespace/deployment.py b/src/tatc/tradespace/deployment.py index 2b106345..33d16d0b 100644 --- a/src/tatc/tradespace/deployment.py +++ b/src/tatc/tradespace/deployment.py @@ -35,12 +35,14 @@ from __future__ import annotations -import bisect import math +import numbers from collections.abc import Callable, Mapping, Sequence from dataclasses import dataclass, field from typing import Any +import numpy as np + from ..schemas import Satellite from .constellations import layout_of from .events import ( @@ -48,6 +50,7 @@ PerType, PlannedPlane, Production, + _Manifest, _per_type, _per_type_values, ) @@ -71,7 +74,10 @@ class Stage: `DeploymentSchedule`); they are then replaced at the end of their design life and restored if they fail, as the satellites of other planes. A stage that is not deployed is neither produced nor launched, and its - satellites never operate. + satellites never operate; but a type of satellite whose planes are all + staged is still developed, and costs its development (see + `CostModel.estimate`), whether or not its stages are deployed: the cost + of the option to deploy them. A rule that depends on the values of a design (such as an uncertain parameter or a value of a scenario, known by the time of the decision) @@ -86,10 +92,11 @@ class Stage: Args: planes (Sequence[int] | int): The planes of the stage (their indices, - in the order of the layouts' planes), produced and launched in - this order. + in the order of the layouts' planes, such as integers of numpy), + produced and launched in this order. times (float | Sequence[float]): The times of the decisions, in years - after the first launch. + after the first launch (a number, or a sequence or array of + them). rule (Callable | None): A function of a `Decision` that returns whether to deploy the stage, or `None` to deploy it at the first time (a planned delay). @@ -104,13 +111,17 @@ class Stage: lead_years: float = 0.0 def __post_init__(self): - planes = (self.planes,) if isinstance(self.planes, int) else self.planes + planes = self.planes + if isinstance(planes, numbers.Integral) or np.ndim(planes) == 0: + planes = (planes,) planes = tuple(int(plane) for plane in planes) if not planes: raise ValueError("a stage needs planes") if len(set(planes)) != len(planes) or min(planes) < 0: raise ValueError("the planes of a stage must be distinct indices") - times = self.times if isinstance(self.times, Sequence) else (self.times,) + times = self.times + if isinstance(times, numbers.Real) or np.ndim(times) == 0: + times = (times,) times = tuple(sorted(float(time) for time in times)) if not times or times[0] < 0: raise ValueError("a stage needs times of decisions, not negative") @@ -133,7 +144,7 @@ class Deployment: planes: list[PlannedPlane] = field(default_factory=list) """list[PlannedPlane]: The planes, in the order of the layouts' planes: the type of their satellites, the number of satellites of the layout, - and of spares.""" + and of spares in orbit.""" development: dict[Any, float] = field(default_factory=dict) """dict: The end of the development of each type of satellite (years).""" production: list[Production] = field(default_factory=list) @@ -171,7 +182,11 @@ def end(self) -> float: @property def deployed(self) -> float: """float: The time by which every satellite of the first generation - is launched (years).""" + is launched (years): of the planes that are not staged, and of the + stages that their rules deploy in the history of the mission without + failures (see `planned` and `MissionHistory.deployed`).""" + if self.stages: + return self.planned().deployed return max( launch.time for launch in self.launches if launch.purpose == "deployment" ) @@ -189,7 +204,7 @@ def units(self) -> dict[Any, int]: def simulate( self, - failures: FailureModel | None = None, + model: FailureModel | None = None, policy: RestorationPolicy | None = None, seed: int | Sequence[int] | None = None, ) -> MissionHistory: @@ -198,15 +213,20 @@ def simulate( satellites and launches (drawn from a seed of a replicate, such as an uncertain parameter, see `Uncertain.seed`) and the restoration of failed satellites by a policy. Without a seed, nothing fails (but a - policy's spares on the ground are still produced). + policy's spares on the ground are still produced). The spares in + orbit are those of the plan (see `DeploymentSchedule.plan`). A satellite's life is drawn when it is launched (or takes the place - of a failed one), from a random number generator seeded by the seed - and its plane, position, and generation, and the success of a launch - from one seeded by its plane and order: with common random numbers, - the satellite at the same position of the same plane fails at the - same age in the same replicate of every design. Spares in orbit do - not age or fail until they take a failed satellite's place. + of a failed one), from uniform numbers of a random number generator + seeded by the seed and its plane, position, and generation; the + success of a planned launch (of the deployment, or a replacement) + from one seeded by its plane, the position of its first satellite, + and its generation; and that of a launch of restorations or spares + from one seeded by its plane and its order among them: with common + random numbers, the satellite at the same position of the same plane + fails at the same age in the same replicate of every design. Spares + in orbit do not age or fail until they take a failed satellite's + place, which they then hold (and which planned replacements replace). A planned replacement (at the end of a design life) whose launch fails is not flown again: the satellite it would replace operates @@ -214,7 +234,7 @@ def simulate( failures). Args: - failures (FailureModel | None): The failures, or `None` for none. + model (FailureModel | None): The failures, or `None` for none. policy (RestorationPolicy | None): The policy for failed satellites, or `None` to restore them by producing new ones. seed (int | Sequence[int] | None): The seed of the replicate (or @@ -225,7 +245,7 @@ def simulate( MissionHistory: the history of the mission """ return _Simulation( - self, failures or FailureModel(), policy or RestorationPolicy(), seed + self, model or FailureModel(), policy or RestorationPolicy(), seed ).run() def planned(self) -> MissionHistory: @@ -242,11 +262,11 @@ def planned(self) -> MissionHistory: def simulate_many( self, - failures: FailureModel, + model: FailureModel | None = None, policy: RestorationPolicy | None = None, seed: int | None = None, - histories: int = 1, *, + histories: int = 1, sampling: str = "stratified", stress: float = 1.0, launch_stress: float | None = None, @@ -274,7 +294,7 @@ def simulate_many( probability that a launch fails times the `launch_stress` (by default the stress, at most 0.5). Each history is weighted by its likelihood ratio (`MissionHistory.weight`, see `Lifetime.stressed`), - which `summarize_missions` applies to every statistic. A stress + which `summarize_histories` applies to every statistic. A stress that samples the outcomes of interest about as often as the others estimates their probabilities (and the quantiles of their tails) with far fewer histories; too large a stress makes a few weights @@ -282,11 +302,11 @@ def simulate_many( Many histories of the failures of a replicate, whose sample of targets (the expensive part of an evaluation) they share, measure the - risk of a mission at little cost (see `evaluate_missions` and + risk of a mission at little cost (see `evaluate_histories` and `PhaseCache`). Args: - failures (FailureModel): The failures. + model (FailureModel | None): The failures, or `None` for none. policy (RestorationPolicy | None): The policy for failed satellites, or `None` to restore them by producing new ones (as `simulate`). @@ -304,18 +324,25 @@ def simulate_many( if histories < 1: raise ValueError("histories must be at least 1") if seed is None: - return [self.simulate(failures, policy, None)] + return [self.simulate(model, policy, None)] return _simulate_many( - self, failures, policy, seed, histories, sampling, stress, launch_stress + self, + model or FailureModel(), + policy, + seed, + histories, + sampling, + stress, + launch_stress, ) def expected_metrics( self, - failures: FailureModel, + model: FailureModel | None = None, policy: RestorationPolicy | None = None, seed: int = 0, - histories: int = 1000, *, + histories: int = 1000, sampling: str = "stratified", ) -> dict[str, float]: """ @@ -323,11 +350,11 @@ def expected_metrics( `MissionHistory.metrics`, such as its `availability`) from many simulated histories (see `simulate_many`), without evaluating their phases: precise and cheap, as the expected values of control - variates (see `summarize_missions`, and the `controls` of + variates (see `summarize_histories`, and the `controls` of `Failures`). Args: - failures (FailureModel): The failures. + model (FailureModel | None): The failures, or `None` for none. policy (RestorationPolicy | None): The policy for failed satellites (see `simulate_many`). seed (int): The seed of the histories. @@ -337,7 +364,9 @@ def expected_metrics( Returns: dict[str, float]: the mean of each measure """ - return _expected_metrics(self, failures, policy, seed, histories, sampling) + return _expected_metrics( + self, model or FailureModel(), policy, seed, histories, sampling + ) def phases(self, satellites: Sequence[Satellite | str]) -> list[Phase]: """ @@ -367,20 +396,26 @@ class DeploymentSchedule: every type, or one for each). * Its satellites are then produced on one line at `production_rate` satellites a year (or at once, if `None`), plane by plane, in the - order of the layouts' planes (or of `order`). + order of the layouts' planes (or of `order`). The line also produces, + after the work before them, the planes of stages that are deployed, + the satellites that restore failed ones, and the spares of a policy + (see `Stage` and `RestorationPolicy`). * Each plane is launched when its satellites are ready, in as many launches as its satellites need (given a `launch_capacity` in number or mass, or one per plane), at most one every `launch_interval` years, in the order the planes are ready. * The mission lasts `years` from the first launch. Satellites are replaced at the end of their `design_life` (one for every type, or one - for each; if before the end of the mission), each replacement produced - at the production rate just before it is needed and launched then - (see `replacements`). A - design life does not retire a satellite: one that is not replaced (as - near the end of the mission, or if its replacement's launch fails) - operates until it fails (by the wear-out of its life, see - `FailureModel`). + for each; if before the end of the mission): those at the positions of + the layout that each launch carries, not its spares in orbit, which do + not age (see `Deployment.simulate`). Each replacement is produced at + the production rate just before it is needed (planned apart from the + line, so that replacements do not wait for each other) and launched + at the next launch slot then (keeping the launch interval), and is + replaced in turn a design life after its launch. A design life does + not retire a satellite: one that is not replaced (as near the end of + the mission, or if its replacement's launch fails) operates until it + fails (by the wear-out of its life, see `FailureModel`). * A `sustained` constellation (such as of an operational program, whose mission is the period of a study) is replaced after the end of the mission as before it: the replacements needed after the end are @@ -410,8 +445,9 @@ class DeploymentSchedule: launch_mass_capacity (float | Callable | None): The most mass (kg) of a launch, if limited (which requires the masses of the satellites): a value, or a function of the index and values of a - plane (as for `order`), such as for planes at different - inclinations, to which a launcher lifts different masses. + plane (see `Plane`, as for `order`), such as for planes at + different inclinations, to which a launcher lifts different + masses. order (Callable | None): A function of the index and values of a plane (`None` for the planes of a Walker layout) that gives the key by which its type's planes are produced and launched, if @@ -456,7 +492,7 @@ def design_life_of(self, kind: Any = None) -> float | None: Gets the design life of a type of satellite. Args: - kind (Any): The type of the satellites. + kind (Any): The type of the satellites (see `plan`). Returns: float | None: the design life (years), or `None` if they last @@ -478,56 +514,6 @@ def production_years(self, kind: Any, satellites: int) -> float: rate = _per_type(self.production_rate, kind, "production rate") return 0.0 if rate is None else satellites / rate - def replacements( - self, launch: Launch, end: float - ) -> list[tuple[Production, Launch | None]]: - """ - Gets the planned replacements of the satellites of a launch, at the - end of their design life: the production of each (just before it is - needed) and its launch. Replacements are launched before the end of - the mission, or, for a sustained constellation, produced after it - (without a launch, `None`) from those whose production begins within - the development years of their type after the end (whose later - blocks of production may be developed before it). - - Args: - launch (Launch): The launch. - end (float): The end of the mission. - - Returns: - list[tuple[Production, Launch | None]]: the production and the - launch of each replacement, in order - """ - life = self.design_life_of(launch.kind) - if life is None: - return [] - producing = self.production_years(launch.kind, launch.satellites) - horizon = end - if self.sustained: - horizon += float( - _per_type(self.development_years, launch.kind, "development") - ) - replacements: list[tuple[Production, Launch | None]] = [] - need, generation = launch.time + life, 1 - while (need - producing if self.sustained else need) < horizon - 1e-9: - production = Production( - launch.kind, need - producing, need, launch.satellites, "replacement" - ) - replacement = None - if need < end - 1e-9: # not those of a sustained constellation after it - replacement = Launch( - need, - launch.plane, - launch.kind, - launch.first, - launch.satellites, - generation, - "replacement", - ) - replacements.append((production, replacement)) - need, generation = need + life, generation + 1 - return replacements - def mass_capacity_of(self, plane: tuple[int, Any] | None = None) -> float | None: """ Gets the most mass (kg) of a launch to a plane, if limited. @@ -549,8 +535,9 @@ def mass_capacity_of(self, plane: tuple[int, Any] | None = None) -> float | None def next_slot(self, booked: Sequence[float], ready: float) -> float: """ Gets the earliest time of a launch at or after a time that keeps the - launch interval from launches booked before (as the deployments of - plans and the launches of simulations book them). + launch interval from launches booked before (as plans and + simulations book every launch: of deployments, replacements, + restorations, and spares). Args: booked (Sequence[float]): The times of the launches booked, in @@ -647,8 +634,9 @@ def launches_of( def plan( self, layout: Any, + *, kind: Any = None, - spares: int = 0, + orbit_spares: int | Mapping[Any, int] = 0, masses: PerType | None = None, stages: Sequence[Stage] = (), ) -> Deployment: @@ -664,11 +652,14 @@ def plan( layout (Any): The layout (or layouts) of the satellites, or a mapping of types of satellites to layouts. kind (Any): The type of the satellites of a layout. - spares (int): The spares in orbit in each plane, produced and - launched with it, which wait in orbit to take the place of - failed satellites (see `RestorationPolicy`). + orbit_spares (int | Mapping[Any, int]): The spares in orbit in + each plane (of every type, or of each), produced and launched + with it, which wait in orbit to take the place of failed + satellites (see `RestorationPolicy`, whose `orbit_spares` a + `MissionPlan` plans). masses (float | Mapping | None): The mass (kg) of the satellites - (of each type), for a launch capacity in mass. + (of each type), for a launch capacity in mass (and the price + of launches by mass, see `CostModel.estimate`). stages (Sequence[Stage]): The stages deployed later, if their rules decide to. @@ -677,11 +668,12 @@ def plan( Raises: ValueError: if a plane is in several stages or is not a plane of - the layouts, or if no satellites are planned. + the layouts, if no satellites are planned, or if spares are + negative. """ # pylint: disable=too-many-locals - if spares < 0: - raise ValueError("spares must not be negative") + if any(spares < 0 for spares in _per_type_values(orbit_spares)): + raise ValueError("orbit_spares must not be negative") stages = tuple(stages) staged = [plane for stage in stages for plane in stage.planes] if len(set(staged)) != len(staged): @@ -692,55 +684,52 @@ def plan( else: fleets = {kind: layout} deployment = Deployment(schedule=self, stages=stages) - planes = [] # (ready, index, kind, satellites, mass) + manifest = _Manifest( + self, + deployment.planes, + deployment.masses, + deployment.plane_values, + {}, + [], + deployment.production, + ) + ready = [] # (ready, index) of the planes that are not staged for name, item in fleets.items(): developed = float(_per_type(self.development_years, name, "development")) - mass = None if masses is None else _per_type(masses, name, "mass") + spares = int(_per_type(orbit_spares, name, "orbit spares")) deployment.development[name] = developed - deployment.masses[name] = mass + deployment.masses[name] = ( + None if masses is None else _per_type(masses, name, "mass") + ) + manifest.lines[name] = developed listed = [] for plane in layout_of(item).planes(): - size, values = plane.satellites, plane.values index = len(deployment.planes) deployment.planes.append( - PlannedPlane(name, size, spares if size > 0 else 0) + PlannedPlane( + name, plane.satellites, spares if plane.satellites > 0 else 0 + ) ) - deployment.plane_values.append(values) - if size > 0 and index not in staged: - listed.append((index, size + spares, values)) + deployment.plane_values.append(plane.values) + if plane.satellites > 0 and index not in staged: + listed.append((index, plane)) if self.order is not None: - listed.sort(key=lambda plane: self.order(plane[0], plane[2])) - line = developed - for index, size, _ in listed: - ready = line + self.production_years(name, size) - deployment.production.append(Production(name, line, ready, size)) - planes.append((ready, index, name, size, mass)) - line = ready + listed.sort(key=lambda item: self.order(item[0], item[1].values)) + for index, plane in listed: + count = plane.satellites + spares + ready.append((manifest.produce(developed, name, count), index)) unknown = sorted(set(staged) - set(range(len(deployment.planes)))) if unknown: raise ValueError( f"stages of planes that the layouts do not have: {unknown}" ) - if not planes: + if not ready: raise ValueError("a deployment requires satellites (that are not staged)") - booked: list[float] = [] - for ready, index, name, size, mass in sorted(planes, key=lambda p: p[0]): - position = 0 - for satellites in self.split( - size, mass, (index, deployment.plane_values[index]) - ): - time = self.next_slot(booked, ready) - bisect.insort(booked, time) - deployment.launches.append( - Launch(time, index, name, position, satellites) - ) - position += satellites - end = deployment.end - for launch in list(deployment.launches): - for production, replacement in self.replacements(launch, end): - deployment.production.append(production) - if replacement is not None: - deployment.launches.append(replacement) + for time, index in sorted(ready, key=lambda item: item[0]): + deployment.launches.extend(manifest.launch(index, time)) + deployment.launches.extend( + manifest.replace(list(deployment.launches), deployment.end) + ) deployment.production.sort(key=lambda batch: batch.begin) deployment.launches.sort(key=lambda launch: (launch.time, launch.plane)) return deployment diff --git a/src/tatc/tradespace/events.py b/src/tatc/tradespace/events.py index 0239f2c8..298ab341 100644 --- a/src/tatc/tradespace/events.py +++ b/src/tatc/tradespace/events.py @@ -1,30 +1,38 @@ """ Events of the deployments of constellations: the production and launches of -satellites (see `Deployment` and `MissionHistory`), and values given for -each type of satellite. +satellites (see `Deployment` and `MissionHistory`), their booking on the +production lines and at the launch slots of a schedule, which plans and +simulations share, and values given for each type of satellite. @author: Paul T. Grogan """ from __future__ import annotations -from collections.abc import Mapping +import bisect +import heapq +import itertools +import math +from collections.abc import Mapping, Sequence from dataclasses import dataclass -from typing import Any, NamedTuple +from typing import TYPE_CHECKING, Any, NamedTuple + +if TYPE_CHECKING: + from .deployment import DeploymentSchedule PerType = float | Mapping[Any, float] -"""A value for every type of satellite, or for each (a mapping by kind).""" +"""A value for every type of satellite, or for each (a mapping by type).""" def _per_type(value: Any, kind: Any, name: str) -> Any: """ - Gets the value of a type of satellite (by its kind) of a value for every - type or a mapping of each, raising a `ValueError` (naming the value) if - the mapping lacks the kind. + Gets the value of a type of satellite of a value for every type or a + mapping of each, raising a `ValueError` (naming the value) if the mapping + lacks the type. """ if isinstance(value, Mapping): if kind not in value: - raise ValueError(f"no {name} of satellites of kind {kind!r}") + raise ValueError(f"no {name} of satellites of type {kind!r}") return value[kind] return value @@ -41,7 +49,7 @@ class PlannedPlane(NamedTuple): """Any: The type of its satellites.""" satellites: int """int: The number of satellites of the layout (its positions).""" - spares: int + orbit_spares: int """int: The number of spares in orbit.""" @@ -90,3 +98,132 @@ class Production: """int: The number of satellites.""" purpose: str = "deployment" """str: `"deployment"`, `"replacement"`, `"restoration"`, or `"spare"`.""" + + +class _Manifest: + """ + The production and launches of a deployment as they are booked, which + plans (see `DeploymentSchedule.plan`) and simulations (of the stages they + deploy, and of restorations) share: the production line of each type of + satellite, the launches booked (which later ones keep the launch + interval from, see `DeploymentSchedule.next_slot`), and the production + added. + + Args: + schedule (DeploymentSchedule): The schedule. + planes (Sequence[PlannedPlane]): The planes of the deployment. + masses (Mapping): The mass of each type of satellite, if given. + values (Sequence): The values of each plane (see `Plane`). + lines (dict): The time from which each type's line is free. + booked (list[float]): The times of the launches booked, in order. + production (list[Production]): The production, to which it adds. + """ + + # pylint: disable=too-many-arguments,too-many-positional-arguments + + def __init__( + self, + schedule: DeploymentSchedule, + planes: Sequence[PlannedPlane], + masses: Mapping[Any, float | None], + values: Sequence[Any], + lines: dict[Any, float], + booked: list[float], + production: list[Production], + ): + self.schedule, self.planes, self.masses = schedule, planes, masses + self.values, self.lines, self.booked = values, lines, booked + self.production = production + + def plane(self, plane: int) -> tuple[int, Any]: + """The index and values of a plane (see `DeploymentSchedule`).""" + return plane, self.values[plane] if plane < len(self.values) else None + + def produce( + self, earliest: float, kind: Any, count: int, purpose: str = "deployment" + ) -> float: + """ + Produces satellites on their type's line, from a time (after the work + before them), returning when they are ready. + """ + begin = max(self.lines[kind], earliest) + ready = begin + self.schedule.production_years(kind, count) + self.lines[kind] = ready + self.production.append(Production(kind, begin, ready, count, purpose)) + return ready + + def slot(self, ready: float) -> float: + """ + Books the earliest launch at or after a time that keeps the launch + interval (see `DeploymentSchedule.next_slot`), returning its time. + """ + time = self.schedule.next_slot(self.booked, ready) + bisect.insort(self.booked, time) + return time + + def launch(self, plane: int, ready: float) -> list[Launch]: + """ + Launches the satellites of a plane (and its spares in orbit) when + they are ready: in as many launches as they need (see + `DeploymentSchedule.split`), each at the next launch slot. + """ + kind, size, spares = self.planes[plane] + launches, first = [], 0 + for satellites in self.schedule.split( + size + spares, self.masses.get(kind), self.plane(plane) + ): + launches.append(Launch(self.slot(ready), plane, kind, first, satellites)) + first += satellites + return launches + + def replace(self, launches: Sequence[Launch], end: float) -> list[Launch]: + """ + Adds the planned replacements of the satellites of launches at the end + of their design life (see `DeploymentSchedule`), returning their + launches: of the positions of the layout that a launch carries (not + of spares in orbit, which do not age), each produced just before it + is needed (at the production rate, apart from the line) and launched + at the next launch slot then, in the order they are needed, and + replaced in turn a design life after that launch. A replacement that + no slot before the end of the mission launches is not produced, but + for a sustained constellation, whose replacements are produced after + the end (their production begun within the development years of + their type after it), though not launched. + """ + schedule = self.schedule + queue: list = [] + order = itertools.count() + for launch in launches: + life = schedule.design_life_of(launch.kind) + built = self.planes[launch.plane].satellites + count = min(launch.first + launch.satellites, built) - launch.first + if life is not None and count > 0: + item = (launch.plane, launch.kind, launch.first, count, life) + heapq.heappush(queue, (launch.time + life, next(order), 1, item)) + replacements = [] + while queue: + need, _, generation, item = heapq.heappop(queue) + plane, kind, first, count, life = item + begin = need - schedule.production_years(kind, count) + time = math.inf + if need < end - 1e-9: + time = schedule.next_slot(self.booked, need) + if time < end - 1e-9: + bisect.insort(self.booked, time) + replacements.append( + Launch(time, plane, kind, first, count, generation, "replacement") + ) + following = time + life + elif ( + schedule.sustained + and begin + < end + + float(_per_type(schedule.development_years, kind, "development")) + - 1e-9 + ): + following = need + life # produced after the end, not launched + else: + continue + self.production.append(Production(kind, begin, need, count, "replacement")) + heapq.heappush(queue, (following, next(order), generation + 1, item)) + return replacements diff --git a/src/tatc/tradespace/failures.py b/src/tatc/tradespace/failures.py index 78dd45b4..2469436a 100644 --- a/src/tatc/tradespace/failures.py +++ b/src/tatc/tradespace/failures.py @@ -12,7 +12,8 @@ how failed satellites are restored: by spares in orbit, by spares on the ground, or by satellites built when needed. A policy is a decision of a design with a fragment of a design space (`policy_space`), whose values -configure it (see `configure`). +configure it (see `configure`), as the policy of each design of a +`MissionPlan` may be. @author: Paul T. Grogan """ @@ -322,7 +323,7 @@ def _age_at(self, target: float) -> float: class FailureModel: """ The failures of a mission: the life of the satellites (of every type, or - of each, by kind; `None` if they do not fail) and the probability that a + of each, by type; `None` if they do not fail) and the probability that a launch fails, losing its satellites. Args: @@ -359,9 +360,12 @@ class RestorationPolicy: of their design life, if they are), or to restore them, from the fastest source available when the failure is known (`detection_years` after it): - * a spare in orbit in the failed satellite's plane (see the `spares` of - `DeploymentSchedule.plan`), which takes its place after - `drift_years`; + * a spare in orbit in the failed satellite's plane (`orbit_spares` in + each plane of every type, or of each, which a deployment plans: see + `DeploymentSchedule.plan`, and `MissionPlan`, which plans those of + the policy of each design), which takes its place after + `drift_years` (and is then replaced as planned, as the satellite it + replaces would have been); * a spare on the ground (`ground_spares` of each type, produced after the first satellites and stored), launched at the next launch slot; * a satellite produced when needed, `procurement_years` after it is @@ -383,8 +387,11 @@ class RestorationPolicy: of a failed satellite. procurement_years (float): The time from ordering a satellite to the start of its production. + orbit_spares (int | Mapping[Any, int]): The spares in orbit in each + plane of every type of satellite, or of each (by type, every type + of the deployment), which the deployment plans. ground_spares (int | Mapping[Any, int]): The spares on the ground of - every type of satellite, or of each (by kind, every kind of the + every type of satellite, or of each (by type, every type of the deployment). replenish (bool): `True` to replace the spares that are used. batch_years (float): The time that restorations of a plane wait to @@ -395,6 +402,7 @@ class RestorationPolicy: detection_years: float = 0.1 drift_years: float = 0.25 procurement_years: float = 0.0 + orbit_spares: int | Mapping[Any, int] = 0 ground_spares: int | Mapping[Any, int] = 0 replenish: bool = False batch_years: float = 0.0 @@ -408,8 +416,21 @@ def __post_init__(self): ): if getattr(self, name) < 0: raise ValueError(f"{name} must not be negative") - if any(value < 0 for value in _per_type_values(self.ground_spares)): - raise ValueError("ground_spares must not be negative") + for name in ("orbit_spares", "ground_spares"): + if any(value < 0 for value in _per_type_values(getattr(self, name))): + raise ValueError(f"{name} must not be negative") + + def orbit_spares_of(self, kind: Any) -> int: + """ + Gets the spares in orbit in each plane of a type of satellite. + + Args: + kind (Any): The type. + + Returns: + int: the number of spares + """ + return int(_per_type(self.orbit_spares, kind, "orbit spares")) def ground_spares_of(self, kind: Any) -> int: """ @@ -444,20 +465,26 @@ def policy_space( `RestorationPolicy`), for trades of their cost against their robustness: whether to `restore` failed satellites (by default a variable, `False` or `True`), the spares in orbit in each plane - (`orbit_spares`, which a deployment plans, see the `spares` of + (`orbit_spares`, which a deployment plans, see `DeploymentSchedule.plan`), the spares on the ground (`ground_spares`), whether to `replenish` used spares, and other fields of the policy (such as `drift_years`). Each is a node of a design space (such as a design variable) or a value. - A design's policy is configured from the values of the fragment, and its - deployment planned with their spares in orbit, as an `ObservationStudy` - does with a mission plan that names the fragment (`MissionPlan.policy`):: + A design's policy is configured from the values of the fragment (see + `configure`), and its deployment planned with its spares in orbit:: policy = configure(BASE_POLICY, d.policy) - deployment = SCHEDULE.plan(d.layout, spares=d.policy.orbit_spares) + deployment = SCHEDULE.plan(d.layout, orbit_spares=policy.orbit_spares) history = deployment.simulate(FAILURE_MODEL, policy, d.failure_seed) + as an `ObservationStudy` does with a mission plan that names the + fragment (see `MissionPlan.policy`), whose values configure the default + policy (give the fields of a base policy to the fragment, or a function + of the design that configures it):: + + PLAN = MissionPlan(SCHEDULE, COST_MODEL, policy="policy") + Spares without restoration would never be used, so a constraint excludes them (unless `require_restoration` is `False`). diff --git a/src/tatc/tradespace/fingerprint.py b/src/tatc/tradespace/fingerprint.py index 7d3b405b..4c6169e7 100644 --- a/src/tatc/tradespace/fingerprint.py +++ b/src/tatc/tradespace/fingerprint.py @@ -3,31 +3,54 @@ and settings), which key persistent results so that results computed with other definitions are not reused. -A definition (see `get_definition`) describes values by their content where -it can: plain values (numbers, strings, dates and times, and their -containers), pydantic models (such as satellites and instruments), arrays -and data frames (by a hash of their data, with geometries by their -well-known binary), the nodes of design spaces, dataclasses (such as cost -models) by their fields (but those whose metadata has `"fingerprint": -False`, such as directories of caches, which do not change results), and -geometries (by their well-known binary), and functions, by their compiled -code (which ties a definition to the version of Python, which it records, -but not their docstrings, which do not change results), the values they -close over and their defaults, and the constants (numbers, strings, dates -and times, and tuples of them), geometries, data (arrays and data frames), -dataclasses, and functions that they refer to as globals (not mutable -containers, which are often state, such as caches). Functions are described -so if they are of their own module or of another module of the study's own, -which is not installed (such as a module next to a notebook), so that a -notebook's function that calls a function it imports from such a module is -described as the module's copy of it is. Functions and classes of installed -modules are described by their names, and other objects by their type only, -but for the classes of the study's own modules (by the code of their -methods) and their objects (by their attributes and classes), such as a -callable object that evaluates designs. -Data that functions read (such as from files) and the code of installed -modules they call (other than TAT-C's) are not described: identify them by -a namespace (see `ResultStore` and `SatelliteCache`). +A definition (see `get_definition`) describes values as follows (the rules +of `_Describer.describe`), whether they are given (such as the design space +and functions of a study), or are referred to by functions (as globals, the +values they close over, and their defaults), or are within other values: + +- By content: + + - plain values (`None`, booleans, numbers, strings, bytes, dates, times, + and durations) and their containers (lists, tuples, sets, and + dictionaries, also as globals, such as a dictionary of instruments); + - pydantic models (such as satellites and instruments); + - arrays and data frames (by a hash of their data, with geometries by + their well-known binary), and geometries; + - dataclasses (such as cost models), by their fields, but those whose + metadata has `"fingerprint": False` (such as directories of caches, + which do not change results); + - the nodes of design spaces, by their attributes; + - partial functions (by their function and arguments), bound methods (by + their function and object), and functions that decorators wrap (such + as by `functools.lru_cache`, by the wrapped function). + +- By code: + + - functions, by their compiled code (which ties a definition to the + version of Python, which it records, but not their docstrings or line + numbers, which do not change results), the values they close over, + their defaults, and the globals they refer to: those of functions of + their own module or of a module of the study's own (one that is not + installed, such as `__main__` or a module next to a notebook) are + described by code, also as attributes of a module of the study's own + (`helpers.score`), so that a notebook's function that calls a function + of such a module is described as the module's copy of it is; + - the classes of the study's own modules, by the code of their methods + (and their constants), and their objects, by their classes and their + attributes, but those that are mutable containers (lists, dictionaries, + and sets), which are often state (such as counters and records of + calls) rather than definitions. + +- By name: the functions of installed modules (as globals of functions), + classes and built-in functions (but the study's own classes), and modules + (but the attributes of the study's own modules that functions refer to). + +- By type: other objects, such as those of installed classes (a cache, or a + connection), whose state does not change results. + +- Not at all: data that functions read (such as from files) and the code of + installed modules other than TAT-C's. Identify them by a namespace (see + `ResultStore` and `SatelliteCache`). TAT-C is described by the source of the modules that the values depend on: the modules that define the functions, classes, and objects of TAT-C they @@ -55,7 +78,7 @@ import sys import sysconfig import types -from collections.abc import Iterable +from collections.abc import Callable, Iterable, Mapping from datetime import date, datetime, time, timedelta from pathlib import Path from typing import Any @@ -65,7 +88,9 @@ import shapely from pydantic import BaseModel +from .alerts import _warn from .hashing import _canonical, _digest +from .nodes import Node _MAX_DEPTH = 24 """The deepest nesting described, beyond which values are described by type.""" @@ -92,10 +117,6 @@ def _name(value: Any) -> str: return f"{getattr(value, '__module__', None)}.{value.__qualname__}" -def _sort_key(value: Any) -> str: - return _canonical(value) - - def _is_package_module(module: Any) -> bool: """Whether a module name is of the package (TAT-C).""" return isinstance(module, str) and ( @@ -108,11 +129,6 @@ def _is_dataclass(value: Any) -> bool: return dataclasses.is_dataclass(value) and not isinstance(value, type) -def _is_data(value: Any) -> bool: - """Whether a value is data (an array or a data frame or series).""" - return isinstance(value, (np.ndarray, pd.DataFrame, pd.Series)) - - @functools.lru_cache(maxsize=1) def _installed_directories() -> tuple[Path, ...]: """Gets the directories of installed modules (and the standard library).""" @@ -140,6 +156,27 @@ def _is_own_module(module: Any) -> bool: return not any(path.is_relative_to(d) for d in _installed_directories()) +def _is_own_class(value: Any) -> bool: + """Whether a value is a class of the study's own (see `_is_own_module`).""" + return isinstance(value, type) and _is_own_module(value.__module__) + + +def _is_own_object(value: Any) -> bool: + """Whether a value is an object of a class of the study's own.""" + return _is_own_module(type(value).__module__) + + +def _wrapped(value: Any) -> types.FunctionType | None: + """ + Gets the function that a decorator wraps (such as `functools.lru_cache`, + or another of `functools.wraps`), if a value is such a wrapper. + """ + if isinstance(value, (types.FunctionType, type)) or not callable(value): + return None + function = getattr(value, "__wrapped__", None) + return function if isinstance(function, types.FunctionType) else None + + def _hash_column(column: pd.Series) -> bytes: """ Gets the hashes of the values of a column (geometries by their @@ -188,22 +225,53 @@ def _has_contents(cell: Any) -> bool: """The instructions that load a global (rather than an attribute, whose names code also lists).""" +_ATTRIBUTE_LOADS = ("LOAD_ATTR", "LOAD_METHOD") +"""The instructions that load an attribute of the value loaded before.""" + -def _global_names(code: types.CodeType) -> list[str]: +def _global_names(code: types.CodeType) -> dict[str, set[tuple[str, ...]]]: """ Gets the global names a code (and its nested code) loads (not the names of attributes, such as `values` of `design.values`, which may be the names - of unrelated globals). + of unrelated globals), each with the chains of attributes that it loads + of the global (such as `("score",)` of `helpers.score`). """ - names = [ - instruction.argval - for instruction in dis.get_instructions(code) - if instruction.opname in _GLOBAL_LOADS - ] + found: dict[str, set[tuple[str, ...]]] = {} + instructions = list(dis.get_instructions(code)) + for i, instruction in enumerate(instructions): + if instruction.opname not in _GLOBAL_LOADS: + continue + chain = [] + for following in instructions[i + 1 :]: + if following.opname not in _ATTRIBUTE_LOADS: + break + chain.append(following.argval) + chains = found.setdefault(instruction.argval, set()) + if chain: + chains.add(tuple(chain)) for constant in code.co_consts: if isinstance(constant, types.CodeType): - names.extend(_global_names(constant)) - return list(dict.fromkeys(names)) + for name, chains in _global_names(constant).items(): + found.setdefault(name, set()).update(chains) + return found + + +def _attribute(module: types.ModuleType, chain: tuple[str, ...]) -> tuple[str, Any]: + """ + Gets the value that a chain of attributes of a module reaches, through + its submodules (stopping at the first value that is not a module), and + the path to it, or `("", None)` if there is none. + """ + value: Any = module + path = [] + for name in chain: + if not isinstance(value, types.ModuleType): + break + if not hasattr(value, name): + return "", None + value = getattr(value, name) + path.append(name) + return ".".join(path), value _PLAIN = (type(None), bool, int, float, str, bytes, date, time, timedelta, np.generic) @@ -213,9 +281,8 @@ def _is_constant(value: Any, depth: int = 0) -> bool: """ Whether a value is a constant: a number, string, date or time, or a (small) tuple or frozen set of them. Mutable containers (lists, - dictionaries, and sets) are not constants: as globals, they are often - state (such as caches) rather than definitions, whose contents change - as a study runs. + dictionaries, and sets) are not constants: as attributes of classes, + they are often state (such as registries) rather than definitions. """ if isinstance(value, _PLAIN): return True @@ -230,10 +297,12 @@ def _is_constant(value: Any, depth: int = 0) -> bool: class _Describer: """ - Describes values as plain data (see the module), noting the modules of - the package that they depend on. + Describes values as plain data (see the module, and `_RULES`), noting + the modules of the package that they depend on. """ + # pylint: disable=too-many-public-methods + def __init__(self): self.modules: set[str] = set() """The modules of the package that the described values refer to.""" @@ -243,6 +312,138 @@ def note(self, module: Any) -> None: if _is_package_module(module): self.modules.add(module) + def describe(self, value: Any, depth: int = 0, seen: set | None = None) -> Any: + """ + Describes a value as plain data, by the first rule that it matches + (see `_RULES`), or by its type if none does. + """ + seen = set() if seen is None else seen + if depth <= _MAX_DEPTH: + for test, rule in _RULES: + if isinstance(value, test) if isinstance(test, tuple) else test(value): + return rule(self, value, depth, seen) + self.note(type(value).__module__) + return _type(value) + + # the rules of descriptions (see `_RULES`) + + def plain(self, value: Any, depth: int, seen: set) -> Any: + """Describes `None`, a boolean, an integer, or a string as itself.""" + del depth, seen + return value + + def number(self, value: float, depth: int, seen: set) -> str: + """Describes a float by its representation (exactly).""" + del depth, seen + return repr(value) + + def scalar(self, value: np.generic, depth: int, seen: set) -> Any: + """Describes a numpy scalar as Python's.""" + return self.describe(value.item(), depth, seen) + + def binary(self, value: bytes, depth: int, seen: set) -> str: + """Describes bytes by their hash.""" + del depth, seen + return hashlib.sha1(value).hexdigest() + + def moment(self, value: date | time, depth: int, seen: set) -> str: + """Describes a date or time by its ISO format.""" + del depth, seen + return value.isoformat() + + def duration(self, value: timedelta, depth: int, seen: set) -> dict: + """Describes a duration by its seconds.""" + del depth, seen + return {"timedelta": value.total_seconds()} + + def dataclass(self, value: Any, depth: int, seen: set) -> dict: + """ + Describes a dataclass by its fields (but those whose metadata has + `"fingerprint": False`), and its class, if of the study's own. + """ + self.note(type(value).__module__) + described = { + **_type(value), + **{ + item.name: self.describe(getattr(value, item.name), depth + 1, seen) + for item in dataclasses.fields(value) + if item.metadata.get("fingerprint", True) + }, + } + if _is_own_module(type(value).__module__): + described["class"] = self.klass(type(value), depth + 1, seen) + return described + + def model(self, value: BaseModel, depth: int, seen: set) -> dict: + """Describes a pydantic model by its data.""" + del depth, seen + self.note(type(value).__module__) + return {**_type(value), **value.model_dump(mode="json")} + + def array(self, value: np.ndarray, depth: int, seen: set) -> dict: + """Describes an array by its type, shape, and a hash of its data.""" + del depth, seen + if value.dtype == object: + return {**_type(value), "shape": list(value.shape)} + return { + "array": str(value.dtype), + "shape": list(value.shape), + "data": hashlib.sha1(np.ascontiguousarray(value).tobytes()).hexdigest(), + } + + def frame(self, value: pd.DataFrame | pd.Series, depth: int, seen: set) -> dict: + """Describes a data frame or series (see `_frame`).""" + del depth, seen + return _frame(value) + + def geometry(self, value: shapely.Geometry, depth: int, seen: set) -> dict: + """Describes a geometry by a hash of its well-known binary.""" + del depth, seen + return {**_type(value), "data": hashlib.sha1(value.wkb).hexdigest()} + + def sequence(self, value: list | tuple, depth: int, seen: set) -> Any: + """Describes a list or tuple by its items (or its length, if long).""" + if len(value) > _MAX_ITEMS: + return {**_type(value), "length": len(value)} + return [self.describe(v, depth + 1, seen) for v in value] + + def collection(self, value: set | frozenset, depth: int, seen: set) -> Any: + """Describes a set by its sorted items (or its length, if long).""" + if len(value) > _MAX_ITEMS: + return {**_type(value), "length": len(value)} + return sorted( + (self.describe(v, depth + 1, seen) for v in value), key=_canonical + ) + + def mapping(self, value: dict, depth: int, seen: set) -> Any: + """ + Describes a dictionary by its items (sorted pairs, if its keys are + not strings), or its length, if long. + """ + if len(value) > _MAX_ITEMS: + return {**_type(value), "length": len(value)} + if all(isinstance(key, str) for key in value): + return {key: self.describe(v, depth + 1, seen) for key, v in value.items()} + pairs = ( + [self.describe(k, depth + 1, seen), self.describe(v, depth + 1, seen)] + for k, v in value.items() + ) + return sorted(pairs, key=_canonical) + + def node(self, value: Node, depth: int, seen: set) -> dict: + """Describes a node of a design space by its attributes.""" + self.note(type(value).__module__) + if id(value) in seen: + return {**_type(value), "recursive": True} + seen = seen | {id(value)} + return { + **_type(value), + **{ + name: self.describe(attribute, depth + 1, seen) + for name, attribute in sorted(vars(value).items()) + }, + } + def code( self, code: types.CodeType, depth: int, seen: set, doc: str | None = None ) -> dict: @@ -269,6 +470,96 @@ def code( "names": list(code.co_names), } + def function(self, function: types.FunctionType, depth: int, seen: set) -> dict: + """ + Describes a function: its code, the values it closes over, its + defaults, and the globals it refers to (see `reference`). + """ + self.note(function.__module__) + if id(function) in seen: + return {"function": function.__qualname__, "recursive": True} + seen = seen | {id(function)} + closure = { + name: self.describe(cell.cell_contents, depth + 1, seen) + for name, cell in zip( + function.__code__.co_freevars, function.__closure__ or () + ) + if _has_contents(cell) + } + referenced = { + name: self.reference( + function.__globals__[name], function.__module__, chains, depth, seen + ) + for name, chains in _global_names(function.__code__).items() + if name in function.__globals__ + } + return { + "function": function.__qualname__, + **self.code(function.__code__, depth, seen, function.__doc__), + "closure": closure, + "defaults": self.describe(function.__defaults__, depth + 1, seen), + "keyword defaults": self.describe(function.__kwdefaults__, depth + 1, seen), + "globals": referenced, + } + + def reference( + self, + value: Any, + module: str, + chains: Iterable[tuple[str, ...]], + depth: int, + seen: set, + ) -> Any: + """ + Describes a global that a function of a module refers to: a function + of another module (or one that a decorator wraps) by its name, unless + it is of a module of the study's own, a module of the study's own by + the attributes of it that the function refers to (by their `chains`, + see `_global_names`), and other values as any other (see `describe`). + """ + # pylint: disable=too-many-arguments,too-many-positional-arguments + function = _wrapped(value) or value + if ( + isinstance(function, types.FunctionType) + and function.__module__ != module + and not _is_own_module(function.__module__) + ): + self.note(function.__module__) + return {"name": _name(function)} + if isinstance(value, types.ModuleType) and _is_own_module(value.__name__): + attributes = {} + for chain in sorted(chains): + path, reached = _attribute(value, chain) + if path: + attributes[path] = self.reference( + reached, value.__name__, (), depth + 1, seen + ) + return {"module": value.__name__, "attributes": attributes} + return self.describe(value, depth + 1, seen) + + def method(self, value: types.MethodType, depth: int, seen: set) -> dict: + """Describes a bound method by its function and its object.""" + return { + "method": self.describe(value.__func__, depth + 1, seen), + "self": self.describe(value.__self__, depth + 1, seen), + } + + def partial(self, value: functools.partial, depth: int, seen: set) -> dict: + """Describes a partial function by its function and arguments.""" + return { + "partial": self.describe(value.func, depth + 1, seen), + "arguments": self.describe(value.args, depth + 1, seen), + "keywords": self.describe(value.keywords, depth + 1, seen), + } + + def wrapper(self, value: Any, depth: int, seen: set) -> dict: + """Describes a decorator's wrapper by its type and wrapped function.""" + self.note(type(value).__module__) + return { + **_type(value), + "wrapped": self.describe(_wrapped(value), depth + 1, seen), + } + def klass(self, cls: type, depth: int, seen: set) -> dict: """ Describes a class of the study's own (see `_is_own_module`): its name, @@ -303,12 +594,24 @@ def klass(self, cls: type, depth: int, seen: set) -> dict: "members": members, } + def named(self, value: Any, depth: int, seen: set) -> dict: + """Describes a class or built-in function by its name.""" + del depth, seen + self.note(getattr(value, "__module__", None)) + return {"name": _name(value)} + + def module(self, value: types.ModuleType, depth: int, seen: set) -> dict: + """Describes a module by its name.""" + del depth, seen + self.note(value.__name__) + return {"module": value.__name__} + def instance(self, value: Any, depth: int, seen: set) -> dict: """ Describes an object of a class of the study's own: its class (see `klass`) and its attributes, but those that are mutable containers (lists, dictionaries, and sets), which are often state (such as - records of calls), as globals of functions are. + counters and records of calls). """ if id(value) in seen: return {**_type(value), "recursive": True} @@ -330,172 +633,39 @@ def instance(self, value: Any, depth: int, seen: set) -> dict: "attributes": self.describe(attributes, depth + 1, seen), } - def function(self, function: types.FunctionType, depth: int, seen: set) -> dict: - """ - Describes a function: its code, the values it closes over, its - defaults, the constants, dataclasses, and functions of its module it - refers to as globals, and the names of the functions, classes, and - modules of other modules it refers to as globals. - """ - self.note(function.__module__) - if id(function) in seen: - return {"function": function.__qualname__, "recursive": True} - seen = seen | {id(function)} - closure = { - name: self.describe(cell.cell_contents, depth + 1, seen) - for name, cell in zip( - function.__code__.co_freevars, function.__closure__ or () - ) - if _has_contents(cell) - } - referenced: dict[str, Any] = {} - module = function.__module__ - for name in _global_names(function.__code__): - if name not in function.__globals__: - continue - value = function.__globals__[name] - if isinstance(value, types.FunctionType): - if value.__module__ == module or _is_own_module(value.__module__): - referenced[name] = self.function(value, depth + 1, seen) - else: - self.note(value.__module__) - referenced[name] = {"name": _name(value)} - elif ( - isinstance(value, (type, types.BuiltinFunctionType, types.ModuleType)) - or _is_constant(value) - or _is_data(value) - or _is_dataclass(value) - or isinstance(value, shapely.Geometry) - ): - referenced[name] = self.describe(value, depth + 1, seen) - else: - # state (such as a cache), whose code may be of the package - self.note(type(value).__module__) - return { - "function": function.__qualname__, - **self.code(function.__code__, depth, seen, function.__doc__), - "closure": closure, - "defaults": self.describe(function.__defaults__, depth + 1, seen), - "keyword defaults": self.describe(function.__kwdefaults__, depth + 1, seen), - "globals": referenced, - } - def describe(self, value: Any, depth: int = 0, seen: set | None = None) -> Any: - """ - Describes a value as plain data (see the module). - """ - # pylint: disable=too-many-return-statements,too-many-branches,import-outside-toplevel - seen = set() if seen is None else seen - if depth > _MAX_DEPTH: - self.note(type(value).__module__) - return _type(value) - if value is None or isinstance(value, (bool, int, str)): - return value - if isinstance(value, float): - return repr(value) - if isinstance(value, np.generic): - return self.describe(value.item(), depth, seen) - if isinstance(value, bytes): - return hashlib.sha1(value).hexdigest() - if isinstance(value, (datetime, date, time)): - return value.isoformat() - if isinstance(value, timedelta): - return {"timedelta": value.total_seconds()} - if _is_dataclass(value): - self.note(type(value).__module__) - described = { - **_type(value), - **{ - item.name: self.describe(getattr(value, item.name), depth + 1, seen) - for item in dataclasses.fields(value) - if item.metadata.get("fingerprint", True) - }, - } - if _is_own_module(type(value).__module__): - described["class"] = self.klass(type(value), depth + 1, seen) - return described - if isinstance(value, BaseModel): - self.note(type(value).__module__) - return {**_type(value), **value.model_dump(mode="json")} - if isinstance(value, np.ndarray): - if value.dtype == object: - return {**_type(value), "shape": list(value.shape)} - return { - "array": str(value.dtype), - "shape": list(value.shape), - "data": hashlib.sha1(np.ascontiguousarray(value).tobytes()).hexdigest(), - } - if isinstance(value, (pd.DataFrame, pd.Series)): - return _frame(value) - if isinstance(value, shapely.Geometry): - return {**_type(value), "data": hashlib.sha1(value.wkb).hexdigest()} - if isinstance(value, (list, tuple)): - if len(value) > _MAX_ITEMS: - return {**_type(value), "length": len(value)} - return [self.describe(v, depth + 1, seen) for v in value] - if isinstance(value, (set, frozenset)): - if len(value) > _MAX_ITEMS: - return {**_type(value), "length": len(value)} - return sorted( - (self.describe(v, depth + 1, seen) for v in value), key=_sort_key - ) - if isinstance(value, dict): - if len(value) > _MAX_ITEMS: - return {**_type(value), "length": len(value)} - if all(isinstance(key, str) for key in value): - return { - key: self.describe(item, depth + 1, seen) - for key, item in value.items() - } - return sorted( - ( - [ - self.describe(k, depth + 1, seen), - self.describe(v, depth + 1, seen), - ] - for k, v in value.items() - ), - key=_sort_key, - ) - if isinstance(value, types.CodeType): - return self.code(value, depth, seen) - if isinstance(value, types.FunctionType): - return self.function(value, depth, seen) - if isinstance(value, types.MethodType): - return { - "method": self.describe(value.__func__, depth + 1, seen), - "self": self.describe(value.__self__, depth + 1, seen), - } - if isinstance(value, functools.partial): - return { - "partial": self.describe(value.func, depth + 1, seen), - "arguments": self.describe(value.args, depth + 1, seen), - "keywords": self.describe(value.keywords, depth + 1, seen), - } - if isinstance(value, type) and _is_own_module(value.__module__): - return self.klass(value, depth, seen) - if isinstance(value, (types.BuiltinFunctionType, type)): - self.note(getattr(value, "__module__", None)) - return {"name": _name(value)} - if isinstance(value, types.ModuleType): - self.note(value.__name__) - return {"module": value.__name__} - self.note(type(value).__module__) - from .nodes import Node - - if isinstance(value, Node): - if id(value) in seen: - return {**_type(value), "recursive": True} - return { - **_type(value), - **{ - name: self.describe(attribute, depth + 1, seen | {id(value)}) - for name, attribute in sorted(vars(value).items()) - }, - } - if _is_own_module(type(value).__module__): - return self.instance(value, depth, seen) - return _type(value) +_RULES: tuple[tuple[tuple[type, ...] | Callable[[Any], bool], Callable], ...] = ( + # by content + ((type(None), bool, int, str), _Describer.plain), + ((float,), _Describer.number), + ((np.generic,), _Describer.scalar), + ((bytes,), _Describer.binary), + ((datetime, date, time), _Describer.moment), + ((timedelta,), _Describer.duration), + (_is_dataclass, _Describer.dataclass), + ((BaseModel,), _Describer.model), + ((np.ndarray,), _Describer.array), + ((pd.DataFrame, pd.Series), _Describer.frame), + ((shapely.Geometry,), _Describer.geometry), + ((list, tuple), _Describer.sequence), + ((set, frozenset), _Describer.collection), + ((dict,), _Describer.mapping), + ((Node,), _Describer.node), + ((functools.partial,), _Describer.partial), + ((types.MethodType,), _Describer.method), + (lambda value: _wrapped(value) is not None, _Describer.wrapper), + # by code + ((types.CodeType,), _Describer.code), + ((types.FunctionType,), _Describer.function), + (_is_own_class, _Describer.klass), + (_is_own_object, _Describer.instance), + # by name + ((types.BuiltinFunctionType, type), _Describer.named), + ((types.ModuleType,), _Describer.module), +) +"""What values are described by (see the module): the first rule whose test +(types, or a predicate) a value matches describes it, and a value that +matches none is described by its type (as is one nested too deep).""" @functools.lru_cache(maxsize=1) @@ -791,6 +961,45 @@ def _differences(before: Any, after: Any, path: str) -> list[str]: return [path] +def _is_code(description: Any) -> bool: + """Whether a description is of compiled code (see `_Describer.code`).""" + return isinstance(description, dict) and {"code", "constants", "names"} <= set( + description + ) + + +_LOCALS = ".." +"""The part of the qualified names of nested code, which some versions of +Python (3.10) keep as constants of the code that makes their functions.""" + + +def _literals(constants: list) -> list: + """ + Gets the literals of the described constants of code, as the same code + gives them in every version of Python: the items of tuples and frozen + sets, and the constants of nested code (whose code is inlined by some + versions), each once, sorted, without `None` (which some versions keep + as a placeholder of a docstring) and the qualified names of nested code. + """ + found: dict[str, Any] = {} + + def visit(constant: Any) -> None: + if constant is None or (isinstance(constant, str) and _LOCALS in constant): + return + if isinstance(constant, list): + for item in constant: + visit(item) + elif _is_code(constant): + for item in constant["constants"]: + visit(item) + else: + found.setdefault(_canonical(constant), constant) + + for constant in constants: + visit(constant) + return [found[key] for key in sorted(found)] + + def _without_code(description: Any) -> Any: """ Gets a description of values without the code of their functions (the @@ -798,37 +1007,54 @@ def _without_code(description: Any) -> Any: the same for the same values with other code (such as a function after its expressions are edited, or compiled by another version of Python). The constants of the code (such as the numbers of a constraint) are - values: functions of other constants are of other studies, whose results - are not those of the same study with other code. + values, as its literals (see `_literals`, which every version of Python + gives alike): functions of other literals are of other studies, whose + results are not those of the same study with other code. """ - if isinstance(description, dict): - code = {"code", "constants", "names"} <= set(description) + if _is_code(description): return { - key: _without_code(value) + key: (_literals(value) if key == "constants" else _without_code(value)) for key, value in description.items() - if not (code and key in ("code", "names")) + if key not in ("code", "names") } + if isinstance(description, dict): + return {key: _without_code(value) for key, value in description.items()} if isinstance(description, list): return [_without_code(value) for value in description] return description -def _with_other_code( - definition: dict, others: Iterable[dict | None] -) -> list[str] | None: +def _with_other_code(definition: dict, others: Mapping[Any, dict | None]) -> list: """ - Gets the differences (see `compare_definitions`) from the first of other - definitions that has the same values as a definition but other code (of - its functions, of TAT-C, or of Python, see `_without_code`), or `None` if - none does: results of the same study with other code, which are not - reused, as opposed to those of other studies (such as variants of other - settings), which share stores and caches freely. + Gets the keys of other definitions (such as of the contexts of a store + or the folders of a cache) that have the same values as a definition but + other code (of its functions, of TAT-C, or of Python, see + `_without_code`), in their order: results of the same study with other + code, which are not reused, as opposed to those of other studies (such + as variants of other settings), which share stores and caches freely. + Definitions that are `None` (unknown) are of no study. """ values = _without_code(definition.get("values", {})) - for other in others: - if other is not None and _without_code(other.get("values", {})) == values: - return compare_definitions(other, definition) - return None + return [ + key + for key, other in others.items() + if other is not None and _without_code(other.get("values", {})) == values + ] + + +def _warn_other_code(subject: str, remedy: str, latest: dict, definition: dict) -> None: + """ + Warns (at the user's call) that results of the same study (or function) + with other code are not reused: `subject` says which (such as `"the + store has 12 evaluations of namespace 'a' by this study"`), and `remedy` + how to remove them, with the differences of the latest of their + definitions from the definition (see `compare_definitions`). + """ + _warn( + f"{subject} with other code, which are not reused ({remedy}); the " + + "latest differs in: " + + "; ".join(compare_definitions(latest, definition)) + ) def compare_definitions(before: dict, after: dict, limit: int = 5) -> list[str]: diff --git a/src/tatc/tradespace/hashing.py b/src/tatc/tradespace/hashing.py index e9b3019d..e3f12b97 100644 --- a/src/tatc/tradespace/hashing.py +++ b/src/tatc/tradespace/hashing.py @@ -13,7 +13,7 @@ from typing import Any -def _plain(value: Any) -> Any: +def _json_default(value: Any) -> Any: """ Gets a value that JSON holds of one it does not: a numpy scalar as Python's, or another value as its string. @@ -30,7 +30,7 @@ def _canonical(value: Any) -> str: mappings sorted (numpy scalars as Python's, and other values as their strings). """ - return json.dumps(value, sort_keys=True, default=_plain) + return json.dumps(value, sort_keys=True, default=_json_default) def _digest(data: str | bytes, length: int | None = None) -> str: diff --git a/src/tatc/tradespace/histories.py b/src/tatc/tradespace/histories.py index 1652d4a8..083fe99e 100644 --- a/src/tatc/tradespace/histories.py +++ b/src/tatc/tradespace/histories.py @@ -3,7 +3,8 @@ their simulation (independent or stratified), evaluation with a cache of the metrics of their phases (see `PhaseCache`), and summaries as the records of evaluations, with control variates and the allocation of -evaluations between replicates and histories. +evaluations between replicates and histories; and the exact expectations +of missions without restoration (`exact_expectations`). @author: Paul T. Grogan """ @@ -35,22 +36,25 @@ from .deployment import Deployment -def evaluate_missions( +def evaluate_histories( histories: Sequence[MissionHistory], capability: Capability, *, cost_model: Any = None, growth: Any = 1.0, + requirements: Sequence[Requirement] = (), ) -> pd.DataFrame: """ Evaluates histories of a mission (such as those of a replicate, see `Deployment.simulate_many`): for each, the mean of each metric over the - phases of the mission (` mission`, see `summarize_phases`), its - measures (see `MissionHistory.metrics`), and its cost (see - `CostEstimate.metrics`, with a cost model). The histories share the - observations of the replicate, so that each set of operating satellites - is evaluated once, by the capability of the satellites (see - `Capability.evaluate`, with the cache of its metric). + phases of the mission (` mission`, see `summarize_phases`), the + time at which a phase first meets each requirement on a metric + (` time`, infinite if none does), its measures (see + `MissionHistory.metrics`), and its cost (see `CostEstimate.metrics`, + with a cost model). The histories share the observations of the + replicate, so that each set of operating satellites is evaluated once, + by the capability of the satellites (see `Capability.evaluate`, with the + cache of its metric). Args: histories (Sequence[MissionHistory]): The histories. @@ -58,6 +62,8 @@ def evaluate_missions( observations (of the replicate) and metric. cost_model (CostModel | None): A model of the cost of each history. growth (float | Mapping[str, float]): The growth of the cost. + requirements (Sequence[Requirement]): Requirements on the metrics of + the phases, if any. Returns: pandas.DataFrame: a row per history (with its likelihood ratio, @@ -67,7 +73,10 @@ def evaluate_missions( weighted = any(history.weight != 1.0 for history in histories) for history in histories: phases = capability.evaluate(history.phases(capability.satellites)) - row = {**summarize_phases(phases), **history.metrics()} + row = { + **summarize_phases(phases, requirements=requirements), + **history.metrics(), + } if weighted: row["weight"] = history.weight if cost_model is not None: @@ -76,15 +85,16 @@ def evaluate_missions( return pd.DataFrame(rows) -def summarize_missions( - missions: pd.DataFrame, +def summarize_histories( + histories: pd.DataFrame, + *, quantiles: Mapping[str, float | Sequence[float]] | None = None, requirements: Sequence[Requirement] = (), controls: Mapping[str, float] | None = None, spread: bool = False, ) -> dict[str, float]: """ - Summarizes histories of a mission (see `evaluate_missions`) as the + Summarizes histories of a mission (see `evaluate_histories`) as the metrics of an evaluation: the mean of each column over the histories (by the same name), quantiles of columns over the histories (` histories p`, such as `"accurate mission histories p10"` for the @@ -94,6 +104,14 @@ def summarize_missions( of a replicate are named apart from statistics over the replicates (such as a `Quantile`, see `Criteria`), which are taken of these. + Missing values (`NaN`, such as the `restoration years` of a history + without restorations) are left out of the statistics of their column, + but infinite ones are not: the mean of the time until a history meets a + requirement (` time`, see `evaluate_histories`) is infinite if a + history never meets it, and its quantiles, or the share of the + histories that meet it by a time (a requirement on it, such as + `Requirement("accurate time", "<=", 4)`), summarize it. + With `controls`, the means are estimated with control variates: columns whose expected values are known (such as the `availability` of a mission, which simulations alone estimate precisely and cheaply, see @@ -117,7 +135,7 @@ def summarize_missions( replicates' other parameters (such as their targets). Args: - missions (pandas.DataFrame): A row per history. + histories (pandas.DataFrame): A row per history. quantiles (Mapping | None): The quantiles of columns, by column. requirements (Sequence[Requirement]): Requirements on columns. controls (Mapping[str, float] | None): The expected values of @@ -128,8 +146,19 @@ def summarize_missions( Returns: dict[str, float]: the summary + + Raises: + ValueError: if a quantile or requirement is of a column that the + histories do not have. """ - numeric = missions.select_dtypes("number") + numeric = histories.select_dtypes("number") + named = [*(quantiles or {}), *(requirement.name for requirement in requirements)] + unknown = sorted(set(named) - set(numeric.columns)) + if unknown: + raise ValueError( + "quantiles or requirements of columns that the histories do not have: " + + f"{unknown} (they have {sorted(numeric.columns)})" + ) weights = np.ones(len(numeric)) if "weight" in numeric.columns: weights = numeric.pop("weight").to_numpy(dtype=float) @@ -137,7 +166,7 @@ def summarize_missions( column: _weighted_mean(numeric[column].to_numpy(dtype=float), weights) for column in numeric.columns } - if "weight" in missions.columns: + if "weight" in histories.columns: summary["effective histories"] = float(weights.sum() ** 2 / np.sum(weights**2)) if controls: summary.update(_controlled_means(numeric, controls, weights)) @@ -159,14 +188,17 @@ def summarize_missions( numeric[column].to_numpy(dtype=float), weights, q ) for requirement in requirements: - met = requirement.met(missions[requirement.name].to_numpy(dtype=float)) + met = requirement.met(histories[requirement.name].to_numpy(dtype=float)) summary[f"P({requirement})"] = float(np.sum(weights * met) / np.sum(weights)) return summary def _weighted_mean(values: np.ndarray, weights: np.ndarray) -> float: - """The weighted mean of the known values (`NaN` without any).""" - known = np.isfinite(values) + """ + The weighted mean of the known values (not `NaN`, but infinite ones), + `NaN` without any. + """ + known = ~np.isnan(values) if not known.any() or weights[known].sum() <= 0: return math.nan return float(np.sum(weights[known] * values[known]) / np.sum(weights[known])) @@ -174,15 +206,16 @@ def _weighted_mean(values: np.ndarray, weights: np.ndarray) -> float: def _weighted_quantile(values: np.ndarray, weights: np.ndarray, q: float) -> float: """ - The quantile of the known values, by their weights: the least value - whose cumulative weight reaches the share `q` of the total (as numpy's - `inverted_cdf`), or numpy's linear quantile without weights. + The quantile of the known values (not `NaN`, but infinite ones), by + their weights: the least value whose cumulative weight reaches the share + `q` of the total (as numpy's `inverted_cdf`), or numpy's linear quantile + of finite values without weights. """ - known = np.isfinite(values) + known = ~np.isnan(values) values, weights = values[known], weights[known] if len(values) == 0: return math.nan - if np.all(weights == weights[0]): + if np.all(weights == weights[0]) and np.all(np.isfinite(values)): return float(np.quantile(values, q)) order = np.argsort(values) cumulative = np.cumsum(weights[order]) / weights.sum() @@ -195,7 +228,7 @@ def _controlled_means( ) -> dict: """ Estimates the means of columns with control variates (see - `summarize_missions`): each column's mean less the regression of the + `summarize_histories`): each column's mean less the regression of the column on the controls applied to the deviations of the controls' means from their expected values, over the histories in which the column and the controls are known. @@ -260,7 +293,7 @@ def __call__(self, key: tuple, dimensions: int) -> np.ndarray: def _simulate_many( deployment: Deployment, - failures: FailureModel, + model: FailureModel, policy: RestorationPolicy | None, seed: int, histories: int, @@ -279,7 +312,7 @@ def _simulate_many( return [ _Simulation( deployment, - failures, + model, policy or RestorationPolicy(), (seed, k), _Sampler(seed, k, histories) if sampling == "stratified" else None, @@ -292,7 +325,7 @@ def _simulate_many( def _expected_metrics( deployment: Deployment, - failures: FailureModel, + model: FailureModel, policy: RestorationPolicy | None, seed: int, histories: int, @@ -306,7 +339,7 @@ def _expected_metrics( [ history.metrics() for history in _simulate_many( - deployment, failures, policy, seed, histories, sampling + deployment, model, policy, seed, histories, sampling ) ] ) @@ -316,6 +349,7 @@ def _expected_metrics( def allocate_histories( records: pd.DataFrame, metric: str, + *, histories: int, replicate_seconds: float, history_seconds: float, @@ -328,7 +362,7 @@ def allocate_histories( its targets, whose observations are expensive to compute) and histories of the failures of its mission in each replicate (cheap, with a `PhaseCache`), from a pilot study: the records of its replicates (see - `summarize_missions`, with `spread`), each the mean (``) and + `summarize_histories`, with `spread`), each the mean (``) and standard deviation (` histories std`) of a metric over `histories` histories. @@ -413,7 +447,7 @@ def allocate_histories( def _launch_groups( - deployment: Deployment, failures: FailureModel, times: np.ndarray + deployment: Deployment, model: FailureModel, times: np.ndarray ) -> tuple[int, list[tuple]]: """ Gets the launch groups of a deployment without restoration: the @@ -429,7 +463,7 @@ def _launch_groups( launches: dict[tuple[int, int], list] = {} for launch in sorted(deployment.launches, key=lambda l: l.time): launches.setdefault((launch.plane, launch.first), []).append(launch) - p = failures.launch + p = model.launch groups = [] for (plane, first), sequence in launches.items(): built = deployment.planes[plane].satellites @@ -439,7 +473,7 @@ def _launch_groups( ] if not members: continue - life = failures.life_of(sequence[0].kind) + life = model.life_of(sequence[0].kind) flown = np.array([[t >= launch.time for t in times] for launch in sequence]) # launches after each one, up to each time later = np.flip(np.cumsum(np.flip(flown, axis=0), axis=0), axis=0) - flown @@ -459,6 +493,18 @@ def _launch_groups( return int(offsets[-1]), groups +def _group_operating(group: tuple, count: int) -> np.ndarray: + """ + Gets the probability at each time that exactly a given set of `count` + satellites of a launch group operates (see `_set_weight`). + """ + members, weights, survival, none, _ = group + probability = np.sum( + weights * survival**count * (1 - survival) ** (len(members) - count), axis=0 + ) + return probability + none if count == 0 else probability + + def _set_weight(active: np.ndarray, groups: list) -> float: """ Gets the share of the mission's time in which exactly the active @@ -471,26 +517,75 @@ def _set_weight(active: np.ndarray, groups: list) -> float: its satellites, and the probability that none has succeeded if `a` is 0. """ probability = 1.0 - for members, weights, survival, none, _ in groups: - count = int(active[members].sum()) - size = len(members) - group = np.sum( - weights * survival**count * (1 - survival) ** (size - count), axis=0 - ) - if count == 0: - group = group + none - probability = probability * group + for group in groups: + probability = probability * _group_operating(group, int(active[group[0]].sum())) return float(np.mean(probability)) -def expected_missions( +def _missing_levels(groups: list, count: int, tolerance: float) -> int: + """ + Gets the most positions missing of the sets that exact expectations + enumerate (see `exact_expectations`): the least number such that the + sets of that many missing positions or fewer operate all but `tolerance` + of the mission's time, in expectation. The distribution of the number + missing at each time is the convolution over the launch groups of the + distributions of theirs (each the probability of a set times the number + of sets of its size), cheap to compute without enumerating the sets. + """ + if not groups: + return count + distribution = np.zeros((count + 1, len(groups[0][3]))) + distribution[0] = 1.0 + for group in groups: + size = len(group[0]) + combined = np.zeros_like(distribution) + for gone in range(size + 1): + share = math.comb(size, gone) * _group_operating(group, size - gone) + combined[gone:] += share * distribution[: count + 1 - gone] + distribution = combined + covered = np.cumsum(distribution.mean(axis=1)) + reached = np.flatnonzero(covered >= 1 - tolerance - 1e-12) + return int(reached[0]) if len(reached) > 0 else count + + +def _exact_sets( + deployment: Deployment, + model: FailureModel, + tolerance: float = 1e-3, + steps: int = 400, +) -> int: + """ + Gets the number of sets of satellites that exact expectations of a + deployment enumerate (see `exact_expectations`), without enumerating + them: the sets of at most the number of positions missing that cover + all but `tolerance` of the mission's time. + """ + times = _times(deployment, steps) + count, groups = _launch_groups(deployment, model, times) + levels = _missing_levels(groups, count, tolerance) + return sum(math.comb(count, missing) for missing in range(levels + 1)) + + +def _times(deployment: Deployment, steps: int) -> np.ndarray: + """The times at which exact expectations integrate probabilities.""" + begin, end = deployment.begin, deployment.end + return begin + (np.arange(steps) + 0.5) * (end - begin) / steps + + +MAX_SETS = 200_000 +"""The most sets of satellites that exact expectations enumerate by default +(see `exact_expectations`), as those of the failures of a study do (see +`Failures`).""" + + +def exact_expectations( deployment: Deployment, - failures: FailureModel, + model: FailureModel, capability: Capability, *, tolerance: float = 1e-3, steps: int = 400, - max_sets: int = 200_000, + max_sets: int = MAX_SETS, ) -> dict[str, float]: """ Computes the expected capability of a mission without restoration @@ -498,7 +593,8 @@ def expected_missions( the end of their design life) over its failures: the expectation of the mean of each metric over the phases of the mission (` mission`, as `summarize_phases` gives for one history) and of its availability - (`availability`), exactly rather than from samples of histories. + (`availability`), exactly rather than from samples of histories (as + `Deployment.expected_metrics` estimates the measures of missions). Without restoration, the satellites fail independently (but for the satellites of a launch, which a failed launch loses together), so that @@ -509,19 +605,22 @@ def expected_missions( share of the mission's time in which exactly that set operates, in expectation (integrated over `steps` times). The sets are enumerated by the number of satellites missing until their shares cover all but - `tolerance` of the mission's time, and evaluated in order of their - shares until they do (`coverage`, the share covered, and `sets`, the - sets evaluated); the expectation is over the sets evaluated. + `tolerance` of the mission's time (a number known before they are + enumerated, from the distribution of the number missing), and evaluated + in order of their shares until they do (`coverage`, the share covered, + and `sets`, the sets evaluated); the expectation is over the sets + evaluated. Without sampling error, an expectation estimates the mean of many histories with none of their variance (see `Deployment.simulate_many`), - for missions of a few to a dozen or two satellites; for larger ones, or - with restoration (whose shared production and launches make failures - dependent), simulate histories. + for missions of a few to a dozen or two satellites; for larger ones + (whose sets number more than `max_sets`, which is known before any is + enumerated), or with restoration (whose shared production and launches + make failures dependent), simulate histories. Args: deployment (Deployment): The deployment. - failures (FailureModel): The failures. + model (FailureModel): The failures. capability (Capability): The capability of the satellites (in the order of the planes, see `MissionHistory.phases`): their observations and metric (see `Capability.evaluate`). @@ -535,7 +634,8 @@ def expected_missions( Raises: ValueError: if the deployment is staged (see `Stage`), whose launches - depend on its rules. + depend on its rules, or has more sets to enumerate than + `max_sets` (raised before any is enumerated). """ # pylint: disable=too-many-locals if deployment.stages: @@ -545,8 +645,10 @@ def expected_missions( ) names = list(_position_names(deployment.planes, capability.satellites).values()) begin, end = deployment.begin, deployment.end - times = begin + (np.arange(steps) + 0.5) * (end - begin) / steps - count, groups = _launch_groups(deployment, failures, times) + count, groups = _launch_groups(deployment, model, _times(deployment, steps)) + levels = _missing_levels(groups, count, tolerance) + if sum(math.comb(count, missing) for missing in range(levels + 1)) > max_sets: + raise ValueError("too many sets of satellites to enumerate: simulate histories") # availability: the expected years of operation of the positions, as a # share of those of the planned deployment operating = sum( @@ -559,22 +661,13 @@ def expected_missions( availability = operating / planned if planned > 0 else math.nan # enumerate the sets by the number of positions missing weights: list[tuple[float, tuple[int, ...]]] = [] - covered, enumerated = 0.0, 0 - for missing in range(count + 1): + for missing in range(levels + 1): for gone in itertools.combinations(range(count), missing): - enumerated += 1 - if enumerated > max_sets: - raise ValueError( - "too many sets of satellites to enumerate: simulate histories" - ) active = np.ones(count, dtype=bool) active[list(gone)] = False weight = _set_weight(active, groups) if weight > 0: weights.append((weight, tuple(np.flatnonzero(active)))) - covered += weight - if covered >= 1 - tolerance: - break weights.sort(key=lambda item: -item[0]) totals: dict[str, float] = {} evaluated, sets = 0.0, 0 diff --git a/src/tatc/tradespace/mission.py b/src/tatc/tradespace/mission.py index f9451de7..938bb10a 100644 --- a/src/tatc/tradespace/mission.py +++ b/src/tatc/tradespace/mission.py @@ -190,6 +190,16 @@ def end(self) -> float: """float: The end of the mission.""" return self.deployment.end + @property + def deployed(self) -> float: + """float: The time by which the satellites of the first generation + are launched (years), whether their launches succeed or not: of the + planes that are not staged, and of the stages that this history + deployed (see `stages`).""" + return max( + launch.time for launch in self.launches if launch.purpose == "deployment" + ) + def in_orbit(self) -> list[tuple[float, float, int]]: """ Gets the intervals in which satellites are in orbit (operating, or @@ -359,6 +369,7 @@ def evaluate_phases( phases: Sequence[Phase], observations: pd.DataFrame, metric: Callable[..., Mapping[str, float]], + *, design: Any = None, ) -> pd.DataFrame: """ @@ -400,6 +411,7 @@ def evaluate_phases( def summarize_phases( phases: pd.DataFrame, + *, metrics: Sequence[str] | None = None, requirements: Sequence[Requirement] = (), ) -> dict[str, float]: @@ -526,6 +538,7 @@ def evaluate( phases: Sequence[Phase], satellites: Sequence[Satellite | str] | Mapping[str, str], observations: pd.DataFrame, + *, context: Any = None, design: Any = None, ) -> pd.DataFrame: @@ -552,29 +565,54 @@ def evaluate( `duration`, number of `satellites`, and metrics """ keys = _satellite_keys(satellites) - metric = _given_design(self.metric, design) def cached(subset: Callable[[], pd.DataFrame], names: frozenset) -> dict: - return self._metrics( - (context, frozenset(keys[name] for name in names)), subset, metric + del subset # the cache filters the observations, if needed + return self.metrics_of( + {name: keys[name] for name in names}, + observations, + context=context, + design=design, ) return _evaluate_phases(phases, observations, cached) - def _metrics( + def metrics_of( self, - key: tuple, - subset: Callable[[], pd.DataFrame], - metric: Callable[[pd.DataFrame], Mapping[str, float]], - ) -> dict: - """The metrics of a set of satellites (keyed by the context and the - keys of the satellites), from the memory if they are in it.""" + keys: Mapping[str, str], + observations: pd.DataFrame, + *, + context: Any = None, + design: Any = None, + ) -> dict[str, float]: + """ + Gets the metrics of satellites that operate together, from the cache + if they are in it (keyed by the context and the keys of the + satellites), or else of their observations (and kept). + + Args: + keys (Mapping[str, str]): The keys of the satellites in the cache + (such as of their content, see `get_satellite_key`), by + their names in the observations. + observations (pandas.DataFrame): The observations of every + satellite, with their names (`satellite`), filtered to those + of the satellites only if they are not in the cache. + context (Any): A hashable identifier of the observations (such + as the seed of their targets and their period). + design (Design | None): The (realized) design of the mission, + for a metric with a parameter named `design`. + + Returns: + dict[str, float]: the metrics + """ + key = (context, frozenset(keys.values())) if key in self._memory: self.hits += 1 else: self.misses += 1 - self._memory[key] = dict(metric(subset())) - return self._memory[key] + metric = _given_design(self.metric, design) + self._memory[key] = dict(metric(_subset(observations, frozenset(keys)))) + return dict(self._memory[key]) def clear(self) -> None: """ @@ -603,7 +641,7 @@ class Capability: the mission, which the evaluation evaluates anyway. A capability also evaluates the phases of the mission's histories (see - `evaluate`, `evaluate_missions`, and `expected_missions`), with its + `evaluate`, `evaluate_histories`, and `exact_expectations`), with its cache. Args: @@ -626,10 +664,10 @@ def __init__( satellites: Sequence[Satellite | str], observations: pd.DataFrame, metric: Callable[..., Mapping[str, float]] | PhaseCache, + *, context: Any = None, design: Any = None, ): - # pylint: disable=too-many-arguments,too-many-positional-arguments self.satellites = list(satellites) """list: The satellites (or their names), in the order of the planes.""" self.observations = observations @@ -667,7 +705,11 @@ def evaluate(self, phases: Sequence[Phase]) -> pd.DataFrame: `duration`, number of `satellites`, and metrics """ return self._cache.evaluate( - phases, self._keys, self.observations, self.context, self.design + phases, + self._keys, + self.observations, + context=self.context, + design=self.design, ) def __call__(self, names: Iterable[str]) -> dict[str, float]: @@ -684,11 +726,12 @@ def __call__(self, names: Iterable[str]) -> dict[str, float]: unknown = names - set(self._names) if unknown: raise ValueError(f"satellites that are not given: {sorted(unknown)}") - subset = partial(_subset, self.observations, names) - metric = _given_design(self._cache.metric, self.design) - key = (self.context, frozenset(self._keys[name] for name in names)) - # pylint: disable-next=protected-access - return dict(self._cache._metrics(key, subset, metric)) + return self._cache.metrics_of( + {name: self._keys[name] for name in names}, + self.observations, + context=self.context, + design=self.design, + ) def at( self, diff --git a/src/tatc/tradespace/nodes.py b/src/tatc/tradespace/nodes.py index 71c1121b..de47f016 100644 --- a/src/tatc/tradespace/nodes.py +++ b/src/tatc/tradespace/nodes.py @@ -403,6 +403,20 @@ def _as_node(value: Any) -> Node: return value if isinstance(value, Node) else Fixed(value) +class Group(Node): + """ + Base class of groups of nodes (see `tatc.tradespace.DesignSpace`): its + children, by name, are decided in order, and its constraints are checked + once they are. + """ + + children: dict[str, Node] + """dict[str, Node]: The nodes, by name, in the order they are decided.""" + + constraints: list[Callable[[Scope], Any]] + """list[Callable]: The constraints on the values of the group.""" + + class Choice(Node): """ A choice of exactly one of several alternatives (branches), each a node diff --git a/src/tatc/tradespace/observations.py b/src/tatc/tradespace/observations.py index a09c9631..75d3da77 100644 --- a/src/tatc/tradespace/observations.py +++ b/src/tatc/tradespace/observations.py @@ -1,15 +1,17 @@ """ Studies of the observations of constellations: the targets of each replicate, the observations of each satellite (cached), and the metrics of a design's -observations, its deployment and costs, the histories of its failures, and -the phases of its mission. - -The parts refer to the values of designs by a `Reference`: a name (such as -`"points_seed"` for `d.points_seed`, or a path of `Design.flat`, such as -`"layout.walker.planes"`), or a function of the (realized) design (such as -`lambda d: d.layout`). A string given where a reference is expected is -always a reference, never a value itself: give a function that returns a -string (or a number, where numbers are references) to give a value:: +observations and, with a mission plan (see the module `plans`), its +deployment and costs, the histories of its failures, and the phases of its +mission. + +The parts refer to the values of designs by a `Reference` (see `value_of`): +a name (such as `"points_seed"` for `d.points_seed`, or a path of +`Design.flat`, such as `"layout.walker.planes"`), or a function of the +(realized) design (such as `lambda d: d.layout`). A string given where a +reference is expected is always a reference, never a value itself: give a +function that returns a string (or a number, where numbers are references) +to give a value:: MissionPlan(SCHEDULE, COST_MODEL, kind="field_of_regard") # d.field_of_regard MissionPlan(SCHEDULE, COST_MODEL, kind=lambda d: "imager") # always "imager" @@ -21,7 +23,6 @@ import dataclasses import json -import numbers import os import warnings from collections.abc import Callable, Mapping, Sequence @@ -30,59 +31,24 @@ from pathlib import Path from typing import Any -import numpy as np import pandas as pd from ..analysis import collect_observations from ..schemas import Satellite from .cache import SatelliteCache, _write from .constellations import count_planes -from .cost import CostEstimate, CostModel from .criteria import Requirement -from .deployment import Deployment, DeploymentSchedule, Stage -from .failures import FailureModel, RestorationPolicy -from .histories import evaluate_missions, expected_missions, summarize_missions -from .mission import Capability, PhaseCache, _given_design, summarize_phases -from .space import Design, DesignSpace, _scenario_of +from .mission import Capability, PhaseCache, _given_design +from .plans import Failures, Mission, MissionPlan +from .references import Reference, value_of +from .space import Design, DesignSpace from .store import _decode, _encode from .study import Study, _Case, _takes_design -from .values import configure +from .walks import _generic _MAX_TARGETS = 32 """The most sets of targets (of seeds) kept in memory.""" -Reference = str | Callable[[Design], Any] -"""A reference to a value of a design: its name or path (see `Design.flat`), -or a function of the (realized) design that gives it (see `value_of`).""" - - -def value_of(design: Design, reference: Reference | None) -> Any: - """ - Gets a value of a design that a reference names: a string names a value - by its name or path (`design[reference]`, see `Values`: such as - `"layout.walker.planes"`, the path of a column of results, see - `Design.flat`, or of a group of values, such as `"cost_risk"`), a - function computes it from the design, and `None` is `None`. - - Args: - design (Design): The (realized) design. - reference (Reference | None): The reference: a string, a function, - or `None`. - - Returns: - Any: the value - - Raises: - KeyError: if the design has no value of a name or path. - """ - if reference is None: - return None - if callable(reference): - return reference(design) - if not isinstance(reference, str): - raise TypeError(f"a reference to a value of a design, not {reference!r}") - return design[reference] - @dataclasses.dataclass(frozen=True, eq=False, init=False) class Targets: @@ -237,6 +203,7 @@ class Observations: start: datetime | Reference duration: timedelta analysis: Callable = collect_observations + _: dataclasses.KW_ONLY directory: str | os.PathLike | None = dataclasses.field( default=None, metadata={"fingerprint": False} ) @@ -397,303 +364,26 @@ def __call__( return self.cache_of(design)(satellites) -@dataclasses.dataclass(frozen=True) -class MissionPlan: - """ - The deployment of the satellites of each design (see - `DeploymentSchedule.plan`) and its costs (see `CostModel`), from the - values of the design (see `value_of`). - - The schedule and the cost model may be functions of the (realized) - design, which size them by its values with relationships of the study's - own (TAT-C includes none, see the module `tatc.tradespace.cost`): for - example, the costs of a type of satellite from the mass of its payload, - or the capacity of launches to the design's altitude:: - - def schedule(d): - return dataclasses.replace(SCHEDULE, launch_mass_capacity=capacity(d.altitude)) - - PLAN = MissionPlan(schedule, COST_MODEL, kind="payload") - - Launches limited in mass take the masses of the satellites from the cost - model (`SatelliteCost.mass`, of each type), unless `masses` are given. - - The growth of the costs of the components of the cost model (see - `Component`) is drawn from scores that are values of the design (such as - a group of `risk_space`), shared by designs that share components:: - - space = space.extend(cost_risk=risk_space(COST_MODEL)) - PLAN = MissionPlan(SCHEDULE, COST_MODEL, kind="payload", scores="cost_risk") - - Args: - schedule (DeploymentSchedule | Callable): The schedule of the - deployment, or a function of the design that gives it. - cost_model (CostModel | Callable | None): The costs, a function of the - design that gives them, or `None`. - kind (Reference | None): The kind of the satellites (for schedules - and costs of several kinds), as a value of the design. - spares (int | Reference): The spares in orbit in each plane, or a - value of the design (replaced by the `orbit_spares` of a design's - policy, see `policy`). - growth (float | Reference | Mapping): The growth of the costs (see - `CostModel.estimate`): a factor, a value of the design, or a - mapping of each element (such as `"development"`) to a factor or - a value of the design, or to a mapping of each kind of satellite - to one. - stages (Sequence[Stage] | Callable): The stages of the deployment - (see `Stage`), or a function of the (realized) design that gives - them, such as of a decision whether to stage it and of the values - its rules read. Their rules may also read the capability of the - satellites operating at a decision, by the study's metrics (see - `Decision.capability`). - masses (float | Mapping | Reference | None): The mass (kg) of the - satellites (or of each type, a mapping), or a value of the - design, for launches limited in mass, or `None` for the masses of - the cost model. - scores (Reference | None): The scores from which the growth of the - components of the cost model is drawn (see `CostModel.draw`), as - a value of the design (such as a group of `risk_space`), or - `None` for the expected costs of the components. - policy (Reference | None): The value of the design that configures - the policy that restores its failures (see `Failures`) and its - spares in orbit (such as a group of `policy_space`, see - `configure`), or `None` for the policy of the failures and the - plan's `spares`. - """ - - schedule: DeploymentSchedule | Callable[[Design], DeploymentSchedule] - cost_model: CostModel | Callable[[Design], CostModel] | None = None - kind: Reference | None = None - spares: int | Reference = 0 - growth: float | Reference | Mapping[str, float | Reference | Mapping[Any, Any]] = ( - 1.0 - ) - stages: Sequence[Stage] | Callable[[Design], Sequence[Stage]] = () - masses: float | Mapping[Any, float] | Reference | None = None - scores: Reference | None = None - policy: Reference | None = None - - def schedule_of(self, design: Design) -> DeploymentSchedule: - """ - Gets the schedule of the deployment of a design. - - Args: - design (Design): The (realized) design. - - Returns: - DeploymentSchedule: the schedule - """ - if isinstance(self.schedule, DeploymentSchedule): - return self.schedule - return self.schedule(design) - - def cost_model_of(self, design: Design) -> CostModel | None: - """ - Gets the cost model of a design, with the growth of its components - drawn from the design's scores (if any, see `CostModel.draw`). - - Args: - design (Design): The (realized) design. - - Returns: - CostModel | None: the cost model, if any - """ - model = self.cost_model - if model is not None and not isinstance(model, CostModel): - model = model(design) - if model is None or self.scores is None: - return model - return model.draw(value_of(design, self.scores)) - - def masses_of(self, design: Design, cost_model: CostModel | None = None) -> Any: - """ - Gets the masses of the satellites of a design, for launches limited in - mass: the given masses (or the value of the design they name), or - those of the types of satellites of its cost model, if any. - - Args: - design (Design): The (realized) design. - cost_model (CostModel | None): The design's cost model. - - Returns: - Any: a mass, a mapping of types to masses, or `None` - """ - if self.masses is not None: - if isinstance(self.masses, (int, float, Mapping)): - return self.masses - return value_of(design, self.masses) - if cost_model is None: - return None - satellites = cost_model.satellites - if isinstance(satellites, Mapping): - masses = {kind: cost.mass for kind, cost in satellites.items()} - return None if all(m is None for m in masses.values()) else masses - return satellites.mass - - def stages_of(self, design: Design) -> tuple: - """ - Gets the stages of the deployment of a design. - - Args: - design (Design): The (realized) design. - - Returns: - tuple[Stage, ...]: the stages - """ - stages = self.stages(design) if callable(self.stages) else self.stages - return tuple(stages or ()) - - def growth_of(self, design: Design) -> Any: - """ - Gets the growth of the costs of a design. - - Args: - design (Design): The (realized) design. - - Returns: - Any: a factor, or a mapping of each element to its factor (or to - a mapping of each kind of satellite to its factor) - """ - if not isinstance(self.growth, Mapping): - return _number(design, self.growth) - growth: dict[str, Any] = {} - for element, value in self.growth.items(): - if isinstance(value, Mapping): - growth[element] = {k: _number(design, g) for k, g in value.items()} - else: - growth[element] = _number(design, value) - return growth - - -def _number(design: Design, value: Any) -> Any: - """A number, or a value of a design that a reference names.""" - if isinstance(value, numbers.Real): - return value - return value_of(design, value) - - -@dataclasses.dataclass(frozen=True) -class Failures: - """ - The failures of the satellites of each design: histories of its mission - (see `Deployment.simulate_many`), restored by a policy (by default by - producing new satellites; `RestorationPolicy(restore=False)` not to - restore them; or configured by the values of each design, see - `MissionPlan.policy`), summarized over the histories (see - `summarize_missions`): the mean of each metric over the phases of the - mission and the histories, `quantiles` and `requirements` of them, and - their costs. Without restoration, the means of the metrics and the - availability are the exact expectations over the failures (see - `expected_missions`) if `exact` (and the histories have failures, with a - `seed`). - - With a `stress`, the failures are drawn from stressed distributions for - importance sampling (see `Deployment.simulate_many`), each history - weighted by its likelihood ratio. With `controls`, the means over the - histories are estimated with control variates (see - `summarize_missions`): measures of the missions (see - `MissionHistory.metrics`, such as `availability`) whose expected values - are estimated from `control_histories` other histories of the replicate, - simulated without evaluating their phases (see - `Deployment.expected_metrics`). With `spread`, the summaries add the - standard deviation of each column over the histories (` - histories std`), as `allocate_histories` needs of a pilot study. - - Args: - model (FailureModel): The failures. - policy (RestorationPolicy): The policy. - histories (int): The histories of each replicate. - seed (Reference | None): The value of the design that seeds the - failures (see `value_of`, such as of `Uncertain.seed`), or - `None` for the one history without failures. - sampling (str): The sampling of the histories (see - `Deployment.simulate_many`). - quantiles (Mapping | None): Quantiles of the metrics of the - histories (see `summarize_missions`). - requirements (Sequence[Requirement]): Requirements on the metrics of - the histories (see `summarize_missions`). - exact (bool): `True` for exact expectations without restoration. - stress (float): The factor of the hazards of stressed failures (1 - for none). - launch_stress (float | None): The factor of the probability that a - launch fails, or `None` for the stress. - controls (Sequence[str]): The measures of the missions that are - control variates, if any. - control_histories (int): The histories that estimate the expected - values of the controls. - spread (bool): `True` to add the standard deviations of the columns - over the histories. - """ - - model: FailureModel - policy: RestorationPolicy = RestorationPolicy() - histories: int = 1 - seed: Reference | None = None - sampling: str = "stratified" - quantiles: Mapping[str, float | Sequence[float]] | None = None - requirements: Sequence[Requirement] = () - exact: bool = True - stress: float = 1.0 - launch_stress: float | None = None - controls: Sequence[str] = () - control_histories: int = 1000 - spread: bool = False +def _hashable(value: Any) -> Any: + """A value, or its representation if it is not hashable.""" + try: + hash(value) + except TypeError: + return repr(value) + return value - def __post_init__(self): - if self.policy is None: # as `Deployment.simulate` takes it - object.__setattr__(self, "policy", RestorationPolicy()) - if isinstance(self.controls, str): - raise TypeError("controls are a sequence of names of measures") - object.__setattr__(self, "controls", tuple(self.controls)) - if self.histories < 1 or self.control_histories < 1: - raise ValueError("histories and control_histories must be at least 1") - -@dataclasses.dataclass(frozen=True) -class _Mission: +def _uncertain_values(design: Design) -> tuple: """ - The mission of a realized design (see `_Evaluation`): its planned - deployment, the policy that restores its failures, its cost model and - growth, and the capability of its satellites (their observations and - the cache of the metrics of their phases), from which its phases, costs, - and histories follow. + Gets the values of the uncertain parameters of a realized design, by + path (see `DesignSpace.uncertain_paths`), as a key. """ - - deployment: Deployment - policy: RestorationPolicy - cost_model: CostModel | None - growth: Any - capability: Capability - - def phases(self) -> pd.DataFrame: - """The metrics of the phases of the planned deployment.""" - satellites = self.capability.satellites - return self.capability.evaluate(self.deployment.phases(satellites)) - - def estimate(self) -> CostEstimate: - """The cost estimate of the planned deployment.""" - if self.cost_model is None: - raise ValueError("the mission plan has no cost model") - return self.cost_model.estimate(self.deployment, self.growth) - - def missions(self, failures: Failures) -> pd.DataFrame: - """The histories of the failures of the mission (see `evaluate_missions`).""" - histories = self.deployment.simulate_many( - failures.model, - self.policy, - self.seed_of(failures), - failures.histories, - sampling=failures.sampling, - stress=failures.stress, - launch_stress=failures.launch_stress, - ) - return evaluate_missions( - histories, self.capability, cost_model=self.cost_model, growth=self.growth - ) - - def seed_of(self, failures: Failures) -> Any: - """The seed of the failures of the mission's replicate.""" - return value_of(self.capability.design, failures.seed) + paths = set(design.space.uncertain_paths()) + return tuple( + (path, _hashable(value)) + for path, value in design.flat().items() + if _generic(path) in paths + ) @dataclasses.dataclass(frozen=True, eq=False) @@ -701,8 +391,8 @@ class _Evaluation: """ The evaluation of the satellites of a design (see `ObservationStudy`): the metrics of the observations of every satellite and, with a plan, of - the mission: its deployment and costs, and either the phases of its - deployment or the histories of its failures. + the mission (see `Mission`): its deployment and costs, and either the + phases of its deployment or the histories of its failures. """ observations: Observations @@ -727,120 +417,58 @@ def __call__(self, satellites: Sequence[Satellite], design: Design) -> dict: mission = None if self.plan is not None: mission = self.mission_of(satellites, observations, design) - record["deployed"] = mission.deployment.deployed - if mission.cost_model is not None and self.failures is None: - # (of failures, the costs are the means over the histories) - record.update(mission.estimate().metrics()) + record.update(mission.metrics()) record.update(_given_design(self.metrics, design)(observations)) - if mission is not None and self.failures is not None: - record.update(self._histories(mission)) - elif mission is not None and self.phases is not None: - record.update(summarize_phases(mission.phases(), requirements=self.phases)) + if mission is not None: + record.update(mission.summarize(self.phases)) return record - def _policy(self, design: Design) -> tuple[RestorationPolicy, Any]: - """The policy of a design, and its spares in orbit in each plane.""" - base = RestorationPolicy() if self.failures is None else self.failures.policy - if self.plan.policy is None: - return base, _number(design, self.plan.spares) - decided = value_of(design, self.plan.policy) - return configure(base, decided), decided.orbit_spares + def context_of(self, design: Design) -> tuple: + """ + Gets the context of the metrics of the phases of a design in the + cache (see `PhaseCache`): its observations (see + `Observations.context_of`) and, if the metrics are given the design, + its scenario and the values of its uncertain parameters, which such + metrics may read (designs of a replicate share them, with common + random numbers). + """ + context = self.observations.context_of(design) + if _takes_design(self.metrics): + context = (context, design.scenario, _uncertain_values(design)) + return context def mission_of( self, satellites: Sequence[Satellite], observations: pd.DataFrame, design: Design, - ) -> _Mission: + ) -> Mission: """ - Plans the mission of a realized design: its deployment (whose stages - read the capability of the satellites operating at their decisions), - policy, and costs. + Plans the mission of a realized design (see `MissionPlan.mission_of`), + with the capability of its satellites (and the cache of the metrics + of their phases). """ - # the metrics of phases are cached by the observations and, if they - # are given the design, by its scenario - context = self.observations.context_of(design) - if _takes_design(self.metrics): - context = (context, _scenario_of(design)) - policy, spares = self._policy(design) - cost_model = self.plan.cost_model_of(design) - deployment = self.plan.schedule_of(design).plan( - value_of(design, self.layout), - kind=value_of(design, self.plan.kind), - spares=spares, - masses=self.plan.masses_of(design, cost_model), - stages=self.plan.stages_of(design), - ) capability = Capability( - satellites, observations, self._phase_cache, context, design + satellites, + observations, + self._phase_cache, + context=self.context_of(design), + design=design, ) - deployment.capability = capability - return _Mission( - deployment, policy, cost_model, self.plan.growth_of(design), capability + return self.plan.mission_of( + design, value_of(design, self.layout), capability, self.failures ) - def _histories(self, mission: _Mission) -> dict[str, float]: - """ - Summarizes histories of the failures of a mission (with exact - expectations of the means of missions that are not restored or - staged, if the failures are exact and have a seed). - """ - failures = self.failures - seed = mission.seed_of(failures) - missions = mission.missions(failures) - controls = None - if failures.controls and seed is not None: - # other histories of the replicate (by a seed of its seed) - other = int(np.random.default_rng([int(seed), 7]).integers(2**31)) - expected = mission.deployment.expected_metrics( - failures.model, - mission.policy, - other, - failures.control_histories, - sampling=failures.sampling, - ) - unknown = sorted(set(failures.controls) - set(expected)) - if unknown: - raise ValueError( - f"controls that are not measures of missions: {unknown} " - + f"(they are {sorted(expected)})" - ) - controls = {name: expected[name] for name in failures.controls} - record = summarize_missions( - missions, - quantiles=failures.quantiles, - requirements=failures.requirements, - controls=controls, - spread=failures.spread, - ) - if ( - failures.exact - and seed is not None - and not mission.policy.restore - and not mission.deployment.stages - ): - exact = expected_missions( - mission.deployment, failures.model, mission.capability - ) - record.update( - { - key: value - for key, value in exact.items() - if key.endswith(" mission") or key == "availability" - } - ) - return record - class ObservationStudy(Study): """ A trade study of the observations of constellations: each replicate of a design builds its satellites, observes the targets of the replicate (see `Observations`), and records the metrics of the observations and, with a - mission `plan`, of the mission: its deployment and costs, and either the - `phases` of its deployment (see `evaluate_phases` and `summarize_phases`, - with requirements, if any) or the histories of its `failures` (see - `Failures`):: + mission `plan`, of the mission (see `Mission`): its deployment and costs, + and either the `phases` of its deployment (see `evaluate_phases` and + `summarize_phases`, with requirements, if any) or the histories of its + `failures` (see `Failures`):: study = ObservationStudy( space, @@ -857,22 +485,28 @@ class ObservationStudy(Study): `layout` of a design space that has one): their numbers. * the metrics of the observations of every satellite (by their names). * with a plan: `deployed`, the years from the start of development to the - last launch of the planned deployment (without stages that rules decide - to deploy, see `Stage`), and, with a cost model, the costs of the - deployment (`cost`, `cost development`, and so on, see + last launch of the first generation of the satellites in the history + of the mission without failures (see `Mission.planned`), including the + stages that their rules deploy then (see `Stage`); with stages, `stages + deployed`, the number of stages that their rules deploy then (with + failures, the mean over the histories); and, with a cost model, the + costs of the deployment (`cost`, `cost development`, and so on, see `CostEstimate.metrics`; with failures, the means of the costs of the histories). * with phases: ` mission`, the mean of each metric over the - phases of the mission as its satellites are deployed, and - ` time`, the years until a phase first meets each requirement - on a metric (see `summarize_phases`). + phases of the mission as its satellites are deployed (from the first + launch), and ` time`, the time at which a phase first meets + each requirement on a metric (see `summarize_phases`), in years from + the start of development, as `deployed` (infinite if none does). * with failures: the means over the histories of the failures of each replicate of ` mission` (the mean over the phases of each history), of the measures of the missions (`availability`, `failures`, - `restorations`, and so on, see `MissionHistory.metrics`), and of their - costs; and the `quantiles` of columns over the histories - (` histories p`) and the shares of the histories that - meet `requirements` (`P()`), see `summarize_missions`. + `restorations`, and so on, see `MissionHistory.metrics`), of their + costs, and of the times of each history that meets the requirements of + the `phases` of the failures (` time`); and the `quantiles` of + columns over the histories (` histories p`) and the + shares of the histories that meet `requirements` (`P()`), + see `summarize_histories`. Statistics over the replicates of these columns (see `Criteria`) judge designs: such as the mean over the replicates of `accurate mission`, or a @@ -886,11 +520,13 @@ class ObservationStudy(Study): with a parameter named `design` is also given the realized design, such as for the window of an epoch drawn for each replicate or for values that scenarios set (see `Study`): the metrics of phases are cached by the - satellites that operate, the targets and window of the observations, and - the scenario, so such a function must depend on the design only through - these. As a `Study`, it runs as any other (see `Study.run`), such as in - parallel, with a store of its records, and in searches (such as - `refine`, `confirm`, `screen`, and the optimizers). Its fingerprint (see + satellites that operate, the targets and window of the observations, the + scenario, and the values of the uncertain parameters of the replicate + (which the designs of a replicate share, with common random numbers), so + such a function must depend on the design only through these. As a + `Study`, it runs as any other (see `Study.run`), such as in parallel, + with a store of its records, and in searches (such as `refine`, + `confirm`, `screen`, and the optimizers). Its fingerprint (see `Study.fingerprint`) describes its parts, including targets by their content (or the recipe of generated targets), so that its store needs no namespace but for what the fingerprint cannot see. @@ -898,9 +534,8 @@ class ObservationStudy(Study): The parts of the evaluation of a design are also given apart, for analyses other than its metrics: its satellites, targets, and observations (`satellites_of`, `targets_of`, and `observations_of`), and - its planned deployment, the metrics of its phases, its cost estimate, - and the histories of its failures (`deployment_of`, `phases_of`, - `estimate_of`, and `missions_of`). + its mission (`mission_of`): its planned deployment, the metrics of its + phases, its cost estimate, and the histories of its failures. Args: space (DesignSpace): The design space. @@ -914,14 +549,20 @@ class ObservationStudy(Study): layout (see `value_of` and `layout_of`), which a `plan` requires, or `None` for the value `layout` of a design space that has one (and none otherwise). - plan (MissionPlan | None): The deployment and costs, if any. + plan (MissionPlan | None): The deployment, policy, and costs, if any. failures (Failures | None): The failures, if any, which require a plan. phases (Sequence[Requirement] | bool | None): `True` (or requirements on the metrics) to summarize the phases of the deployment, which - require a plan. + require a plan (with failures, the requirements on the phases of + the histories are those of `Failures`). **options (Any): The settings of the study (see `Study`), such as `replicates`, `seed`, `n_jobs`, and `store`. + + Raises: + ValueError: if failures or phases are given without a plan, a plan + without a layout, failures with phases, or the quantiles or + requirements of failures are of costs without a cost model. """ def __init__( @@ -930,6 +571,7 @@ def __init__( build: Callable[[Design], Sequence[Satellite]], observations: Observations, metrics: Callable[[pd.DataFrame], Mapping[str, Any]], + *, layout: Reference | None = None, plan: MissionPlan | None = None, failures: Failures | None = None, @@ -947,8 +589,21 @@ def __init__( raise ValueError("a mission plan requires a layout") if failures is not None and phases is not None: raise ValueError( - "failures summarize the phases of their histories: give one or the other" + "failures summarize the phases of their histories: give the " + + "requirements on them to Failures (phases), not to the study" ) + if failures is not None and plan.cost_model is None: + named = [ + *(failures.quantiles or {}), + *(r.name for r in failures.requirements), + ] + costs = [ + name for name in named if name == "cost" or name.startswith("cost ") + ] + if costs: + raise ValueError( + f"quantiles or requirements of costs without a cost model: {costs}" + ) self.observations, self.metrics, self.layout = observations, metrics, layout self.plan, self.failures, self.phases = plan, failures, phases evaluation = _Evaluation(observations, metrics, layout, plan, failures, phases) @@ -977,9 +632,7 @@ def _prepare( # the cache of the observations of the first evaluation, in this # process, so that it warns of results of other code here (once, see # `SatelliteCache`), rather than in a worker process - realized = design.realize( - replicate, self.seed, self.common_random_numbers, shift, case.values - ) + realized = self._realized(design, replicate, shift, case) self.observations.cache_of(realized) def satellites_of( @@ -1032,37 +685,21 @@ def observations_of( realized = self.realize(design, replicate, scenario) return self.observations(self.build(realized), realized) - def deployment_of( - self, design: Design, replicate: int = 0, scenario: str | None = None - ) -> Deployment: - """ - Gets the planned deployment of a replicate of a design, as its - evaluation plans it (see `MissionPlan`): with the plan's schedule, - kind, spares, masses, and stages, and the capability of its - satellites, which the rules of stages read (see `Deployment.capability`). - - Args: - design (Design): The design. - replicate (int): The replicate. - scenario (str | None): A scenario of the study (by name), if any. - - Returns: - Deployment: the deployment - - Raises: - ValueError: if the study has no mission plan. - """ - return self._mission_of(design, replicate, scenario).deployment - - def phases_of( + def mission_of( self, design: Design, replicate: int = 0, scenario: str | None = None - ) -> pd.DataFrame: - """ - Gets the metrics of the phases of the planned deployment of a - replicate of a design (see `deployment_of` and `evaluate_phases`), - which the evaluation of a study with `phases` summarizes (see - `summarize_phases`); those of the histories of failures are of - `missions_of`. + ) -> Mission: + """ + Gets the mission of a replicate of a design, as its evaluation plans + it (see `MissionPlan.mission_of`), for analyses other than its + metrics: its planned deployment (`Mission.deployment`, with the + plan's schedule, type, policy and spares, masses, and stages, and the + capability of its satellites, which the rules of stages read), the + metrics of its phases (`Mission.phases`, which a study with `phases` + summarizes), its cost estimate (`Mission.estimate`, the costs of a + study without failures), and the histories of its failures + (`Mission.histories`, a row per history, which a study with failures + summarizes). The design is realized, built, and observed once for + all of them. Args: design (Design): The design. @@ -1070,82 +707,29 @@ def phases_of( scenario (str | None): A scenario of the study (by name), if any. Returns: - pandas.DataFrame: a row per phase: its `start`, `end`, - `duration`, number of `satellites`, and metrics + Mission: the mission Raises: ValueError: if the study has no mission plan. """ - return self._mission_of(design, replicate, scenario).phases() - - def estimate_of( - self, design: Design, replicate: int = 0, scenario: str | None = None - ) -> CostEstimate: - """ - Gets the cost estimate of the planned deployment of a replicate of a - design (see `deployment_of` and `CostModel.estimate`), with its - growth, which is the cost of the evaluation of a study without - failures (the costs of a study with failures are the means of those - of the histories, see `missions_of`). - - Args: - design (Design): The design. - replicate (int): The replicate. - scenario (str | None): A scenario of the study (by name), if any. - - Returns: - CostEstimate: the estimate - - Raises: - ValueError: if the study's plan has no cost model. - """ - return self._mission_of(design, replicate, scenario).estimate() - - def missions_of( - self, design: Design, replicate: int = 0, scenario: str | None = None - ) -> pd.DataFrame: - """ - Gets the histories of the failures of a replicate of a design, which - its evaluation summarizes (see `Failures` and `evaluate_missions`): - a row per history, with the mean of each metric over its phases, - the measures of its mission, and its costs. - - Args: - design (Design): The design. - replicate (int): The replicate. - scenario (str | None): A scenario of the study (by name), if any. - - Returns: - pandas.DataFrame: a row per history - - Raises: - ValueError: if the study has no failures. - """ - if self.failures is None: - raise ValueError("the study has no failures") - return self._mission_of(design, replicate, scenario).missions(self.failures) + if self.plan is None: + raise ValueError("the study has no mission plan") + realized = self.realize(design, replicate, scenario) + satellites = list(self.build(realized)) + observations = self.observations(satellites, realized) + return self.evaluate.mission_of(satellites, observations, realized) def prune(self) -> int: """ Removes the evaluations of the study's store by this study with other code (see `Study.prune`), and the results of its observations' caches - with other code (see `Observations.prune`). + with other code (see `Observations.prune`, which returns their number + when called alone). Returns: - int: the number of evaluations and results removed + int: the number of evaluations removed (as `Study.prune`, not + counting the results of the observations' caches) """ - return super().prune() + self.observations.prune() - - def _mission_of( - self, design: Design, replicate: int, scenario: str | None - ) -> _Mission: - """ - Plans the mission of a replicate of a design, as its evaluation does - (see `_Evaluation.mission_of`). - """ - if self.plan is None: - raise ValueError("the study has no mission plan") - realized = self.realize(design, replicate, scenario) - satellites = list(self.build(realized)) - observations = self.observations(satellites, realized) - return self.evaluate.mission_of(satellites, observations, realized) + evaluations = super().prune() + self.observations.prune() + return evaluations diff --git a/src/tatc/tradespace/optimization.py b/src/tatc/tradespace/optimization.py index a1ec1714..caeaf486 100644 --- a/src/tatc/tradespace/optimization.py +++ b/src/tatc/tradespace/optimization.py @@ -22,10 +22,17 @@ designs proposed together are evaluated together, in parallel if the study is (see `Study`). +Designs are judged by their feasible replicates, as summaries judge them +(see `aggregate`): a design infeasible in some replicates is judged by the +others (a requirement on `feasible`, the share of its replicates that are +feasible, such as `Requirement("feasible", ">=", 1)`, rejects it), and a +design without a feasible replicate is infeasible, which the optimizers' +constraint of feasibility rejects. + A search chooses its front from one evaluation of each design (with the study's replicates), which favors the designs whose replicates were lucky: refine the designs it evaluated (see `refine`) and confirm its front (see -`confirm`) with the designs of the search (see `Search`), as for any study. +`confirm`, of the designs of the search, see `Search`), as for any study. @author: Paul T. Grogan """ @@ -39,28 +46,20 @@ import numpy as np import pandas as pd -from .criteria import ( - Criteria, - _across_groups, - _as_criteria, - _combiners, - _resolve, - _signs, - _Statistics, - aggregate, -) +from .criteria import Criteria, _as_criteria, _signs from .space import Design, Infeasible from .study import Study +from .summary import aggregate @dataclass class Search: """ The outcome of a search with an optimizer (see `optimize_optuna` and - `optimize_pymoo`): its `results`, the `summary` of its designs, and the - `designs` themselves, as the outcomes of other steps of a trade study - (see `Refinement`), which refine and confirm its front as for any - study:: + `optimize_pymoo`): as the outcomes of other steps of a trade study (see + `Refinement`), its `results`, the `summary` of its designs, the `designs` + it selects for the next step (the efficient designs it found), and its + `criteria`, which refine and confirm its front as for any study:: search = optimize_optuna(study, criteria, n_trials=200) refinement = refine(study, criteria, search.results) @@ -69,13 +68,18 @@ class Search: results: pd.DataFrame """pandas.DataFrame: The results of every evaluation (see `Study.run`).""" + criteria: Criteria + """Criteria: The criteria of the search.""" summary: pd.DataFrame = field(default_factory=pd.DataFrame) - """pandas.DataFrame: A row per design that the search found feasible - (feasible in every replicate, as the optimizers judge designs): the - summary of the criteria over its replicates (see `aggregate`), with - whether it is efficient among these designs (`pareto`, with the - tolerances of the criteria).""" + """pandas.DataFrame: A row per design that the search found feasible (in + any replicate, judged by its feasible replicates, see `aggregate`): the + summary of the criteria over its replicates, with whether it is + efficient among these designs (`pareto`, with the tolerances of the + criteria).""" designs: list[Design] = field(default_factory=list) + """list[Design]: The efficient designs that the search found (`pareto` of + `summary`), for the next step.""" + evaluated: list[Design] = field(default_factory=list) """list[Design]: The designs evaluated, in the order of their evaluation.""" state: Any = None """Any: The optimizer's own outcome: the Optuna study (`optuna.Study`) or @@ -86,7 +90,8 @@ class Evaluations: """ The evaluations of designs for a search: the objectives of each design (by its key), the violations of its requirements, and the records of the - study's evaluations. + study's evaluations. Designs are judged by their feasible replicates (see + `aggregate`), and a design without a feasible replicate is infeasible. Args: study (Study): The study that evaluates designs. @@ -101,9 +106,6 @@ def __init__(self, study: Study, criteria: Criteria | Mapping[str, str]): raise ValueError( "searches need one record per evaluation: give criteria without `by`" ) - self._statistics = _resolve(self.criteria) - across = self.criteria.across - self._combiners = None if across is None else _combiners(self.criteria) self.values: dict[str, tuple[float, ...] | None] = {} """dict: The objectives of each evaluated design (by key), or `None` if it is infeasible.""" @@ -111,9 +113,12 @@ def __init__(self, study: Study, criteria: Criteria | Mapping[str, str]): """dict: The violation of each requirement by each evaluated design (by key), or `None` if it is infeasible.""" self.infeasibility: dict[str, float] = {} - """dict: The share of the replicates of each evaluated design (by - key) that are infeasible (0 for a feasible design), the violation of - its feasibility for constraint-aware optimizers.""" + """dict: The violation of the feasibility of each evaluated design (by + key), for constraint-aware optimizers: 0 for a design that has + feasible replicates (by which it is judged), and otherwise the share + of its evaluations that are infeasible (1 for a design infeasible in + every replicate, and less, with criteria `across` scenarios, for one + without a feasible replicate in some of them).""" self.designs: dict[str, Design] = {} """dict: The evaluated designs (by key), in the order of their evaluation.""" @@ -131,10 +136,10 @@ def results(self) -> pd.DataFrame: def evaluate(self, designs: list[Design]) -> list[tuple[float, ...] | None]: """ Gets the objectives of designs, evaluating those not yet evaluated - together (see also `violations`). A design is infeasible if any of - its replicates is (see `infeasibility`). The first design evaluated - is evaluated alone, to check that the study's evaluations give one - record each before evaluating others. + together (see also `violations`). A design is infeasible if none of + its replicates is feasible (see `infeasibility`). The first design + evaluated is evaluated alone, to check that the study's evaluations + give one record each before evaluating others. Args: designs (list[Design]): The designs. @@ -153,13 +158,13 @@ def evaluate(self, designs: list[Design]) -> list[tuple[float, ...] | None]: def _run(self, designs: list[Design]) -> None: """ - Evaluates designs, recording their objectives and violations. + Evaluates designs, recording their objectives and violations (of + their summary, see `aggregate`). """ self.designs.update((design.key, design) for design in designs) records = self.study.run(designs) self._records.append(records) across = self.criteria.across - groups = _across_groups(records, across) keys = ["design", "replicate", *([] if across is None else [across.column])] if records.groupby(keys).size().max() > 1: if across is None and "scenario" in records.columns: @@ -173,25 +178,24 @@ def _run(self, designs: list[Design]) -> None: + "study's evaluate function return a mapping of metrics" ) self._checked = self._checked or bool(records["feasible"].any()) - shares = 1.0 - records.groupby("design")["feasible"].mean() - self.infeasibility.update(shares.astype(float).to_dict()) - infeasible = set(shares.index[shares > 0]) - for key in infeasible: - self.values[key] = self.violations[key] = None - feasible = records[~records["design"].isin(infeasible)] - if len(feasible) > 0: - table = _Statistics( - feasible, self._statistics, (), across, self._combiners, groups + summary = aggregate(records, self.criteria, design_columns=[]) + summary = summary.set_index("design") + shares = records.groupby("design")["feasible"].mean() + for design in designs: + key = design.key + if key not in summary.index: + self.values[key] = self.violations[key] = None + self.infeasibility[key] = 1.0 - float(shares[key]) + continue + row = summary.loc[key] + self.values[key] = tuple( + float(row[name]) for name in self.criteria.objectives ) - values, _ = table.evaluate() - for i, key in enumerate(table.designs): - self.values[key] = tuple( - float(values[name][i]) for name in self.criteria.objectives - ) - self.violations[key] = tuple( - float(requirement.violation(values[requirement.name][i])) - for requirement in self.criteria.requirements - ) + self.violations[key] = tuple( + float(requirement.violation(row[requirement.name])) + for requirement in self.criteria.requirements + ) + self.infeasibility[key] = 0.0 def search(self, state: Any) -> Search: """ @@ -204,16 +208,14 @@ def search(self, state: Any) -> Search: Search: the search """ results = self.results - summary = pd.DataFrame() - feasible = [key for key, value in self.values.items() if value is not None] - if feasible: - summary = aggregate( - results[results["design"].isin(feasible)], self.criteria - ) + summary = aggregate(results, self.criteria) + efficient = pd.unique(summary.loc[summary["pareto"].astype(bool), "design"]) return Search( results=results, + criteria=self.criteria, summary=summary, - designs=list(self.designs.values()), + designs=[self.designs[key] for key in efficient], + evaluated=list(self.designs.values()), state=state, ) @@ -258,19 +260,24 @@ def optimize_optuna( With `constraints`, each trial records the violation of the constraints of its design (`trial.set_constraint`, under the name `"feasibility"`): - 0 for a feasible design, the amount by which it violates a constraint of - the design space (see `DesignSpace`), or the share of its replicates - that the study finds infeasible. Optuna's constraint-aware samplers (such as TPE and NSGA-II) - then prefer feasible designs, and infeasible designs that violate their - constraints less. An infeasible trial is told the worst objectives of the - feasible designs evaluated before it, which these samplers do not use to - rank it. Without `constraints` (or with a version of Optuna before 5, - which lacks `set_constraint`), an infeasible design prunes its trial. + 0 for a design with feasible replicates (by which it is judged, see + `aggregate`), the amount by which it violates a constraint of the design + space (see `DesignSpace`), or, for a design without a feasible replicate, + the share of its evaluations that the study finds infeasible (see + `Evaluations.infeasibility`). Optuna's constraint-aware samplers (such + as TPE and NSGA-II) then prefer feasible designs, and infeasible designs + that violate their constraints less. An infeasible trial is told the + worst objectives of the feasible designs evaluated before it, which + these samplers do not use to rank it. Without `constraints` (or with a + version of Optuna before 5, which lacks `set_constraint`), an infeasible + design prunes its trial. Each requirement of the criteria is a constraint of the trials (named by - its statement, such as `"sufficient p10 >= 80"`), whose value is its - violation (see `Requirement.violation`), and which requires - `constraints`. + its statement, `str(requirement)`, such as `"sufficient p10 >= 80"`), + whose value is its violation (see `Requirement.violation`), and which + requires `constraints`. A requirement on `feasible` (the share of a + design's replicates that are feasible) constrains the designs that are + infeasible in some of their replicates. Trials are asked in batches, whose designs are evaluated together (in parallel, if the study is) before they are told. A batch defaults to one @@ -306,6 +313,11 @@ def optimize_optuna( Returns: Search: the results and designs of the search, and the Optuna study + + Raises: + ValueError: if the criteria have requirements without `constraints` + (or with a version of Optuna before 5), or if `max_designs` is + less than 1. """ # pylint: disable=import-outside-toplevel try: @@ -314,6 +326,8 @@ def optimize_optuna( raise ImportError( "optimize_optuna requires optuna (pip install optuna)" ) from error + if max_designs is not None and max_designs < 1: + raise ValueError("max_designs must be at least 1") evaluations = Evaluations(study, criteria) requirements = evaluations.criteria.requirements directions = [ @@ -330,7 +344,7 @@ def optimize_optuna( constrained = constraints and hasattr(optuna.trial.Trial, "set_constraint") if requirements and not constrained: raise ValueError("requirements need constraints (and Optuna 5 or later)") - names = [f"{r.name} {r.operator} {r.value}" for r in requirements] + names = [str(requirement) for requirement in requirements] def set_constraints(trial: Any, feasibility: float, violations) -> None: trial.set_constraint("feasibility", feasibility) @@ -386,8 +400,9 @@ def make_pymoo_problem(study: Study, criteria: Criteria | Mapping[str, str]) -> and `DesignSpace.unit_paths`), its objectives are minimized (maximized objectives are negated), and its constraint (`G <= 0`) is violated by designs that violate a constraint of the design space (by the amount of - the violation, see `DesignSpace`) or that the study finds infeasible (by - the share of their infeasible replicates). Each requirement of the + the violation, see `DesignSpace`) or that have no feasible replicate (by + the share of their infeasible evaluations, see + `Evaluations.infeasibility`). Each requirement of the criteria is a further constraint, whose value is its violation (see `Requirement.violation`). The designs of a population are evaluated together. @@ -521,6 +536,38 @@ def _eliminate_duplicates(algorithm: Any, duplicates: Any) -> None: part.eliminate_duplicates = duplicates +def _designs_termination( + evaluations: Evaluations, max_designs: int, termination: Any +) -> Any: + """ + Gets a pymoo termination of a search once it has evaluated `max_designs` + designs, or by another termination (if any), whichever is first. + """ + # pylint: disable=import-outside-toplevel + from pymoo.core.termination import Termination + from pymoo.util.misc import termination_from_tuple + + class DesignsTermination(Termination): + """ + A termination by the number of designs evaluated (see + `optimize_pymoo`), or by another termination. + """ + + def __init__(self, other: Any): + super().__init__() + self.other = other + + def _update(self, algorithm: Any) -> float: + progress = len(evaluations.values) / max_designs + if self.other is not None: + progress = max(progress, self.other.update(algorithm)) + return progress + + return DesignsTermination( + None if termination is None else termination_from_tuple(termination) + ) + + def optimize_pymoo( study: Study, criteria: Criteria | Mapping[str, str], @@ -529,6 +576,7 @@ def optimize_pymoo( *, seed: int | None = 0, distinct: bool = True, + max_designs: int | None = None, **kwargs: Any, ) -> Search: """ @@ -539,6 +587,14 @@ def optimize_pymoo( that each generation proposes as many new designs as it can: as many generations then evaluate more designs, and find more of the front. + The generations of a search (of the `termination`) are a poor measure of + its cost if they propose designs evaluated before (without `distinct`), + whose objectives are known without evaluating them again: `max_designs` + limits the designs evaluated instead, as of `optimize_optuna` (the search + stops after the generation in which it has evaluated as many, or by the + `termination`, whichever is first). As a generation evaluates its new + designs together, the last may evaluate more designs than are left. + Args: study (Study): The study that evaluates designs. criteria (Criteria | Mapping[str, str]): The criteria, without `by` @@ -552,6 +608,8 @@ def optimize_pymoo( distinct (bool): `True` to eliminate the proposals of designs proposed or evaluated before, `False` for the algorithm's own elimination of duplicates (of equal points). + max_designs (int | None): The most designs to evaluate (but those of + the last generation), if limited. **kwargs (Any): Other arguments of `pymoo.optimize.minimize`. Returns: @@ -559,7 +617,8 @@ def optimize_pymoo( Raises: ValueError: if the search is distinct but the algorithm does not - eliminate duplicates as pymoo's genetic algorithms do. + eliminate duplicates as pymoo's genetic algorithms do, or if + `max_designs` is less than 1. """ # pylint: disable=import-outside-toplevel try: @@ -569,6 +628,8 @@ def optimize_pymoo( "optimize_pymoo requires pymoo (pip install pymoo)" ) from error + if max_designs is not None and max_designs < 1: + raise ValueError("max_designs must be at least 1") if algorithm is None: from pymoo.algorithms.moo.nsga2 import NSGA2 @@ -576,6 +637,10 @@ def optimize_pymoo( problem = make_pymoo_problem(study, criteria) if distinct: _eliminate_duplicates(algorithm, problem.duplicates) + if max_designs is not None: + termination = _designs_termination( + problem.evaluations, max_designs, termination + ) result = minimize(problem, algorithm, termination, seed=seed, **kwargs) evaluations = problem.evaluations return evaluations.search(result) diff --git a/src/tatc/tradespace/pareto.py b/src/tatc/tradespace/pareto.py index b0657f90..94208762 100644 --- a/src/tatc/tradespace/pareto.py +++ b/src/tatc/tradespace/pareto.py @@ -10,7 +10,9 @@ separately. A mapping of objectives to their directions (`"min"` or `"max"`) is the criteria of these objectives alone. A design with a missing objective (`NaN`, such as a statistic of a metric that none of its feasible -replicates gives) is not efficient, and dominates no other. +replicates gives) is not efficient, and dominates no other. The probability +that a design is efficient, given the uncertainty of its replicates, is that +of `pareto_probability` (of the summaries of studies, see `aggregate`). @author: Paul T. Grogan """ @@ -26,21 +28,13 @@ Criteria, Requirement, _as_criteria, - _bootstrap_error, - _check_summary, - _combiners, _costs_of, _get_tolerances, - _groups, - _judge, - _resamples, - _resolve, _signs, - _summary_groups, _violation_of, - aggregate, ) from .dominance import _dominated, _efficient +from .summary import _check_summary, _groups, aggregate def _get_costs(frame: pd.DataFrame, criteria: Criteria) -> np.ndarray: @@ -111,7 +105,7 @@ def pareto_front( """ criteria = _as_criteria(criteria) _check_summary(summary, criteria.by) - tolerances = _get_tolerances(criteria.objectives, criteria.tolerance) + tolerances = _get_tolerances(criteria.objectives, criteria.tolerances) efficient = np.zeros(len(summary), dtype=bool) for _, positions in _groups(summary, criteria.by): group = summary.iloc[positions] @@ -148,7 +142,7 @@ def pareto_ranks( """ criteria = _as_criteria(criteria) _check_summary(summary, criteria.by) - tolerances = _get_tolerances(criteria.objectives, criteria.tolerance) + tolerances = _get_tolerances(criteria.objectives, criteria.tolerances) ranks = np.full(len(summary), -1, dtype=int) for _, positions in _groups(summary, criteria.by): group = summary.iloc[positions] @@ -298,109 +292,3 @@ def hypervolume_progress( name="hypervolume", dtype=float, ) - - -def pareto_probability( - results: pd.DataFrame, - criteria: Criteria | Mapping[str, str], - *, - n_resamples: int = 500, - seed: int = 0, - design_columns: Sequence[str] | None = None, -) -> pd.DataFrame: - """ - Estimates the probability that each design is Pareto-efficient by - criteria (and meets their requirements, if any), given the uncertainty - of its replicates, by a bootstrap: each resample draws replicates with - replacement, the same replicates for every design (which keeps the - correlation between designs of common random numbers, see - `Design.realize`), computes the statistics of each design over the drawn - replicates, and finds the front of the designs that meet the - requirements (in each group of the criteria's `by`). The probability is - the share of resamples in which a design is on that front. - - Designs that are efficient with a probability between 0 and 1 are those - whose efficiency the replicates do not settle: more replicates (see - `refine`) would settle it, unless designs differ by less than matters (as - near saturation), which a tolerance of the objectives settles: designs - within the tolerances of the front are efficient (see `pareto_front`). - With few replicates, the bootstrap has few distinct resamples and - understates the uncertainty. Designs may have different replicates (as - after `refine`): replicates are drawn from all of them, and each design's - statistics are those of its drawn replicates (or of all of its - replicates, if none is drawn). With criteria `across` the scenarios of a - study (see `Across`), a drawn replicate is drawn in every scenario, in - which it has the same uncertain parameters. - - Args: - results (pandas.DataFrame): The results of a study (see - `Study.run`), with a record per replicate of each design (and - group of the criteria's `by`). Infeasible results are ignored. - criteria (Criteria | Mapping[str, str]): The criteria, or the - objectives (metrics whose means they are) and their directions - (`"min"` or `"max"`). - n_resamples (int): The number of resamples (at least 2). - seed (int): The seed of the resamples. - design_columns (Sequence[str] | None): The columns of the values of - designs, or `None` for those that are the same in every - replicate of a design (see `aggregate`). - - Returns: - pandas.DataFrame: a row per design (and group): the summary of the - criteria over every replicate (see `aggregate`: the values of the - design, the statistics, the number of `replicates`, the - `violation` of the requirements, whether the design meets them, - `meets_requirements`, and whether it is efficient among those - that do, `pareto`), the standard error of each objective - (` se`, its standard deviation over the resamples), - the probability that it is efficient (`pareto_probability`), and - the probability that it meets the requirements - (`requirements_probability`) - """ - criteria = _as_criteria(criteria) - resolved = _resolve(criteria) - tolerances = _get_tolerances(criteria.objectives, criteria.tolerance) - combiners = None if criteria.across is None else _combiners(criteria) - rng = np.random.default_rng(seed) - frames = [] - for frame, table in _summary_groups( - results, - resolved, - criteria.by, - criteria.requirements, - criteria.across, - combiners, - design_columns, - ): - values, violation = table.evaluate() - counts = np.zeros(len(table.designs)) - met = np.zeros(len(table.designs)) - # the sums of the objectives (and of their squares) over the resamples - sums = {name: np.zeros(len(table.designs)) for name in criteria.objectives} - squares = {name: np.zeros(len(table.designs)) for name in criteria.objectives} - for drawn in _resamples(len(table.replicates), n_resamples, rng): - sample, sample_violation = table.evaluate(drawn) - # designs without a drawn replicate keep the statistics of all of theirs - for name in sample: - missing = np.isnan(sample[name]) & ~np.isnan(values[name]) - sample[name][missing] = values[name][missing] - missing = np.isnan(sample_violation) - sample_violation[missing] = violation[missing] - meets = sample_violation == 0 - counts += _efficient(_costs_of(sample, criteria), meets, tolerances) - met += meets - for name in criteria.objectives: - sums[name] += sample[name] - squares[name] += sample[name] ** 2 - for name, value in values.items(): - frame[name] = value - for name in criteria.objectives: - frame[f"{name} se"] = _bootstrap_error( - sums[name], squares[name], n_resamples - ) - frame["replicates"] = table.counts - _judge(frame, values, violation, criteria) - frame["pareto_probability"] = counts / n_resamples - frame["requirements_probability"] = met / n_resamples - frames.append(frame) - return pd.concat(frames, ignore_index=True) diff --git a/src/tatc/tradespace/plans.py b/src/tatc/tradespace/plans.py new file mode 100644 index 00000000..3cfb5bd5 --- /dev/null +++ b/src/tatc/tradespace/plans.py @@ -0,0 +1,655 @@ +""" +The missions of the designs of an observation study (see `ObservationStudy`): +the plan of each design's mission (`MissionPlan`: its deployment, the policy +that restores the failures of its satellites, and its costs, from the +values of the design), the failures of its satellites (`Failures`), and the +mission of a replicate of a design (`Mission`), which an evaluation plans +and summarizes into its record, and which `ObservationStudy.mission_of` +gives for other analyses. + +The parts refer to the values of designs by a `Reference` (see `value_of`), +such as the type of the satellites of a design:: + + MissionPlan(SCHEDULE, COST_MODEL, kind="field_of_regard") # d.field_of_regard + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +import dataclasses +from collections.abc import Callable, Mapping, Sequence +from functools import cached_property +from typing import Any + +import numpy as np +import pandas as pd + +from .cost import CostEstimate, CostModel +from .criteria import Requirement +from .deployment import Deployment, DeploymentSchedule, Stage +from .failures import FailureModel, RestorationPolicy +from .histories import ( + MAX_SETS, + SAMPLINGS, + _exact_sets, + evaluate_histories, + exact_expectations, + summarize_histories, +) +from .mission import Capability, MissionHistory, summarize_phases +from .references import Reference, _number, value_of +from .space import Design +from .values import ChoiceValues, configure + + +@dataclasses.dataclass(frozen=True) +class MissionPlan: + """ + The deployment of the satellites of each design (see + `DeploymentSchedule.plan`), the policy that restores the failures of its + satellites (see `RestorationPolicy`), and its costs (see `CostModel`), + from the values of the design (see `value_of`). + + The schedule, the policy, and the cost model may be functions of the + (realized) design, which size them by its values with relationships of + the study's own (TAT-C includes none, see the module + `tatc.tradespace.cost`): for example, the costs of a type of satellite + from the mass of its payload, or the capacity of launches to the + design's altitude:: + + def schedule(d): + return dataclasses.replace(SCHEDULE, launch_mass_capacity=capacity(d.altitude)) + + PLAN = MissionPlan(schedule, COST_MODEL, kind="payload") + + The policy of a design gives its spares: in orbit in each plane + (`RestorationPolicy.orbit_spares`, which its deployment plans) and on + the ground, which are produced (and cost) whether or not the study has + failures (see `Failures`). A policy may be a decision of each design, + such as a group of `policy_space` whose values configure the default + policy (see `configure`), or a function of the design that gives its + policy (such as one that configures a base policy):: + + space = space.extend(policy=policy_space(orbit_spares=Integer(0, 1), procurement_years=0.5)) + PLAN = MissionPlan(SCHEDULE, COST_MODEL, policy="policy") + PLAN = MissionPlan(SCHEDULE, COST_MODEL, policy=lambda d: configure(BASE_POLICY, d.policy)) + + Launches limited in mass take the masses of the satellites from the cost + model (`SatelliteCost.mass`, of each type), unless `masses` are given, + and launches priced by mass take the same masses (see + `CostModel.estimate`). + + The growth of the costs of the components of the cost model (see + `Component`) is drawn from scores that are values of the design (such as + a group of `risk_space`), shared by designs that share components:: + + space = space.extend(cost_risk=risk_space(COST_MODEL)) + PLAN = MissionPlan(SCHEDULE, COST_MODEL, kind="payload", scores="cost_risk") + + Args: + schedule (DeploymentSchedule | Callable): The schedule of the + deployment, or a function of the design that gives it. + cost_model (CostModel | Callable | None): The costs, a function of the + design that gives them, or `None`. + kind (Reference | None): The type of the satellites (for schedules, + failures, and costs of several types), as a value of the design. + policy (RestorationPolicy | Reference): The policy for the failed + satellites of each design, and its spares (by default, failed + satellites are restored by producing new ones), or a value of + the design (see `value_of`) that is its policy, or the values of + a group (such as of `policy_space`) that configure the default + policy (see `configure`). + growth (float | Reference | Mapping): The growth of the costs (see + `CostModel.estimate`): a factor, a value of the design, or a + mapping of each element (such as `"development"`) to a factor or + a value of the design, or to a mapping of each type of satellite + to one. + stages (Sequence[Stage] | Callable): The stages of the deployment + (see `Stage`), or a function of the (realized) design that gives + them, such as of a decision whether to stage it and of the values + its rules read. Their rules may also read the capability of the + satellites operating at a decision, by the study's metrics (see + `Decision.capability`). + masses (float | Mapping | Reference | None): The mass (kg) of the + satellites (or of each type, a mapping), or a value of the + design, for launches limited (or priced) in mass, or `None` for + the masses of the cost model. + scores (Reference | None): The scores from which the growth of the + components of the cost model is drawn (see `CostModel.draw`), as + a value of the design (such as a group of `risk_space`), or + `None` for the expected costs of the components. + """ + + schedule: DeploymentSchedule | Callable[[Design], DeploymentSchedule] + cost_model: CostModel | Callable[[Design], CostModel | None] | None = None + _: dataclasses.KW_ONLY + kind: Reference | None = None + policy: RestorationPolicy | Reference = RestorationPolicy() + growth: float | Reference | Mapping[str, float | Reference | Mapping[Any, Any]] = ( + 1.0 + ) + stages: Sequence[Stage] | Callable[[Design], Sequence[Stage]] = () + masses: float | Mapping[Any, float] | Reference | None = None + scores: Reference | None = None + + def schedule_of(self, design: Design) -> DeploymentSchedule: + """ + Gets the schedule of the deployment of a design. + + Args: + design (Design): The (realized) design. + + Returns: + DeploymentSchedule: the schedule + """ + if isinstance(self.schedule, DeploymentSchedule): + return self.schedule + return self.schedule(design) + + def policy_of(self, design: Design) -> RestorationPolicy: + """ + Gets the policy for the failed satellites of a design, and its spares. + + Args: + design (Design): The (realized) design. + + Returns: + RestorationPolicy: the policy + """ + if isinstance(self.policy, RestorationPolicy): + return self.policy + policy = value_of(design, self.policy) + if isinstance(policy, RestorationPolicy): + return policy + if isinstance(policy, (Mapping, ChoiceValues)): + return configure(RestorationPolicy(), policy) + raise TypeError( + "the policy of a design is a RestorationPolicy, or values that " + + f"configure one, not {policy!r}" + ) + + def cost_model_of(self, design: Design) -> CostModel | None: + """ + Gets the cost model of a design, with the growth of its components + drawn from the design's scores (if any, see `CostModel.draw`). + + Args: + design (Design): The (realized) design. + + Returns: + CostModel | None: the cost model, if any + """ + model = self.cost_model + if model is not None and not isinstance(model, CostModel): + model = model(design) + if model is None or self.scores is None: + return model + return model.draw(value_of(design, self.scores)) + + def masses_of(self, design: Design, cost_model: CostModel | None = None) -> Any: + """ + Gets the masses of the satellites of a design, for launches limited in + mass: the given masses (or the value of the design they name), or + those of the types of satellites of its cost model, if any. + + Args: + design (Design): The (realized) design. + cost_model (CostModel | None): The design's cost model. + + Returns: + Any: a mass, a mapping of types to masses, or `None` + """ + if self.masses is not None: + if isinstance(self.masses, (int, float, Mapping)): + return self.masses + return value_of(design, self.masses) + if cost_model is None: + return None + satellites = cost_model.satellites + if isinstance(satellites, Mapping): + masses = {kind: cost.mass for kind, cost in satellites.items()} + return None if all(m is None for m in masses.values()) else masses + return satellites.mass + + def stages_of(self, design: Design) -> tuple: + """ + Gets the stages of the deployment of a design. + + Args: + design (Design): The (realized) design. + + Returns: + tuple[Stage, ...]: the stages + """ + stages = self.stages(design) if callable(self.stages) else self.stages + return tuple(stages or ()) + + def growth_of(self, design: Design) -> Any: + """ + Gets the growth of the costs of a design. + + Args: + design (Design): The (realized) design. + + Returns: + Any: a factor, or a mapping of each element to its factor (or to + a mapping of each type of satellite to its factor) + """ + if not isinstance(self.growth, Mapping): + return _number(design, self.growth) + growth: dict[str, Any] = {} + for element, value in self.growth.items(): + if isinstance(value, Mapping): + growth[element] = {k: _number(design, g) for k, g in value.items()} + else: + growth[element] = _number(design, value) + return growth + + def mission_of( + self, + design: Design, + layout: Any, + capability: Capability, + failures: Failures | None = None, + ) -> Mission: + """ + Plans the mission of a realized design: its deployment (with the + spares in orbit of its policy, and whose stages read the capability + of the satellites operating at their decisions), its policy, and its + costs. + + Args: + design (Design): The (realized) design. + layout (Any): The layout of its satellites (see `layout_of`). + capability (Capability): The capability of its satellites. + failures (Failures | None): The failures of its satellites, if + any. + + Returns: + Mission: the mission + """ + policy = self.policy_of(design) + cost_model = self.cost_model_of(design) + deployment = self.schedule_of(design).plan( + layout, + kind=value_of(design, self.kind), + orbit_spares=policy.orbit_spares, + masses=self.masses_of(design, cost_model), + stages=self.stages_of(design), + ) + deployment.capability = capability + return Mission( + design, + deployment, + policy, + cost_model, + self.growth_of(design), + capability, + failures, + ) + + +@dataclasses.dataclass(frozen=True) +class Failures: + """ + The failures of the satellites of each design: histories of its mission + (see `Deployment.simulate_many`), restored by the policy of the design + (see `MissionPlan.policy`: by default by producing new satellites; with + `RestorationPolicy(restore=False)`, not restored), summarized over the + histories (see `summarize_histories`): the mean of each metric over the + phases of the mission and the histories, `quantiles` and `requirements` + of them, and their costs. With requirements on the metrics of the + `phases`, each history also gives the time until a phase first meets + each (` time`, see `summarize_phases`), summarized over the + histories as the other columns: its quantiles, or the share of the + histories that meet it by a time (a requirement on it), say more than + its mean, which is infinite if a history never meets it. + + Without restoration, the means of the metrics and the availability are + the exact expectations over the failures (see `exact_expectations`) if + `exact`, if the histories have failures (with a `seed`), if the + deployment is not staged (see `Stage`, whose rules make its launches + depend on the history), and if it has at most `MAX_SETS` (200,000) sets + of satellites to enumerate, which is known before they are enumerated; + otherwise (such as for constellations of about 20 satellites or more) + they are the means of the histories. + + With a `stress`, the failures are drawn from stressed distributions for + importance sampling (see `Deployment.simulate_many`), each history + weighted by its likelihood ratio. With `controls`, the means over the + histories are estimated with control variates (see + `summarize_histories`): measures of the missions (see + `MissionHistory.metrics`, such as `availability`) whose expected values + are estimated from `control_histories` other histories of the replicate, + simulated without evaluating their phases (see + `Deployment.expected_metrics`). With `spread`, the summaries add the + standard deviation of each column over the histories (` + histories std`), as `allocate_histories` needs of a pilot study. + + Args: + model (FailureModel): The failures. + histories (int): The histories of each replicate. + seed (Reference | None): The value of the design that seeds the + failures (see `value_of`, such as of `Uncertain.seed`), or + `None` for the one history without failures. + sampling (str): The sampling of the histories (`"stratified"` or + `"random"`, see `Deployment.simulate_many`). + phases (Sequence[Requirement]): Requirements on the metrics of the + phases of each history, whose times it gives (` time`). + quantiles (Mapping | None): Quantiles of the columns of the + histories (see `summarize_histories`). + requirements (Sequence[Requirement]): Requirements on the columns of + the histories (see `summarize_histories`), such as on a time. + exact (bool): `True` for exact expectations without restoration. + stress (float): The factor of the hazards of stressed failures (1 + for none). + launch_stress (float | None): The factor of the probability that a + launch fails, or `None` for the stress. + controls (Sequence[str]): The measures of the missions that are + control variates, if any. + control_histories (int): The histories that estimate the expected + values of the controls. + spread (bool): `True` to add the standard deviations of the columns + over the histories. + + Raises: + ValueError: if the numbers of histories are less than 1, the + sampling is unknown, or a stress is not positive. + """ + + model: FailureModel + _: dataclasses.KW_ONLY + histories: int = 1 + seed: Reference | None = None + sampling: str = "stratified" + phases: Sequence[Requirement] = () + quantiles: Mapping[str, float | Sequence[float]] | None = None + requirements: Sequence[Requirement] = () + exact: bool = True + stress: float = 1.0 + launch_stress: float | None = None + controls: Sequence[str] = () + control_histories: int = 1000 + spread: bool = False + + def __post_init__(self): + if isinstance(self.controls, str): + raise TypeError("controls are a sequence of names of measures") + object.__setattr__(self, "controls", tuple(self.controls)) + object.__setattr__(self, "phases", tuple(self.phases)) + object.__setattr__(self, "requirements", tuple(self.requirements)) + if not all( + isinstance(requirement, Requirement) + for requirement in (*self.phases, *self.requirements) + ): + raise TypeError("phases and requirements are sequences of Requirements") + if self.histories < 1 or self.control_histories < 1: + raise ValueError("histories and control_histories must be at least 1") + if self.sampling not in SAMPLINGS: + raise ValueError( + f"sampling must be one of {SAMPLINGS}, not {self.sampling!r}" + ) + if self.stress <= 0 or ( + self.launch_stress is not None and self.launch_stress <= 0 + ): + raise ValueError("stress and launch_stress must be positive") + + def seed_of(self, design: Design) -> Any: + """ + Gets the seed of the failures of a (realized) design's replicate. + + Args: + design (Design): The (realized) design. + + Returns: + Any: the seed, or `None` for the one history without failures + """ + return value_of(design, self.seed) + + def simulate(self, mission: Mission) -> list[MissionHistory]: + """ + Simulates the histories of a mission (see `Deployment.simulate_many`), + restored by its policy. + + Args: + mission (Mission): The mission. + + Returns: + list[MissionHistory]: the histories + """ + return mission.deployment.simulate_many( + self.model, + mission.policy, + self.seed_of(mission.design), + histories=self.histories, + sampling=self.sampling, + stress=self.stress, + launch_stress=self.launch_stress, + ) + + def evaluate(self, mission: Mission) -> pd.DataFrame: + """ + Evaluates the histories of a mission (see `simulate` and + `evaluate_histories`): for each, the mean of each metric over its + phases, the times until they meet the requirements of the `phases`, + the measures of its mission, and its costs. + + Args: + mission (Mission): The mission. + + Returns: + pandas.DataFrame: a row per history + """ + return evaluate_histories( + self.simulate(mission), + mission.capability, + cost_model=mission.cost_model, + growth=mission.growth, + requirements=self.phases, + ) + + def summarize(self, mission: Mission) -> dict[str, float]: + """ + Summarizes the histories of a mission as the metrics of its + evaluation (see `evaluate` and `summarize_histories`): with the + controls (if any), and with exact expectations of its means if they + apply (see `Failures`). + + Args: + mission (Mission): The mission. + + Returns: + dict[str, float]: the summary + """ + seed = self.seed_of(mission.design) + controls = None + if self.controls and seed is not None: + # other histories of the replicate (by a seed of its seed) + other = int(np.random.default_rng([int(seed), 7]).integers(2**31)) + expected = mission.deployment.expected_metrics( + self.model, + mission.policy, + other, + histories=self.control_histories, + sampling=self.sampling, + ) + unknown = sorted(set(self.controls) - set(expected)) + if unknown: + raise ValueError( + f"controls that are not measures of missions: {unknown} " + + f"(they are {sorted(expected)})" + ) + controls = {name: expected[name] for name in self.controls} + record = summarize_histories( + self.evaluate(mission), + quantiles=self.quantiles, + requirements=self.requirements, + controls=controls, + spread=self.spread, + ) + if self._exact(mission, seed): + exact = exact_expectations( + mission.deployment, self.model, mission.capability + ) + record.update( + { + key: value + for key, value in exact.items() + if key.endswith(" mission") or key == "availability" + } + ) + return record + + def _exact(self, mission: Mission, seed: Any) -> bool: + """ + Whether the means of the histories of a mission are exact + expectations (see `Failures`): of failures with a seed, without + restoration, of a deployment that is not staged and whose sets of + satellites are few enough. + """ + return ( + self.exact + and seed is not None + and not mission.policy.restore + and not mission.deployment.stages + and _exact_sets(mission.deployment, self.model) <= MAX_SETS + ) + + +@dataclasses.dataclass(frozen=True, eq=False) +class Mission: + """ + The mission of a replicate of a design, as the evaluation of an + observation study plans it (see `MissionPlan.mission_of` and + `ObservationStudy.mission_of`): its planned deployment, the policy that + restores the failures of its satellites, its cost model and growth, and + the capability of its satellites (their observations, and the cache of + the metrics of their phases), from which follow the history of the + mission without failures (`planned`), the metrics of its phases + (`phases`), its cost estimate (`estimate`), and the histories of its + failures (`histories`, with `failures`). + """ + + design: Design + """Design: The realized design.""" + deployment: Deployment + """Deployment: The planned deployment, with the capability of its + satellites (which the rules of its stages read, see + `Deployment.capability`).""" + policy: RestorationPolicy + """RestorationPolicy: The policy for failed satellites, and the spares.""" + cost_model: CostModel | None + """CostModel | None: The cost model (with the growth of its components + drawn), if any.""" + growth: Any + """Any: The growth of the costs (see `CostModel.estimate`).""" + capability: Capability + """Capability: The capability of the satellites.""" + failures: Failures | None = None + """Failures | None: The failures of the satellites, if any.""" + + @cached_property + def _planned(self) -> MissionHistory: + """The history of the mission without failures (simulated once).""" + return self.deployment.simulate(policy=self.policy) + + def planned(self) -> MissionHistory: + """ + Gets the history of the mission without failures (see + `Deployment.simulate`): its deployment, with the stages that their + rules deploy and the spares on the ground of its policy. + + Returns: + MissionHistory: the history + """ + return self._planned + + def phases(self) -> pd.DataFrame: + """ + Gets the metrics of the phases of the mission without failures (see + `planned` and `evaluate_phases`), which the evaluation of a study + with `phases` summarizes (see `summarize_phases`). + + Returns: + pandas.DataFrame: a row per phase: its `start`, `end`, + `duration`, number of `satellites`, and metrics + """ + satellites = self.capability.satellites + return self.capability.evaluate(self.planned().phases(satellites)) + + def estimate(self) -> CostEstimate: + """ + Gets the cost estimate of the mission without failures (see `planned` + and `CostModel.estimate`), with its growth: the costs of the + evaluation of a study without failures (those of a study with + failures are the means of those of its histories, see `histories`). + + Returns: + CostEstimate: the estimate + + Raises: + ValueError: if the plan has no cost model. + """ + if self.cost_model is None: + raise ValueError("the mission plan has no cost model") + return self.cost_model.estimate(self.planned(), self.growth) + + def histories(self) -> pd.DataFrame: + """ + Gets the histories of the failures of the mission, which the + evaluation of a study with failures summarizes (see + `Failures.evaluate` and `evaluate_histories`): a row per history, + with the mean of each metric over its phases, the measures of its + mission, and its costs. + + Returns: + pandas.DataFrame: a row per history + + Raises: + ValueError: if the mission has no failures. + """ + if self.failures is None: + raise ValueError("the study has no failures") + return self.failures.evaluate(self) + + def metrics(self) -> dict[str, float]: + """ + Gets the metrics of the planned mission that its evaluation records: + `deployed` (see `MissionHistory.deployed`, of the history without + failures), `stages deployed` (of a staged deployment, the stages that + its rules deploy without failures), and, without failures, its costs + (see `estimate` and `CostEstimate.metrics`). + + Returns: + dict[str, float]: the metrics + """ + planned = self.planned() + record = {"deployed": planned.deployed} + if self.deployment.stages: + record["stages deployed"] = planned.metrics()["stages deployed"] + if self.cost_model is not None and self.failures is None: + record.update(self.estimate().metrics()) + return record + + def summarize( + self, phases: Sequence[Requirement] | None = None + ) -> dict[str, float]: + """ + Summarizes the mission as metrics of its evaluation: the histories of + its failures (see `Failures.summarize`), or else, with requirements + on its phases (or none, `()`), the phases of the mission without + failures (see `phases` and `summarize_phases`). + + Args: + phases (Sequence[Requirement] | None): The requirements on the + phases, or `None` not to summarize them. + + Returns: + dict[str, float]: the summary (empty without failures or phases) + """ + if self.failures is not None: + return self.failures.summarize(self) + if phases is not None: + return summarize_phases(self.phases(), requirements=phases) + return {} diff --git a/src/tatc/tradespace/plotting.py b/src/tatc/tradespace/plotting.py index df99ebd6..c7a94d2e 100644 --- a/src/tatc/tradespace/plotting.py +++ b/src/tatc/tradespace/plotting.py @@ -120,6 +120,10 @@ def style_axes(ax: Any, grid: str | None = "y") -> Any: return ax +_OTHERS = object() +"""The group of the rows without a value of the column that groups them.""" + + def _color(colors: Sequence[str] | Mapping[Any, str], value: Any, k: int) -> str: if isinstance(colors, Mapping): if value is None and None not in colors: @@ -187,9 +191,12 @@ def plot_designs( """ Plots designs (such as a summary of a study, see `aggregate`) by two metrics: a point per row, colored by the value of a column `by` (if - any), with the efficient designs (`front`) ringed and labeled. With - `highlight`, only some designs are colored, over the others in gray - (such as the designs a search evaluated, over every design):: + any), with the efficient designs (`front`) ringed and labeled. Rows + without a value of `by` (`NaN`, such as of a variable of a branch that a + design does not choose) are drawn in gray, named `others` (or "other") + in the legend. With `highlight`, only some designs are colored, over the + others in gray (such as the designs a search evaluated, over every + design):: plot_designs(summary, "satellites", "sufficient", front="pareto") plot_designs( @@ -217,7 +224,9 @@ def plot_designs( to color every design. label (str | None): The name of the colored designs in the legend, without `by`. - others (str | None): The name of the designs in gray in the legend. + others (str | None): The name of the designs in gray in the legend: + those not highlighted, or without a value of `by` ("other" if + not given). front_label (str): The name of the efficient designs in the legend. jitter (float): The most that `x` is shifted at random (in its units), to separate designs of the same `x` (such as numbers of @@ -264,6 +273,19 @@ def plot_designs( lw=0, label=_name(names, value), ) + missing = groups.isna().to_numpy() & shown + if missing.any(): + # the designs not highlighted, if any, are named so already + named = highlight is not None and others is not None + ax.scatter( + xs[missing], + ys[missing], + s=14, + color=GRAY, + alpha=0.55, + lw=0, + label=None if named else (others or "other"), + ) if front is not None: if isinstance(front, (Criteria, Mapping)): efficient = np.asarray(pareto_front(frame, front), dtype=bool) @@ -351,6 +373,7 @@ def plot_means( *, by: str | None = None, names: Mapping[Any, str] | Callable[[Any], str] | None = None, + others: str | None = None, colors: Sequence[str] | Mapping[Any, str] = COLORS, legend: str | None = "best", ax: Any = None, @@ -359,7 +382,8 @@ def plot_means( Plots the mean of a metric over the feasible records of each value of a column (such as over the replicates of the designs of each number of satellites), with a band of one standard deviation about it, a line for - each value of a column `by` (if any). + each value of a column `by` (if any), and a line in gray of the records + without a value of `by` (`NaN`), named `others` (or "other"). Args: results (pandas.DataFrame): The results of a study (see `Study.run`). @@ -369,6 +393,8 @@ def plot_means( `None`. names (Mapping | Callable | None): The names of the values of `by` in the legend (by default, the values). + others (str | None): The name of the records without a value of `by` + in the legend ("other" if not given). colors (Sequence[str] | Mapping): The colors of the values of `by`, in order (or by value). legend (str | None): The location of the legend, or `None` for none. @@ -385,10 +411,13 @@ def plot_means( if by is None else [(value, results[results[by] == value]) for value in _groups(results[by])] ) + missing = None if by is None else results[results[by].isna()] + if missing is not None and len(missing) > 0: + groups.append((_OTHERS, missing)) for k, (value, group) in enumerate(groups): stats = group.groupby(x)[y].agg(["mean", "std"]).sort_index() spread = stats["std"].fillna(0.0) - color = _color(colors, value, k) + color = GRAY if value is _OTHERS else _color(colors, value, k) ax.fill_between( stats.index, stats["mean"] - spread, @@ -406,7 +435,11 @@ def plot_means( color=color, mec="white", mew=1.2, - label=None if value is None else _name(names, value), + label=( + None + if value is None + else (others or "other") if value is _OTHERS else _name(names, value) + ), ) ax.set(xlabel=x, ylabel=y) style_axes(ax) diff --git a/src/tatc/tradespace/references.py b/src/tatc/tradespace/references.py new file mode 100644 index 00000000..0a39d2c9 --- /dev/null +++ b/src/tatc/tradespace/references.py @@ -0,0 +1,62 @@ +""" +References to the values of designs, by which the parts of observation +studies (see `ObservationStudy`, `Observations`, `MissionPlan`, and +`Failures`) read them: a name (such as `"points_seed"` for `d.points_seed`, +or a path of `Design.flat`, such as `"layout.walker.planes"`), or a function +of the (realized) design (such as `lambda d: d.layout`). A string given +where a reference is expected is always a reference, never a value itself: +give a function that returns a string (or a number, where numbers are +references) to give a value:: + + MissionPlan(SCHEDULE, COST_MODEL, kind="field_of_regard") # d.field_of_regard + MissionPlan(SCHEDULE, COST_MODEL, kind=lambda d: "imager") # always "imager" + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +import numbers +from collections.abc import Callable +from typing import Any + +from .space import Design + +Reference = str | Callable[[Design], Any] +"""A reference to a value of a design: its name or path (see `Design.flat`), +or a function of the (realized) design that gives it (see `value_of`).""" + + +def value_of(design: Design, reference: Reference | None) -> Any: + """ + Gets a value of a design that a reference names: a string names a value + by its name or path (`design[reference]`, see `Values`: such as + `"layout.walker.planes"`, the path of a column of results, see + `Design.flat`, or of a group of values, such as `"cost_risk"`), a + function computes it from the design, and `None` is `None`. + + Args: + design (Design): The (realized) design. + reference (Reference | None): The reference: a string, a function, + or `None`. + + Returns: + Any: the value + + Raises: + KeyError: if the design has no value of a name or path. + """ + if reference is None: + return None + if callable(reference): + return reference(design) + if not isinstance(reference, str): + raise TypeError(f"a reference to a value of a design, not {reference!r}") + return design[reference] + + +def _number(design: Design, value: Any) -> Any: + """A number, or a value of a design that a reference names.""" + if isinstance(value, numbers.Real): + return value + return value_of(design, value) diff --git a/src/tatc/tradespace/refinement.py b/src/tatc/tradespace/refinement.py index bcab27fb..032b9f79 100644 --- a/src/tatc/tradespace/refinement.py +++ b/src/tatc/tradespace/refinement.py @@ -15,9 +15,9 @@ import pandas as pd from .criteria import Criteria, _as_criteria, _get_tolerances -from .pareto import pareto_probability from .space import Design, _designs from .study import Study +from .summary import pareto_probability @dataclass @@ -25,11 +25,17 @@ class Refinement: """ The outcome of an adaptive replication (see `refine`): as the outcomes of other steps of a trade study (see `Confirmation`, `Screening`, and - `Search`), its `results`, the `summary` of its designs, and the `designs` - themselves, for the next step:: + `Search`), its `results`, the `summary` of its designs, the `designs` it + selects for the next step, and its `criteria`:: refinement = refine(study, criteria, results) - confirmation = confirm(study, criteria, refinement.results) + confirmation = confirm(study, criteria, refinement.results, refinement.designs) + + The designs a refinement selects are those efficient by the criteria over + every replicate after its last round (`pareto` of its `summary`), which a + confirmation checks with new replicates (see `confirm`, which selects + them by default): designs whose efficiency is still uncertain may be + efficient by more replicates too (see `uncertain`). """ results: pd.DataFrame @@ -42,13 +48,27 @@ class Refinement: efficiency is `uncertain` (by the bounds of `refine`, or with fewer than its least replicates) and, if so, whether it is `indifferent` (its objectives are known to within the precision of their tolerances).""" + criteria: Criteria + """Criteria: The criteria of the refinement.""" history: pd.DataFrame = field(default_factory=pd.DataFrame) """pandas.DataFrame: For each round (`round`, from 0), the number of designs whose efficiency is uncertain (`uncertain`), of these, those that are indifferent (`indifferent`), the number to which replicates were added (`refined`), and the evaluations added (`evaluations`).""" designs: list[Design] = field(default_factory=list) - """list[Design]: The designs that could be refined.""" + """list[Design]: The designs efficient after the last round (`pareto` of + `summary`, in any group of the criteria's `by`), for the next step.""" + candidates: list[Design] = field(default_factory=list) + """list[Design]: The designs that could be refined (those given to + `refine`).""" + + @property + def evaluations(self) -> int: + """int: The number of evaluations added (a design in a replicate, in + each scenario of a study with scenarios), over every round.""" + if "evaluations" not in self.history: + return 0 + return int(self.history["evaluations"].sum()) @property def uncertain(self) -> pd.DataFrame: @@ -78,9 +98,9 @@ def _precise( not precise. """ precise = np.zeros(len(probability), dtype=bool) - if precision is None or not criteria.tolerance: + if precision is None or not criteria.tolerances: return precise - tolerances = _get_tolerances(criteria.objectives, criteria.tolerance) + tolerances = _get_tolerances(criteria.objectives, criteria.tolerances) precise[:] = True for i, name in enumerate(criteria.objectives): error = probability[f"{name} se"].to_numpy(dtype=float) @@ -147,6 +167,17 @@ def refine( lack a tolerance is never indifferent. A warning is given if designs remain uncertain (but not indifferent) without a tolerance. + Designs are judged by their feasible replicates (see `aggregate`): a + design has fewer than `min_replicates` if fewer of its replicates are + feasible, and `max_replicates` limits all of its replicates. Designs + without a feasible replicate are not refined (and a refinement of results + without a feasible record adds none). + + The refinement selects the designs efficient after its last round for + the next step (`Refinement.designs`, such as of `confirm`), and keeps + those that could be refined (`Refinement.candidates`) and the number of + evaluations it added (`Refinement.evaluations`). + Args: study (Study): The study that evaluates designs. criteria (Criteria | Mapping[str, str]): The criteria, or the @@ -157,17 +188,17 @@ def refine( `Study.run`), such as those of an enumeration or a search. designs (Sequence[Design | str] | pandas.DataFrame | None): The designs that may be refined (designs, their keys, or a data - frame of them, such as rows of a summary), or `None` for every - design of the results (rebuilt from them, see - `DesignSpace.designs_of`). + frame of them, such as rows of a summary, or the `designs` of + another step), or `None` for every design of the results + (rebuilt from them, see `DesignSpace.designs_of`). bounds (tuple[float, float]): The probabilities between which a design is uncertain. step (int | None): The replicates added to an uncertain design in a round, or `None` for the study's number of replicates. max_replicates (int | None): The most replicates of a design, if limited. - min_replicates (int): The fewest replicates with which a design's - efficiency can be settled. + min_replicates (int): The fewest feasible replicates with which a + design's efficiency can be settled. max_rounds (int): The most rounds. precision (float | None): The standard error of an objective, as a share of its tolerance, below which an uncertain design is @@ -180,8 +211,8 @@ def refine( seed (int): The seed of the bootstraps. Returns: - Refinement: the results, the final probabilities, the history, and - the designs + Refinement: the results, the final probabilities, the history, the + efficient designs, and the candidates """ criteria = _as_criteria(criteria) low, high = bounds @@ -250,18 +281,22 @@ def estimate(round_: int) -> pd.DataFrame: remaining = probability.loc[ probability["uncertain"] & ~probability["indifferent"], "design" ].nunique() - if remaining > 0 and not criteria.tolerance: + if remaining > 0 and not criteria.tolerances: warnings.warn( f"{remaining} designs remain uncertain: designs that differ by less " + "than replicates separate stay uncertain without a tolerance of " + "the objectives (see Criteria)", stacklevel=2, ) + efficient = probability.loc[probability["pareto"].astype(bool), "design"] + selected = [by_key.get(key, key) for key in pd.unique(efficient)] return Refinement( results=combined, summary=probability, + criteria=criteria, history=pd.DataFrame(history), - designs=refined, + designs=_designs(study.space, selected, combined), + candidates=refined, ) diff --git a/src/tatc/tradespace/scenarios.py b/src/tatc/tradespace/scenarios.py index a938299e..48964d2d 100644 --- a/src/tatc/tradespace/scenarios.py +++ b/src/tatc/tradespace/scenarios.py @@ -9,19 +9,13 @@ from __future__ import annotations import dataclasses -from collections.abc import Mapping +from collections.abc import Mapping, Sequence import numpy as np import pandas as pd -from .criteria import ( - Criteria, - _as_criteria, - _get_tolerances, - _signs, - _with_values, - aggregate, -) +from .criteria import Criteria, _as_criteria, _get_tolerances, _resolve, _signs +from .summary import _feasible_records, _value_columns, _with_values, aggregate def _scales(criteria: Criteria, scale: Mapping[str, float] | None) -> np.ndarray: @@ -34,7 +28,7 @@ def _scales(criteria: Criteria, scale: Mapping[str, float] | None) -> np.ndarray unknown = sorted(set(scale) - set(objectives)) if unknown: raise ValueError(f"scales of names that are not objectives: {unknown}") - absolute = _get_tolerances(criteria.objectives, criteria.tolerance)[0] + absolute = _get_tolerances(criteria.objectives, criteria.tolerances)[0] values = np.array( [ float(scale[name]) if name in scale else (absolute[i] or 1.0) @@ -46,28 +40,20 @@ def _scales(criteria: Criteria, scale: Mapping[str, float] | None) -> np.ndarray return values -def _same_in_every(table: pd.DataFrame) -> bool: - """Whether every row of a table has the same value in each of its columns - that has one.""" - values = table.to_numpy(dtype=float) - reference = pd.DataFrame(values).bfill(axis=1).to_numpy()[:, :1] - with np.errstate(invalid="ignore"): - same = np.isclose(values, reference, rtol=1e-12, atol=0.0) | np.isnan(values) - return bool(same.all()) - - def robustness( results: pd.DataFrame, criteria: Criteria | Mapping[str, str], *, - scenario: str = "scenario", scale: Mapping[str, float] | None = None, + design_columns: Sequence[str] | None = None, ) -> pd.DataFrame: """ Measures the robustness of designs across scenarios (see `Study`): how often each design is efficient, and how far it falls from the front of each scenario, from the results of a study in each scenario (judged by - the criteria in each scenario, see `aggregate` and `pareto_front`). + the criteria in each scenario, see `aggregate` and `pareto_front`). The + scenarios are the groups of the column of the criteria's `by` (by + default, `"scenario"`, as of a study with scenarios). * `pareto_trace`: the share of the scenarios in which the design is efficient (with the tolerances of the criteria, within which designs @@ -78,8 +64,9 @@ def robustness( objective (in units of its `scale`) that the design would need to match a design of the scenario's front (the additive epsilon indicator, as the fuzzy Pareto number of epoch-era analysis): 0 if it is efficient, - and infinite if it misses the requirements of the criteria (or is - infeasible in every replicate). With one objective, it is the + and infinite if it misses the requirements of the criteria, is + infeasible in every replicate, or has a missing objective (`NaN`, which + is not efficient, see `pareto_front`). With one objective, it is the difference from the best design. * `max_regret`: the largest regret of the design over the scenarios, which the most robust designs minimize (minimax regret). @@ -98,25 +85,29 @@ def robustness( results (pandas.DataFrame): The results of a study with scenarios (see `Study.run`). criteria (Criteria | Mapping[str, str]): The criteria, by which - designs are judged in each scenario (`by` none, or the scenario), - or the objectives (metrics whose means they are) and their - directions (`"min"` or `"max"`). - scenario (str): The column of the scenarios. + designs are judged in each scenario (`by` none, for the column + `"scenario"`, or the column of the scenarios), or the objectives + (metrics whose means they are) and their directions (`"min"` or + `"max"`). scale (Mapping[str, float] | None): The units of regret of objectives (by name): by default, the absolute tolerance of an objective (if it has one), or else 1 (its units). + design_columns (Sequence[str] | None): The columns of the values of + designs, or `None` for those that are the same in every feasible + record of a design (see `aggregate`). Returns: pandas.DataFrame: a row per design (`design`): the values of the design (as a summary keeps them, see `aggregate`), each objective - in each scenario (` `, or `` if - it is the same in every scenario, such as a number of - satellites), its `pareto_trace`, `max_regret`, and regret in each - scenario (` regret`) + in each scenario (` `), or once + (``) if it is a value of the designs (a column of + `design_columns`, such as a number of satellites), its + `pareto_trace`, `max_regret`, and regret in each scenario + (` regret`) Raises: ValueError: if the results have no scenarios, or the criteria group - records by other columns or combine them across scenarios (see + records by several columns or combine them across scenarios (see `Across`, by which searches find robust designs). """ criteria = _as_criteria(criteria) @@ -125,20 +116,22 @@ def robustness( "robustness judges designs in each scenario: give criteria without " + "`across`" ) - if criteria.by not in ((), (scenario,)): + if len(criteria.by) > 1: raise ValueError( - f"criteria judge designs by the scenario ({scenario!r}) alone: " - + f"give criteria without other columns `by`, not {list(criteria.by)}" + "robustness judges designs in each scenario: give criteria `by` the " + + f"column of the scenarios alone, not {list(criteria.by)}" ) + scenario = criteria.by[0] if criteria.by else "scenario" if scenario not in results.columns: raise ValueError( - f"the results have no column {scenario!r} of scenarios (see Study)" + f"the results have no column {scenario!r} of scenarios (see Study, " + + "or give the column as the criteria's `by`)" ) judged = dataclasses.replace(criteria, by=(scenario,)) objectives = list(criteria.objectives) # each objective in units of its scale, larger being better units = -_signs(criteria) / _scales(criteria, scale) - summary = aggregate(results, judged) + summary = aggregate(results, judged, design_columns=[]) efficient = summary["pareto"].to_numpy(dtype=bool) scenarios = list(pd.unique(results[scenario])) designs = list(pd.unique(results["design"])) @@ -156,32 +149,36 @@ def robustness( # largest shortfall over the objectives shortfall = values[front][None, :, :] - values[:, None, :] needed = np.maximum(shortfall.max(axis=2).min(axis=1), 0.0) + # a design with a missing objective is not efficient: infinite regret + needed = np.where(np.isnan(values).any(axis=1), np.inf, needed) meets = group["meets_requirements"].to_numpy(dtype=bool) regret.loc[keys, name] = np.where(front, 0.0, np.where(meets, needed, np.inf)) trace[keys[front]] += 1 - # the values of each design (of its first record, as of a summary) - judged_columns = { - "design", - scenario, - *judged.names, - "replicates", - "violation", - "meets_requirements", - "pareto", + # the values of the designs (of their first records, as of a summary), and + # the objectives that are values of the designs, which are the same in + # every scenario + statistics = _resolve(judged) + feasible, _ = _feasible_records(results) + every = _value_columns(feasible, {}, (scenario,), None, design_columns) + metrics = {column for s in statistics.values() for column in s.columns} + columns = [c for c in every if c not in metrics and c not in statistics] + collapsed = { + name + for name in objectives + if name in every and set(statistics[name].columns) <= set(every) } - values = [column for column in summary.columns if column not in judged_columns] frame = pd.DataFrame({"design": designs}) - _with_values(frame, results, designs, values) + _with_values(frame, results, designs, columns) for name in objectives: table = summary.pivot(index="design", columns=scenario, values=name) table = table.reindex(index=designs, columns=scenarios) - if _same_in_every(table): + if name in collapsed: frame[name] = table.bfill(axis=1).iloc[:, 0].to_numpy() else: for group in scenarios: frame[f"{group} {name}"] = table[group].to_numpy() frame["pareto_trace"] = (trace / max(len(scenarios), 1)).to_numpy() - frame["max_regret"] = regret.max(axis=1).to_numpy() + frame["max_regret"] = regret.max(axis=1, skipna=False).to_numpy() for name in scenarios: frame[f"{name} regret"] = regret[name].to_numpy() return frame diff --git a/src/tatc/tradespace/screening.py b/src/tatc/tradespace/screening.py index 2f64b4a6..1d9927e0 100644 --- a/src/tatc/tradespace/screening.py +++ b/src/tatc/tradespace/screening.py @@ -9,28 +9,43 @@ from __future__ import annotations import math +import numbers from collections.abc import Mapping, Sequence from dataclasses import dataclass, field import pandas as pd -from .criteria import Criteria, _as_criteria, aggregate +from .criteria import Criteria, _as_criteria from .pareto import pareto_ranks from .space import Design, _designs from .study import Study +from .summary import aggregate @dataclass class Screening: """ - The outcome of a screening (see `screen`): its `results`, the `summary` - of the designs of its last stage, and the `designs` themselves, as the - outcomes of other steps of a trade study (see `Refinement`). + The outcome of a screening (see `screen`): as the outcomes of other steps + of a trade study (see `Refinement`), its `results` and the `summary` of + its designs (those of its last stage, the analysis of the highest + fidelity), the `designs` it selects for the next step (those that + survive every stage), and its `criteria` (those of the last stage), + which refine and confirm its designs as for any study:: + + screening = screen([quick, full], criteria, designs, keep=0.1) + refinement = refine(full, criteria, screening.results, screening.designs) + + The results and summaries of every stage are kept as well (`history` and + `summaries`). """ results: pd.DataFrame - """pandas.DataFrame: The results of every stage (see `Study.run`), with - the `stage` (0 for the first).""" + """pandas.DataFrame: The results of the last stage (see `Study.run`).""" + criteria: Criteria + """Criteria: The criteria of the last stage.""" + history: pd.DataFrame = field(default_factory=pd.DataFrame) + """pandas.DataFrame: The results of every stage, with the `stage` (0 for + the first), such as for the cost of the screening.""" summaries: list[pd.DataFrame] = field(default_factory=list) """list[pandas.DataFrame]: For each stage, the summary of its designs (see `aggregate`, with whether each is efficient by the stage's @@ -38,7 +53,8 @@ class Screening: `pareto_ranks`), whether they were `kept` for the next stage, and the `stage`.""" designs: list[Design] = field(default_factory=list) - """list[Design]: The designs analyzed in the last stage.""" + """list[Design]: The designs that survive every stage (those the last + stage analyzes), for the next step.""" @property def summary(self) -> pd.DataFrame: @@ -57,6 +73,22 @@ def _per_stage(value, count: int, name: str) -> list: return [value] * count +def _check_keep(value) -> None: + """ + Checks a number of designs to keep (an integer of at least 1) or a share + of them (a float greater than 0 and at most 1). + """ + if isinstance(value, bool) or not isinstance(value, numbers.Real): + raise TypeError(f"keep must be a number or a share of designs, not {value!r}") + if isinstance(value, numbers.Integral): + if value < 1: + raise ValueError(f"a number of designs to keep must be at least 1: {value}") + elif not 0 < value <= 1: + raise ValueError( + f"a share of designs to keep must be greater than 0 and at most 1: {value}" + ) + + def screen( studies: Sequence[Study], criteria: Criteria | Mapping[str, str] | Sequence[Criteria | Mapping[str, str]], @@ -87,12 +119,18 @@ def screen( within which differences do not separate fronts (see `pareto_front`), so that nearly efficient designs are kept:: - cheap = Criteria(objectives, tolerance={"sufficient": 5.0}) + cheap = Criteria(objectives, tolerances={"sufficient": 5.0}) screening = screen([quick, full], [cheap, objectives], designs, keep=0.1) Compare the final front with one found without screening on a sample of designs to check that screening does not lose efficient designs. + The screening's `results` are those of its last stage, which the next + steps continue (such as `refine` and `confirm`), and its `designs` are + those that survive every stage (that the last stage analyzes); its + `history` gives the results of every stage (with the `stage`), such as + for the cost of the screening. + Args: studies (Sequence[Study]): The studies of each stage, in order of increasing fidelity. @@ -104,17 +142,21 @@ def screen( screen, or a data frame of their values (see `DesignSpace.designs_of`). keep (float | int | Sequence): The designs kept by each stage but the - last: a number (int), or a share of its feasible designs (float), - or a value for each stage. + last: a number (an int of at least 1), or a share of its feasible + designs (a float greater than 0 and at most 1), or a value for + each stage. Returns: - Screening: the results and summaries of each stage, and the designs - of the last + Screening: the results and summary of the last stage, the designs + that survive every stage, and the results and summaries of each + stage """ if len(studies) == 0: raise ValueError("at least one study is required") transitions = len(studies) - 1 keeps = _per_stage(keep, transitions, "keep") + for amount in keeps: + _check_keep(amount) if isinstance(criteria, (Criteria, Mapping)): stages = [_as_criteria(criteria)] * len(studies) else: @@ -128,20 +170,19 @@ def screen( + "give criteria without `by`" ) current = _designs(studies[0].space, designs) - screening = Screening(results=pd.DataFrame()) - frames = [] + frames, summaries = [], [] for stage, study in enumerate(studies): criteria = stages[stage] - results = study.run(current).assign(stage=stage) - frames.append(results) + results = study.run(current) + frames.append(results.assign(stage=stage)) summary = aggregate(results, criteria) summary["pareto_rank"] = pareto_ranks(summary, criteria) if stage < transitions: amount = keeps[stage] count = ( - math.ceil(amount * len(summary)) - if isinstance(amount, float) - else min(int(amount), len(summary)) + min(int(amount), len(summary)) + if isinstance(amount, numbers.Integral) + else math.ceil(amount * len(summary)) ) ranks = summary["pareto_rank"].sort_values(kind="stable") last = ranks.iloc[count - 1] if count > 0 else -1 @@ -150,7 +191,11 @@ def screen( current = [design for design in current if design.key in kept] else: summary["kept"] = True - screening.summaries.append(summary.assign(stage=stage)) - screening.results = pd.concat(frames, ignore_index=True) - screening.designs = current - return screening + summaries.append(summary.assign(stage=stage)) + return Screening( + results=results, + criteria=criteria, + history=pd.concat(frames, ignore_index=True), + summaries=summaries, + designs=current, + ) diff --git a/src/tatc/tradespace/sensitivity.py b/src/tatc/tradespace/sensitivity.py index f245955d..3ca5495f 100644 --- a/src/tatc/tradespace/sensitivity.py +++ b/src/tatc/tradespace/sensitivity.py @@ -13,7 +13,15 @@ import numpy as np import pandas as pd -from .criteria import _check_summary, _names +from .statistics import _names +from .summary import _check_summary + +_ONE_ROW = ( + "summarize the results of a study (a row per replicate) first, with a row " + + "per design (see aggregate), or select the rows of one group (such as those " + + "of a scenario)" +) +"""How to give designs a row each.""" def _levels(values: pd.Series, max_levels: int) -> pd.Series: @@ -48,7 +56,7 @@ def main_effects( pandas.DataFrame: a row per level: the `mean`, `std`, and `count` of the metric """ - _check_summary(summary) + _check_summary(summary, hint=_ONE_ROW) active = summary.dropna(subset=[variable, metric]) levels = _levels(active[variable], max_levels) return active.groupby(levels, sort=True)[metric].agg(["mean", "std", "count"]) @@ -104,7 +112,7 @@ def sensitivity( variance it explains, and the share of designs in which it is `active`, sorted by the share of the first metric """ - _check_summary(summary) + _check_summary(summary, hint=_ONE_ROW) variables, metrics = _names(variables), _names(metrics) rows = [] for variable in variables: diff --git a/src/tatc/tradespace/simulation.py b/src/tatc/tradespace/simulation.py index d6f2687e..d0158f90 100644 --- a/src/tatc/tradespace/simulation.py +++ b/src/tatc/tradespace/simulation.py @@ -10,7 +10,6 @@ from __future__ import annotations -import bisect import heapq import itertools import math @@ -21,7 +20,7 @@ import numpy as np -from .events import Launch, Production +from .events import Launch, _Manifest from .failures import FailureModel, RestorationPolicy from .mission import Decision, Failure, MissionHistory, Restoration @@ -122,16 +121,15 @@ class _Simulation: def __init__( self, deployment: Deployment, - failures: FailureModel, + model: FailureModel, policy: RestorationPolicy, seed: int | Sequence[int] | None, uniforms: Callable[[tuple, int], np.ndarray] | None = None, stress: float = 1.0, launch_stress: float = 1.0, ): - self.deployment, self.failures, self.policy = deployment, failures, policy + self.deployment, self.model, self.policy = deployment, model, policy self.draws = _Draws(seed, uniforms, stress, launch_stress) - self.schedule = deployment.schedule self.end = deployment.end self.history = MissionHistory( deployment, production=list(deployment.production) @@ -146,7 +144,9 @@ def __init__( self.spares = dict.fromkeys(range(len(deployment.planes)), 0) self.spares_since: dict[int, float] = {} self.ground: dict[Any, int] = {} - self.line = { + # the production lines (free after the deployment's production) and + # the launches booked, shared with the plan's routine + lines = { kind: max( ( b.end @@ -157,7 +157,15 @@ def __init__( ) for kind, developed in deployment.development.items() } - self.booked = sorted(launch.time for launch in deployment.launches) + self.manifest = _Manifest( + deployment.schedule, + deployment.planes, + deployment.masses, + deployment.plane_values, + lines, + sorted(launch.time for launch in deployment.launches), + self.history.production, + ) self.open: dict[int, list[_Booking]] = {} self.launches_of_plane: dict[int, int] = {} self.decided: dict[int, float] = {} @@ -167,17 +175,17 @@ def __init__( def _life( self, plane: int, position: int, generation: int, start: float = 0.0 ) -> float: - life = self.failures.life_of(self.deployment.planes[plane].kind) + life = self.model.life_of(self.deployment.planes[plane].kind) key = (0, plane, position, generation) return self.draws.life(life, key, self.end - start) def _launch_fails(self, *key: int) -> bool: - return self.draws.launch_fails(self.failures.launch, (1, *key)) + return self.draws.launch_fails(self.model.launch, (1, *key)) # --- events - def _push(self, time: float, kind: str, *payload: Any) -> None: - heapq.heappush(self.events, (time, next(self.counter), kind, payload)) + def _push(self, time: float, event: str, *payload: Any) -> None: + heapq.heappush(self.events, (time, next(self.counter), event, payload)) def run(self) -> MissionHistory: """Runs the simulation, returning the history of the mission.""" @@ -185,7 +193,7 @@ def run(self) -> MissionHistory: for kind in self.deployment.development: count = self.policy.ground_spares_of(kind) if count > 0: - ready = self._produce(self.line[kind], kind, count, "spare") + ready = self._produce(0.0, kind, count, "spare") self.ground.setdefault(kind, 0) self._push(ready, "stock", kind, count) for launch in self.deployment.launches: @@ -195,13 +203,13 @@ def run(self) -> MissionHistory: self._push(self.deployment.begin + time, "decide", index) steps = 0 while self.events: - time, _, kind, payload = heapq.heappop(self.events) + time, _, event, payload = heapq.heappop(self.events) if time >= self.end: break steps += 1 if steps > 1_000_000: raise RuntimeError("the simulation does not progress") - getattr(self, f"_on_{kind}")(time, *payload) + getattr(self, f"_on_{event}")(time, *payload) for (plane, position), slot in self.slots.items(): if slot.up is not None: self._close(plane, position, self.end) @@ -239,17 +247,11 @@ def _on_planned(self, time: float, launch: Launch) -> None: if slot.up is not None: self._close(launch.plane, position, time) self._up(time, launch.plane, position) + # the spares in orbit of a deployment (planned replacements carry + # none: spares in orbit do not age) spares = sum(position >= built for position in positions) if spares and not failed: - level = self.deployment.planes[launch.plane].spares - if launch.purpose == "deployment": - self._park(time, launch.plane, spares) - else: - self._park( - time, - launch.plane, - max(0, min(spares, level - self.spares[launch.plane])), - ) + self._park(time, launch.plane, spares) def _on_decide(self, time: float, index: int) -> None: if index in self.decided: @@ -406,32 +408,20 @@ def _park(self, time: float, plane: int, change: int) -> None: def _deploy(self, time: float, stage: Any) -> None: """ - Deploys the planes of a stage: produced after its lead time (on their + Deploys the planes of a stage, as a plan deploys the others (see + `DeploymentSchedule.plan`): produced after its lead time (on their type's line), launched at the next launch slots, and replaced at the end of their design life. """ + launches = [] for plane in stage.planes: kind, size, spares = self.deployment.planes[plane] - count = size + spares - if count == 0: + if size + spares == 0: continue - ready = self._produce(time + stage.lead_years, kind, count) - position = 0 - for carried in self.schedule.split( - count, self.deployment.masses.get(kind), self._plane(plane) - ): - at = self._slot(ready) - bisect.insort(self.booked, at) - launch = Launch(at, plane, kind, position, carried) - self._push(at, "planned", launch) - for production, replacement in self.schedule.replacements( - launch, self.end - ): - self.history.production.append(production) - if replacement is not None: - bisect.insort(self.booked, replacement.time) - self._push(replacement.time, "planned", replacement) - position += carried + ready = self._produce(time + stage.lead_years, kind, size + spares) + launches.extend(self.manifest.launch(plane, ready)) + for launch in launches + self.manifest.replace(launches, self.end): + self._push(launch.time, "planned", launch) def _produce( self, earliest: float, kind: Any, count: int, purpose: str = "deployment" @@ -440,24 +430,11 @@ def _produce( Produces satellites on their type's line, from a time (after the work before them), returning when they are ready. """ - begin = max(self.line[kind], earliest) - ready = begin + self.schedule.production_years(kind, count) - self.line[kind] = ready - self.history.production.append(Production(kind, begin, ready, count, purpose)) - return ready - - def _slot(self, ready: float) -> float: - """The earliest launch at or after a time (see `next_slot`).""" - return self.schedule.next_slot(self.booked, ready) - - def _plane(self, plane: int) -> tuple[int, Any]: - """The index and values of a plane (see `DeploymentSchedule`).""" - values = self.deployment.plane_values - return plane, values[plane] if plane < len(values) else None + return self.manifest.produce(earliest, kind, count, purpose) def _capacity(self, plane: int, kind: Any) -> float: - return self.schedule.per_launch( - self.deployment.masses.get(kind), self._plane(plane) + return self.deployment.schedule.per_launch( + self.deployment.masses.get(kind), self.manifest.plane(plane) ) def _book(self, plane: int, kind: Any, ready: float, item: tuple) -> None: @@ -468,10 +445,9 @@ def _book(self, plane: int, kind: Any, ready: float, item: tuple) -> None: ): booking.items.append(item) return - time = self._slot(ready + self.policy.batch_years) + time = self.manifest.slot(ready + self.policy.batch_years) order = self.launches_of_plane.get(plane, 0) self.launches_of_plane[plane] = order + 1 booking = _Booking(time, plane, kind, [item], order) self.open.setdefault(plane, []).append(booking) - bisect.insort(self.booked, time) self._push(time, "booking", booking) diff --git a/src/tatc/tradespace/space.py b/src/tatc/tradespace/space.py index 9707155a..16367c41 100644 --- a/src/tatc/tradespace/space.py +++ b/src/tatc/tradespace/space.py @@ -22,8 +22,7 @@ from __future__ import annotations -import math -import re +import numbers import zlib from collections.abc import Callable, Iterable, Iterator, Mapping, Sequence from functools import partial @@ -32,31 +31,30 @@ import numpy as np import pandas as pd -from .fingerprint import _Describer from .hashing import _canonical, _digest from .nodes import ( Choice, - Derived, Fixed, + Group, Infeasible, - Integer, - Node, - Repeat, Uncertain, - Variable, _as_node, _Domain, ) -from .values import ( - Scope, - Values, - _ChoiceValue, - _RepeatValue, +from .values import Scope, Values +from .walks import ( + _Context, + _decided, + _flatten, + _generic, + _leaf_paths, + _level_of, + _node_at, + _Odometer, + _unit_paths, + _walk, ) -_ABSENT = object() -"""Marker of a node that records no decision (fixed, derived, or uncertain).""" - _RESERVED_NAMES = { # names that the views of values give otherwise (see `Values`) "index", @@ -72,335 +70,17 @@ "key", "realize", "replicate", + "scenario", "space", + # columns of the results of a study (see `Study.run`) + "design", + "error", + "feasible", + "seconds", } """Names that cannot be given to the children of a design space, as the views -of the values of designs (and designs) give them otherwise.""" - - -# --------------------------------------------------------------------------- -# deciding designs -# --------------------------------------------------------------------------- - - -def _decision_key(decision: Any) -> str: - """ - Gets a canonical string of a decision. - """ - return _canonical(decision) - - -def _plain(value: Any) -> Any: - """ - Converts a numpy scalar to a plain Python value, for decisions. - """ - return value.item() if isinstance(value, np.generic) else value - - -class _Context: - """ - How a walk of a design space decides its nodes: `choose(path, domain)` - decides a variable, `draw(path, node)` draws an uncertain parameter (or - `None` for nominal values), `fix(path, node)` gives a fixed value (or - `None` for its value), and `check` enables constraints. If given, - `record(path, domain, value)` is called with every decision, chosen or - prescribed, and `normalize(path, domain, value)` gives the value of the - domain that a prescribed decision is (such as its level, see - `_level_of`). With an `odometer` (of an enumeration), the items of - unordered repetitions are only walked in the order of their levels. - """ - - def __init__( - self, - choose: Callable[[str, _Domain], Any] | None = None, - draw: Callable[[str, Uncertain], Any] | None = None, - check: bool = True, - record: Callable[[str, _Domain, Any], None] | None = None, - odometer: _Odometer | None = None, - fix: Callable[[str, Fixed], Any] | None = None, - normalize: Callable[[str, _Domain, Any], Any] | None = None, - ): - # pylint: disable=too-many-arguments,too-many-positional-arguments - self.choose, self.draw, self.check = choose, draw, check - self.fix, self.normalize = fix, normalize - self.record, self.odometer = record, odometer - - def decide(self, path: str, domain: _Domain, prescribed: Any) -> Any: - """ - Decides a value of a domain: the prescribed value (normalized, if - the walk normalizes them), or a chosen one. - """ - if prescribed is _ABSENT: - value = _plain(_choose(self, path, domain)) - elif self.normalize is not None: - value = self.normalize(path, domain, prescribed) - else: - value = prescribed - if self.record is not None: - self.record(path, domain, value) - return value - - -class _Unsorted(Infeasible): - """ - Raised while enumerating a walk whose unordered items are not in the - order of their levels: another walk gives the same design. - """ - - -def _join(path: str, name: str) -> str: - return f"{path}.{name}" if path else name - - -_ITEM_INDEX = re.compile(r"\[\d+\]") - - -def _generic(path: str) -> str: - """ - Gets the path of a node with `[*]` for the index of any item of a - repetition (as of `DesignSpace.uncertain_paths`). - """ - return _ITEM_INDEX.sub("[*]", path) - - -def _walk( - node: Node, - path: str, - scope: Scope, - ctx: _Context, - prescribed: Any = _ABSENT, - publish: Callable[[Any], None] | None = None, -) -> tuple[Any, Any]: - """ - Decides a node: returns its value and its decision (the values of its - design variables, or `_ABSENT` if it has none). A prescribed decision is - followed instead of choosing. A container publishes its (partial) value - as soon as it is created, so that its contents are visible to the - callables of later nodes within it. - """ - if isinstance(node, Variable): - if prescribed is not _ABSENT and ctx.record is None and ctx.normalize is None: - return prescribed, prescribed - value = ctx.decide(path, node.domain(scope), prescribed) - return value, value - if isinstance(node, Fixed): - return (node.value if ctx.fix is None else ctx.fix(path, node)), _ABSENT - if isinstance(node, Derived): - return node.function(scope), _ABSENT - if isinstance(node, Uncertain): - return (node.nominal if ctx.draw is None else ctx.draw(path, node)), _ABSENT - if isinstance(node, DesignSpace): - return _walk_group(node, path, scope, ctx, prescribed, publish) - if isinstance(node, Choice): - return _walk_choice(node, path, scope, ctx, prescribed, publish) - if isinstance(node, Repeat): - return _walk_repeat(node, path, scope, ctx, prescribed, publish) - raise TypeError(f"unknown node {node!r} at {path or 'the root'}") - - -def _choose(ctx: _Context, path: str, domain: _Domain) -> Any: - """ - Chooses a value of a domain, if the walk can choose. - """ - if ctx.choose is None: - raise ValueError(f"no decision for {path}") - return ctx.choose(path, domain) - - -def _walk_group( - node: DesignSpace, - path: str, - scope: Scope, - ctx: _Context, - prescribed: Any, - publish: Callable[[Any], None] | None, -) -> tuple[dict, dict]: - """ - Decides the children of a design space in order, then checks its - constraints (see `_walk`). - """ - values: dict = {} - if publish is not None: - publish(values) - inner = scope.push(values) - decisions = {} - for name, child in node.children.items(): - value, decision = _walk( - child, - _join(path, name), - inner, - ctx, - _ABSENT if prescribed is _ABSENT else prescribed.get(name, _ABSENT), - partial(values.__setitem__, name), - ) - values[name] = value - if decision is not _ABSENT: - decisions[name] = decision - if ctx.check: - for i, constraint in enumerate(node.constraints): - violation = _get_violation(constraint(inner)) - if violation > 0: - label = getattr(constraint, "__name__", "") - raise Infeasible( - f"constraint {i} ({label}) of {path or 'the design space'} " - + "is not satisfied", - violation, - ) - return values, decisions - - -def _get_violation(result: Any) -> float: - """ - Gets the violation of a constraint from its result: a boolean (`True` if - satisfied, a violation of 1 otherwise) or a number (satisfied if it is - not positive, its value is the violation otherwise). - """ - if isinstance(result, (bool, np.bool_)): - return 0.0 if result else 1.0 - return float(result) - - -def _walk_choice( - node: Choice, - path: str, - scope: Scope, - ctx: _Context, - prescribed: Any, - publish: Callable[[Any], None] | None, -) -> tuple[_ChoiceValue, list]: - """ - Decides the branch of a choice, then the branch (see `_walk`). - """ - choice = _ABSENT if prescribed is _ABSENT else prescribed[0] - name = ctx.decide(path, _Domain(levels=list(node.branches)), choice) - sub = None if prescribed is _ABSENT else prescribed[1] - result = _ChoiceValue(name) - if publish is not None: - publish(result) - result.value, decision = _walk( - node.branches[name], - _join(path, name), - scope, - ctx, - _ABSENT if sub is None else sub, - partial(setattr, result, "value"), - ) - return result, [name, None if decision is _ABSENT else decision] - - -def _walk_items( - node: Repeat, - path: str, - scope: Scope, - ctx: _Context, - count: int, - prescribed: Any, - publish: Callable[[Any], None] | None, -) -> tuple[_RepeatValue, list]: - """ - Decides the items of a repetition (see `_walk_repeat`). - """ - result = _RepeatValue(count) - if publish is not None: - publish(result) - decisions = [] - # with an odometer, permutations of unordered items give the same design: - # enumerate only the first, whose items are in the order of their levels - odometer = ctx.odometer if prescribed is _ABSENT and not node.ordered else None - previous: list[int] | None = None - for k in range(count): - sub = _ABSENT if prescribed is _ABSENT else prescribed[k] - start = 0 if odometer is None else odometer.position - if odometer is not None and previous is not None: - odometer.floors.append((start, previous)) - try: - value, decision = _walk( - node.item, - f"{path}[{k}]", - scope.push({}, k), - ctx, - _ABSENT if sub is None else sub, - result.items.append, - ) - finally: - if odometer is not None and previous is not None: - odometer.floors.pop() - if len(result.items) == k: - # a value that is not a container is not published - result.items.append(value) - decisions.append(None if decision is _ABSENT else decision) - if odometer is not None: - previous = odometer.indices[start : odometer.position] - return result, decisions - - -def _walk_repeat( - node: Repeat, - path: str, - scope: Scope, - ctx: _Context, - prescribed: Any, - publish: Callable[[Any], None] | None, -) -> tuple[_RepeatValue, list]: - """ - Decides the count of a repetition, then its items, which are sorted by - their decisions and decided again in that order if they are unordered - (see `_walk`). - """ - if isinstance(node.count, Variable): - count = int( - ctx.decide( - _join(path, "count"), - node.count.domain(scope), - _ABSENT if prescribed is _ABSENT else len(prescribed), - ) - ) - elif isinstance(node.count, Fixed): - count = int(node.count.value) - elif isinstance(node.count, Derived): - count = int(node.count.function(scope)) - else: - count = int(node.count) - if count < 0: - raise Infeasible(f"the count of {path} is negative ({count})") - if prescribed is not _ABSENT and len(prescribed) != count: - raise ValueError( - f"{len(prescribed)} items are given for {path}, whose count is {count}" - ) - result, decisions = _walk_items(node, path, scope, ctx, count, prescribed, publish) - if not node.ordered: - canonical = sorted(decisions, key=_decision_key) - if canonical != decisions: - result, decisions = _walk_items( - node, path, scope, ctx, count, canonical, publish - ) - return result, decisions - - -def _flatten(node: Node, value: Any, path: str, out: dict) -> None: - """ - Flattens the values of a node into `out`, by path: the chosen branch of - a choice at its path (and its values under the branch's name), the count - of a repetition at `.count` (also of a fixed count) and its items - at `[k]`, and the other values (except fixed values) at their - paths. - """ - if isinstance(node, Fixed): - return - if isinstance(node, DesignSpace): - for name, child in node.children.items(): - _flatten(child, value[name], _join(path, name), out) - elif isinstance(node, Choice): - out[path] = value.choice - _flatten( - node.branches[value.choice], value.value, _join(path, value.choice), out - ) - elif isinstance(node, Repeat): - out[_join(path, "count")] = value.count - for k, item in enumerate(value.items): - _flatten(node.item, item, f"{path}[{k}]", out) - else: - out[path] = value +of the values of designs (and designs) give them otherwise, or as the columns +of the results of a study that are not values of designs.""" # --------------------------------------------------------------------------- @@ -422,17 +102,33 @@ def __init__( decisions: dict, values: dict, replicate: int | None = None, - scenario: str = "", + scenario: str | None = None, ): - self.space, self.decisions, self.replicate = space, decisions, replicate + # pylint: disable=too-many-arguments,too-many-positional-arguments + self.space, self.replicate = space, replicate + self.decisions = decisions + """dict: The decisions of the design, as the design space declares + them: those of a group are a mapping of the decisions of its + children, by name (omitting those without decisions: fixed, + derived, and uncertain values); that of a design variable is its + value; that of a choice is a list of the name of its branch and the + decisions of the branch (`None` if it has none), such as + `["walker", {"planes": 3}]`; and that of a repetition is a list of + the decisions of its items (`None` for an item without decisions), + as many as its count, whose unordered items are in the order of the + levels of their decisions (see `Repeat`).""" self._values = values self._scenario = scenario - """str: A description of the values of the scenario of a realized - design (see `realize`), `""` without one.""" - self.key = _digest(_decision_key(decisions), 12) + self.key = _digest(_canonical(decisions), 12) """str: An identifier of the design, from its decisions only (not from its derived values or uncertain parameters).""" + @property + def scenario(self) -> str | None: + """str | None: The name of the scenario in which the design is + realized (see `realize`), or `None` if it is not realized in one.""" + return self._scenario + @property def values(self) -> Values: """Values: the values of the design.""" @@ -479,17 +175,19 @@ def flat(self) -> dict[str, Any]: def realize( self, replicate: int, + *, seed: int = 0, - common: bool = True, + common_random_numbers: bool = True, shift: Mapping[str, int] | None = None, - scenario: Mapping[str, Any] | None = None, + overrides: Mapping[str, Any] | None = None, + scenario: str | None = None, ) -> Design: """ Realizes a replicate of the design: draws its uncertain parameters (and computes the values derived from them). Each uncertain parameter is drawn from a random number generator - seeded by `seed`, `replicate`, and its path, so that with `common` + seeded by `seed`, `replicate`, and its path, so that with common random numbers, a parameter at the same path (such as the phase of the first orbit plane) takes the same value in the same replicate of every design. Comparisons between designs then measure the @@ -506,42 +204,51 @@ def realize( named parameters only, which measures their effects on the outcomes of a design (see `attribute_variance`). - A `scenario` gives fixed values and uncertain parameters other values - (by their paths, with `[*]` for the index of any item of a - repetition, as of `DesignSpace.uncertain_paths`): a condition under - which designs are compared, such as a requirement, rather than - averaged over (see `Study`). Values derived from them are derived - from the scenario's, and an uncertain parameter that it gives is not - drawn. + The `overrides` of a scenario give fixed values and uncertain + parameters other values (by their paths, with `[*]` for the index of + any item of a repetition, as of `DesignSpace.uncertain_paths`): a + condition under which designs are compared, such as a requirement, + rather than averaged over (see `Study`). Values derived from them are + derived from the overrides, an uncertain parameter that they give is + not drawn, and the constraints of the design space are checked + again, as the overrides may change what they depend on. The realized + design is of the scenario named `scenario` (see `Design.scenario`). Args: replicate (int): The replicate. - seed (int): The seed of the trade study. - common (bool): `True` to use common random numbers between - designs. + seed (int): The seed of the trade study (a non-negative integer). + common_random_numbers (bool): `True` to use common random numbers + between designs. shift (Mapping[str, int] | None): The offsets of the replicates as in which the named uncertain parameters are drawn, if any. - scenario (Mapping[str, Any] | None): The values of fixed values - and uncertain parameters of a scenario (by path), if any. + overrides (Mapping[str, Any] | None): The values of fixed values + and uncertain parameters in a scenario (by path), if any. + scenario (str | None): The name of the scenario of the overrides, + if any. Returns: Design: the realized design Raises: - ValueError: if `shift` names a path that is not of an uncertain - parameter of the design space, or `scenario` one that is not - of a fixed value or an uncertain parameter. - """ + Infeasible: if the design violates a constraint with the + overrides. + ValueError: if `seed` is negative, `shift` names a path that is + not of an uncertain parameter of the design space, or + `overrides` one that is not of a fixed value or an uncertain + parameter. + """ + # pylint: disable=too-many-arguments + _check_seed(seed) shift = dict(shift or {}) - _check_uncertain(self.space, shift) - scenario = dict(scenario or {}) - _check_scenario(self.space, scenario) - tail = [] if common else [int(self.key, 16)] + self.space.check_uncertain(shift) + overrides = dict(overrides or {}) + self.space.check_overrides(overrides) + tail = [] if common_random_numbers else [int(self.key, 16)] def draw(path: str, node: Uncertain) -> Any: name = _generic(path) - if name in scenario: - return scenario[name] + if name in overrides: + return overrides[name] drawn_in = replicate + int(shift.get(name, 0)) rng = np.random.default_rng( [seed, drawn_in, *tail, zlib.crc32(path.encode())] @@ -549,78 +256,34 @@ def draw(path: str, node: Uncertain) -> Any: return node.sampler(rng) def fix(path: str, node: Fixed) -> Any: - return scenario.get(_generic(path), node.value) + return overrides.get(_generic(path), node.value) - ctx = _Context(draw=draw, check=False, fix=fix if scenario else None) - values, _ = _walk(self.space, "", Scope(), ctx, self.decisions) - return Design( - self.space, - self.decisions, - values, - replicate, - _describe_scenario(scenario), + ctx = _Context( + draw=draw, + check=bool(overrides), + fix=fix if overrides else None, + canonical=True, ) + values, _ = _walk(self.space, "", Scope(), ctx, self.decisions) + return Design(self.space, self.decisions, values, replicate, scenario) def __repr__(self) -> str: replicate = "" if self.replicate is None else f", replicate={self.replicate}" - return f"Design({self.key}{replicate}: {self.flat()})" + scenario = "" if self._scenario is None else f", scenario={self._scenario!r}" + return f"Design({self.key}{replicate}{scenario}: {self.flat()})" -class _Odometer: +def _check_seed(seed: Any) -> None: """ - Chooses the levels of the variables of successive walks in the order of - an odometer whose digits are the decisions of a walk, so that walks - enumerate every combination of levels, including those of variables - whose existence or domain depends on earlier decisions. + Checks that a seed of uncertain parameters is a non-negative integer (as + numpy's generators require), raising a `ValueError` if not. """ - - def __init__(self): - self.indices: list[int] = [] - self.sizes: list[int] = [] - self.position = 0 - self.floors: list[tuple[int, list[int]]] = [] - """The levels of the previous unordered items (and where the - current items' levels start), which the current items must not - precede.""" - - def choose(self, path: str, domain: _Domain) -> Any: - """ - Chooses the level of the current digit of the odometer (adding a - digit, at the first level, if the walk is longer than before), and - stops a walk whose unordered items precede the previous ones. - """ - if domain.levels is None: - raise ValueError( - f"{path} is continuous: give it a step to enumerate the design space" - ) - if len(domain.levels) == 0: - raise Infeasible(f"{path} has no levels") - if self.position == len(self.indices): - self.indices.append(0) - self.sizes.append(len(domain.levels)) - level = domain.levels[self.indices[self.position]] - self.position += 1 - for start, previous in self.floors: - current = self.indices[start : self.position] - if current < previous[: len(current)]: - raise _Unsorted() - return level - - def advance(self) -> bool: - """ - Advances to the next combination after a walk, returning `False` - after the last. - """ - del self.indices[self.position :], self.sizes[self.position :] - self.position = 0 - self.floors.clear() - while self.indices: - if self.indices[-1] + 1 < self.sizes[-1]: - self.indices[-1] += 1 - return True - self.indices.pop() - self.sizes.pop() - return False + if ( + isinstance(seed, (bool, np.bool_)) + or not isinstance(seed, numbers.Integral) + or seed < 0 + ): + raise ValueError(f"the seed must be a non-negative integer, not {seed!r}") def _lhs_column(n: int, rng: np.random.Generator) -> np.ndarray: @@ -631,11 +294,15 @@ def _lhs_column(n: int, rng: np.random.Generator) -> np.ndarray: return (rng.permutation(n) + rng.random(n)) / n -class DesignSpace(Node): +class DesignSpace(Group): """ A group of nodes: the root of a design space, or a group within it (such as the design of each orbit plane). Children are given by name, in the - order they are decided; plain values are fixed values. + order they are decided; plain values are fixed values. Children may not + be named as the attributes of designs and of the views of their values + (such as `key`, `values`, or `index`), nor as the columns of the results + of a study that are not values of designs (`design`, `replicate`, + `scenario`, `feasible`, `error`, and `seconds`). Constraints are callables of the group's values (and those of enclosing groups), checked once the group's values are decided, that return @@ -674,14 +341,20 @@ def design( self, decisions: Mapping | Design | None = None, /, **overrides: Any ) -> Design: """ - Gets the design of given decisions (see `Design.decisions`), or of the - decisions of another design (such as of a design space this one - extends, see `extend`), with the decisions of some children replaced - (by name: a value, the decisions of a group or a choice, or a design - of their own space), checking its constraints:: + Gets the design of given decisions (see `Design.decisions` for their + shapes), or of the decisions of another design (such as of a design + space this one extends, see `extend`), with the decisions of some + children replaced (by name: a value, the decisions of a group or a + choice, or a design of their own space), checking its constraints:: space = base.extend(policy=policy_space(orbit_spares=Integer(0, 1))) design = space.design(base_design, policy=policy_design) + sso = space.design(base_design, layout="sso") + + A choice may also be given the name of its branch alone, here and in + the decisions: the branch's decisions are then those given (of a + replaced child that chose the same branch) or, otherwise, the first + levels of its variables (and the lower bounds of continuous ones). Args: decisions (Mapping | Design | None): The decisions, or a design @@ -703,9 +376,18 @@ def design( if unknown: raise ValueError(f"no children {unknown} of the design space") for name, decision in overrides.items(): - merged[name] = ( - decision.decisions if isinstance(decision, Design) else decision - ) + if isinstance(decision, Design): + decision = decision.decisions + given = merged.get(name) + if ( + isinstance(self.children[name], Choice) + and isinstance(decision, str) + and isinstance(given, (list, tuple)) + and len(given) == 2 + and given[0] == decision + ): + continue # the branch, with the decisions given of it + merged[name] = decision values, merged = _walk(self, "", Scope(), _Context(normalize=_level_of), merged) return Design(self, merged, values) @@ -845,6 +527,7 @@ def size(self) -> int: def sample( self, n: int, + *, method: str = "lhs", seed: int = 0, max_tries: int = 1000, @@ -930,6 +613,51 @@ def uncertain_paths(self) -> list[str]: """ return _leaf_paths(self, "", Uncertain) + def check_uncertain(self, paths: Iterable[str]) -> None: + """ + Checks that paths are of uncertain parameters of the design space (as + of `uncertain_paths`, with `[*]` for the index of any item of a + repetition), such as those of a shift (see `Design.realize`). + + Args: + paths (Iterable[str]): The paths. + + Raises: + ValueError: if a path is not of an uncertain parameter. + """ + unknown = [p for p in paths if not isinstance(_node_at(self, p), Uncertain)] + if unknown: + raise ValueError( + "not uncertain parameters of the design space: " + + f"{sorted(unknown, key=str)} (it has {self.uncertain_paths()})" + ) + + def check_overrides(self, overrides: Iterable[str]) -> None: + """ + Checks that the paths of the overrides of a scenario (see + `Design.realize`) are of fixed values or uncertain parameters of the + design space (with `[*]` for the index of any item of a repetition). + + Args: + overrides (Iterable[str]): The overrides (a mapping by path), or + their paths. + + Raises: + ValueError: if a path is not of a fixed value or an uncertain + parameter. + """ + unknown = [ + p + for p in overrides + if not isinstance(_node_at(self, p), (Fixed, Uncertain)) + ] + if unknown: + known = [*_leaf_paths(self, "", Fixed), *self.uncertain_paths()] + raise ValueError( + "not fixed values or uncertain parameters of the design space: " + + f"{sorted(unknown, key=str)} (it has {known})" + ) + def decode(self, unit: Sequence[float]) -> Design: """ Decodes a design from a point of the unit hypercube (a value in @@ -974,7 +702,8 @@ def encode(self, design: Design) -> np.ndarray: def record(path: str, domain: _Domain, value: Any) -> None: unit[index[path]] = domain.to_unit(value) - _walk(self, "", Scope(), _Context(record=record), design.decisions) + ctx = _Context(record=record, canonical=True) + _walk(self, "", Scope(), ctx, design.decisions) return unit def suggest(self, trial: Any) -> Design: @@ -999,138 +728,6 @@ def suggest(self, trial: Any) -> Design: ) -def _unit_paths(node: Node, path: str) -> list[str]: - """ - Gets the paths of the decisions of a node (see `DesignSpace.unit_paths`). - """ - if isinstance(node, Variable): - return [path] - if isinstance(node, DesignSpace): - return [ - p - for name, child in node.children.items() - for p in _unit_paths(child, _join(path, name)) - ] - if isinstance(node, Choice): - return [path] + [ - p - for name, branch in node.branches.items() - for p in _unit_paths(branch, _join(path, name)) - ] - if isinstance(node, Repeat): - paths, largest = [], _largest_count(node.count, path) - if isinstance(node.count, Variable): - paths = [_join(path, "count")] - return paths + [ - p for k in range(largest) for p in _unit_paths(node.item, f"{path}[{k}]") - ] - return [] - - -def _largest_count(count: Any, path: str) -> int: - """ - Gets the largest count of a repetition (see `_unit_paths`), which must - not depend on other values. - """ - if isinstance(count, Integer) and not callable(count.high): - return int(count.high) - if isinstance(count, Variable) and not isinstance(count, Integer): - options = getattr(count, "options", None) - if options is not None and not callable(options): - return int(max(options)) - elif isinstance(count, Fixed): - return int(count.value) - elif isinstance(count, int): - return count - raise ValueError(f"the count of {path} needs a fixed upper bound to be encoded") - - -def _is_number(value: Any) -> bool: - """Whether a value is a number (not a boolean).""" - return isinstance(value, (int, float, np.number)) and not isinstance( - value, (bool, np.bool_) - ) - - -def _level_of(path: str, domain: _Domain, value: Any) -> Any: - """ - Gets the value of a domain that a decision is (see `DesignSpace.design` - and `DesignSpace.designs_of`): the level that equals it (whose type a - data frame may have changed, as integers in a column of floats, or that - is given as a numpy scalar), or the value (a float) in the range of a - continuous domain, raising a `ValueError` if there is none. - """ - if domain.levels is None: - try: - number = float(value) - except (TypeError, ValueError): - number = math.nan - if domain.low <= number <= domain.high: - return number - raise ValueError( - f"{value!r} is not in the range of {path} ({domain.low}, {domain.high})" - ) - for level in domain.levels: - try: - if level == value: - return _plain(level) - except (TypeError, ValueError): - continue - if _is_number(value): - for level in domain.levels: - if _is_number(level) and math.isclose( - float(level), float(value), rel_tol=1e-9, abs_tol=1e-12 - ): - return _plain(level) - raise ValueError(f"{value!r} is not a level of {path} ({domain.levels})") - - -def _leaf_paths(node: Node, path: str, kind: type) -> list[str]: - """ - Gets the paths of the leaves of a kind of a node (such as its fixed - values), with `[*]` for the index of any item of a repetition, and with - the branches of choices, whether a design chooses them or not. - """ - if isinstance(node, kind): - return [path] - if isinstance(node, DesignSpace): - return [ - p - for name, child in node.children.items() - for p in _leaf_paths(child, _join(path, name), kind) - ] - if isinstance(node, Choice): - return [ - p - for name, branch in node.branches.items() - for p in _leaf_paths(branch, _join(path, name), kind) - ] - if isinstance(node, Repeat): - return _leaf_paths(node.item, f"{path}[*]", kind) - return [] - - -def _missing(value: Any) -> bool: - """Whether a value of a data frame is missing (`None` or `NaN`).""" - return value is None or (isinstance(value, float) and math.isnan(value)) - - -def _decided(values: Mapping[str, Any], path: str, domain: _Domain) -> Any: - """ - Gets the decision of a path from values by path (such as a row of the - results of a study, see `DesignSpace.designs_of`): the level of the domain - that equals the value (whose type a data frame may have changed, as - integers in a column of floats), or the value of a continuous domain. - """ - value = values.get(path) - if _missing(value): - raise ValueError( - f"no value of {path}: rebuild designs from the results of a study, or " - + "from a summary that keeps the values of designs (see aggregate)" - ) - return _level_of(path, domain, value) - - def _design_items(designs: Iterable[Design | str] | pd.DataFrame) -> list[Design | str]: """ Gets designs given as designs, keys, or a data frame of designs (with @@ -1166,19 +763,24 @@ def _designs( *frames: pd.DataFrame, ) -> list[Design]: """ - Gets designs given as designs, keys, or a data frame of designs (with - their keys, `design`), each once, in order: designs given by their keys - are rebuilt from the values of the frame (if it has them) or of other - frames (such as the results of a study, see `DesignSpace.designs_of`). + Gets designs of a design space given as designs, keys, or a data frame + of designs (with their keys, `design`), each once, in order: designs of + other design spaces (such as of a design space that this one extends) + are the designs of this one of their decisions (see + `DesignSpace.design`), and designs given by their keys are rebuilt from + the values of the frame (if it has them) or of other frames (such as the + results of a study, see `DesignSpace.designs_of`). """ if isinstance(designs, pd.DataFrame): frames = (designs, *frames) found: dict[str, Design | None] = {} for item in _design_items(designs): if isinstance(item, Design): - found[item.key] = item + design = item if item.space is space else space.design(item) + found[design.key] = design else: found.setdefault(item, None) + error: ValueError | None = None for frame in frames: missing = [key for key, design in found.items() if design is None] if not missing: @@ -1186,65 +788,18 @@ def _designs( rows = frame.reset_index() if "design" not in frame else frame if "design" not in rows: continue - present = [key for key in missing if key in set(rows["design"])] + keys = set(rows["design"]) + present = [key for key in missing if key in keys] try: for design in space.designs_of(rows, present): found[design.key] = design - except ValueError: - continue # the frame lacks values of the designs: try the next + except ValueError as failure: + error = failure # the frame lacks values of the designs: try the next missing = [key for key, design in found.items() if design is None] if missing: raise ValueError( f"the values of designs {missing[:5]} are not given: give the designs, " + "or their keys with the results of a study (or a summary that keeps " + "the values of designs, see aggregate)" - ) + ) from error return [design for design in found.values() if design is not None] - - -def _check_scenario(space: DesignSpace, values: Mapping[str, Any]) -> None: - """ - Checks that the values of a scenario are of fixed values or uncertain - parameters of a design space (by path), raising a `ValueError` if not. - """ - if not values: - return - known = [*_leaf_paths(space, "", Fixed), *space.uncertain_paths()] - unknown = sorted(set(values) - set(known)) - if unknown: - raise ValueError( - "not fixed values or uncertain parameters of the design space: " - + f"{unknown} (it has {known})" - ) - - -def _describe_scenario(values: Mapping[str, Any]) -> str: - """ - Gets a description of the values of a scenario (`""` without values), - which identifies them (by their content, see `get_definition`). - """ - if not values: - return "" - described = _Describer().describe(dict(values)) - return _canonical(described) - - -def _scenario_of(design: Design) -> str: - """ - Gets the description of the values of the scenario of a realized design - (see `Design.realize`), `""` without one. - """ - return design._scenario # pylint: disable=protected-access - - -def _check_uncertain(space: DesignSpace, paths: Iterable[str]) -> None: - """ - Checks that paths are of uncertain parameters of a design space (see - `DesignSpace.uncertain_paths`), raising a `ValueError` if not. - """ - known = space.uncertain_paths() - unknown = sorted(set(paths) - set(known)) - if unknown: - raise ValueError( - f"not uncertain parameters of the design space: {unknown} (it has {known})" - ) diff --git a/src/tatc/tradespace/statistics.py b/src/tatc/tradespace/statistics.py new file mode 100644 index 00000000..88d14b18 --- /dev/null +++ b/src/tatc/tradespace/statistics.py @@ -0,0 +1,323 @@ +""" +Statistics of the metrics of designs over their replicates: such as a mean, +a standard deviation, a quantile, or the probability of meeting a threshold. + +The outcomes of a design are uncertain if its replicates differ (see +`Uncertain`), and a statistic over the replicates states how a design is +judged (see `Criteria`): by its mean, by a pessimistic quantile, or by how +reliably it meets a threshold. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +import operator as op +from collections.abc import Mapping, Sequence +from typing import Any + +import numpy as np + +_OPERATORS = {">=": op.ge, ">": op.gt, "<=": op.le, "<": op.lt} + + +def _names(value: str | Sequence[str]) -> list[str]: + """Gets names given as a name or a sequence of names.""" + return [value] if isinstance(value, str) else list(value) + + +def _is_derived(metric: Any) -> bool: + """ + Whether a metric is computed from others in each replicate (such as a + `Utility`): an object with the `columns` it needs and an `evaluate` + method of their values. + """ + return ( + not isinstance(metric, (str, Statistic)) + and hasattr(metric, "columns") + and callable(getattr(metric, "evaluate", None)) + ) + + +def _as_statistic(name: str, value: Any) -> Statistic: + """ + Gets a statistic given by name: a statistic, or the mean of a metric + given as a string or a metric computed from others (such as a + `Utility`). + """ + if isinstance(value, str) or _is_derived(value): + return Mean(value) + if not isinstance(value, Statistic): + raise TypeError(f"statistic {name!r} is not a Statistic") + return value + + +def _named_statistics(statistics: Any) -> dict[str, Statistic]: + """ + Gets statistics by name: of a mapping of names to statistics (or metrics, + whose means they are), or of a sequence of statistics (or metrics), named + by their conventional names (see `Statistic.name`). + """ + if statistics is None: + return {} + if isinstance(statistics, Mapping): + return {name: _as_statistic(name, value) for name, value in statistics.items()} + if isinstance(statistics, (str, Statistic)) or _is_derived(statistics): + statistics = [statistics] + named: dict[str, Statistic] = {} + for item in statistics: + statistic = _as_statistic(str(item), item) + if statistic.name in named and named[statistic.name] != statistic: + raise ValueError(f"statistics of the same name: {statistic.name!r}") + named[statistic.name] = statistic + return named + + +class Statistic: + """ + Base class of statistics of a metric over the replicates of each design: + a column of the results of a study, or a metric computed from others in + each replicate (such as a `Utility`, whose mean is the expected utility). + + The column `feasible` of the results is the feasibility of each replicate + (1 if it is feasible, 0 if not), whose statistics are over every + replicate of a design, feasible or not (its mean is the share of its + replicates that are feasible, see `aggregate`); the statistics of other + metrics are over the feasible replicates. + + Args: + column (str | Utility): The metric. + """ + + def __init__(self, column: Any): + self.column = column + + @property + def metric(self) -> str: + """str: The name of the statistic's metric: its column, or `"utility"` + of a metric computed from others.""" + return "utility" if _is_derived(self.column) else str(self.column) + + @property + def name(self) -> str: + """str: The conventional name of the statistic (the suffixes of which + are those of `summarize` and `summarize_histories`): such as `cost` + (a mean), `cost std`, `cost se`, `cost min`, `cost max`, `cost p70` + (a quantile), or `P(cost <= 150)`, by which criteria name the + statistics given without names.""" + return self.metric + + @property + def columns(self) -> tuple[str, ...]: + """tuple[str, ...]: The columns of the results that the statistic + needs: its metric, or those its metric is computed from.""" + if _is_derived(self.column): + return tuple(self.column.columns) + return (self.column,) + + def values_of(self, matrices: Mapping[str, np.ndarray]) -> np.ndarray: + """ + Gets the values of the statistic's metric in each replicate of each + design, from those of the columns of the results. + + Args: + matrices (Mapping[str, numpy.ndarray]): The values of each column + (shape (designs, replicates)). + + Returns: + numpy.ndarray: the values of the metric (shape (designs, + replicates)) + """ + if _is_derived(self.column): + values = {name: matrices[name] for name in self.columns} + return np.asarray(self.column.evaluate(values), dtype=float) + return matrices[self.column] + + def reduce(self, values: np.ndarray) -> np.ndarray: + """ + Computes the statistic of each design (row) from its values in its + replicates (columns), ignoring missing values (`NaN`). + + Args: + values (numpy.ndarray): The values (shape (designs, replicates)). + + Returns: + numpy.ndarray: the statistic of each design (`NaN` without values) + """ + raise NotImplementedError + + def __eq__(self, other: object) -> bool: + return type(self) is type(other) and vars(self) == vars(other) + + def __hash__(self) -> int: + return hash((type(self), tuple(sorted(vars(self).items())))) + + def __repr__(self) -> str: + return f"{type(self).__name__}({self.column!r})" + + +def _all_nan(values: np.ndarray) -> np.ndarray: + return np.all(np.isnan(values), axis=1) + + +def _nan_reduce(function, values: np.ndarray) -> np.ndarray: + """ + Applies a nan-aware reduction along replicates, giving `NaN` (without a + warning) for designs without values. + """ + result = np.full(values.shape[0], np.nan) + valid = ~_all_nan(values) + if np.any(valid): + result[valid] = function(values[valid], axis=1) + return result + + +class Mean(Statistic): + """ + The mean of a metric over the replicates. + """ + + def reduce(self, values: np.ndarray) -> np.ndarray: + return _nan_reduce(np.nanmean, values) + + +class StandardDeviation(Statistic): + """ + The (sample) standard deviation of a metric over the replicates, a + measure of how much a design's outcome depends on its uncertain + parameters (`NaN` with fewer than two replicates). + """ + + @property + def name(self) -> str: + return f"{self.metric} std" + + def reduce(self, values: np.ndarray) -> np.ndarray: + counts = np.sum(~np.isnan(values), axis=1) + result = np.full(values.shape[0], np.nan) + valid = counts > 1 + if np.any(valid): + result[valid] = np.nanstd(values[valid], axis=1, ddof=1) + return result + + +class StandardError(Statistic): + """ + The standard error of the mean of a metric over the replicates: its + standard deviation over the square root of the number of replicates, a + measure of the uncertainty of the mean (`NaN` with fewer than two + replicates). + """ + + @property + def name(self) -> str: + return f"{self.metric} se" + + def reduce(self, values: np.ndarray) -> np.ndarray: + counts = np.sum(~np.isnan(values), axis=1) + deviation = StandardDeviation(self.column).reduce(values) + return deviation / np.sqrt(np.maximum(counts, 1)) + + +class Minimum(Statistic): + """ + The least value of a metric over the replicates (the worst case of a + metric to maximize). + """ + + @property + def name(self) -> str: + return f"{self.metric} min" + + def reduce(self, values: np.ndarray) -> np.ndarray: + return _nan_reduce(np.nanmin, values) + + +class Maximum(Statistic): + """ + The greatest value of a metric over the replicates (the worst case of a + metric to minimize). + """ + + @property + def name(self) -> str: + return f"{self.metric} max" + + def reduce(self, values: np.ndarray) -> np.ndarray: + return _nan_reduce(np.nanmax, values) + + +class Quantile(Statistic): + """ + A quantile of a metric over the replicates: for example, the 0.1 + quantile of a metric to maximize is a value that the design exceeds in + 90% of the replicates (by linear interpolation between them). + + Args: + column (str | Utility): The metric. + q (float): The quantile, between 0 and 1. + """ + + def __init__(self, column: str, q: float): + super().__init__(column) + if not 0 <= q <= 1: + raise ValueError("q must be between 0 and 1") + self.q = q + + def reduce(self, values: np.ndarray) -> np.ndarray: + # numpy's nanquantile, vectorized: sort each row (missing values + # last), and interpolate linearly between the values around the + # quantile's position among each row's values + ordered = np.sort(values, axis=1) + counts = np.sum(~np.isnan(values), axis=1) + position = self.q * np.maximum(counts - 1, 0) + below = np.floor(position).astype(int) + above = np.minimum(below + 1, np.maximum(counts - 1, 0)) + rows = np.arange(len(values)) + weight = position - below + with np.errstate(invalid="ignore"): + result = (1 - weight) * ordered[rows, below] + weight * ordered[rows, above] + result[weight == 0] = ordered[rows, below][weight == 0] + result[counts == 0] = np.nan + return result + + @property + def name(self) -> str: + return f"{self.metric} p{100 * self.q:g}" + + def __repr__(self) -> str: + return f"Quantile({self.column!r}, {self.q!r})" + + +class Probability(Statistic): + """ + The probability that a metric meets a threshold: the share (0 to 1) of + the replicates in which it does, such as the reliability of a design. + + Args: + column (str | Utility): The metric. + operator (str): The comparison: `">="`, `">"`, `"<="`, or `"<"`. + threshold (float): The threshold. + """ + + def __init__(self, column: str, operator: str, threshold: float): + super().__init__(column) + if operator not in _OPERATORS: + raise ValueError(f"operator must be one of {list(_OPERATORS)}") + self.operator, self.threshold = operator, threshold + + def reduce(self, values: np.ndarray) -> np.ndarray: + valid = ~np.isnan(values) + with np.errstate(invalid="ignore"): + met = _OPERATORS[self.operator](values, self.threshold) & valid + counts = valid.sum(axis=1) + result = np.full(values.shape[0], np.nan) + result[counts > 0] = met.sum(axis=1)[counts > 0] / counts[counts > 0] + return result + + @property + def name(self) -> str: + return f"P({self.metric} {self.operator} {self.threshold:g})" + + def __repr__(self) -> str: + return f"Probability({self.column!r}, {self.operator!r}, {self.threshold!r})" diff --git a/src/tatc/tradespace/store.py b/src/tatc/tradespace/store.py index 6ef9a63a..7438a9ad 100644 --- a/src/tatc/tradespace/store.py +++ b/src/tatc/tradespace/store.py @@ -99,8 +99,13 @@ class ResultStore: """ A store of the records of the evaluations of a study (see `Study.run`), by the key of each design, its replicate, and the variant of the - replicate (`""`, or the parameters drawn as in other replicates, see - `Study.run`), in a SQLite database file. + replicate, in a SQLite database file. The variant of a plain replicate + is `""`; that of a replicate whose parameters are drawn as in other + replicates (see `Study.run`), or that is evaluated in a scenario (see + `Study`), names the shift and a hash of the overrides of the scenario + (by their content, not the scenario's name), so that the evaluations of + a scenario are those of any scenario of the same overrides, and a + scenario without overrides shares the evaluations of plain replicates. Records are also keyed by a `context`: a study gives its fingerprint (see `Study.fingerprint`), which changes with its seed, its use of @@ -278,19 +283,26 @@ def definition(self, context: str) -> dict | None: def contexts(self) -> dict[str, int]: """ - Gets the contexts of the namespace's stored evaluations, in the order - they were defined (see `define`; those not defined first). + Gets the contexts of the namespace: those of its stored evaluations + and of its kept definitions (see `define`, such as of a study whose + evaluations all failed), in the order they were defined (those not + defined first). Returns: - dict[str, int]: the number of evaluations of each context + dict[str, int]: the number of evaluations of each context (0 for + a definition without evaluations) """ with closing(self._connect()) as connection: rows = connection.execute( - "SELECT r.context, COUNT(*) FROM results AS r LEFT JOIN definitions " - + "AS d ON d.namespace = r.namespace AND d.context = r.context " - + "WHERE r.namespace = ? GROUP BY r.context " - + "ORDER BY MIN(d.defined), MIN(d.rowid), r.context", - [self.namespace], + "SELECT c.context, COALESCE(r.evaluations, 0) FROM " + + "(SELECT context FROM results WHERE namespace = ? UNION " + + "SELECT context FROM definitions WHERE namespace = ?) AS c " + + "LEFT JOIN (SELECT context, COUNT(*) AS evaluations FROM results " + + "WHERE namespace = ? GROUP BY context) AS r ON r.context = c.context " + + "LEFT JOIN definitions AS d ON d.namespace = ? " + + "AND d.context = c.context " + + "ORDER BY d.defined, d.rowid, c.context", + [self.namespace] * 4, ).fetchall() return dict(rows) @@ -301,8 +313,9 @@ def remove(self, contexts: str | Iterable[str]) -> int: """ Removes the stored records (and definitions) of contexts of the namespace, such as those of earlier definitions of a study (see - `Study.prune`, which removes those of the study with other code, and - not those of other studies that share the namespace). + `Study.prune`, which removes those of the study with other code, + also of definitions without records, and not those of other studies + that share the namespace). Args: contexts (str | Iterable[str]): The contexts. diff --git a/src/tatc/tradespace/study.py b/src/tatc/tradespace/study.py index a7fda149..27e593b5 100644 --- a/src/tatc/tradespace/study.py +++ b/src/tatc/tradespace/study.py @@ -11,7 +11,6 @@ import math import os import time -import warnings from collections.abc import Callable, Iterable, Mapping, Sequence from concurrent.futures import Executor, as_completed from typing import Any, NamedTuple @@ -19,17 +18,17 @@ import pandas as pd from pydantic import ValidationError -from .fingerprint import _fingerprint_of, _with_other_code, get_definition +from .alerts import _warn +from .fingerprint import ( + _Describer, + _fingerprint_of, + _warn_other_code, + _with_other_code, + get_definition, +) from .hashing import _canonical, _digest from .nodes import Infeasible -from .space import ( - Design, - DesignSpace, - _check_scenario, - _check_uncertain, - _describe_scenario, - _designs, -) +from .space import Design, DesignSpace, _check_seed, _designs from .store import ResultStore _STATUS_COLUMNS = ["design", "replicate", "feasible", "error", "seconds"] @@ -91,7 +90,12 @@ class Study: `build`, and evaluates the result with `evaluate`, which returns its outcomes: a mapping (or `pandas.Series`) of metrics, or a `pandas.DataFrame` of several records of metrics (such as one per - sensor), whose named index is kept as columns. An `evaluate` function + sensor), whose named index is kept as columns, and which must have at + least one record (an empty data frame raises a `ValueError`, whatever + `errors` is: give a record of no sensors, for example, with missing + metrics). Designs given of another design space (such as of a design + space that the study's extends) are evaluated as the designs of the + study's design space of their decisions. An `evaluate` function with a parameter named `design` is also given the realized design (with the uncertain parameters of the replicate), as for an evaluation that depends on values of the design other than those it builds:: @@ -127,14 +131,17 @@ def evaluate(satellites, design): A study may evaluate designs in `scenarios`: conditions under which designs are compared rather than averaged over (as uncertain parameters are), such as the requirements of a mission or the field it must sample. - A scenario gives fixed values or uncertain parameters of the design space - other values (by path, see `Design.realize`), which the functions read - from the design as any other value (so that they need not change), and - each design is evaluated in each scenario in each replicate (with the - same uncertain parameters in every scenario), recorded with the name of - its scenario (`scenario`, so that the design space may not have a value - of that name). Judge designs in each scenario with criteria `by` the - scenario (see `Criteria`), and across them with `robustness`. Scenarios + A scenario overrides fixed values or uncertain parameters of the design + space with other values (by path, see `Design.realize`), which the + functions read from the design as any other value (so that they need + not change), and each design is evaluated in each scenario in each + replicate (with the same uncertain parameters in every scenario), + recorded with the name of its scenario (`scenario`, which the realized + design also gives, see `Design.scenario`). A design that violates a + constraint of the design space with the values of a scenario is + recorded as infeasible in that scenario. Judge designs in each scenario + with criteria `by` the scenario (see `Criteria`), and across them with + `robustness`. Scenarios are not part of the study's fingerprint: the evaluations of each are stored by its values (as a variant of the replicates, see `ResultStore`), so that a scenario added later is evaluated alone, and @@ -162,7 +169,8 @@ def evaluate(satellites, design): (and of the realized design, if it has a parameter named `design`). replicates (int): The number of replicates of each design. - seed (int): The seed of the uncertain parameters. + seed (int): The seed of the uncertain parameters (a non-negative + integer). common_random_numbers (bool): `True` to draw the same uncertain parameters in the same replicate of every design (see `Design.realize`). @@ -186,8 +194,8 @@ def evaluate(satellites, design): evaluations of the same study with other code (of its functions, of TAT-C, or of Python), which are not reused. scenarios (Mapping[str, Mapping[str, Any]] | None): The scenarios - in which to evaluate designs, if any: the values of fixed values - and uncertain parameters of each (by path), by name. + in which to evaluate designs, if any: the overrides of fixed + values and uncertain parameters of each (by path), by name. """ def __init__( @@ -195,6 +203,7 @@ def __init__( space: DesignSpace, build: Callable[[Design], Any], evaluate: Callable[[Any], Any], + *, replicates: int = 1, seed: int = 0, common_random_numbers: bool = True, @@ -213,6 +222,7 @@ def __init__( raise ValueError("n_jobs must be positive or -1") if chunks_per_job < 1: raise ValueError("chunks_per_job must be at least 1") + _check_seed(seed) self.space, self.build, self.evaluate = space, build, evaluate self.replicates, self.seed = replicates, seed self.common_random_numbers = common_random_numbers @@ -240,12 +250,15 @@ def _evaluate( replicates, if shifted) in a case (a scenario, or none), returning its records. """ - realized = design.realize( - replicate, self.seed, self.common_random_numbers, shift, case.values - ) + # pylint: disable=too-many-return-statements,too-many-branches base: dict = {"design": design.key, "replicate": replicate} if case.name is not None: base["scenario"] = case.name + try: + realized = self._realized(design, replicate, shift, case) + except Infeasible as error: + # the scenario's values violate a constraint of the design + return [{**base, **design.flat(), "feasible": False, "error": str(error)}] base.update(realized.flat()) began = time.perf_counter() try: @@ -271,6 +284,12 @@ def _evaluate( return [self._failure(base, error)] base.update(feasible=True, seconds=time.perf_counter() - began) if isinstance(outcome, pd.DataFrame): + if len(outcome) == 0: + raise ValueError( + f"the evaluation of design {design.key} (replicate {replicate}) " + + "gives an empty data frame: give at least one record (such as " + + "of no sensors, with missing metrics)" + ) named = any(name is not None for name in outcome.index.names) frame = outcome.reset_index() if named else outcome records = frame.to_dict("records") @@ -336,12 +355,12 @@ def _run_chunk( def _cases(self, shift: Mapping[str, int]) -> list[_Case]: """ Gets the cases of a run: its scenarios (or none), and the variants of - their evaluations in a store. + their evaluations in a store, with a (normalized) shift. """ if not self.scenarios: return [_Case(None, {}, _variant_of(shift))] return [ - _Case(name, values, _variant_of(shift, _describe_scenario(values))) + _Case(name, values, _variant_of(shift, _describe_overrides(values))) for name, values in self.scenarios.items() ] @@ -405,9 +424,10 @@ def realize( ) -> Design: """ Realizes a replicate of a design as the study evaluates it (see - `Design.realize`): with the study's seed and common random numbers, - and in one of its scenarios (by name), if given, such as for analyses - of a design other than its metrics. + `Design.realize`): as a design of the study's design space (if it is + of another), with the study's seed and common random numbers, and in + one of its scenarios (by name), if given, such as for analyses of a + design other than its metrics. Args: design (Design): The design. @@ -420,6 +440,7 @@ def realize( Raises: KeyError: if the study has no scenario of the name. + Infeasible: if the design violates a constraint in the scenario. """ values = None if scenario is not None: @@ -429,8 +450,31 @@ def realize( + f"(it has {list(self.scenarios or {})})" ) values = self.scenarios[scenario] + (design,) = _designs(self.space, [design]) + return self._realized(design, replicate, None, _Case(scenario, values, "")) + + def _realized( + self, + design: Design, + replicate: int, + shift: Mapping[str, int] | None, + case: _Case, + ) -> Design: + """ + Realizes a replicate of a design (of the study's design space) as the + study evaluates it in a case (a scenario, or none), with parameters + drawn as in other replicates, if shifted. + + Raises: + Infeasible: if the design violates a constraint in the scenario. + """ return design.realize( - replicate, self.seed, self.common_random_numbers, None, values + replicate, + seed=self.seed, + common_random_numbers=self.common_random_numbers, + shift=shift, + overrides=case.values, + scenario=case.name, ) def _prepare( @@ -452,8 +496,8 @@ def definition(self) -> dict: its fingerprint hashes: its seed, its use of common random numbers, its design space (including fixed values and the distributions of uncertain parameters), its build and evaluation functions (their - code, the values they close over, and the plain values and functions - of their module they refer to), and the source of the modules of + code, the values they close over, and the globals they refer to, see + `tatc.tradespace.fingerprint`), and the source of the modules of TAT-C that these, and studies, depend on.""" return get_definition( study=Study, @@ -467,11 +511,21 @@ def definition(self) -> dict: @property def fingerprint(self) -> str: """str: A key of the definition of the study (see `definition`), which - changes if it does. It keys the records of a store (see - `ResultStore`); what it cannot describe (data that the functions read, - such as from files, and the code of installed modules other than - TAT-C's, see `get_definition`) must be identified by the store's - namespace.""" + changes if it does: if its seed or use of common random numbers + changes, or its design space, or the code of its functions, the + values they close over or take as defaults, or the globals they + refer to (plain values and their containers, models, data, and the + functions, classes, and objects of the study's own modules, which + are described by content or code, see `tatc.tradespace.fingerprint`), + or the source of the modules of TAT-C they depend on, or the version + of Python. It does not change with the study's scenarios (whose + evaluations a store keeps apart, see `ResultStore`), nor its other + settings (such as its number of replicates or workers). It keys the + records of a store (see `ResultStore`); what it cannot describe + (data that the functions read, such as from files, the code of + installed modules other than TAT-C's, and objects of installed + classes, which are described by type) must be identified by the + store's namespace.""" return _fingerprint_of(self.definition) def prune(self) -> int: @@ -489,7 +543,7 @@ def prune(self) -> int: return 0 definition = self.definition context = _fingerprint_of(definition) - return self.store.remove(_other_code(self.store, context, definition)) + return self.store.remove(_stale_contexts(self.store, context, definition)) @property def workers(self) -> int: @@ -546,10 +600,11 @@ def run( the `replicate` (and the `scenario`, with scenarios), the values of the design by path (see `Design.flat`), whether it is `feasible` (and the `error` if not), the time to build and - evaluate it (`seconds`), and the metrics. + evaluate it (`seconds`), and the metrics (the status columns + alone, without evaluations). """ shift = {name: int(offset) for name, offset in (shift or {}).items() if offset} - _check_uncertain(self.space, shift) + self.space.check_uncertain(shift) cases = self._cases(shift) unique = ( self.space.enumerate() if designs is None else _designs(self.space, designs) @@ -569,16 +624,23 @@ def run( context, results, tasks = self._stored(tasks, cases) if tasks: first = tasks[0] - self._prepare(first.design, first.replicate, shift, cases[first.case]) + try: + self._prepare(first.design, first.replicate, shift, cases[first.case]) + except Infeasible: + pass # infeasible in its scenario, which its evaluation records results.extend(self._execute(tasks, context, shift, cases, progress)) results.sort(key=lambda outcome: outcome[:3]) - frame = pd.DataFrame.from_records( - [ - _in_scenario(record, cases[case].name) - for _, case, _, records in results - for record in records - ] - ) + records = [ + _in_scenario(record, cases[case].name) + for _, case, _, records in results + for record in records + ] + if not records: + scenario = [] if self.scenarios is None else ["scenario"] + return pd.DataFrame( + columns=[*_STATUS_COLUMNS[:2], *scenario, *_STATUS_COLUMNS[2:]] + ) + frame = pd.DataFrame.from_records(records) _check_feasible(frame) return frame @@ -728,29 +790,34 @@ def _check_scenarios( return None if not isinstance(scenarios, Mapping): raise TypeError("scenarios must be a mapping of names to values") - if "scenario" in space.children: - raise ValueError( - "a design space with a value named 'scenario' cannot have scenarios, " - + "whose names the results give as `scenario`" - ) checked = {} for name, values in scenarios.items(): if not isinstance(name, str): raise TypeError(f"the name of a scenario must be a string, not {name!r}") if not isinstance(values, Mapping): raise TypeError(f"the values of scenario {name!r} must be a mapping") - _check_scenario(space, values) + space.check_overrides(values) checked[name] = dict(values) return checked -def _variant_of(shift: Mapping[str, int] | None, scenario: str = "") -> str: +def _describe_overrides(values: Mapping[str, Any]) -> str: + """ + Gets a description of the overrides of a scenario (`""` without values), + which identifies them (by their content, see `get_definition`). + """ + if not values: + return "" + return _canonical(_Describer().describe(dict(values))) + + +def _variant_of(shift: Mapping[str, int], scenario: str = "") -> str: """ Gets the variant of replicates in a store (see `ResultStore`): `""` for - plain replicates, or (as JSON) a hash of the description of the values of - a scenario (see `_describe_scenario`) and the shift of each parameter. + plain replicates, or (as JSON) a hash of the description of the overrides + of a scenario (see `_describe_overrides`) and the shift of each parameter + (normalized: offsets that are not zero, as integers, see `Study.run`). """ - shift = {name: int(offset) for name, offset in (shift or {}).items() if offset} parts: dict[str, Any] = {} if scenario: parts["scenario"] = _digest(scenario, 16) @@ -774,41 +841,43 @@ def _takes_design(function: Callable) -> bool: ) -def _other_code(store: ResultStore, context: str, definition: dict) -> list[str]: +def _stale_contexts( + store: ResultStore, context: str, definition: dict +) -> dict[str, int]: """ - Gets the contexts of a store's namespace whose evaluations are of the same - study with other code (its functions', TAT-C's, or Python's: the same - values but for the code of functions, see `_with_other_code`), the latest - first. + Gets the contexts of a store's namespace (and their numbers of + evaluations) of the same study with other code (its functions', TAT-C's, + or Python's: the same values but for the code of functions, see + `_with_other_code`), the latest first, including those whose definitions + are kept without evaluations. """ - others = [other for other in store.contexts() if other != context] - return [ - other - for other in reversed(others) - if _with_other_code(definition, [store.definition(other)]) is not None - ] + contexts = store.contexts() + others = {other: store.definition(other) for other in reversed(contexts)} + others.pop(context, None) + return {other: contexts[other] for other in _with_other_code(definition, others)} def _warn_other_definitions(store: ResultStore, context: str, definition: dict) -> None: """ Warns if a store has evaluations of its namespace by the same study with - other code (see `_other_code`), which a study does not reuse, with the - differences from the latest (see `compare_definitions`). Studies of other - values (such as other settings) share a namespace without a warning, as - their fingerprints keep their evaluations apart. + other code (see `_stale_contexts`), which a study does not reuse, with + the differences from the latest (see `compare_definitions`). Studies of + other values (such as other settings) share a namespace without a + warning, as their fingerprints keep their evaluations apart. """ - stale = _other_code(store, context, definition) + stale = { + other: count + for other, count in _stale_contexts(store, context, definition).items() + if count + } if not stale: return - contexts = store.contexts() - count = sum(contexts.get(other, 0) for other in stale) - differences = _with_other_code(definition, [store.definition(stale[0])]) - warnings.warn( - f"the store has {count} evaluations of namespace {store.namespace!r} by " - + "this study with other code, which are not reused (see " - + "Study.fingerprint; Study.prune removes them); the latest differs in: " - + "; ".join(differences or []), - stacklevel=3, + _warn_other_code( + f"the store has {sum(stale.values())} evaluations of namespace " + + f"{store.namespace!r} by this study", + "see Study.fingerprint; Study.prune removes them", + store.definition(next(iter(stale))), + definition, ) @@ -863,8 +932,7 @@ def _check_feasible(results: pd.DataFrame) -> None: if designs < 2: return errors = results["error"].value_counts() - warnings.warn( + _warn( f"none of the {designs} designs is feasible; the most common error " - + f"({errors.iloc[0]} of {len(results)} evaluations): {errors.index[0]}", - stacklevel=3, + + f"({errors.iloc[0]} of {len(results)} evaluations): {errors.index[0]}" ) diff --git a/src/tatc/tradespace/summary.py b/src/tatc/tradespace/summary.py new file mode 100644 index 00000000..a44bf6ff --- /dev/null +++ b/src/tatc/tradespace/summary.py @@ -0,0 +1,884 @@ +""" +Summaries of the results of trade studies: the statistics of each design over +its replicates (see `Statistic`), its judgment by criteria (see `Criteria`), +and the probability that it is efficient, given the uncertainty of its +replicates (by a bootstrap). + +Designs are judged by their feasible replicates: the statistics of a metric +are over the replicates in which a design is feasible, and the share of its +replicates that are feasible is the statistic `feasible` (over every +replicate of the design), which requirements may name. Designs without a +feasible replicate are infeasible, and are left out of summaries. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +from collections.abc import Iterator, Mapping, Sequence +from dataclasses import replace +from typing import Any + +import numpy as np +import pandas as pd + +from .criteria import ( + Across, + Criteria, + Requirement, + _as_criteria, + _combiners, + _costs_of, + _get_tolerances, + _resolve, + _violation_of, +) +from .dominance import _efficient +from .statistics import ( + Mean, + StandardDeviation, + StandardError, + Statistic, + _named_statistics, +) +from .study import _STATUS_COLUMNS + +_FEASIBLE = "feasible" +"""The statistic (and column of summaries) of the share of a design's +replicates that are feasible, and the column of the results of a study of +whether each record is feasible.""" + +_JUDGMENT = ("violation", "meets_requirements", "pareto") +"""The columns of the judgment of designs by criteria in their summaries (see +`aggregate`).""" + +_SEPARATE = ( + "give the columns that separate them as `by` (of the criteria), or combine " + + "their groups `across` (see Across)" +) +"""How to separate several records of an evaluation for criteria.""" + +_SUMMARIZE = ( + "summarize the results of a study (a row per replicate) first, with a row " + + "per design (see aggregate), or judge designs in groups (see Criteria's " + + "`by`)" +) +"""How to judge the results of a study (a row per replicate) by criteria.""" + + +def _resamples(count: int, n_resamples: int, seed: Any) -> np.ndarray: + """ + Gets the replicates of each resample of a bootstrap: a row per resample of + `count` replicates (their positions) drawn with replacement, from a seed + (or a random number generator, which draws them). + """ + if n_resamples < 2: + raise ValueError("n_resamples must be at least 2") + return np.random.default_rng(seed).integers(count, size=(n_resamples, count)) + + +def _bootstrap_error(sums: np.ndarray, squares: np.ndarray, n: int) -> np.ndarray: + """ + Gets the standard errors of statistics from the sums of their values (and + of their squares) over `n` resamples of a bootstrap: their standard + deviations over the resamples. + """ + mean = sums / n + return np.sqrt(np.maximum(squares - n * mean**2, 0.0) / max(n - 1, 1)) + + +def _feasible_records(results: pd.DataFrame) -> tuple[pd.DataFrame, pd.DataFrame]: + """ + Gets the feasible and the infeasible records of results (every record is + feasible without a column `feasible`). + """ + if _FEASIBLE not in results.columns: + return results, results.iloc[:0] + status = results[_FEASIBLE].astype(bool).to_numpy() + return results[status], results[~status] + + +def _groups(frame: pd.DataFrame, by: Sequence[str]) -> Iterator[tuple[tuple, Any]]: + """ + Iterates over the groups of a data frame by columns (or the frame, if + none): the values of the columns, and the positions of the group's rows. + """ + if not by: + yield (), np.arange(len(frame)) + return + missing = [column for column in by if column not in frame.columns] + if missing: + raise ValueError(f"no columns {missing} to group by") + for key, positions in frame.groupby(list(by), sort=False).indices.items(): + yield (key if isinstance(key, tuple) else (key,)), positions + + +def _check_summary( + summary: pd.DataFrame, by: Sequence[str] = (), hint: str = _SUMMARIZE +) -> None: + """ + Checks that a data frame is a summary of designs (a row per design, in + each group of the columns `by`), not the results of a study (a row per + replicate), which the functions of summaries would judge as if each + replicate were a design, raising a `ValueError` with a hint of what to do + if not. + """ + if "design" in summary.columns: + keys = summary[["design", *(c for c in by if c in summary.columns)]] + elif summary.index.name == "design" and not by: + keys = summary.index.to_frame() + else: + return + if keys.duplicated().any(): + raise ValueError(f"the data frame has several rows of a design: {hint}") + + +def _get_matrices( + group: pd.DataFrame, + columns: Sequence[str], + designs: pd.Index | None = None, + replicates: pd.Index | None = None, + hint: str = _SEPARATE, +) -> tuple[pd.Index, pd.Index, dict[str, np.ndarray]]: + """ + Gets the values of metrics of each design (rows) in each replicate + (columns) of the results of a group, which must have one record per + evaluation (a design in a replicate, or a `ValueError` with a hint of + how to separate them): of the designs and replicates of the group, or of + those given (`NaN` without a record). + """ + missing = [column for column in columns if column not in group.columns] + if missing: + raise ValueError(f"metrics that are not in the results: {missing}") + keys = ["design", "replicate"] + if group.duplicated(keys).any(): + candidates = [ + column + for column in group.columns + if column not in (*_STATUS_COLUMNS, *columns) + ] + counts = group.groupby(keys)[candidates].nunique(dropna=False).max() + varying = list(counts.index[counts > 1]) + raise ValueError( + "the results have several records of an evaluation (a design in a " + + f"replicate): {hint}" + + (f", such as {varying}" if varying else "") + ) + if designs is None: + designs = pd.Index(group["design"].drop_duplicates()) + if replicates is None: + replicates = pd.Index(sorted(group["replicate"].unique())) + matrices = {} + for column in columns: + table = group.pivot(index="design", columns="replicate", values=column) + matrices[column] = table.reindex(index=designs, columns=replicates).to_numpy( + dtype=float + ) + return designs, replicates, matrices + + +def _replicates_of(feasible: pd.DataFrame, infeasible: pd.DataFrame) -> pd.Index: + """Gets the replicates of feasible and infeasible records, in order.""" + return pd.Index(sorted({*feasible["replicate"], *infeasible["replicate"]})) + + +def _feasibility( + feasible: pd.DataFrame, + infeasible: pd.DataFrame, + designs: pd.Index, + replicates: pd.Index, +) -> np.ndarray: + """ + Gets the feasibility of each design (rows) in each replicate (columns): 1 + if it has feasible records, 0 if it has infeasible ones, and `NaN` if it + has none. + """ + matrix = np.full((len(designs), len(replicates)), np.nan) + for records, flag in ((infeasible, 0.0), (feasible, 1.0)): + rows = designs.get_indexer(records["design"]) + columns = replicates.get_indexer(records["replicate"]) + known = (rows >= 0) & (columns >= 0) + matrix[rows[known], columns[known]] = flag + return matrix + + +def _evaluate( + statistics: Mapping[str, Statistic], + requirements: Sequence[Requirement], + matrices: Mapping[str, np.ndarray], + columns: np.ndarray | None = None, +) -> tuple[dict[str, np.ndarray], np.ndarray]: + """ + Computes statistics (of the replicates `columns` of the matrices, or all) + and the total violation of the requirements of each design. + """ + values = {} + for name, statistic in statistics.items(): + matrix = statistic.values_of(matrices) + values[name] = statistic.reduce( + matrix if columns is None else matrix[:, columns] + ) + n = len(next(iter(matrices.values()))) if matrices else 0 + return values, _violation_of(values, requirements, n) + + +def _across_groups(results: pd.DataFrame, across: Across | None) -> list | None: + """ + Gets the groups of results (values of a column, in order) across which + criteria combine statistics, if any. + """ + if across is None: + return None + if across.column not in results.columns: + raise ValueError( + f"the results have no column {across.column!r} to combine across " + + "(such as the scenarios of a study, see Study)" + ) + return list(pd.unique(results[across.column])) + + +def _attributed( + infeasible: pd.DataFrame, by: Sequence[str], key: Sequence[Any] +) -> pd.DataFrame: + """ + Gets the infeasible records of a group of the columns `by` (of the values + `key`): those of its values, or without a value (such as a sensor, which + an infeasible evaluation does not give), which are of every group. + """ + if not by or infeasible.empty: + return infeasible + mask = np.ones(len(infeasible), dtype=bool) + for column, value in zip(by, key): + values = infeasible[column] + mask &= ((values == value) | values.isna()).to_numpy() + return infeasible[mask] + + +class _Statistics: + """ + The statistics of the designs of the feasible results of a group (of the + criteria's `by`), over every replicate or some of them (see `evaluate`), + from the values of their metrics in each replicate: in each group of a + column, combined across the groups (see `Across`), if any. Designs + without feasible results in every group are left out. + + The statistics of the feasibility of replicates (`feasible`, see + `aggregate`) are over the replicates of the feasible and infeasible + records of the designs, and, across groups, over those of every group + together (they are not combined). + + Args: + results (pandas.DataFrame): The feasible results of a group. + statistics (Mapping[str, Statistic]): The statistics, by name. + requirements (Sequence[Requirement]): The requirements. + across (Across | None): The rule that combines the groups of a + column, if any. + combiners (Mapping[str, str] | None): How each statistic is combined + (see `_combiners`), with a rule. + groups (Sequence | None): The groups of the column (of every result), + with a rule. + infeasible (pandas.DataFrame | None): The infeasible results of the + group, if any. + """ + + def __init__( + self, + results: pd.DataFrame, + statistics: Mapping[str, Statistic], + requirements: Sequence[Requirement] = (), + across: Across | None = None, + combiners: Mapping[str, str] | None = None, + groups: Sequence | None = None, + infeasible: pd.DataFrame | None = None, + ): + self.statistics, self.requirements = statistics, requirements + self.combiners = combiners + infeasible = results.iloc[:0] if infeasible is None else infeasible + columns = {c for statistic in statistics.values() for c in statistic.columns} + metrics = sorted(columns - {_FEASIBLE}) + # statistics of the feasibility alone are over every group together + self.pooled = { + name + for name, statistic in statistics.items() + if set(statistic.columns) == {_FEASIBLE} + } + if across is None: + self.designs = pd.Index(results["design"].drop_duplicates()) + infeasible = infeasible[infeasible["design"].isin(self.designs)] + self.replicates = _replicates_of(results, infeasible) + matrices = _get_matrices(results, metrics, self.designs, self.replicates)[2] + if _FEASIBLE in columns: + matrices[_FEASIBLE] = _feasibility( + results, infeasible, self.designs, self.replicates + ) + self.matrices = [matrices] + self.counts = ( + results.groupby("design")["replicate"] + .nunique() + .reindex(self.designs) + .to_numpy() + ) + return + combined = [name for name in statistics if name not in self.pooled] + self.weights = ( + across.weights_of(groups) + if any(combiners[name] == "mean" for name in combined) + else None + ) + parts = [ + results[(results[across.column] == group).to_numpy()] for group in groups + ] + complete = set.intersection(*(set(part["design"]) for part in parts)) + designs = results["design"].drop_duplicates() + self.designs = pd.Index(designs[designs.isin(complete)]) + infeasible = infeasible[infeasible["design"].isin(self.designs)] + self.replicates = _replicates_of(results, infeasible) + self.matrices = [] + for group, part in zip(groups, parts): + matrices = _get_matrices(part, metrics, self.designs, self.replicates)[2] + if _FEASIBLE in columns: + failed = infeasible[(infeasible[across.column] == group).to_numpy()] + matrices[_FEASIBLE] = _feasibility( + part, failed, self.designs, self.replicates + ) + self.matrices.append(matrices) + self.counts = ( + results.groupby(["design", across.column])["replicate"] + .nunique() + .groupby(level="design") + .min() + .reindex(self.designs) + .to_numpy() + ) + + def _pooled(self, statistic: Statistic, columns: np.ndarray | None) -> np.ndarray: + """ + Computes a statistic over the replicates (`columns`, or all) of every + group together. + """ + matrix = np.hstack([statistic.values_of(m) for m in self.matrices]) + if columns is not None: + n = len(self.replicates) + matrix = matrix[ + :, np.concatenate([columns + k * n for k in range(len(self.matrices))]) + ] + return statistic.reduce(matrix) + + def evaluate( + self, columns: np.ndarray | None = None + ) -> tuple[dict[str, np.ndarray], np.ndarray]: + """ + Computes the statistics of each design (of the replicates `columns` + of the matrices, or all) and the total violation of the requirements. + """ + if self.combiners is None: + return _evaluate( + self.statistics, self.requirements, self.matrices[0], columns + ) + combined = { + name: statistic + for name, statistic in self.statistics.items() + if name not in self.pooled + } + parts = [_evaluate(combined, (), m, columns)[0] for m in self.matrices] + values = {} + for name, statistic in self.statistics.items(): + if name in self.pooled: + values[name] = self._pooled(statistic, columns) + continue + stacked = np.vstack([part[name] for part in parts]) + how = self.combiners[name] + if how == "max": + values[name] = stacked.max(axis=0) + elif how == "min": + values[name] = stacked.min(axis=0) + else: + values[name] = self.weights @ stacked + return values, _violation_of(values, self.requirements, len(self.designs)) + + +def _design_columns(results: pd.DataFrame, excluded: set[str]) -> list[str]: + """ + Gets the columns of the values of designs: those (other than `excluded`) + that are the same in every record of each design. + """ + candidates = [column for column in results.columns if column not in excluded] + if not candidates or len(results) == 0: + return [] + constant = results.groupby("design")[candidates].nunique(dropna=False) + return [column for column in candidates if (constant[column] <= 1).all()] + + +def _value_columns( + feasible: pd.DataFrame, + statistics: Mapping[str, Statistic], + by: Sequence[str], + across: Across | None, + design_columns: Sequence[str] | None, +) -> list[str]: + """ + Gets the columns of the values of designs that a summary keeps: those + given, or those that are the same in every record of each design (but + the metrics of the statistics, the columns of groups, and status + columns). + """ + combined = [] if across is None else [across.column] + if design_columns is None: + metrics = { + column for statistic in statistics.values() for column in statistic.columns + } + design_columns = _design_columns( + feasible, {*_STATUS_COLUMNS, *metrics, *by, *combined} + ) + return [ + c for c in design_columns if c not in statistics and c not in (*by, *combined) + ] + + +def _with_values( + frame: pd.DataFrame, group: pd.DataFrame, designs: Any, columns: Sequence[str] +) -> None: + """ + Adds the values of designs (columns of the first record of each design of + a group of results) to the rows of a summary of the designs. + """ + first = group.drop_duplicates("design").set_index("design") + for column in columns: + frame[column] = first.loc[designs, column].to_numpy() + + +def _summary_groups( + results: pd.DataFrame, + statistics: Mapping[str, Statistic], + by: Sequence[str], + requirements: Sequence[Requirement] = (), + across: Across | None = None, + combiners: Mapping[str, str] | None = None, + design_columns: Sequence[str] | None = None, +) -> Iterator[tuple[pd.DataFrame, _Statistics]]: + """ + Iterates over the groups (of the columns `by`) of the feasible results of + a study, for summaries of their designs: a data frame of the designs of + each group (`design`, the values of `by`, and the values of the designs, + see `aggregate`), and their statistics (see `_Statistics`). Results + without a feasible record have no groups. + """ + feasible, infeasible = _feasible_records(results) + if feasible.empty: + return + groups = _across_groups(results, across) + columns = _value_columns(feasible, statistics, by, across, design_columns) + for key, positions in _groups(feasible, by): + group = feasible.iloc[positions] + failed = _attributed(infeasible, by, key) + table = _Statistics( + group, statistics, requirements, across, combiners, groups, failed + ) + frame = pd.DataFrame({"design": table.designs}) + for name, value in zip(by, key): + frame[name] = value + _with_values(frame, group, table.designs, columns) + yield frame, table + + +def _criteria_of( + criteria: Criteria | Mapping[str, str] | Sequence[str] | str, + statistics: Mapping[str, Statistic | str] | Sequence[str] | None, + by: Sequence[str] | str, +) -> tuple[Criteria | None, dict[str, Statistic], tuple[str, ...]]: + """ + Gets the criteria (if any) of the arguments of `aggregate`, the + statistics to compute (by name), and the columns that group records. + """ + by = (by,) if isinstance(by, str) else tuple(by) + extra = _named_statistics(statistics) + if isinstance(criteria, Mapping) and not set(criteria.values()) <= {"min", "max"}: + raise ValueError( + "a mapping of criteria gives the directions of objectives ('min' or " + + "'max'): give statistics by name as `statistics`" + ) + if isinstance(criteria, (Criteria, Mapping)): + if by and isinstance(criteria, Criteria): + raise ValueError( + "criteria group records by their own `by`: give it to the criteria" + ) + judged = _as_criteria(criteria) + if by: + judged = replace(judged, by=by) + if extra: + clashes = sorted( + name + for name in extra + if name in judged.names and judged.statistic(name) != extra[name] + ) + if clashes: + raise ValueError( + f"statistics that the criteria name otherwise: {clashes}" + ) + judged = replace(judged, statistics={**judged.statistics, **extra}) + return judged, _resolve(judged), judged.by + metrics = [criteria] if isinstance(criteria, str) else list(criteria) + resolved: dict[str, Statistic] = {name: Mean(name) for name in metrics} + resolved.update(extra) + if not resolved: + raise ValueError( + "give criteria, the metrics whose means to compute, or statistics" + ) + return None, resolved, by + + +def _with_feasibility(statistics: Mapping[str, Statistic]) -> dict[str, Statistic]: + """ + Gets statistics with the share of the replicates of each design that are + feasible (`feasible`), unless a statistic has the name. + """ + if _FEASIBLE in statistics: + return dict(statistics) + return {**statistics, _FEASIBLE: Mean(_FEASIBLE)} + + +def _judge( + frame: pd.DataFrame, + values: Mapping[str, np.ndarray], + violation: np.ndarray, + criteria: Criteria, +) -> None: + """ + Adds the judgment of designs by criteria to the rows of a summary of + them, from the values of their statistics and the violation of the + criteria's requirements: the `violation`, whether each design meets the + requirements (`meets_requirements`), and whether it is efficient among + those that do (`pareto`). + """ + meets = violation == 0 + tolerances = _get_tolerances(criteria.objectives, criteria.tolerances) + violations, requirements, efficient = _JUDGMENT + frame[violations] = violation + frame[requirements] = meets + frame[efficient] = _efficient(_costs_of(values, criteria), meets, tolerances) + + +def _assemble( + frame: pd.DataFrame, + table: _Statistics, + values: Mapping[str, np.ndarray], + violation: np.ndarray, + criteria: Criteria | None, + extra: Mapping[str, np.ndarray] | None = None, +) -> pd.DataFrame: + """ + Adds to the rows of the designs of a group (of `_summary_groups`) their + statistics, `extra` columns (if any), the number of their feasible + `replicates`, the share of their replicates that are feasible + (`feasible`), and their judgment by criteria (if any, see `_judge`). + """ + for name, value in values.items(): + if name != _FEASIBLE: + frame[name] = value + for name, value in (extra or {}).items(): + frame[name] = value + frame["replicates"] = table.counts + frame[_FEASIBLE] = values[_FEASIBLE] + if criteria is not None: + _judge(frame, values, violation, criteria) + return frame + + +def _summaries( + frames: Sequence[pd.DataFrame], + by: Sequence[str], + statistics: Mapping[str, Statistic], + criteria: Criteria | None, + extra: Sequence[str] = (), + after: Sequence[str] = (), +) -> pd.DataFrame: + """ + Gets a summary of the frames of its groups (see `_assemble`), or an empty + one of its columns (without the values of designs) if there are none, + such as of results without a feasible record: the statistics, `extra` + columns, `replicates`, `feasible`, the judgment (with criteria), and the + columns `after`. + """ + if frames: + return pd.concat(frames, ignore_index=True) + names = [name for name in statistics if name != _FEASIBLE] + dtypes = { + "design": object, + **{column: object for column in by}, + **{name: float for name in [*names, *extra]}, + "replicates": int, + _FEASIBLE: float, + } + if criteria is not None: + dtypes.update(zip(_JUDGMENT, (float, bool, bool))) + dtypes.update({column: float for column in after}) + return pd.DataFrame( + {column: pd.Series(dtype=dtype) for column, dtype in dtypes.items()} + ) + + +def aggregate( + results: pd.DataFrame, + criteria: Criteria | Mapping[str, str] | Sequence[str] | str = (), + *, + statistics: Mapping[str, Statistic | str] | Sequence | None = None, + by: Sequence[str] | str = (), + design_columns: Sequence[str] | None = None, +) -> pd.DataFrame: + """ + Aggregates the results of a study (see `Study.run`, a row per replicate) + into a summary of its designs (a row per design, and per group of the + columns `by`, such as a sensor): statistics over the feasible replicates + of each design, the number of these `replicates`, the share of its + replicates that are feasible (`feasible`), and the values of the design + (see `Design.flat`), from which `DesignSpace.designs_of` rebuilds the + designs. + + The statistics are those of criteria (see `Criteria`, or a mapping of + objectives to their directions, which are the means of the metrics of + their names), or the means of metrics (a list of their names), and other + `statistics`, by name (a statistic, or a metric given as a string, whose + mean it is), or a list of statistics (or metrics), named by their + conventional names (see `Statistic.name`):: + + aggregate(results, {"satellites": "min", "sufficient": "max"}) + aggregate(results, ["sufficient", "accurate"]) + aggregate(results, statistics=[Quantile("cost", 0.7)]) # cost p70 + aggregate(results, COST, statistics=["cost development"]) + + With criteria, the summary also gives the `violation` of their + requirements (the sum of the violations, see `Requirement`, 0 if the + design meets them all), whether the design meets them + (`meets_requirements`), and whether it is efficient among the designs + that do (`pareto`, see `pareto_front`, in each group of the criteria's + `by`; a design with a missing objective, `NaN`, is not). Criteria + `across` a column combine the statistics of each design across its + groups (see `Across`), of which `replicates` is the fewest of any group. + + Designs are judged by their feasible replicates. `feasible` is a + statistic over every replicate of a design (the mean of the feasibility + of each, 1 or 0, see `Statistic`), and across the groups of criteria + `across` a column, over the replicates of every group together, which + requirements may name: `Requirement("feasible", ">=", 1)` requires every + replicate to be feasible. In groups of columns `by` that infeasible + records lack (such as a sensor, which an infeasible evaluation does not + give), the infeasible replicates of a design count in each of its groups. + Designs without a feasible replicate (in a group) are infeasible, and are + left out: a summary of results without a feasible record is empty. + + The results must have one record per evaluation (a design in a + replicate) in each group (and in each group of the column of the + criteria's `across`). + + Args: + results (pandas.DataFrame): The results. + criteria (Criteria | Mapping[str, str] | Sequence[str] | str): The + criteria (or objectives and their directions), or the metrics + whose means to compute. + statistics (Mapping[str, Statistic | str] | Sequence | None): Other + statistics, by name, or a sequence of statistics (or metrics, + whose means they are), named by their conventional names. + by (Sequence[str] | str): The columns that group records of an + evaluation (those of the criteria, if they have any). + design_columns (Sequence[str] | None): The columns of the values of + designs, or `None` for those that are the same in every + replicate of a design (except the metrics). + + Returns: + pandas.DataFrame: a row per feasible design (and group) + """ + judged, resolved, by = _criteria_of(criteria, statistics, by) + statistics = _with_feasibility(resolved) + across, combiners, requirements = None, None, () + if judged is not None: + requirements, across = judged.requirements, judged.across + combiners = None if across is None else _combiners(judged) + frames = [ + _assemble(frame, table, *table.evaluate(), judged) + for frame, table in _summary_groups( + results, statistics, by, requirements, across, combiners, design_columns + ) + ] + return _summaries(frames, by, statistics, judged) + + +def summarize( + results: pd.DataFrame, + criteria: Criteria | Mapping[str, str] | Sequence[str] | str = (), + *, + statistics: Mapping[str, Statistic | str] | Sequence | None = None, + by: Sequence[str] | str = (), + design_columns: Sequence[str] | None = None, +) -> pd.DataFrame: + """ + Summarizes the feasible results of a study over their replicates (see + `aggregate`), with the spread of the means of metrics: for each design + (and each group of the columns `by`, such as a sensor), the statistics + of criteria (or the means of a list of metrics) and of other + `statistics`, the standard deviation (` std`) and standard error + (` se`) between replicates of each that is the mean of a metric + (a column, or a metric computed from others, such as a `Utility`), the + number of feasible replicates (`replicates`), the share of the replicates + that are feasible (`feasible`), and the values of the design. Of criteria + (or a mapping of objectives to their directions), the summary is theirs + (see `aggregate`: the violation of their requirements, and whether each + design is efficient, `pareto`):: + + summary = summarize(results, {"satellites": "min", "sufficient": "max"}) + front = summary[summary.pareto] + summarize(results, ACCURACY, statistics=["sufficient"]) # and its mean + + Args: + results (pandas.DataFrame): The results (see `Study.run`). + criteria (Criteria | Mapping[str, str] | Sequence[str] | str): The + criteria (or objectives and their directions), or the metrics + whose means to summarize. + statistics (Mapping[str, Statistic | str] | Sequence | None): Other + statistics (see `aggregate`). + by (Sequence[str] | str): Other columns that group records of an + evaluation (those of criteria, if they have any). + design_columns (Sequence[str] | None): The columns of the values of + designs, or `None` for those that are the same in every + replicate of a design (except the metrics). + + Returns: + pandas.DataFrame: the summary, a row per feasible design (and group) + """ + judged, resolved, by = _criteria_of(criteria, statistics, by) + summarized: dict[str, Statistic] = {} + spread: dict[str, Statistic] = {} + for name, statistic in resolved.items(): + summarized[name] = statistic + if type(statistic) is Mean and _FEASIBLE not in statistic.columns: + spread[f"{name} std"] = StandardDeviation(statistic.column) + spread[f"{name} se"] = StandardError(statistic.column) + summarized.update( + { + f"{name} std": spread[f"{name} std"], + f"{name} se": spread[f"{name} se"], + } + ) + if judged is None: + # each mean of a metric followed by its spread + return aggregate( + results, statistics=summarized, by=by, design_columns=design_columns + ) + return aggregate(results, judged, statistics=spread, design_columns=design_columns) + + +def pareto_probability( + results: pd.DataFrame, + criteria: Criteria | Mapping[str, str], + *, + n_resamples: int = 500, + seed: int = 0, + design_columns: Sequence[str] | None = None, +) -> pd.DataFrame: + """ + Estimates the probability that each design is Pareto-efficient by + criteria (and meets their requirements, if any), given the uncertainty + of its replicates, by a bootstrap: each resample draws replicates with + replacement, the same replicates for every design (which keeps the + correlation between designs of common random numbers, see + `Design.realize`), computes the statistics of each design over the drawn + replicates, and finds the front of the designs that meet the + requirements (in each group of the criteria's `by`). The probability is + the share of resamples in which a design is on that front. + + Designs that are efficient with a probability between 0 and 1 are those + whose efficiency the replicates do not settle: more replicates (see + `refine`) would settle it, unless designs differ by less than matters (as + near saturation), which a tolerance of the objectives settles: designs + within the tolerances of the front are efficient (see `pareto_front`). + With few replicates, the bootstrap has few distinct resamples and + understates the uncertainty. Designs may have different replicates (as + after `refine`): replicates are drawn from all of them, and each design's + statistics are those of its drawn replicates (or of all of its + replicates, if none is drawn). With criteria `across` the scenarios of a + study (see `Across`), a drawn replicate is drawn in every scenario, in + which it has the same uncertain parameters. + + Designs are judged by their feasible replicates, and the replicates in + which a design is infeasible are drawn too: the statistics of a resample + are those of its feasible replicates, and the share of its replicates + that are feasible (`feasible`, see `aggregate`) is that of the drawn + replicates. + + Args: + results (pandas.DataFrame): The results of a study (see + `Study.run`), with a record per replicate of each design (and + group of the criteria's `by`). + criteria (Criteria | Mapping[str, str]): The criteria, or the + objectives (metrics whose means they are) and their directions + (`"min"` or `"max"`). + n_resamples (int): The number of resamples (at least 2). + seed (int): The seed of the resamples. + design_columns (Sequence[str] | None): The columns of the values of + designs, or `None` for those that are the same in every + replicate of a design (see `aggregate`). + + Returns: + pandas.DataFrame: a row per feasible design (and group), empty + without one: the summary of the criteria over every replicate + (see `aggregate`: the values of the design, the statistics, the + standard error of each objective, ` se`, its standard + deviation over the resamples, the number of feasible + `replicates`, the share of the replicates that are `feasible`, + the `violation` of the requirements, whether the design meets + them, `meets_requirements`, and whether it is efficient among + those that do, `pareto`), the probability that it is efficient + (`pareto_probability`), and the probability that it meets the + requirements (`requirements_probability`) + """ + criteria = _as_criteria(criteria) + statistics = _with_feasibility(_resolve(criteria)) + tolerances = _get_tolerances(criteria.objectives, criteria.tolerances) + combiners = None if criteria.across is None else _combiners(criteria) + errors = [f"{name} se" for name in criteria.objectives] + rng = np.random.default_rng(seed) + frames = [] + for frame, table in _summary_groups( + results, + statistics, + criteria.by, + criteria.requirements, + criteria.across, + combiners, + design_columns, + ): + values, violation = table.evaluate() + counts = np.zeros(len(table.designs)) + met = np.zeros(len(table.designs)) + # the sums of the objectives (and of their squares) over the resamples + sums = {name: np.zeros(len(table.designs)) for name in criteria.objectives} + squares = {name: np.zeros(len(table.designs)) for name in criteria.objectives} + for drawn in _resamples(len(table.replicates), n_resamples, rng): + sample, sample_violation = table.evaluate(drawn) + # designs without a drawn replicate keep the statistics of all of theirs + for name in sample: + missing = np.isnan(sample[name]) & ~np.isnan(values[name]) + sample[name][missing] = values[name][missing] + missing = np.isnan(sample_violation) + sample_violation[missing] = violation[missing] + meets = sample_violation == 0 + counts += _efficient(_costs_of(sample, criteria), meets, tolerances) + met += meets + for name in criteria.objectives: + sums[name] += sample[name] + squares[name] += sample[name] ** 2 + bootstrap = { + error: _bootstrap_error(sums[name], squares[name], n_resamples) + for name, error in zip(criteria.objectives, errors) + } + _assemble(frame, table, values, violation, criteria, bootstrap) + frame["pareto_probability"] = counts / n_resamples + frame["requirements_probability"] = met / n_resamples + frames.append(frame) + return _summaries( + frames, + criteria.by, + statistics, + criteria, + extra=errors, + after=["pareto_probability", "requirements_probability"], + ) diff --git a/src/tatc/tradespace/values.py b/src/tatc/tradespace/values.py index 5c7037bc..a7057eae 100644 --- a/src/tatc/tradespace/values.py +++ b/src/tatc/tradespace/values.py @@ -350,17 +350,29 @@ def configure(base: Any, values: Any = None, **overrides: Any) -> Any: Args: base (Any): The dataclass instance, whose other fields are kept. - values (Any): The values of a design (a `Values` or `ChoiceValues` - view, or a mapping), or `None`. + values (Any): The values of a design (a `Design`, a `Values` or + `ChoiceValues` view, or a mapping), or `None`. **overrides (Any): Other values of fields. Returns: Any: a copy of `base` with the values of its fields + + Raises: + TypeError: if `base` is not a dataclass instance, or `values` are + not values of a design. """ if not dataclasses.is_dataclass(base) or isinstance(base, type): raise TypeError("configure requires a dataclass instance") if isinstance(values, ChoiceValues): values = values.value + elif values is not None and not isinstance(values, Mapping): + # a design (see `Design.values`), whose module imports this one + view = getattr(values, "values", None) + if not isinstance(view, Values): + raise TypeError( + f"configure requires the values of a design, not {values!r}" + ) + values = view names = {field.name for field in dataclasses.fields(base)} changes = {name: values[name] for name in (values or {}) if name in names} unknown = set(overrides) - names diff --git a/src/tatc/tradespace/walks.py b/src/tatc/tradespace/walks.py new file mode 100644 index 00000000..8cbe931c --- /dev/null +++ b/src/tatc/tradespace/walks.py @@ -0,0 +1,651 @@ +""" +Walks of design spaces: the decisions of the nodes of a design space in the +order they are declared, which decide designs (see `DesignSpace`), and the +paths of its nodes. + +A walk decides each node in turn: a design variable by a decision that is +prescribed (such as the decisions of a design) or chosen (by an enumeration, +a sample, or an optimizer), a fixed, derived, or uncertain value by its +value (or a value of a scenario, or a draw), a group by its children (then +its constraints), a choice by its branch (then the branch), and a repetition +by its count (then its items, sorted by the levels of their decisions if they +are unordered). + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +import copy +import math +import re +from collections.abc import Callable, Mapping +from functools import partial +from typing import Any + +import numpy as np + +from .nodes import ( + Choice, + Derived, + Fixed, + Group, + Infeasible, + Integer, + Node, + Repeat, + Uncertain, + Variable, + _Domain, +) +from .values import Scope, _ChoiceValue, _join, _RepeatValue + +_ABSENT = object() +"""Marker of a node that records no decision (fixed, derived, or uncertain), +or of a decision that is not prescribed.""" + +_FIRST = object() +"""Marker of a node whose decisions are their first levels (as of a branch +of a choice given by its name, see `DesignSpace.design`).""" + + +def _scalar(value: Any) -> Any: + """ + Converts a numpy scalar to a plain Python value, for decisions. + """ + return value.item() if isinstance(value, np.generic) else value + + +def _first_level(path: str, domain: _Domain) -> Any: + """ + Chooses the first level of a domain (or its lower bound). + """ + if domain.levels is not None and len(domain.levels) == 0: + raise Infeasible(f"{path} has no levels") + return domain.from_unit(0.0) + + +def _rank(domain: _Domain, value: Any) -> float: + """ + Gets the rank of a decision in its domain, by which unordered items are + sorted: the index of its level (or its value, if continuous). + """ + if domain.levels is None: + return float(value) + try: + return domain.levels.index(value) + except ValueError: + return len(domain.levels) + + +class _Context: + """ + How a walk of a design space decides its nodes: `choose(path, domain)` + decides a variable, `draw(path, node)` draws an uncertain parameter (or + `None` for nominal values), `fix(path, node)` gives a fixed value (or + `None` for its value), and `check` enables constraints. If given, + `record(path, domain, value)` is called with every decision, chosen or + prescribed, and `normalize(path, domain, value)` gives the value of the + domain that a prescribed decision is (such as its level, see + `_level_of`). With an `odometer` (of an enumeration), the items of + unordered repetitions are only walked in the order of their levels. A + walk of the decisions of a design (`canonical`), whose unordered items + are in order, does not sort them again. + """ + + # pylint: disable=too-many-instance-attributes + + def __init__( + self, + choose: Callable[[str, _Domain], Any] | None = None, + draw: Callable[[str, Uncertain], Any] | None = None, + check: bool = True, + record: Callable[[str, _Domain, Any], None] | None = None, + odometer: _Odometer | None = None, + fix: Callable[[str, Fixed], Any] | None = None, + normalize: Callable[[str, _Domain, Any], Any] | None = None, + canonical: bool = False, + ): + # pylint: disable=too-many-arguments,too-many-positional-arguments + self.choose, self.draw, self.check = choose, draw, check + self.fix, self.normalize = fix, normalize + self.record, self.odometer = record, odometer + self.canonical = canonical + self.ranks: list[list[float]] = [] + """The ranks of the decisions of the unordered items being walked + (the innermost last), by which they are sorted (see `_rank`).""" + + def decide(self, path: str, domain: _Domain, prescribed: Any) -> Any: + """ + Decides a value of a domain: the prescribed value (normalized, if + the walk normalizes them), or a chosen one. + """ + if prescribed is _ABSENT: + value = _scalar(_choose(self, path, domain)) + elif self.normalize is not None: + value = self.normalize(path, domain, prescribed) + else: + value = prescribed + if self.record is not None: + self.record(path, domain, value) + if self.ranks: + rank = _rank(domain, value) + for ranks in self.ranks: + ranks.append(rank) + return value + + def first(self) -> _Context: + """ + Gets this context, but choosing the first levels of the domains (see + `_FIRST`). + """ + other = copy.copy(self) + other.choose = _first_level + return other + + +class _Unsorted(Infeasible): + """ + Raised while enumerating a walk whose unordered items are not in the + order of their levels: another walk gives the same design. + """ + + +_ITEM_INDEX = re.compile(r"\[\d+\]") + + +def _generic(path: str) -> str: + """ + Gets the path of a node with `[*]` for the index of any item of a + repetition (as of `DesignSpace.uncertain_paths`). + """ + return _ITEM_INDEX.sub("[*]", path) + + +def _walk( + node: Node, + path: str, + scope: Scope, + ctx: _Context, + prescribed: Any = _ABSENT, + publish: Callable[[Any], None] | None = None, +) -> tuple[Any, Any]: + """ + Decides a node: returns its value and its decision (the values of its + design variables, or `_ABSENT` if it has none). A prescribed decision is + followed instead of choosing (or, if `_FIRST`, the first levels are). A + container publishes its (partial) value as soon as it is created, so + that its contents are visible to the callables of later nodes within it. + """ + if prescribed is _FIRST: + ctx, prescribed = ctx.first(), _ABSENT + if isinstance(node, Variable): + if ( + prescribed is not _ABSENT + and ctx.record is None + and ctx.normalize is None + and not ctx.ranks + ): + return prescribed, prescribed + value = ctx.decide(path, node.domain(scope), prescribed) + return value, value + if isinstance(node, Fixed): + return (node.value if ctx.fix is None else ctx.fix(path, node)), _ABSENT + if isinstance(node, Derived): + return node.function(scope), _ABSENT + if isinstance(node, Uncertain): + return (node.nominal if ctx.draw is None else ctx.draw(path, node)), _ABSENT + if isinstance(node, Group): + return _walk_group(node, path, scope, ctx, prescribed, publish) + if isinstance(node, Choice): + return _walk_choice(node, path, scope, ctx, prescribed, publish) + if isinstance(node, Repeat): + return _walk_repeat(node, path, scope, ctx, prescribed, publish) + raise TypeError(f"unknown node {node!r} at {path or 'the root'}") + + +def _choose(ctx: _Context, path: str, domain: _Domain) -> Any: + """ + Chooses a value of a domain, if the walk can choose. + """ + if ctx.choose is None: + raise ValueError(f"no decision for {path}") + return ctx.choose(path, domain) + + +def _walk_group( + node: Group, + path: str, + scope: Scope, + ctx: _Context, + prescribed: Any, + publish: Callable[[Any], None] | None, +) -> tuple[dict, dict]: + """ + Decides the children of a group in order, then checks its constraints + (see `_walk`). + """ + values: dict = {} + if publish is not None: + publish(values) + inner = scope.push(values) + decisions = {} + for name, child in node.children.items(): + value, decision = _walk( + child, + _join(path, name), + inner, + ctx, + _ABSENT if prescribed is _ABSENT else prescribed.get(name, _ABSENT), + partial(values.__setitem__, name), + ) + values[name] = value + if decision is not _ABSENT: + decisions[name] = decision + if ctx.check: + for i, constraint in enumerate(node.constraints): + violation = _get_violation(constraint(inner)) + if math.isnan(violation) or violation > 0: + label = getattr(constraint, "__name__", "") + raise Infeasible( + f"constraint {i} ({label}) of {path or 'the design space'} " + + ("is NaN" if math.isnan(violation) else "is not satisfied"), + 1.0 if math.isnan(violation) else violation, + ) + return values, decisions + + +def _get_violation(result: Any) -> float: + """ + Gets the violation of a constraint from its result: a boolean (`True` if + satisfied, a violation of 1 otherwise) or a number (satisfied if it is + not positive, its value is the violation otherwise, and `NaN`, which is + not satisfied, if it is `NaN`). + """ + if isinstance(result, (bool, np.bool_)): + return 0.0 if result else 1.0 + return float(result) + + +def _walk_choice( + node: Choice, + path: str, + scope: Scope, + ctx: _Context, + prescribed: Any, + publish: Callable[[Any], None] | None, +) -> tuple[_ChoiceValue, list]: + """ + Decides the branch of a choice, then the branch (see `_walk`). A branch + prescribed by its name alone is decided at its first levels. + """ + if prescribed is _ABSENT: + choice, sub = _ABSENT, _ABSENT + elif isinstance(prescribed, str): + choice, sub = prescribed, _FIRST + else: + choice = prescribed[0] + sub = _ABSENT if prescribed[1] is None else prescribed[1] + name = ctx.decide(path, _Domain(levels=list(node.branches)), choice) + result = _ChoiceValue(name) + if publish is not None: + publish(result) + result.value, decision = _walk( + node.branches[name], + _join(path, name), + scope, + ctx, + sub, + partial(setattr, result, "value"), + ) + return result, [name, None if decision is _ABSENT else decision] + + +def _walk_items( + node: Repeat, + path: str, + scope: Scope, + ctx: _Context, + count: int, + prescribed: Any, + publish: Callable[[Any], None] | None, + ranked: bool = False, +) -> tuple[_RepeatValue, list, list[list[float]]]: + """ + Decides the items of a repetition (see `_walk_repeat`), and the ranks of + their decisions, if `ranked` (see `_rank`). + """ + # pylint: disable=too-many-arguments,too-many-positional-arguments,too-many-locals + result = _RepeatValue(count) + if publish is not None: + publish(result) + decisions, ranks = [], [] + # with an odometer, permutations of unordered items give the same design: + # enumerate only the first, whose items are in the order of their levels + odometer = ctx.odometer if prescribed is _ABSENT and not node.ordered else None + previous: list[int] | None = None + for k in range(count): + sub = _ABSENT if prescribed is _ABSENT else prescribed[k] + start = 0 if odometer is None else odometer.position + if odometer is not None and previous is not None: + odometer.floors.append((start, previous)) + item_ranks: list[float] = [] + if ranked: + ctx.ranks.append(item_ranks) + try: + value, decision = _walk( + node.item, + _join(path, k), + scope.push({}, k), + ctx, + _ABSENT if sub is None else sub, + result.items.append, + ) + finally: + if odometer is not None and previous is not None: + odometer.floors.pop() + if ranked: + ctx.ranks.pop() + if len(result.items) == k: + # a value that is not a container is not published + result.items.append(value) + decisions.append(None if decision is _ABSENT else decision) + ranks.append(item_ranks) + if odometer is not None: + previous = odometer.indices[start : odometer.position] + return result, decisions, ranks + + +def _walk_repeat( + node: Repeat, + path: str, + scope: Scope, + ctx: _Context, + prescribed: Any, + publish: Callable[[Any], None] | None, +) -> tuple[_RepeatValue, list]: + """ + Decides the count of a repetition, then its items, which are sorted by + the levels of their decisions (in the order they are decided, see + `_rank`) and decided again in that order if they are unordered (see + `_walk`). + """ + if isinstance(node.count, Variable): + count = int( + ctx.decide( + _join(path, "count"), + node.count.domain(scope), + _ABSENT if prescribed is _ABSENT else len(prescribed), + ) + ) + elif isinstance(node.count, Fixed): + count = int(node.count.value) + elif isinstance(node.count, Derived): + count = int(node.count.function(scope)) + else: + count = int(node.count) + if count < 0: + raise Infeasible(f"the count of {path} is negative ({count})") + if prescribed is not _ABSENT and len(prescribed) != count: + raise ValueError( + f"{len(prescribed)} items are given for {path}, whose count is {count}" + ) + ranked = not node.ordered and not ctx.canonical + # the ranks of the enclosing unordered items, which take those of these + # items in their order + marks = [len(ranks) for ranks in ctx.ranks] + result, decisions, ranks = _walk_items( + node, path, scope, ctx, count, prescribed, publish, ranked + ) + if ranked: + order = sorted(range(count), key=ranks.__getitem__) + if order != list(range(count)): + for enclosing, mark in zip(ctx.ranks, marks): + del enclosing[mark:] + canonical = [decisions[k] for k in order] + result, decisions, _ = _walk_items( + node, path, scope, ctx, count, canonical, publish + ) + return result, decisions + + +def _flatten(node: Node, value: Any, path: str, out: dict) -> None: + """ + Flattens the values of a node into `out`, by path: the chosen branch of + a choice at its path (and its values under the branch's name), the count + of a repetition at `.count` (also of a fixed count) and its items + at `[k]`, and the other values (except fixed values) at their + paths. + """ + if isinstance(node, Fixed): + return + if isinstance(node, Group): + for name, child in node.children.items(): + _flatten(child, value[name], _join(path, name), out) + elif isinstance(node, Choice): + out[path] = value.choice + _flatten( + node.branches[value.choice], value.value, _join(path, value.choice), out + ) + elif isinstance(node, Repeat): + out[_join(path, "count")] = value.count + for k, item in enumerate(value.items): + _flatten(node.item, item, _join(path, k), out) + else: + out[path] = value + + +class _Odometer: + """ + Chooses the levels of the variables of successive walks in the order of + an odometer whose digits are the decisions of a walk, so that walks + enumerate every combination of levels, including those of variables + whose existence or domain depends on earlier decisions. + """ + + def __init__(self): + self.indices: list[int] = [] + self.sizes: list[int] = [] + self.position = 0 + self.floors: list[tuple[int, list[int]]] = [] + """The levels of the previous unordered items (and where the + current items' levels start), which the current items must not + precede.""" + + def choose(self, path: str, domain: _Domain) -> Any: + """ + Chooses the level of the current digit of the odometer (adding a + digit, at the first level, if the walk is longer than before), and + stops a walk whose unordered items precede the previous ones. + """ + if domain.levels is None: + raise ValueError( + f"{path} is continuous: give it a step to enumerate the design space" + ) + if len(domain.levels) == 0: + raise Infeasible(f"{path} has no levels") + if self.position == len(self.indices): + self.indices.append(0) + self.sizes.append(len(domain.levels)) + level = domain.levels[self.indices[self.position]] + self.position += 1 + for start, previous in self.floors: + current = self.indices[start : self.position] + if current < previous[: len(current)]: + raise _Unsorted() + return level + + def advance(self) -> bool: + """ + Advances to the next combination after a walk, returning `False` + after the last. + """ + del self.indices[self.position :], self.sizes[self.position :] + self.position = 0 + self.floors.clear() + while self.indices: + if self.indices[-1] + 1 < self.sizes[-1]: + self.indices[-1] += 1 + return True + self.indices.pop() + self.sizes.pop() + return False + + +def _is_number(value: Any) -> bool: + """Whether a value is a number (not a boolean).""" + return isinstance(value, (int, float, np.number)) and not isinstance( + value, (bool, np.bool_) + ) + + +def _level_of(path: str, domain: _Domain, value: Any) -> Any: + """ + Gets the value of a domain that a decision is (see `DesignSpace.design` + and `DesignSpace.designs_of`): the level that equals it (whose type a + data frame may have changed, as integers in a column of floats, or that + is given as a numpy scalar), or the value (a float) in the range of a + continuous domain, raising a `ValueError` if there is none. + """ + if domain.levels is None: + try: + number = float(value) + except (TypeError, ValueError): + number = math.nan + if domain.low <= number <= domain.high: + return number + raise ValueError( + f"{value!r} is not in the range of {path} ({domain.low}, {domain.high})" + ) + for level in domain.levels: + try: + if level == value: + return _scalar(level) + except (TypeError, ValueError): + continue + if _is_number(value): + for level in domain.levels: + if _is_number(level) and math.isclose( + float(level), float(value), rel_tol=1e-9, abs_tol=1e-12 + ): + return _scalar(level) + raise ValueError(f"{value!r} is not a level of {path} ({domain.levels})") + + +def _missing(value: Any) -> bool: + """Whether a value of a data frame is missing (`None` or `NaN`).""" + return value is None or (isinstance(value, float) and math.isnan(value)) + + +def _decided(values: Mapping[str, Any], path: str, domain: _Domain) -> Any: + """ + Gets the decision of a path from values by path (such as a row of the + results of a study, see `DesignSpace.designs_of`): the level of the domain + that equals the value (whose type a data frame may have changed, as + integers in a column of floats), or the value of a continuous domain. + """ + value = values.get(path) + if _missing(value): + raise ValueError( + f"no value of {path}: rebuild designs from the results of a study, or " + + "from a summary that keeps the values of designs (see aggregate)" + ) + return _level_of(path, domain, value) + + +# --------------------------------------------------------------------------- +# paths of nodes +# --------------------------------------------------------------------------- + + +def _unit_paths(node: Node, path: str) -> list[str]: + """ + Gets the paths of the decisions of a node (see `DesignSpace.unit_paths`). + """ + if isinstance(node, Variable): + return [path] + if isinstance(node, Group): + return [ + p + for name, child in node.children.items() + for p in _unit_paths(child, _join(path, name)) + ] + if isinstance(node, Choice): + return [path] + [ + p + for name, branch in node.branches.items() + for p in _unit_paths(branch, _join(path, name)) + ] + if isinstance(node, Repeat): + paths, largest = [], _largest_count(node.count, path) + if isinstance(node.count, Variable): + paths = [_join(path, "count")] + return paths + [ + p for k in range(largest) for p in _unit_paths(node.item, _join(path, k)) + ] + return [] + + +def _largest_count(count: Any, path: str) -> int: + """ + Gets the largest count of a repetition (see `_unit_paths`), which must + not depend on other values. + """ + if isinstance(count, Integer) and not callable(count.high): + return int(count.high) + if isinstance(count, Variable) and not isinstance(count, Integer): + options = getattr(count, "options", None) + if options is not None and not callable(options): + return int(max(options)) + elif isinstance(count, Fixed): + return int(count.value) + elif isinstance(count, int): + return count + raise ValueError(f"the count of {path} needs a fixed upper bound to be encoded") + + +def _leaf_paths(node: Node, path: str, kind: type) -> list[str]: + """ + Gets the paths of the leaves of a kind of a node (such as its fixed + values), with `[*]` for the index of any item of a repetition, and with + the branches of choices, whether a design chooses them or not. + """ + if isinstance(node, kind): + return [path] + if isinstance(node, Group): + return [ + p + for name, child in node.children.items() + for p in _leaf_paths(child, _join(path, name), kind) + ] + if isinstance(node, Choice): + return [ + p + for name, branch in node.branches.items() + for p in _leaf_paths(branch, _join(path, name), kind) + ] + if isinstance(node, Repeat): + return _leaf_paths(node.item, f"{path}[*]", kind) + return [] + + +def _node_at(node: Node, path: Any) -> Node | None: + """ + Gets the node at a path of leaves (see `_leaf_paths`): through the + children of groups and the branches of choices by their names, and the + items of repetitions by `[*]`, or `None` if there is none. + """ + if not isinstance(path, str) or not path: + return None + for segment in path.replace("[*]", ".[*]").split("."): + if isinstance(node, Group): + node = node.children.get(segment) + elif isinstance(node, Choice): + node = node.branches.get(segment) + elif isinstance(node, Repeat) and segment == "[*]": + node = node.item + else: + return None + if node is None: + return None + return node diff --git a/tests/tradespace/test_cache.py b/tests/tradespace/test_cache.py index dad1bc68..5b4e8e08 100644 --- a/tests/tradespace/test_cache.py +++ b/tests/tradespace/test_cache.py @@ -133,8 +133,10 @@ def make(rows): # a namespace with results only of the function with other code warns with self.assertWarnsRegex( UserWarning, r"1 results.*with other code.*function.(code|constants)" - ): + ) as context: cache = make(2) + # at the call that makes the cache + self.assertEqual(Path(context.filename).resolve(), Path(__file__).resolve()) # once, of the caches of the definition (such as of parallel workers) with warnings.catch_warnings(record=True) as caught: warnings.simplefilter("always") @@ -147,7 +149,11 @@ def make(rows): folders = [p for p in namespaces[0].iterdir() if p.is_dir()] self.assertEqual(len(folders), 2) self.assertTrue(all((p / "definition.json").exists() for p in folders)) - # results of other definitions are removed + # results of other definitions are removed, and their definitions + # (also those without results) + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + make(3) self.assertEqual(cache.prune(), 1) self.assertEqual(len([p for p in namespaces[0].iterdir() if p.is_dir()]), 1) self.assertEqual(SatelliteCache(_name).prune(), 0) # in memory diff --git a/tests/tradespace/test_comparison.py b/tests/tradespace/test_comparison.py index d6492f0a..2213bb6d 100644 --- a/tests/tradespace/test_comparison.py +++ b/tests/tradespace/test_comparison.py @@ -75,8 +75,11 @@ def test_groups(self): hot = _results({"a": [1.0, 2.0], "b": [3.0, 4.0]}, scenario="hot") cold = _results({"a": [5.0, 6.0], "b": [3.0, 4.0]}, scenario="cold") results = pd.concat([hot, cold], ignore_index=True) - with self.assertRaises(ValueError): + with self.assertRaisesRegex(ValueError, "as `by`") as context: exceedance(results, "cost") + # exceedance has its own `by`, and no criteria to combine groups across + self.assertNotIn("across", str(context.exception)) + self.assertNotIn("criteria", str(context.exception)) compared = exceedance(results, "cost", by="scenario").set_index( ["scenario", "design", "other"] ) diff --git a/tests/tradespace/test_constellations.py b/tests/tradespace/test_constellations.py index 67a506d5..425d7c6e 100644 --- a/tests/tradespace/test_constellations.py +++ b/tests/tradespace/test_constellations.py @@ -9,6 +9,8 @@ import numpy as np +import tatc.tradespace + from tatc.schemas import ( CircularOrbit, Instrument, @@ -44,6 +46,7 @@ remove_failures, ) from tatc.tradespace.constellations import ( + WALKER, Layouts, MOGLayout, SOCLayout, @@ -96,7 +99,7 @@ def test_enumeration(self): self.assertTrue(all(count_satellites(d.layout) <= 4 for d in designs)) def test_counts(self): - """Satellites and planes are counted for each kind of layout.""" + """Satellites and planes are counted for each pattern of layout.""" designs = _space().enumerate() walker = [d for d in designs if d.layout.choice == "walker"][-1] self.assertEqual(count_planes(walker.layout), walker.layout.planes) @@ -720,7 +723,10 @@ def test_layout_of(self): self.assertEqual(planes[0].values.crossing, sso.layout.planes[0].crossing) self.assertIsNone(layout_of(walker.layout).planes()[0].values) with self.assertRaises(ValueError): - layout_of({"kind": "flower"}) + layout_of({"pattern": "flower"}) + # the values of a fragment name its pattern (not a type of satellite) + self.assertEqual(walker.layout.value.pattern, WALKER) + self.assertIs(tatc.tradespace.layout_of, layout_of) def test_walker_planes(self): """The satellites of a Walker layout follow each other plane by plane.""" diff --git a/tests/tradespace/test_cost.py b/tests/tradespace/test_cost.py index 435fd64d..af0b5e82 100644 --- a/tests/tradespace/test_cost.py +++ b/tests/tradespace/test_cost.py @@ -167,10 +167,34 @@ def test_spares(self): operations=OperationsCost(per_satellite_year=1), ) schedule = DeploymentSchedule(launch_capacity=4) - estimate = model.estimate(schedule.plan(_walker(2, 4), spares=1)) + estimate = model.estimate(schedule.plan(_walker(2, 4), orbit_spares=1)) self.assertEqual(estimate.units[None], 10) self.assertEqual(estimate.launches, 4) self.assertEqual(estimate.operations, 10) + # spares (which do not age) are not replaced at each design life + replaced = dataclasses.replace(schedule, years=6, design_life=2) + units = model.estimate(replaced.plan(_walker(2, 4), orbit_spares=1)).units + self.assertEqual(units[None], 10 + 2 * 8) + + def test_masses_of_the_deployment(self): + """Launches are priced by the masses that size them: those of the + deployment, or else of the cost model.""" + schedule = DeploymentSchedule(years=3, launch_mass_capacity=250) + deployment = schedule.plan(_walker(1, 4), masses=100) + self.assertEqual(len(deployment.launches), 2) + by_kg = LaunchCost(per_kg=0.01) + # without masses of the cost model + priced = CostModel(SatelliteCost(first_unit=1), launch=by_kg).estimate( + deployment + ) + self.assertAlmostEqual(priced.launch, 4 * 100 * 0.01) + # the masses of the deployment take the place of the cost model's + other = CostModel(SatelliteCost(first_unit=1, mass=60), launch=by_kg) + self.assertAlmostEqual(other.estimate(deployment).launch, 4 * 100 * 0.01) + unsized = DeploymentSchedule(years=3).plan(_walker(1, 4)) + self.assertAlmostEqual(other.estimate(unsized).launch, 4 * 60 * 0.01) + with self.assertRaisesRegex(ValueError, "masses"): + CostModel(SatelliteCost(), launch=by_kg).estimate(unsized) def test_types(self): """Types of satellites are developed once each, with their own curves.""" @@ -369,7 +393,8 @@ def test_operations_from_launch(self): """Satellites launched later are operated for less of the mission.""" dated = self._estimate(development_years=2, launch_interval=1) launches = [t for t, element, _ in dated.flows if element == "launch"] - self.assertEqual(launches, [2, 3, 4, 5, 5, 6, 6, 7, 7]) + # (no slot is free for replacements before the end of the mission) + self.assertEqual(launches, [2, 3, 4, 5, 6, 7]) expected = 5 * 6 + sum(2 * (8 - t) for t in [2, 3, 4, 5, 6, 7]) self.assertAlmostEqual(dated.operations, expected) diff --git a/tests/tradespace/test_criteria.py b/tests/tradespace/test_criteria.py index 760d6dcf..4c19e469 100644 --- a/tests/tradespace/test_criteria.py +++ b/tests/tradespace/test_criteria.py @@ -11,6 +11,7 @@ import pandas as pd from tatc.tradespace import ( + Across, Criteria, DesignSpace, Integer, @@ -203,12 +204,13 @@ def test_criteria(self): ) frame = aggregate(_results(), criteria).set_index("design") self.assertEqual( - list(frame.columns[-7:]), + list(frame.columns[-8:]), [ "cost", "value", "value p25", "replicates", + "feasible", "violation", "meets_requirements", "pareto", @@ -262,11 +264,11 @@ def test_invalid(self): with self.assertRaises(ValueError): Criteria({"a": "lowest"}) with self.assertRaises(ValueError): - Criteria({"a": "min"}, tolerance={"b": 1}) + Criteria({"a": "min"}, tolerances={"b": 1}) with self.assertRaises(ValueError): - Criteria({"a": "min"}, tolerance={"a": "5"}) + Criteria({"a": "min"}, tolerances={"a": "5"}) with self.assertRaises(ValueError): - Criteria({"a": "min"}, tolerance={"a": -1}) + Criteria({"a": "min"}, tolerances={"a": -1}) with self.assertRaises(TypeError): Criteria({"a": "min"}, statistics={"b": 1}) with self.assertRaises(TypeError): @@ -438,9 +440,9 @@ def test_names(self): self.assertEqual(criteria.names, ["value p25", "cost"]) self.assertEqual( list(aggregate(_results(), statistics=[Quantile("value", 0.25)]).columns)[ - -2: + -3: ], - ["value p25", "replicates"], + ["value p25", "replicates", "feasible"], ) def test_requirements(self): @@ -456,3 +458,141 @@ def test_summarize_statistics(self): summary = summarize(_results(), {"value": "max"}, statistics=["cost"]) for column in ("value", "value se", "cost", "cost std", "cost se", "pareto"): self.assertIn(column, summary.columns) + + +def _partly_infeasible(scenario=None, shares=None): + """Results of three designs in four replicates: a is feasible in every + replicate, b in two, and c in none (whose records lack metrics).""" + values = {"a": [1, 2, 3, 4], "b": [10, None, 30, None], "c": [None] * 4} + values.update(shares or {}) + return pd.DataFrame( + [ + { + "design": key, + "replicate": r, + **({} if scenario is None else {"scenario": scenario}), + "feasible": v is not None, + "cost": ( + {"a": 2.0, "b": 1.0, "c": 1.0}[key] if v is not None else np.nan + ), + "value": np.nan if v is None else float(v), + } + for key, row in values.items() + for r, v in enumerate(row) + ] + ) + + +class TestFeasibility(unittest.TestCase): + """ + Unit tests for the judgment of designs by their feasible replicates. + """ + + def test_feasible_share(self): + """Designs are judged by their feasible replicates, of which + `replicates` is the number and `feasible` the share; designs without a + feasible replicate are left out.""" + summary = aggregate(_partly_infeasible(), {"cost": "min", "value": "max"}) + summary = summary.set_index("design") + self.assertEqual(list(summary.index), ["a", "b"]) + self.assertEqual(summary.loc["b", "value"], 20) + self.assertEqual(list(summary.replicates), [4, 2]) + self.assertEqual(list(summary.feasible), [1.0, 0.5]) + # b, cheaper and better in its feasible replicates, dominates a + self.assertEqual(list(summary.pareto), [False, True]) + self.assertEqual( + list(summary.columns[-5:]), + ["replicates", "feasible", "violation", "meets_requirements", "pareto"], + ) + + def test_requirement(self): + """Requirements on `feasible` judge the share of feasible replicates + over every replicate of a design.""" + every = Criteria( + {"cost": "min", "value": "max"}, + requirements=[Requirement("feasible", ">=", 1)], + ) + summary = aggregate(_partly_infeasible(), every).set_index("design") + self.assertEqual(list(summary.feasible), [1.0, 0.5]) + self.assertEqual(list(summary.meets_requirements), [True, False]) + self.assertAlmostEqual(summary.loc["b", "violation"], 0.5) + self.assertEqual(list(summary.pareto), [True, False]) + half = Criteria( + {"cost": "min", "value": "max"}, + requirements=[Requirement("feasible", ">=", 0.5)], + ) + summary = aggregate(_partly_infeasible(), half) + self.assertTrue(summary.meets_requirements.all()) + # its spread is not summarized + summary = summarize(_partly_infeasible(), every) + self.assertNotIn("feasible se", summary.columns) + self.assertEqual(list(summary.feasible), [1.0, 0.5]) + + def test_groups(self): + """Infeasible records without a value of a group (such as a sensor) + count in every group of the design.""" + results = _partly_infeasible() + feasible = results[results.feasible] + records = pd.concat( + [ + feasible.assign(sensor="x"), + feasible.assign(sensor="y", value=feasible.value + 1), + results[~results.feasible], + ], + ignore_index=True, + ) + summary = aggregate(records, ["value"], by="sensor") + summary = summary.set_index(["sensor", "design"]) + self.assertEqual(summary.loc[("y", "b"), "value"], 21) + self.assertEqual(summary.loc[("x", "b"), "feasible"], 0.5) + self.assertEqual(summary.loc[("y", "b"), "feasible"], 0.5) + self.assertEqual(summary.loc[("y", "a"), "feasible"], 1.0) + + def test_across(self): + """Across groups, `feasible` is over the replicates of every group + together, and designs need feasible replicates in every group.""" + results = pd.concat( + [ + _partly_infeasible("s1", {"b": [10, 20, 30, 40]}), + _partly_infeasible("s2"), + ], + ignore_index=True, + ) + for rule in ("worst", "mean"): + with self.subTest(rule=rule): + criteria = Criteria( + {"cost": "min", "value": "max"}, + requirements=[Requirement("feasible", ">=", 0.7)], + across=Across(rule=rule), + ) + summary = aggregate(results, criteria).set_index("design") + self.assertEqual(list(summary.index), ["a", "b"]) + self.assertEqual(summary.loc["b", "feasible"], 0.75) + self.assertEqual(summary.loc["b", "replicates"], 2) + self.assertTrue(summary.meets_requirements.all()) + + def test_no_feasible_design(self): + """Results without a feasible record have empty summaries.""" + results = _partly_infeasible() + infeasible = results[results.design == "c"].drop(columns=["cost", "value"]) + criteria = Criteria({"cost": "min", "value": "max"}, by="size") + for summary in ( + aggregate(infeasible, {"cost": "min", "value": "max"}), + aggregate(infeasible.assign(size=1), criteria), + aggregate(infeasible.iloc[:0], {"cost": "min", "value": "max"}), + ): + self.assertTrue(summary.empty) + self.assertEqual( + list(summary.columns[-5:]), + ["replicates", "feasible", "violation", "meets_requirements", "pareto"], + ) + # of the types of their columns, which select rows + self.assertEqual(summary.pareto.dtype, bool) + self.assertTrue(summary[summary.pareto].empty) + self.assertTrue(aggregate(infeasible, ["value"]).empty) + across = Criteria({"cost": "min", "value": "max"}, across=Across(rule="mean")) + scenarios = pd.concat( + [_partly_infeasible("s1"), _partly_infeasible("s2")], ignore_index=True + ) + self.assertEqual(len(aggregate(scenarios, across)), 2) + self.assertTrue(aggregate(scenarios.iloc[:0], across).empty) diff --git a/tests/tradespace/test_deployment.py b/tests/tradespace/test_deployment.py index 905c98e2..e8bfbd18 100644 --- a/tests/tradespace/test_deployment.py +++ b/tests/tradespace/test_deployment.py @@ -5,6 +5,7 @@ @author Paul T. Grogan """ +import dataclasses import math import unittest @@ -90,9 +91,10 @@ def test_production_rate(self): self.assertGreater(larger.deployed, deployment.deployed) def test_launch_cadence(self): - """Launches are at least an interval apart, a plane taking several.""" + """Launches are at least an interval apart, a plane taking several, + planned replacements too.""" schedule = DeploymentSchedule( - years=6, + years=8, design_life=3, development_years=2, launch_interval=1, @@ -105,11 +107,74 @@ def test_launch_cadence(self): [(l.plane, l.first, l.satellites) for l in first[:2]], [(0, 0, 2), (0, 2, 2)], ) - # replacements 3 years later, before the end of the mission at year 8 - replacements = [l.time for l in deployment.launches if l.generation > 0] - self.assertEqual(replacements, [5, 6, 7]) - self.assertEqual(deployment.end, 8) - self.assertEqual(deployment.units, {None: 12 + 6}) + # replacements needed 3 years later, from year 5, wait for the slots + # after the first generation: two before the end of the mission at 10 + replacements = [ + (l.time, l.plane, l.first) for l in deployment.launches if l.generation > 0 + ] + self.assertEqual(replacements, [(8, 0, 0), (9, 0, 2)]) + self.assertEqual(deployment.end, 10) + self.assertEqual(deployment.units, {None: 12 + 4}) + + def test_replacements_keep_the_interval(self): + """Planned replacements of several types keep the launch interval, from + the launches of the deployment and from each other, and are replaced a + design life after their launch.""" + schedule = DeploymentSchedule( + years=8, launch_interval=0.5, design_life={"a": 3.0, "b": 2.5} + ) + deployment = schedule.plan({"a": _walker(1, 2), "b": _walker(1, 2)}) + launches = [(l.time, l.kind, l.purpose) for l in deployment.launches] + self.assertEqual( + launches, + [ + (0.0, "a", "deployment"), + (0.5, "b", "deployment"), + (3.0, "a", "replacement"), + (3.5, "b", "replacement"), # needed at 3.0, with a's + (6.0, "a", "replacement"), + (6.5, "b", "replacement"), # needed at 3.5 + 2.5, with a's + ], + ) + times = [time for time, _, _ in launches] + self.assertGreaterEqual(min(np.diff(times)), 0.5) + # produced just before they are needed + produced = [ + (b.kind, b.end) for b in deployment.production if b.purpose == "replacement" + ] + self.assertEqual( + sorted(produced), [("a", 3.0), ("a", 6.0), ("b", 3.0), ("b", 6.0)] + ) + + def test_spares_are_not_replaced(self): + """Planned replacements replace the satellites of the layout, not the + spares in orbit, which do not age: a spare is launched once.""" + schedule = DeploymentSchedule(years=6, design_life=2) + deployment = schedule.plan(_walker(1, 2), orbit_spares=1) + self.assertEqual( + [(l.time, l.satellites, l.purpose) for l in deployment.launches], + [(0, 3, "deployment"), (2, 2, "replacement"), (4, 2, "replacement")], + ) + self.assertEqual(deployment.units, {None: 3 + 2 + 2}) + self.assertEqual(schedule.plan(_walker(1, 2)).units, {None: 6}) + # the spare waits in orbit for the whole mission + self.assertEqual(deployment.simulate().parked, [(0, 6, 1)]) + # a launch of the spare alone is not replaced + single = dataclasses.replace(schedule, launch_capacity=1) + launches = single.plan(_walker(1, 2), orbit_spares=1).launches + self.assertEqual( + sorted((l.purpose, l.first) for l in launches), + [("deployment", 0), ("deployment", 1), ("deployment", 2)] + + [("replacement", 0)] * 2 + + [("replacement", 1)] * 2, + ) + with self.assertRaises(ValueError): + schedule.plan(_walker(1, 2), orbit_spares=-1) + # spares of each type + mixed = schedule.plan( + {"a": _walker(1, 2), "b": _walker(1, 2)}, orbit_spares={"a": 1, "b": 0} + ) + self.assertEqual([p.orbit_spares for p in mixed.planes], [1, 0]) def test_types_and_order(self): """Types are developed over their own durations, planes in an order.""" diff --git a/tests/tradespace/test_failures.py b/tests/tradespace/test_failures.py index 51560387..7e4274d2 100644 --- a/tests/tradespace/test_failures.py +++ b/tests/tradespace/test_failures.py @@ -8,6 +8,7 @@ import math import unittest from dataclasses import dataclass +from unittest import mock import numpy as np import pandas as pd @@ -35,12 +36,15 @@ policy_space, walker_space, ) +from tatc.tradespace import histories as histories_module from tatc.tradespace.failures import Lifetime from tatc.tradespace.histories import ( + MAX_SETS, + _exact_sets, allocate_histories, - evaluate_missions, - expected_missions, - summarize_missions, + evaluate_histories, + exact_expectations, + summarize_histories, ) from tatc.tradespace.mission import ( Capability, @@ -188,8 +192,8 @@ def setUp(self): # every satellite fails 1.5 years after it begins to operate self.failures = FailureModel(life=_Fixed(1.5)) - def _simulate(self, policy, spares=0, failures=None, seed=0): - deployment = self.schedule.plan(self.layout, spares=spares) + def _simulate(self, policy, orbit_spares=0, failures=None, seed=0): + deployment = self.schedule.plan(self.layout, orbit_spares=orbit_spares) return deployment.simulate(failures or self.failures, policy, seed) def test_without_failures(self): @@ -250,7 +254,7 @@ def test_restore_by_production(self): def test_restore_from_orbit(self): """A spare in orbit takes a failed satellite's place after drifting.""" policy = RestorationPolicy(detection_years=0.1, drift_years=0.2) - history = self._simulate(policy, spares=1) + history = self._simulate(policy, orbit_spares=1) first = sorted(history.restorations, key=lambda r: r[3])[0] self.assertEqual(first[4], "orbit") self.assertAlmostEqual(first[3] - first[2], 0.3) @@ -353,7 +357,7 @@ def test_costs_of_policies(self): costs, availability = [], [] for seed in range(100): history = self._simulate( - policy, spares=spares, failures=failures, seed=seed + policy, orbit_spares=spares, failures=failures, seed=seed ) costs.append(model.estimate(history).total) availability.append(history.metrics()["availability"]) @@ -370,11 +374,15 @@ def test_policy_validation(self): {"procurement_years": -1}, {"batch_years": -1}, {"ground_spares": -1}, + {"orbit_spares": {"a": -1}}, ): with self.assertRaises(ValueError): RestorationPolicy(**invalid) with self.assertRaisesRegex(ValueError, "ground spares"): RestorationPolicy(ground_spares={"a": 2}).ground_spares_of("b") + self.assertEqual( + RestorationPolicy(orbit_spares={"a": 2}).orbit_spares_of("a"), 2 + ) class TestPolicySpace(unittest.TestCase): @@ -443,10 +451,9 @@ def test_trade_of_policies(self): ) def evaluate(d): - deployment = schedule.plan(d.layout, spares=d.policy.orbit_spares) - history = deployment.simulate( - failures, configure(RestorationPolicy(), d.policy), d.failure_seed - ) + policy = configure(RestorationPolicy(), d.policy) + deployment = schedule.plan(d.layout, orbit_spares=policy.orbit_spares) + history = deployment.simulate(failures, policy, d.failure_seed) return { "cost": model.estimate(history).total, "availability": history.metrics()["availability"], @@ -510,31 +517,43 @@ def test_simulate_many(self): """Histories of a replicate differ, and are the same in every design.""" deployment = self.schedule.plan(self.layout) histories = deployment.simulate_many( - self.failures, RestorationPolicy(), 7, 10, sampling="random" + self.failures, RestorationPolicy(), 7, histories=10, sampling="random" ) self.assertEqual(len(histories), 10) self.assertGreater(len({tuple(h.failures) for h in histories}), 1) again = deployment.simulate(self.failures, RestorationPolicy(), (7, 3)) self.assertEqual(again.failures, histories[3].failures) degraded = deployment.simulate_many( - self.failures, RestorationPolicy(restore=False), 7, 10, sampling="random" + self.failures, + RestorationPolicy(restore=False), + 7, + histories=10, + sampling="random", ) self.assertEqual(degraded[3].failures[0], histories[3].failures[0]) self.assertEqual( - len(deployment.simulate_many(self.failures, None, None, 10)), 1 + len(deployment.simulate_many(self.failures, None, None, histories=10)), 1 ) self.assertIs(deployment.planned(), deployment.planned()) with self.assertRaises(ValueError): - deployment.simulate_many(self.failures, None, 7, 0) + deployment.simulate_many(self.failures, None, 7, histories=0) + # without a model of failures, as simulate, nothing fails + unfailing = deployment.simulate_many(seed=7, histories=3) + self.assertEqual([h.failures for h in unfailing], [[], [], []]) + self.assertEqual(deployment.expected_metrics(histories=3)["availability"], 1) def test_phase_cache(self): """A cache evaluates each set of satellites once, as without it.""" deployment = self.schedule.plan(self.layout) - histories = deployment.simulate_many(self.failures, RestorationPolicy(), 7, 20) + histories = deployment.simulate_many( + self.failures, RestorationPolicy(), 7, histories=20 + ) cache = PhaseCache(self._metric) for history in histories: phases = history.phases(self.satellites) - cached = cache.evaluate(phases, self.satellites, self.observations, "r0") + cached = cache.evaluate( + phases, self.satellites, self.observations, context="r0" + ) direct = evaluate_phases(phases, self.observations, self._metric) pd.testing.assert_frame_equal(cached, direct) self.assertGreater(cache.hits, cache.misses) @@ -547,14 +566,16 @@ def test_phase_cache(self): {s.name: r.name for s, r in zip(self.satellites, renamed)} ) misses = cache.misses - cache.evaluate(histories[0].phases(renamed), renamed, observations, "r0") + cache.evaluate( + histories[0].phases(renamed), renamed, observations, context="r0" + ) self.assertEqual(cache.misses, misses) # other observations (another context) are evaluated again cache.evaluate( histories[0].phases(self.satellites), self.satellites, self.observations, - "r1", + context="r1", ) self.assertGreater(cache.misses, misses) cache.clear() @@ -563,14 +584,16 @@ def test_phase_cache(self): def test_evaluate_and_summarize(self): """Histories are evaluated, priced, and summarized as one record.""" deployment = self.schedule.plan(self.layout) - histories = deployment.simulate_many(self.failures, RestorationPolicy(), 7, 30) + histories = deployment.simulate_many( + self.failures, RestorationPolicy(), 7, histories=30 + ) model = CostModel( SatelliteCost(development=10, first_unit=5), launch=LaunchCost(per_launch=3) ) capability = Capability( - self.satellites, self.observations, PhaseCache(self._metric), "r0" + self.satellites, self.observations, PhaseCache(self._metric), context="r0" ) - missions = evaluate_missions(histories, capability, cost_model=model) + missions = evaluate_histories(histories, capability, cost_model=model) self.assertEqual(len(missions), 30) for column in ( "share mission", @@ -580,7 +603,7 @@ def test_evaluate_and_summarize(self): "cost present", ): self.assertIn(column, missions.columns) - summary = summarize_missions( + summary = summarize_histories( missions, quantiles={"share mission": [0.1, 0.5], "cost": 0.7}, requirements=[Requirement("share mission", ">=", 60)], @@ -598,7 +621,7 @@ def test_evaluate_and_summarize(self): summary["P(share mission >= 60)"], (missions["share mission"] >= 60).mean() ) # without a cache, the same evaluations - direct = evaluate_missions( + direct = evaluate_histories( histories, Capability(self.satellites, self.observations, self._metric) ) np.testing.assert_allclose(direct["share mission"], missions["share mission"]) @@ -661,7 +684,7 @@ def test_stratified_histories(self): self.failures, RestorationPolicy(restore=False), seed, - 20, + histories=20, sampling=sampling, ) ] @@ -675,12 +698,16 @@ def test_stratified_histories(self): ) # common random numbers: the same failures of a slot under other policies first = deployment.simulate_many( - self.failures, RestorationPolicy(restore=False), 1, 8 + self.failures, RestorationPolicy(restore=False), 1, histories=8 + ) + other = deployment.simulate_many( + self.failures, RestorationPolicy(), 1, histories=8 ) - other = deployment.simulate_many(self.failures, RestorationPolicy(), 1, 8) self.assertEqual(first[3].failures[0], other[3].failures[0]) with self.assertRaises(ValueError): - deployment.simulate_many(self.failures, None, 1, 8, sampling="antithetic") + deployment.simulate_many( + self.failures, None, 1, histories=8, sampling="antithetic" + ) def test_expected_metrics(self): """Expected measures of a mission from many histories.""" @@ -702,8 +729,8 @@ def test_control_variates(self): missions = pd.DataFrame( {"availability": x, "share": y, "failures": rng.poisson(2, 20)} ) - plain = summarize_missions(missions) - controlled = summarize_missions(missions, controls={"availability": 0.8}) + plain = summarize_histories(missions) + controlled = summarize_histories(missions, controls={"availability": 0.8}) self.assertEqual(controlled["availability"], 0.8) self.assertAlmostEqual(plain["failures"], missions.failures.mean(), delta=1) estimates["plain"].append(plain["share"]) @@ -716,10 +743,19 @@ def test_control_variates(self): missions = pd.DataFrame( {"availability": [0.7, 0.8, 0.9, 1.0], "years": [np.nan, 1.0, 2.0, 3.0]} ) - summary = summarize_missions(missions, controls={"availability": 0.85}) + summary = summarize_histories(missions, controls={"availability": 0.85}) self.assertTrue(np.isfinite(summary["years"])) with self.assertRaises(ValueError): - summarize_missions(missions, controls={"cost": 1.0}) + summarize_histories(missions, controls={"cost": 1.0}) + + +def _costs(replicate_seconds, history_seconds): + """The histories of a pilot of 20 and the costs of an allocation.""" + return { + "histories": 20, + "replicate_seconds": replicate_seconds, + "history_seconds": history_seconds, + } class TestAllocateHistories(unittest.TestCase): @@ -733,7 +769,7 @@ def _pilot(self, between, within, replicates=200, histories=20, seed=0): for _ in range(replicates): expected = rng.normal(50, between) missions = pd.DataFrame({"share": rng.normal(expected, within, histories)}) - rows.append(summarize_missions(missions, spread=True)) + rows.append(summarize_histories(missions, spread=True)) return pd.DataFrame(rows) def test_recommendation(self): @@ -743,7 +779,7 @@ def test_recommendation(self): result = allocate_histories( records, "share", - 20, + histories=20, replicate_seconds=100, history_seconds=1, standard_error=0.5, @@ -758,17 +794,21 @@ def test_recommendation(self): result["seconds"], result["replicates"] * result["replicate seconds"] ) # costlier histories call for fewer of them - fewer = allocate_histories(records, "share", 20, 100, 10) + fewer = allocate_histories(records, "share", **_costs(100, 10)) self.assertLess(fewer["histories"], result["histories"]) def test_limits(self): """Without variance between replicates, the most histories.""" records = self._pilot(between=0, within=6, replicates=50) - result = allocate_histories(records, "share", 20, 100, 1, max_histories=500) + result = allocate_histories( + records, "share", **_costs(100, 1), max_histories=500 + ) self.assertLessEqual(result["histories"], 500) self.assertGreater(result["histories"], 100) # a standard error that two replicates achieve: the fewest histories - enough = allocate_histories(records, "share", 20, 100, 1, standard_error=0.5) + enough = allocate_histories( + records, "share", **_costs(100, 1), standard_error=0.5 + ) self.assertEqual(enough["replicates"], 2) self.assertLess(enough["histories"], 100) self.assertLessEqual( @@ -778,11 +818,11 @@ def test_limits(self): # means that vary less than independent histories can (stratified) steady = records.assign(share=50.0) with self.assertWarns(UserWarning): - allocate_histories(steady, "share", 20, 100, 1) + allocate_histories(steady, "share", **_costs(100, 1)) with self.assertRaises(ValueError): - allocate_histories(records.iloc[:1], "share", 20, 100, 1) + allocate_histories(records.iloc[:1], "share", **_costs(100, 1)) with self.assertRaises(ValueError): - allocate_histories(records, "share", 20, 0, 1) + allocate_histories(records, "share", **_costs(0, 1)) class TestExpectedMissions(unittest.TestCase): @@ -820,11 +860,11 @@ def _compare(self, schedule, failures): capability = Capability( self.satellites, self.observations, PhaseCache(self._metric) ) - exact = expected_missions(deployment, failures, capability) + exact = exact_expectations(deployment, failures, capability) histories = deployment.simulate_many( - failures, RestorationPolicy(restore=False), 3, 4000 + failures, RestorationPolicy(restore=False), 3, histories=4000 ) - missions = evaluate_missions(histories, capability) + missions = evaluate_histories(histories, capability) error = missions["score mission"].std() / np.sqrt(len(missions)) self.assertAlmostEqual( exact["score mission"], missions["score mission"].mean(), delta=4 * error @@ -858,7 +898,7 @@ def test_without_failures(self): years=4, development_years=1, production_rate=2 ).plan(self.layout) capability = Capability(self.satellites, self.observations, self._metric) - exact = expected_missions(deployment, FailureModel(), capability) + exact = exact_expectations(deployment, FailureModel(), capability) phases = deployment.phases(self.satellites) planned = summarize_phases( evaluate_phases(phases, self.observations, self._metric) @@ -868,23 +908,53 @@ def test_without_failures(self): ) self.assertEqual(exact["availability"], 1.0) # every launch fails: nothing operates - lost = expected_missions(deployment, FailureModel(launch=1.0), capability) + lost = exact_expectations(deployment, FailureModel(launch=1.0), capability) self.assertEqual(lost["availability"], 0.0) self.assertEqual(lost["score mission"], 0.0) + def test_sets_known_before_enumerating(self): + """The sets that exact expectations enumerate are counted before they + are, so that a constellation of too many fails at once (and the + failures of a study fall back to histories, see Failures).""" + deployment = DeploymentSchedule(years=4, launch_interval=0.5).plan(self.layout) + failures = FailureModel(life=Exponential(0.3), launch=0.05) + capability = Capability(self.satellites, self.observations, self._metric) + weigh = mock.Mock(wraps=histories_module._set_weight) + with mock.patch.object(histories_module, "_set_weight", weigh): + exact = exact_expectations(deployment, failures, capability) + self.assertEqual(weigh.call_count, _exact_sets(deployment, failures)) + self.assertGreaterEqual(exact["coverage"], 0.999) + # reliable satellites: the sets of fewer missing cover the mission + reliable = FailureModel(life=Exponential(0.001)) + self.assertLess(_exact_sets(deployment, reliable), 2**4) + # 20 satellites (of 4 planes of 5) of a few years: too many, at once + large = DeploymentSchedule(years=5).plan(_walker(4, 5)) + failures = FailureModel(life=Exponential(0.3)) + self.assertGreater(_exact_sets(large, failures), MAX_SETS) + names = _names(20) + weigh = mock.Mock(wraps=histories_module._set_weight) + with mock.patch.object(histories_module, "_set_weight", weigh): + with self.assertRaisesRegex(ValueError, "too many sets"): + exact_expectations( + large, + failures, + Capability(names, pd.DataFrame({"satellite": names}), len), + ) + weigh.assert_not_called() + def test_limits(self): """Sets are enumerated within limits.""" deployment = DeploymentSchedule(years=4).plan(self.layout) failures = FailureModel(life=Exponential(0.5)) with self.assertRaises(ValueError): - expected_missions( + exact_expectations( deployment, failures, Capability(self.satellites, self.observations, self._metric), max_sets=3, ) with self.assertRaises(ValueError): - expected_missions( + exact_expectations( deployment, failures, Capability(self.satellites[:3], self.observations, self._metric), @@ -932,12 +1002,16 @@ def test_rare_losses(self): values = [] for seed in range(25): histories = deployment.simulate_many( - failures, RestorationPolicy(restore=False), seed, 200, stress=stress + failures, + RestorationPolicy(restore=False), + seed, + histories=200, + stress=stress, ) rows = pd.DataFrame( [{**h.metrics(), "weight": h.weight} for h in histories] ) - summary = summarize_missions( + summary = summarize_histories( rows, requirements=[Requirement("failures", ">=", 2)] ) values.append(summary["P(failures >= 2)"]) @@ -947,17 +1021,17 @@ def test_rare_losses(self): self.assertAlmostEqual(estimates[8.0].mean(), exact, delta=0.001) self.assertLess(estimates[8.0].var(), estimates[1.0].var() / 5) # without stress, histories are not weighted - plain = deployment.simulate_many(failures, None, 1, 5) + plain = deployment.simulate_many(failures, None, 1, histories=5) self.assertTrue(all(h.weight == 1.0 for h in plain)) with self.assertRaises(ValueError): - deployment.simulate_many(failures, None, 1, 5, stress=0) + deployment.simulate_many(failures, None, 1, histories=5, stress=0) def test_stressed_launches(self): """Stressed launches are weighted to their probability of failure.""" deployment = DeploymentSchedule(years=2).plan(_walker(1, 2)) failures = FailureModel(launch=0.02) histories = deployment.simulate_many( - failures, RestorationPolicy(restore=False), 4, 3000, stress=10.0 + failures, RestorationPolicy(restore=False), 4, histories=3000, stress=10.0 ) weights = np.array([h.weight for h in histories]) lost = np.array([h.launches[0].failed for h in histories]) @@ -966,12 +1040,30 @@ def test_stressed_launches(self): np.sum(weights * lost) / weights.sum(), 0.02, delta=0.005 ) + def test_times_and_columns(self): + """Times that a history never meets are infinite in the summaries, and + quantiles and requirements need columns of the histories.""" + histories = pd.DataFrame({"accurate time": [2.0, 3.0, math.inf, np.nan]}) + summary = summarize_histories( + histories, + quantiles={"accurate time": [0.3, 0.9]}, + requirements=[Requirement("accurate time", "<=", 3)], + ) + self.assertEqual(summary["accurate time"], math.inf) + self.assertEqual(summary["accurate time histories p30"], 2.0) + self.assertEqual(summary["accurate time histories p90"], math.inf) + self.assertEqual(summary["P(accurate time <= 3)"], 0.5) + with self.assertRaisesRegex(ValueError, "other"): + summarize_histories(histories, quantiles={"other": 0.5}) + with self.assertRaisesRegex(ValueError, "other"): + summarize_histories(histories, requirements=[Requirement("other", ">", 1)]) + def test_weighted_summaries(self): """Weighted histories give weighted statistics.""" missions = pd.DataFrame( {"value": [1.0, 2.0, 3.0, 4.0], "weight": [4.0, 1.0, 1.0, 2.0]} ) - summary = summarize_missions( + summary = summarize_histories( missions, quantiles={"value": 0.5}, requirements=[Requirement("value", ">=", 3)], diff --git a/tests/tradespace/test_fingerprint.py b/tests/tradespace/test_fingerprint.py index cddbdf1a..9145b199 100644 --- a/tests/tradespace/test_fingerprint.py +++ b/tests/tradespace/test_fingerprint.py @@ -5,6 +5,7 @@ """ import ast +import functools import importlib import os import tempfile @@ -75,13 +76,51 @@ def _uses_attribute(d): values = pd.DataFrame({"a": [1.0]}) # pylint: disable=invalid-name -CACHES = {} +class _Cache: + """State of the study's own, kept in an attribute (not described).""" + + def __init__(self): + self.results = {} + + +CACHE = _Cache() def _uses_cache(d): - if d not in CACHES: - CACHES[d] = object() - return CACHES[d] + if d not in CACHE.results: + CACHE.results[d] = object() + return CACHE.results[d] + + +PAYLOAD = Instrument(name="imager", field_of_regard=30) +INSTRUMENTS = {30: Instrument(name="a", field_of_regard=30)} +SCORER = _Own(3) +METRIC = partial(max, 3) + + +def _uses_payload(d): + return PAYLOAD.field_of_regard * d + + +def _uses_instruments(d): + return INSTRUMENTS[d] + + +def _uses_scorer(d): + return SCORER.value * d + + +def _uses_metric(d): + return METRIC(d) + + +@functools.lru_cache(maxsize=None) +def _cached(x): + return x * THRESHOLD + + +def _uses_cached(d): + return _cached(d) def _uses_model(d): @@ -215,10 +254,103 @@ def test_data_globals(self): TABLE = pd.DataFrame({"a": [1.0]}) def test_global_state(self): - """Mutable globals (such as caches) do not change the fingerprint.""" + """State in the attributes of objects (such as caches) does not change + the fingerprint, but global containers (such as of instruments) do.""" before = get_fingerprint(_uses_cache) _uses_cache(1) self.assertEqual(before, get_fingerprint(_uses_cache)) + global INSTRUMENTS # pylint: disable=global-statement + before = get_fingerprint(_uses_instruments) + INSTRUMENTS = {30: Instrument(name="a", field_of_regard=45)} + try: + self.assertNotEqual(before, get_fingerprint(_uses_instruments)) + finally: + INSTRUMENTS = {30: Instrument(name="a", field_of_regard=30)} + + def test_globals_by_content(self): + """Globals are described as the values they are: models, objects of the + study's own classes, partial functions, and decorated functions.""" + global THRESHOLD # pylint: disable=global-statement + cases = [ + ("PAYLOAD", _uses_payload, Instrument(name="imager", field_of_regard=60)), + ("SCORER", _uses_scorer, _Own(5)), + ("METRIC", _uses_metric, partial(max, 5)), + ] + for name, function, changed in cases: + with self.subTest(name=name): + original = globals()[name] + before = get_fingerprint(function) + globals()[name] = changed + try: + self.assertNotEqual(before, get_fingerprint(function)) + finally: + globals()[name] = original + # a function that a decorator wraps, by the wrapped function's code + before = get_fingerprint(_uses_cached) + THRESHOLD = 5 + try: + self.assertNotEqual(before, get_fingerprint(_uses_cached)) + finally: + THRESHOLD = 4 + + def test_one_rule(self): + """A global is described as the same value given directly is.""" + for name, function in ( + ("PAYLOAD", _uses_payload), + ("INSTRUMENTS", _uses_instruments), + ("SCORER", _uses_scorer), + ("METRIC", _uses_metric), + ("TABLE", _uses_table), + ): + with self.subTest(name=name): + described = get_definition(f=function)["values"]["f"]["globals"] + given = get_definition(globals()[name])["values"]["0"] + self.assertEqual(described[name], given) + + def test_versions(self): + """The same study with other code is found across versions of Python, + whose code orders, groups, and repeats constants differently, and a + study of other literals is not.""" + # pylint: disable=protected-access + # the constants of the same function in Python 3.10 and 3.14 + older = { + "code": "aa", + "constants": [ + "target_hash", + 0, + "sufficient", + "0.0", + 100, + {"code": "bb", "constants": [1], "names": []}, + "evaluate..", + ["sufficient", "n"], + None, + ], + "names": ["groupby"], + } + newer = { + "code": "cc", + "constants": ["target_hash", "sufficient", "0.0", "n", 0, 100, 100, 1], + "names": ["groupby", "size"], + } + self.assertEqual( + fingerprint._without_code({"f": older}), + fingerprint._without_code({"f": newer}), + ) + other = {**newer, "constants": [*newer["constants"], 4]} + self.assertNotEqual( + fingerprint._without_code({"f": older}), + fingerprint._without_code({"f": other}), + ) + # of definitions + definition = {"values": {"f": newer}} + self.assertEqual( + fingerprint._with_other_code( + definition, + {"a": {"values": {"f": older}}, "b": None, "c": {"values": {}}}, + ), + ["a"], + ) def test_dataclasses(self): """Dataclasses, such as cost models, are described by their fields.""" @@ -426,6 +558,36 @@ def test_own_modules(self): sys.path.remove(directory) sys.modules.pop("tatc_own_helpers", None) + def test_own_module_attributes(self): + """Functions and values of a module of the study's own that a function + reaches through the module are described as globals.""" + with tempfile.TemporaryDirectory() as directory: + path = Path(directory, "tatc_own_attributes.py") + path.write_text( + "LIMIT = 2\n\ndef score(x):\n return x * 1\n", encoding="utf-8" + ) + sys.path.insert(0, directory) + try: + module = importlib.import_module("tatc_own_attributes") + calling = _function( + "def f(x):\n return helpers.score(x) + helpers.LIMIT\n", + helpers=module, + ) + before = get_fingerprint(f=calling) + described = get_definition(f=calling)["values"]["f"]["globals"] + self.assertEqual( + set(described["helpers"]["attributes"]), {"score", "LIMIT"} + ) + # (of another size, so that its compiled code is not reused) + path.write_text( + "LIMIT = 2\n\ndef score(x):\n return x * 20\n", encoding="utf-8" + ) + importlib.reload(module) + self.assertNotEqual(before, get_fingerprint(f=calling)) + finally: + sys.path.remove(directory) + sys.modules.pop("tatc_own_attributes", None) + class TestOwnClasses(unittest.TestCase): """ diff --git a/tests/tradespace/test_layering.py b/tests/tradespace/test_layering.py index cb42fe47..f76c5a2b 100644 --- a/tests/tradespace/test_layering.py +++ b/tests/tradespace/test_layering.py @@ -15,6 +15,7 @@ PACKAGE = Path(tatc.tradespace.__file__).parent GENERAL = { + "alerts", "attribution", "comparison", "confirmation", @@ -31,10 +32,13 @@ "screening", "sensitivity", "space", + "statistics", "store", "study", + "summary", "utility", "values", + "walks", } """The modules of trade studies of any designs.""" diff --git a/tests/tradespace/test_observations.py b/tests/tradespace/test_observations.py index d495b986..60c63b70 100644 --- a/tests/tradespace/test_observations.py +++ b/tests/tradespace/test_observations.py @@ -14,6 +14,7 @@ from datetime import datetime, timedelta, timezone from functools import partial from pathlib import Path +from unittest import mock import numpy as np import pandas as pd @@ -51,8 +52,10 @@ risk_space, walker_space, ) +from tatc.tradespace.histories import exact_expectations, summarize_histories from tatc.tradespace.mission import summarize_phases from tatc.tradespace.observations import value_of +from tatc.tradespace.values import configure HAS_JOBLIB = importlib.util.find_spec("joblib") is not None @@ -71,6 +74,7 @@ COSTS = CostModel(SatelliteCost(development=10, first_unit=2)) PLAN = MissionPlan(SCHEDULE, COSTS, growth={"development": "growth"}) FAILURES = FailureModel(life=Exponential(0.2)) +DEGRADE = dataclasses.replace(PLAN, policy=RestorationPolicy(restore=False)) def _build(d): @@ -246,16 +250,14 @@ def test_phases_and_failures(self): # the years by which the plan deploys every satellite planned = [SCHEDULE.plan(d.layout).deployed for d in designs for _ in range(1)] self.assertEqual(list(phased.deployed), planned) - failures = Failures( - FAILURES, RestorationPolicy(restore=False), histories=4, seed="failure_seed" - ) + failures = Failures(FAILURES, histories=4, seed="failure_seed") degraded = ObservationStudy( SPACE, _build, _observations(), _metrics, layout="layout", - plan=PLAN, + plan=DEGRADE, failures=failures, ).run(designs) self.assertTrue({"observed mission", "availability", "cost"} <= set(degraded)) @@ -269,7 +271,7 @@ def test_phases_and_failures(self): _observations(), _metrics, plan=dataclasses.replace(PLAN, policy="policy"), - failures=Failures(FAILURES, histories=4, seed="failure_seed"), + failures=failures, ).run(trade.enumerate()[:4]) self.assertTrue(restored.feasible.all()) spares = restored.groupby("policy.orbit_spares")["cost production"].mean() @@ -296,13 +298,8 @@ def study(times, **options): _observations(), observed_at, layout="layout", - plan=PLAN, - failures=Failures( - FAILURES, - RestorationPolicy(restore=False), - histories=4, - seed="failure_seed", - ), + plan=DEGRADE, + failures=Failures(FAILURES, histories=4, seed="failure_seed"), replicates=2, **options, ) @@ -477,9 +474,15 @@ def stages(design): means.loc[True, "observed mission"], means.loc[False, "observed mission"] ) self.assertLess(means.loc[True, "cost"], means.loc[False, "cost"]) + # the stages deployed, and when the first generation is deployed + staged = phased.groupby("staged")[["stages deployed", "deployed"]].mean() + self.assertEqual(staged.loc[True, "stages deployed"], 0.0) + self.assertTrue(np.isnan(staged.loc[False, "stages deployed"])) # no stages + self.assertLess(staged.loc[True, "deployed"], staged.loc[False, "deployed"]) # failures without restoration: histories are sampled rather than exact - failures = Failures( - FAILURES, RestorationPolicy(restore=False), histories=4, seed="failure_seed" + failures = Failures(FAILURES, histories=4, seed="failure_seed") + options["plan"] = dataclasses.replace( + plan, policy=RestorationPolicy(restore=False) ) degraded = ObservationStudy( space, _build, _observations(), _metrics, failures=failures, **options @@ -508,11 +511,11 @@ def stages(design): for d in space.enumerate() if d.layout.planes == 2 and d.layout.per_plane == 1 ] - plan = MissionPlan(SCHEDULE, COSTS, stages=stages) - options = {"layout": "layout", "plan": plan, "replicates": 2} - failures = Failures( - FAILURES, RestorationPolicy(restore=False), histories=4, seed="failure_seed" + plan = MissionPlan( + SCHEDULE, COSTS, stages=stages, policy=RestorationPolicy(restore=False) ) + options = {"layout": "layout", "plan": plan, "replicates": 2} + failures = Failures(FAILURES, histories=4, seed="failure_seed") for summary in ({"phases": True}, {"failures": failures}): with self.subTest(summary=list(summary)): results = ObservationStudy( @@ -529,6 +532,172 @@ def stages(design): means.loc["never", "cost"], means.loc["delayed", "cost"] ) + def test_metrics_of_uncertain_values(self): + """The metrics of phases that read uncertain values of the design are + those of its replicate, and shared by the designs of a replicate.""" + space = SPACE.extend(u=Uncertain.uniform(0, 1)) + fixed = Targets(generate_points_rotated_lattice(N_POINTS, seed=1)) + + def metric(observations, design): + del observations + return {"m": design.u} + + study = ObservationStudy( + space, + _build, + Observations(fixed, START, HOURS), + metric, + plan=PLAN, + phases=True, + replicates=3, + ) + designs = space.enumerate()[:2] + results = study.run(designs) + self.assertEqual(results.u.nunique(), 3) + np.testing.assert_allclose(results["m mission"], results["m"]) + # with common random numbers, the designs of a replicate share a context + first, second = (study.realize(d, 1) for d in designs) + evaluation = study.evaluate + self.assertEqual(evaluation.context_of(first), evaluation.context_of(second)) + other = study.realize(designs[0], 2) + self.assertNotEqual(evaluation.context_of(first), evaluation.context_of(other)) + # metrics not given the design are cached by the observations alone + plain = study.replace(metrics=_metrics).evaluate + self.assertEqual(plain.context_of(first), plain.context_of(other)) + + def test_staging_recorded(self): + """Studies record the stages that rules deploy (without failures), and + when the first generation is deployed, with them.""" + space = DesignSpace(**SPACE.children, go=Categorical([False, True])) + designs = [ + d + for d in space.enumerate() + if d.layout.planes == 2 and d.layout.per_plane == 1 + ] + plan = MissionPlan( + SCHEDULE, COSTS, stages=lambda d: [Stage(1, 1.0, lambda _: d.go)] + ) + study = ObservationStudy( + space, _build, _observations(), _metrics, plan=plan, phases=True + ) + results = study.run(designs) + means = results.groupby("go")[["stages deployed", "deployed"]].mean() + self.assertEqual(list(means["stages deployed"]), [0.0, 1.0]) + # the first plane launched at 0.25, the second produced from the + # decision a year later, and launched at 1.5 + self.assertEqual(list(means["deployed"]), [0.25, 1.5]) + + def test_spares_of_the_policy(self): + """The policy of each design gives its spares, which are produced + whether or not the study has failures.""" + designs = [d for d in SPACE.enumerate() if d.altitude == 600e3] + + def study(policy): + plan = dataclasses.replace(PLAN, policy=policy) + return ObservationStudy( + SPACE, _build, _observations(), _metrics, plan=plan, phases=True + ) + + plain = study(RestorationPolicy()).run(designs) + spared = study(RestorationPolicy(orbit_spares=1, ground_spares=1)) + results = spared.run(designs) + # a spare in orbit in each plane and one on the ground, of 2 each + np.testing.assert_allclose( + results["cost production"] - plain["cost production"], + 2 * (plain.planes + 1), + ) + # (whose production delays the deployment of the planes) + self.assertTrue( + (results["observed mission"] <= plain["observed mission"]).all() + ) + self.assertTrue((results["deployed"] >= plain["deployed"]).all()) + mission = spared.mission_of(designs[-1]) + self.assertEqual({p.orbit_spares for p in mission.deployment.planes}, {1}) + # a policy of each design (or type), from its values + by_type = study(lambda d: RestorationPolicy(orbit_spares={None: 2})) + mission = by_type.mission_of(designs[-1]) + self.assertEqual({p.orbit_spares for p in mission.deployment.planes}, {2}) + with self.assertRaises(TypeError): + study(lambda d: "spares").run(designs[:1]) + # a group of values that configures the default policy, or a base one + space = SPACE.extend(policy=policy_space(restore=True, orbit_spares=1)) + realized = space.enumerate()[0].realize(0) + named = dataclasses.replace(PLAN, policy="policy").policy_of(realized) + self.assertEqual(named, RestorationPolicy(orbit_spares=1)) + base = RestorationPolicy(drift_years=1.0) + configured = dataclasses.replace( + PLAN, policy=lambda d: configure(base, d.policy) + ).policy_of(realized) + self.assertEqual(configured, RestorationPolicy(orbit_spares=1, drift_years=1.0)) + + def test_failure_times(self): + """Failures give each history the time until it meets requirements on + its phases, summarized over the histories.""" + failures = Failures( + FAILURES, + histories=6, + seed="failure_seed", + phases=[Requirement("observed", ">=", 50)], + quantiles={"observed time": 0.5}, + requirements=[Requirement("observed time", "<=", 1)], + ) + study = ObservationStudy( + SPACE, _build, _observations(), _metrics, plan=PLAN, failures=failures + ) + design = SPACE.enumerate()[3] + result = study.run([design]).iloc[0] + histories = study.mission_of(design).histories() + self.assertIn("observed time", histories) + summary = summarize_histories( + histories, + quantiles=failures.quantiles, + requirements=failures.requirements, + ) + for column in ( + "observed time", + "observed time histories p50", + "P(observed time <= 1)", + ): + self.assertEqual(result[column], summary[column]) + self.assertAlmostEqual( + result["P(observed time <= 1)"], (histories["observed time"] <= 1).mean() + ) + + def test_failure_validation(self): + """Failures are validated as they are made, and quantiles of costs need a + cost model.""" + for invalid in ( + {"sampling": "antithetic"}, + {"stress": 0.0}, + {"launch_stress": -1.0}, + {"histories": 0}, + ): + with self.subTest(invalid=invalid): + with self.assertRaises(ValueError): + Failures(FAILURES, **invalid) + with self.assertRaises(TypeError): + Failures(FAILURES, phases=["observed >= 50"]) + with self.assertRaisesRegex(ValueError, "cost model"): + ObservationStudy( + SPACE, + _build, + _observations(), + _metrics, + plan=MissionPlan(SCHEDULE), + failures=Failures(FAILURES, quantiles={"cost": 0.7}), + ) + # quantiles of other columns that the histories do not have + study = ObservationStudy( + SPACE, + _build, + _observations(), + _metrics, + plan=PLAN, + failures=Failures(FAILURES, quantiles={"other": 0.5}), + ) + with self.assertRaisesRegex(ValueError, "other"): + study.run(SPACE.enumerate()[:1]) + def test_replace(self): """Variants of an observation study replace its arguments.""" study = ObservationStudy(SPACE, _build, _observations(), _metrics) @@ -609,19 +778,24 @@ def test_mission(self): """The deployment, phases, and costs of a design are its evaluation's.""" result = self.study.run([self.design]).iloc[1] realized = self.study.realize(self.design, 1) - deployment = self.study.deployment_of(self.design, 1) + mission = self.study.mission_of(self.design, 1) + self.assertIs(mission.design.decisions, realized.decisions) + self.assertEqual(mission.design.growth, realized.growth) + deployment = mission.deployment self.assertEqual(deployment.planes, SCHEDULE.plan(realized.layout).planes) - self.assertIsNotNone(deployment.capability) - phases = self.study.phases_of(self.design, 1) + self.assertIs(deployment.capability, mission.capability) + phases = mission.phases() self.assertAlmostEqual( summarize_phases(phases)["observed mission"], result["observed mission"] ) - self.assertAlmostEqual( - self.study.estimate_of(self.design, 1).total, result["cost"] - ) + self.assertAlmostEqual(mission.estimate().total, result["cost"]) + self.assertEqual(mission.planned().deployed, result["deployed"]) + self.assertIs(mission.planned(), mission.planned()) + with self.assertRaisesRegex(ValueError, "failures"): + mission.histories() unplanned = self.study.replace(plan=None, phases=None) with self.assertRaisesRegex(ValueError, "plan"): - unplanned.deployment_of(self.design) + unplanned.mission_of(self.design) def test_realize(self): """A study realizes designs with its seed, and in its scenarios.""" @@ -672,7 +846,12 @@ def analysis(source): others(satellites, realized) with self.assertWarnsRegex(UserWarning, "other code"): latest(satellites, realized) - self.assertEqual(latest.prune(), len(satellites)) + stale = first.cache_of(realized).folder + self.assertEqual(len(list(stale.glob("*.pkl"))), len(satellites)) + # a study removes them too, and counts the evaluations it removes + study = ObservationStudy(SPACE, _build, latest, _metrics) + self.assertEqual(study.prune(), 0) # (without a store) + self.assertEqual(list(stale.glob("*.pkl")), []) self.assertEqual(latest.prune(), 0) # the results of the other targets (another definition) are kept kept = others.cache_of(realized).folder @@ -681,7 +860,7 @@ def analysis(source): def test_failure_options(self): """Failures sample stressed histories, with controls and spreads.""" - self.assertTrue(Failures(FAILURES).policy.restore) + self.assertTrue(MissionPlan(SCHEDULE).policy.restore) # restored by default study = ObservationStudy( SPACE, _build, @@ -726,14 +905,37 @@ def test_costs_and_histories(self): failures=Failures(FAILURES, histories=5, seed="failure_seed"), ) result = study.run([design]).iloc[0] - missions = study.missions_of(design) - self.assertEqual(len(missions), 5) - self.assertAlmostEqual(result["cost"], missions["cost"].mean()) + histories = study.mission_of(design).histories() + self.assertEqual(len(histories), 5) + self.assertAlmostEqual(result["cost"], histories["cost"].mean()) self.assertAlmostEqual( - result["observed mission"], missions["observed mission"].mean() + result["observed mission"], histories["observed mission"].mean() ) with self.assertRaisesRegex(ValueError, "failures"): - study.replace(failures=None).missions_of(design) + study.replace(failures=None).mission_of(design).histories() + + def test_exact_or_sampled(self): + """Without restoration, the means are exact expectations if the sets of + satellites are few enough, and otherwise those of the histories.""" + design = SPACE.enumerate()[3] + study = ObservationStudy( + SPACE, + _build, + _observations(), + _metrics, + plan=DEGRADE, + failures=Failures(FAILURES, histories=4, seed="failure_seed"), + ) + mission = study.mission_of(design) + exact = exact_expectations(mission.deployment, FAILURES, mission.capability) + sampled = mission.histories() + result = study.run([design]).iloc[0] + for column in ("observed mission", "availability"): + self.assertAlmostEqual(result[column], exact[column]) + with mock.patch("tatc.tradespace.plans.MAX_SETS", 1): + fallback = study.run([design]).iloc[0] + for column in ("observed mission", "availability"): + self.assertAlmostEqual(fallback[column], sampled[column].mean()) def test_exact_without_seed(self): """Without a seed, the one history without failures is not replaced by @@ -744,8 +946,8 @@ def test_exact_without_seed(self): _build, _observations(), _metrics, - plan=PLAN, - failures=Failures(FAILURES, RestorationPolicy(restore=False)), + plan=DEGRADE, + failures=Failures(FAILURES), ) result = study.run([design]).iloc[0] self.assertEqual(result["availability"], 1.0) diff --git a/tests/tradespace/test_optimization.py b/tests/tradespace/test_optimization.py index 08fc5567..1d9c0147 100644 --- a/tests/tradespace/test_optimization.py +++ b/tests/tradespace/test_optimization.py @@ -23,6 +23,7 @@ Requirement, Study, Uncertain, + aggregate, hypervolume, optimize_optuna, optimize_pymoo, @@ -77,6 +78,20 @@ def _study(**kwargs): return Study(_space(), _build, lambda metrics: metrics, replicates=2, **kwargs) +def _partly_infeasible(): + """A study of three designs, of which the first is feasible in every + replicate, the second in some, and the third in none, and its designs.""" + space = DesignSpace(x=Integer(0, 2), noise=Uncertain.uniform(0, 1)) + + def build(d): + if d.x == 2 or (d.x == 1 and d.noise < 0.5): + raise Infeasible("unlucky") + return d + + study = Study(space, build, lambda d: {"f": d.x}, replicates=8) + return study, space.enumerate() + + class TestEncoding(unittest.TestCase): """ Unit tests for encoding designs in the unit hypercube. @@ -141,6 +156,42 @@ def test_memo(self): evaluations.evaluate(designs) self.assertEqual(len(evaluations.results), 5 * 2) + def test_feasible_replicates(self): + """A design infeasible in some replicates is judged by the others, as + summaries judge it, unless a requirement on its share of feasible + replicates rejects it; a design without a feasible replicate is + infeasible.""" + study, designs = _partly_infeasible() + results = study.run(designs) + share = results[results.design == designs[1].key].feasible.mean() + self.assertGreater(share, 0) + self.assertLess(share, 1) + evaluations = Evaluations(study, {"f": "max"}) + values = evaluations.evaluate(designs) + self.assertEqual(values[:2], [(0.0,), (1.0,)]) + self.assertIsNone(values[2]) + self.assertEqual( + [evaluations.infeasibility[d.key] for d in designs], [0.0, 0.0, 1.0] + ) + # the summary of a search is that of its results (see aggregate) + search = evaluations.search(None) + pd.testing.assert_frame_equal(search.summary, aggregate(results, {"f": "max"})) + self.assertEqual([d.key for d in search.designs], [designs[1].key]) + self.assertEqual(len(search.evaluated), 3) + # a requirement on the share of feasible replicates + reliable = Criteria( + {"f": "max"}, requirements=[Requirement("feasible", ">=", 1)] + ) + evaluations = Evaluations(study, reliable) + evaluations.evaluate(designs) + self.assertEqual(evaluations.violations[designs[0].key], (0.0,)) + self.assertAlmostEqual(evaluations.violations[designs[1].key][0], 1 - share) + # a search of designs without a feasible replicate finds none + none = Evaluations(study, reliable) + none.evaluate(designs[2:]) + self.assertTrue(none.search(None).summary.empty) + self.assertEqual(none.search(None).designs, []) + def test_one_record_per_evaluation(self): """Objectives need one record per evaluation.""" study = Study( @@ -222,7 +273,13 @@ def test_optimize(self): search = optimize_pymoo(_study(), OBJECTIVES, termination=("n_gen", 15), seed=1) result, results = search.state, search.results self.assertEqual(result.F.shape[1], 2) - self.assertEqual({d.key for d in search.designs}, set(results.design)) + self.assertEqual({d.key for d in search.evaluated}, set(results.design)) + # the designs of a search are the efficient designs it found + self.assertEqual( + [d.key for d in search.designs], + list(search.summary.design[search.summary.pareto]), + ) + self.assertEqual(search.criteria.objectives, OBJECTIVES) found = summarize(results, list(OBJECTIVES)) self.assertGreater(hypervolume(found, OBJECTIVES, REFERENCE), 0.9 * exact) self.assertFalse(results.feasible.all()) # some designs were too heavy @@ -276,10 +333,42 @@ def test_distinct(self): plain = optimize_pymoo( _study(), OBJECTIVES, termination=("n_gen", 5), seed=1, distinct=False ) - self.assertGreater(len(distinct.designs), len(plain.designs)) + self.assertGreater(len(distinct.evaluated), len(plain.evaluated)) with self.assertRaises(ValueError): optimize_pymoo(_study(), OBJECTIVES, algorithm=object(), seed=1) + def test_max_designs(self): + """A search stops after the generation in which it has evaluated the + most designs, or by its termination.""" + from pymoo.algorithms.moo.nsga2 import ( # pylint: disable=import-outside-toplevel + NSGA2, + ) + + search = optimize_pymoo( + _study(), + OBJECTIVES, + NSGA2(pop_size=10), + ("n_gen", 50), + seed=1, + max_designs=25, + ) + evaluated = search.results.design.nunique() + self.assertGreaterEqual(evaluated, 25) + self.assertLess(evaluated, 25 + 10) + self.assertLess(search.state.algorithm.n_gen, 50) + # the termination, if first + short = optimize_pymoo( + _study(), + OBJECTIVES, + NSGA2(pop_size=10), + ("n_gen", 2), + seed=1, + max_designs=1000, + ) + self.assertLessEqual(short.results.design.nunique(), 20) + with self.assertRaises(ValueError): + optimize_pymoo(_study(), OBJECTIVES, max_designs=0) + @unittest.skipUnless(HAS_OPTUNA, "requires optuna") class TestOptunaConstraints(unittest.TestCase): @@ -458,37 +547,32 @@ def test_max_designs(self): ) optuna_study, results = search.state, search.results self.assertEqual(results.design.nunique(), 2) - # the designs of the search, in the order of their evaluation + # the designs evaluated by the search, in the order of their evaluation self.assertEqual( - [design.key for design in search.designs], + [design.key for design in search.evaluated], results.design.drop_duplicates().tolist(), ) self.assertLessEqual(len(optuna_study.trials), 50) + with self.assertRaises(ValueError): + optimize_optuna(study, {"f": "min"}, n_trials=5, max_designs=0) def test_partially_infeasible(self): - """A design infeasible in some replicates violates by their share.""" - space = DesignSpace(x=Integer(0, 1), noise=Uncertain.uniform(0, 1)) - - def build(d): - if d.x == 1 and d.noise < 0.5: - raise Infeasible("unlucky") - return d - - study = Study(space, build, lambda d: {"f": d.x}, replicates=8) - evaluations = Evaluations(study, {"f": "max"}) - values = evaluations.evaluate(space.enumerate()) - self.assertIsNotNone(values[0]) - self.assertIsNone(values[1]) - share = evaluations.infeasibility[space.enumerate()[1].key] - self.assertGreater(share, 0) - self.assertLess(share, 1) - # the summary of a search is of the designs it found feasible - summary = evaluations.search(None).summary - self.assertEqual(list(summary.design), [space.enumerate()[0].key]) - optuna_study = optimize_optuna(study, {"f": "max"}, n_trials=6).state + """A design without a feasible replicate violates the constraint of + feasibility; one infeasible in some replicates does not, but violates + a requirement on its share of feasible replicates.""" + study, designs = _partly_infeasible() + results = study.run(designs) + share = results[results.design == designs[1].key].feasible.mean() + reliable = Criteria( + {"f": "max"}, requirements=[Requirement("feasible", ">=", 1)] + ) + optuna_study = optimize_optuna(study, reliable, n_trials=12).state for trial in optuna_study.trials: - if trial.params.get("x") == 1: - self.assertAlmostEqual(trial.constraints["feasibility"], share) + x = trial.params.get("x") + feasibility = trial.constraints["feasibility"] + self.assertEqual(feasibility, 1.0 if x == 2 else 0.0) + if x == 1: + self.assertAlmostEqual(trial.constraints["feasible >= 1"], 1 - share) def test_records_checked_first(self): """A study of several records per evaluation fails after one design.""" diff --git a/tests/tradespace/test_pareto.py b/tests/tradespace/test_pareto.py index b6c10e27..7b71e1c4 100644 --- a/tests/tradespace/test_pareto.py +++ b/tests/tradespace/test_pareto.py @@ -97,11 +97,11 @@ def test_tolerance(self): ) # c is worse than a and b by 0.01 and 0.03 in value, within the # tolerance; d is not - loose = Criteria(objectives, tolerance={"value": 0.05}) + loose = Criteria(objectives, tolerances={"value": 0.05}) self.assertEqual(list(pareto_front(frame, loose)), [True, True, True, False]) self.assertEqual(list(pareto_ranks(frame, loose)), [0, 0, 0, 1]) # a larger tolerance keeps d (worse than a by 0.5 in value) - looser = Criteria(objectives, tolerance={"value": 0.6}) + looser = Criteria(objectives, tolerances={"value": 0.6}) self.assertTrue(pareto_front(frame, looser).all()) def test_requirements_and_groups(self): @@ -144,10 +144,10 @@ def test_relative(self): objectives = {"cost": "min", "value": "max"} # 5% of 96 (4.8) tolerates 96 against 100; 5% of 3 (0.15) does not # tolerate 3 against 4 - front = pareto_front(frame, Criteria(objectives, tolerance={"value": "5%"})) + front = pareto_front(frame, Criteria(objectives, tolerances={"value": "5%"})) self.assertEqual(list(front), [True, True, False, False]) # an absolute tolerance of 1 does not tolerate 96 against 100 - absolute = pareto_front(frame, Criteria(objectives, tolerance={"value": 1.0})) + absolute = pareto_front(frame, Criteria(objectives, tolerances={"value": 1.0})) self.assertEqual(list(absolute), [True, False, False, False]) @@ -320,7 +320,8 @@ def test_many_points(self): front = pareto_front(frame, {"a": "min", "b": "min", "c": "max"}) self.assertGreater(front.sum(), 0) tolerant = pareto_front( - frame, Criteria({"a": "min", "b": "min", "c": "max"}, tolerance={"c": "5%"}) + frame, + Criteria({"a": "min", "b": "min", "c": "max"}, tolerances={"c": "5%"}), ) self.assertTrue((tolerant >= front).all()) @@ -399,3 +400,69 @@ def test_not_efficient(self): self.assertEqual(list(pareto_front(summary, objectives)), [True, False, True]) self.assertEqual(list(pareto_ranks(summary, objectives)), [0, 1, 0]) self.assertAlmostEqual(hypervolume(summary, objectives, {"x": 3, "y": 2}), 3.0) + + +class TestFeasibleProbability(unittest.TestCase): + """ + Unit tests for the probability of efficiency of designs infeasible in + some replicates. + """ + + @staticmethod + def _results(feasible): + """Two designs in eight replicates: d1, better, is feasible only where + given.""" + return pd.DataFrame( + [ + { + "design": design, + "replicate": r, + "feasible": True if design == "d0" else feasible[r], + "cost": 1.0, + "value": 1.0 if design == "d0" else 2.0, + } + for design in ("d0", "d1") + for r in range(len(feasible)) + ] + ) + + def test_feasible_requirement(self): + """A requirement on the share of feasible replicates is uncertain in + the bootstrap.""" + results = self._results([True, False] * 4) + criteria = Criteria( + {"cost": "min", "value": "max"}, + requirements=[Requirement("feasible", ">=", 0.5)], + ) + probability = pareto_probability(results, criteria, n_resamples=200) + probability = probability.set_index("design") + self.assertEqual(probability.loc["d1", "feasible"], 0.5) + self.assertEqual(probability.loc["d1", "replicates"], 4) + met = probability.loc["d1", "requirements_probability"] + self.assertGreater(met, 0.2) + self.assertLess(met, 0.9) + self.assertEqual(probability.loc["d0", "requirements_probability"], 1.0) + # without the requirement, d1 is judged by its feasible replicates + plain = pareto_probability(results, {"cost": "min", "value": "max"}) + plain = plain.set_index("design") + self.assertEqual(plain.loc["d1", "pareto_probability"], 1.0) + self.assertEqual(plain.loc["d0", "pareto_probability"], 0.0) + + def test_no_feasible_design(self): + """Results without a feasible record have an empty summary.""" + results = self._results([False] * 4) + results = results[results.design == "d1"].drop(columns=["cost", "value"]) + probability = pareto_probability(results, {"cost": "min", "value": "max"}) + self.assertTrue(probability.empty) + self.assertEqual( + list(probability.columns[-6:]), + [ + "feasible", + "violation", + "meets_requirements", + "pareto", + "pareto_probability", + "requirements_probability", + ], + ) + self.assertIn("value se", probability.columns) diff --git a/tests/tradespace/test_plotting.py b/tests/tradespace/test_plotting.py index 29dc103f..48dc9826 100644 --- a/tests/tradespace/test_plotting.py +++ b/tests/tradespace/test_plotting.py @@ -210,6 +210,57 @@ def test_groups_of_values(self): [text.get_text() for text in ax.get_legend().get_texts()], ["one", "two"] ) + def test_missing_groups(self): + """Designs without a value of `by` are drawn in gray, named others.""" + from tatc.tradespace import GRAY # pylint: disable=import-outside-toplevel + from matplotlib.colors import ( # pylint: disable=import-outside-toplevel + to_rgba, + ) + + frame = pd.DataFrame( + { + "x": [1.0, 2.0, 3.0, 4.0], + "y": [1.0, 2.0, 3.0, 4.0], + "inclination": [50.0, 60.0, np.nan, np.nan], + "pareto": [False, False, True, True], + } + ) + ax = plot_designs(frame, "x", "y", by="inclination", front="pareto") + drawn = sum(len(c.get_offsets()) for c in ax.collections[:-1]) + self.assertEqual(drawn, len(frame)) + gray = ax.collections[-2] + self.assertEqual(len(gray.get_offsets()), 2) + np.testing.assert_allclose(gray.get_facecolor()[0][:3], to_rgba(GRAY)[:3]) + labels = [text.get_text() for text in ax.get_legend().get_texts()] + self.assertEqual(labels, ["50.0", "60.0", "other", "Pareto-efficient"]) + named = plot_designs(frame, "x", "y", by="inclination", others="sso") + labels = [text.get_text() for text in named.get_legend().get_texts()] + self.assertEqual(labels[-1], "sso") + # with highlights, the designs in gray share their name + both = plot_designs( + frame, + "x", + "y", + by="inclination", + highlight=[True, False, True, False], + others="the rest", + ) + labels = [text.get_text() for text in both.get_legend().get_texts()] + self.assertEqual(labels, ["the rest", "50.0", "60.0"]) + # means of records without a value of `by`, in gray + results = pd.DataFrame( + { + "satellites": [1, 2, 1, 2], + "sensor": ["a", "a", None, None], + "resolved": [1.0, 2.0, 3.0, 4.0], + } + ) + ax = plot_means(results, "satellites", "resolved", by="sensor") + self.assertEqual(len(ax.lines), 2) + self.assertEqual(to_rgba(ax.lines[1].get_color()), to_rgba(GRAY)) + labels = [text.get_text() for text in ax.get_legend().get_texts()] + self.assertEqual(labels, ["a", "other"]) + def test_style(self): """The style of plots applies to the figures of the session.""" import matplotlib as mpl # pylint: disable=import-outside-toplevel diff --git a/tests/tradespace/test_refinement.py b/tests/tradespace/test_refinement.py index 4606f654..b4c9d027 100644 --- a/tests/tradespace/test_refinement.py +++ b/tests/tradespace/test_refinement.py @@ -13,6 +13,7 @@ from tatc.tradespace import ( Criteria, DesignSpace, + Infeasible, Integer, Quantile, Study, @@ -64,8 +65,17 @@ def test_designs_of_results(self): rebuilt.results.drop(columns="seconds"), ) self.assertEqual( - [d.key for d in rebuilt.designs], [d.key for d in self.designs] + [d.key for d in rebuilt.candidates], [d.key for d in self.designs] ) + # the designs selected for the next step: the efficient designs + summary = rebuilt.summary + self.assertEqual( + [d.key for d in rebuilt.designs], list(summary.design[summary.pareto]) + ) + self.assertEqual(rebuilt.criteria, given.criteria) + # the evaluations added, over every round + self.assertEqual(rebuilt.evaluations, len(rebuilt.results) - len(self.results)) + self.assertGreater(rebuilt.evaluations, 0) keys = [d.key for d in self.designs[:4]] some = refine(self.study, OBJECTIVES, self.results, keys) added = some.results.iloc[len(self.results) :] @@ -146,7 +156,7 @@ def test_statistics(self): def test_tolerance(self): """A tolerance settles designs that are within it of the front.""" strict = pareto_probability(self.results, OBJECTIVES, n_resamples=300) - criteria = Criteria(OBJECTIVES, tolerance={"value": 2.0}) + criteria = Criteria(OBJECTIVES, tolerances={"value": 2.0}) tolerant = pareto_probability(self.results, criteria, n_resamples=300) # designs efficient for sure, of the better variant (within 2 of each other) self.assertGreater( @@ -225,7 +235,7 @@ def test_precision(self): ) designs = space.enumerate() results = study.run(designs) - criteria = Criteria(OBJECTIVES, tolerance={"value": 2.0}) + criteria = Criteria(OBJECTIVES, tolerances={"value": 2.0}) def refined(precision): refinement = refine( @@ -284,7 +294,7 @@ def test_precise(self): } ) # a tolerance of 10% of 100: precise below a standard error of 5 - criteria = Criteria(OBJECTIVES, tolerance={"value": "10%"}) + criteria = Criteria(OBJECTIVES, tolerances={"value": "10%"}) np.testing.assert_array_equal( _precise(probability, criteria, 0.5), [True, False, False] ) @@ -294,3 +304,25 @@ def test_precise(self): np.testing.assert_array_equal( _precise(probability, Criteria(OBJECTIVES), 0.5), [False, False, False] ) + + +class TestRefineInfeasible(unittest.TestCase): + """ + Unit tests for the refinement of results without a feasible design. + """ + + def test_no_feasible_design(self): + """Nothing is refined, and nothing is selected.""" + + def reject(design): + raise Infeasible("never") + + study = Study(_study().space, reject, lambda built: built, replicates=2) + with self.assertWarnsRegex(UserWarning, "feasible"): + results = study.run(study.space.enumerate()[:4]) + refinement = refine(study, OBJECTIVES, results, max_rounds=2, n_resamples=10) + self.assertTrue(refinement.summary.empty) + self.assertEqual(refinement.designs, []) + self.assertEqual(len(refinement.candidates), 4) + self.assertEqual(refinement.evaluations, 0) + self.assertEqual(len(refinement.results), len(results)) diff --git a/tests/tradespace/test_scenarios.py b/tests/tradespace/test_scenarios.py index 73833929..cabd3d2c 100644 --- a/tests/tradespace/test_scenarios.py +++ b/tests/tradespace/test_scenarios.py @@ -160,9 +160,8 @@ def test_invalid(self): with self.subTest(scenarios=scenarios): with self.assertRaises(TypeError): self._study(scenarios) - named = DesignSpace(x=Integer(1, 2), scenario=Fixed("a")) - with self.assertRaises(ValueError): - Study(named, lambda d: d, _evaluate, scenarios={"a": {}}) + with self.assertRaisesRegex(ValueError, "reserved"): + DesignSpace(x=Integer(1, 2), scenario=Fixed("a")) def _results(rows): @@ -241,7 +240,7 @@ def test_scale(self): def test_tolerance(self): """With tolerances, designs near the front are efficient, and regret is in tolerances by default.""" - criteria = Criteria(OBJECTIVES, tolerance={"cost": 2}) + criteria = Criteria(OBJECTIVES, tolerances={"cost": 2}) r = self._robustness(criteria=criteria) np.testing.assert_allclose(r["pareto_trace"], [0.5, 1.0, 1.0]) # A in s2: 3 short of B and C in perf @@ -274,6 +273,55 @@ def test_invalid(self): with self.assertRaises(ValueError): robustness(RESULTS, Criteria(OBJECTIVES, across=Across())) + def test_missing_objective(self): + """A design whose objective is missing in a scenario is not efficient + there, and its regret is infinite.""" + missing = RESULTS.copy() + missing.loc[(missing.design == "C") & (missing.scenario == "s2"), "perf"] = ( + math.nan + ) + r = self._robustness(results=missing) + self.assertEqual(r.loc["C", "s2 regret"], math.inf) + self.assertEqual(r.loc["C", "max_regret"], math.inf) + self.assertEqual(r.loc["C", "pareto_trace"], 0.0) + self.assertFalse(r[["max_regret", "s1 regret", "s2 regret"]].isna().any().any()) + + def test_design_values(self): + """Only objectives that are values of designs are given once; others + are given in each scenario, even if equal in every scenario.""" + rows = [] + for replicate, noise in enumerate((-1.0, 1.0)): + for design, (perf, cost) in {"A": (10, 5), "B": (8, 3)}.items(): + for scenario in ("s1", "s2"): + rows.append( + { + "design": design, + "replicate": replicate, + "scenario": scenario, + "feasible": True, + "perf": perf + noise, + "cost": cost, + } + ) + r = self._robustness(results=pd.DataFrame(rows)) + self.assertEqual(list(r.columns[:3]), ["s1 perf", "s2 perf", "cost"]) + np.testing.assert_allclose(r["s1 perf"], r["s2 perf"]) + # columns given as the values of designs + r = self._robustness(results=pd.DataFrame(rows), design_columns=[]) + self.assertEqual( + list(r.columns[:4]), ["s1 perf", "s2 perf", "s1 cost", "s2 cost"] + ) + + def test_scenario_column(self): + """The scenarios are the column of the criteria's `by`.""" + renamed = RESULTS.rename(columns={"scenario": "field"}) + r = robustness(renamed, Criteria(OBJECTIVES, by="field")).set_index("design") + pd.testing.assert_frame_equal(r, self._robustness()) + with self.assertRaises(ValueError): + robustness(renamed, OBJECTIVES) + with self.assertRaises(ValueError): + robustness(RESULTS, Criteria(OBJECTIVES, by=["scenario", "design"])) + def test_study(self): """The robustness of the designs of a study in scenarios.""" results = Study(SPACE, lambda d: d, _evaluate, scenarios=SCENARIOS).run() diff --git a/tests/tradespace/test_screening.py b/tests/tradespace/test_screening.py index fd265e56..8a771871 100644 --- a/tests/tradespace/test_screening.py +++ b/tests/tradespace/test_screening.py @@ -5,6 +5,7 @@ """ import unittest +import warnings import numpy as np @@ -14,7 +15,9 @@ Integer, Study, Uncertain, + confirm, pareto_front, + refine, screen, summarize, ) @@ -69,14 +72,19 @@ def test_keeps_whole_fronts(self): self.assertTrue((first[first.pareto_rank <= last_rank].kept).all()) self.assertFalse((first[first.pareto_rank > last_rank].kept).any()) self.assertEqual(len(screening.designs), first.kept.sum()) - self.assertEqual(set(screening.results.stage), {0, 1}) + self.assertEqual(set(screening.history.stage), {0, 1}) self.assertEqual(len(screening.summary), len(screening.designs)) + # the results of the last stage, which other steps continue + last = screening.history[screening.history.stage == 1] + self.assertEqual(len(screening.results), len(last)) + self.assertNotIn("stage", screening.results.columns) + self.assertEqual(screening.criteria.objectives, OBJECTIVES) def test_finds_front(self): """A tolerance of the noise of the first stage keeps the efficient designs.""" stages = [_study(0.3, 1), _study(0, 1)] # about two standard deviations of the noise of the first stage - cheap = Criteria(OBJECTIVES, tolerance={"value": 0.6}) + cheap = Criteria(OBJECTIVES, tolerances={"value": 0.6}) screening = screen(stages, [cheap, OBJECTIVES], self.designs, keep=0.1) final = screening.summary found = set(final.design[pareto_front(final, OBJECTIVES)]) @@ -92,7 +100,7 @@ def test_three_stages(self): """Values of keep and criteria can be given for each stage.""" screening = screen( [_study(0.5, 1), _study(0.1, 2), _study(0, 1)], - [Criteria(OBJECTIVES, tolerance={"value": 1.0}), OBJECTIVES, OBJECTIVES], + [Criteria(OBJECTIVES, tolerances={"value": 1.0}), OBJECTIVES, OBJECTIVES], self.designs, keep=[0.5, 10], ) @@ -107,10 +115,49 @@ def test_three_stages(self): with self.assertRaises(ValueError): screen([_study(0, 1)], Criteria(OBJECTIVES, by="sensor"), self.designs) + def test_next_steps(self): + """The results and designs of a screening continue in other steps.""" + full = _study(0, 2) + screening = screen([_study(0.3, 1), full], OBJECTIVES, self.designs, keep=10) + confirmation = confirm(full, OBJECTIVES, screening.results, screening.designs) + self.assertEqual( + {d.key for d in confirmation.designs}, {d.key for d in screening.designs} + ) + confirm(full, OBJECTIVES, screening.results) + with warnings.catch_warnings(): + warnings.simplefilter("ignore", UserWarning) # designs still uncertain + refinement = refine( + full, + OBJECTIVES, + screening.results, + screening.designs, + max_rounds=1, + n_resamples=20, + ) + self.assertEqual(len(refinement.candidates), len(screening.designs)) + + def test_keep(self): + """Designs are kept by a number of at least 1, or a share of at most 1.""" + stages = [_study(0, 1), _study(0, 1)] + designs = self.designs[:20] + everything = screen(stages, OBJECTIVES, designs, keep=1.0) + self.assertEqual(len(everything.designs), len(designs)) + for keep in (0, -1, 0.0, 1.5, -0.5, [0.5, 0]): + with self.subTest(keep=keep): + stages_of = ( + stages if not isinstance(keep, list) else stages + stages[:1] + ) + with self.assertRaises(ValueError): + screen(stages_of, OBJECTIVES, designs, keep=keep) + for keep in (True, "10", None): + with self.subTest(keep=keep): + with self.assertRaises(TypeError): + screen(stages, OBJECTIVES, designs, keep=keep) + def test_criteria_tolerance(self): """Every stage uses the tolerance of the criteria unless given its own.""" stages = [_study(0.3, 1), _study(0, 1)] - criteria = Criteria(OBJECTIVES, tolerance={"value": 0.6}) + criteria = Criteria(OBJECTIVES, tolerances={"value": 0.6}) tolerant = screen(stages, criteria, self.designs, keep=0.1) overridden = screen(stages, [OBJECTIVES, criteria], self.designs, keep=0.1) self.assertGreater(len(tolerant.designs), len(overridden.designs)) diff --git a/tests/tradespace/test_sensitivity.py b/tests/tradespace/test_sensitivity.py index fabdaa7b..6232b7f8 100644 --- a/tests/tradespace/test_sensitivity.py +++ b/tests/tradespace/test_sensitivity.py @@ -73,8 +73,10 @@ def test_results_raise(self): ) with self.assertRaisesRegex(ValueError, "aggregate"): sensitivity(results, ["a"], ["metric"]) - with self.assertRaisesRegex(ValueError, "aggregate"): + with self.assertRaisesRegex(ValueError, "aggregate") as context: main_effects(results, "a", "metric") + # summaries of designs in groups give a row of each design per group + self.assertNotIn("Criteria", str(context.exception)) def test_irrelevant_variable(self): """The adjusted share of a variable that does not matter is near 0.""" diff --git a/tests/tradespace/test_space.py b/tests/tradespace/test_space.py index 464eb8a3..e035d8f8 100644 --- a/tests/tradespace/test_space.py +++ b/tests/tradespace/test_space.py @@ -215,7 +215,8 @@ def test_common_random_numbers(self): other = designs[0].realize(3, seed=7).planes[0].phase self.assertNotIn(other, phases) independent = { - d.realize(2, seed=7, common=False).planes[0].phase for d in designs + d.realize(2, seed=7, common_random_numbers=False).planes[0].phase + for d in designs } self.assertEqual(len(independent), len(designs)) @@ -248,17 +249,17 @@ def test_scenario(self): design = space.enumerate()[0] plain = design.realize(3, seed=5) scenario = {"level": 3.0, "u": 0.25, "parts[*].k": 7} - changed = design.realize(3, seed=5, scenario=scenario) + changed = design.realize(3, seed=5, overrides=scenario) self.assertEqual((changed.level, changed.double, changed.u), (3.0, 6.0, 0.25)) self.assertEqual([part.k for part in changed.parts], [7, 7]) # other parameters are drawn as without the scenario self.assertEqual(changed.v, plain.v) self.assertEqual((plain.level, plain.double), (1.0, 2.0)) - self.assertEqual(design.realize(3, seed=5, scenario={}).flat(), plain.flat()) + self.assertEqual(design.realize(3, seed=5, overrides={}).flat(), plain.flat()) for values in ({"a": 2}, {"double": 1.0}, {"w": 1}): with self.subTest(values=values): with self.assertRaises(ValueError): - design.realize(3, scenario=values) + design.realize(3, overrides=values) def test_uncertain_paths(self): """Uncertain parameters are listed by path, with [*] for items.""" @@ -294,8 +295,10 @@ def test_shift(self): self.assertEqual( design.realize(3, shift={"u": 0}).flat(), design.realize(3).flat() ) - independent = design.realize(3, common=False, shift={"u": 10}) - self.assertEqual(independent.u, design.realize(13, common=False).u) + independent = design.realize(3, common_random_numbers=False, shift={"u": 10}) + self.assertEqual( + independent.u, design.realize(13, common_random_numbers=False).u + ) with self.assertRaises(ValueError): design.realize(3, shift={"w": 1}) with self.assertRaises(ValueError): @@ -312,7 +315,7 @@ class TestEnumeration(unittest.TestCase): def _every_walk(space): """Enumerates by walking every order of the items.""" # pylint: disable=import-outside-toplevel,protected-access - from tatc.tradespace.space import _Context, _Odometer + from tatc.tradespace.walks import _Context, _Odometer odometer = _Odometer() ctx = _Context(choose=odometer.choose) @@ -511,10 +514,14 @@ class TestReservedNames(unittest.TestCase): """ def test_reserved(self): - """Children and branches may not be named as attributes of views.""" + """Children and branches may not be named as attributes of views, or + as the status columns of the results of studies.""" for name in ("values", "items", "keys", "get", "key", "flat", "space"): with self.assertRaisesRegex(ValueError, "reserved"): DesignSpace(**{name: 1}) + for name in ("design", "feasible", "error", "seconds", "scenario"): + with self.assertRaisesRegex(ValueError, "reserved"): + DesignSpace(**{name: Integer(1, 2)}) for name in ("choice", "value"): with self.assertRaisesRegex(ValueError, "reserved"): Choice(**{name: DesignSpace()}) @@ -645,3 +652,222 @@ def test_counts_given(self): ) with self.assertRaisesRegex(ValueError, "items are given"): space.design({"n": 1, "parts": [0, 1]}) + + +class TestBranchNames(unittest.TestCase): + """ + Unit tests for choices given the names of their branches. + """ + + def test_override(self): + """A choice given its branch's name keeps the decisions given of it, or + decides it at its first levels.""" + space = _layouts_space() + walker = space.design({"altitude": 600e3, "layout": ["walker", {"planes": 2}]}) + sso = space.design(walker, layout="sso") + self.assertEqual(sso.layout, "sso") + self.assertEqual(sso.altitude, 600e3) + self.assertEqual( + sso.decisions["layout"], ["sso", {"planes": [{"crossing": 6.0}]}] + ) + again = space.design(walker, layout="walker") + self.assertEqual(again.key, walker.key) + # in the decisions too + first = space.design({"altitude": 500e3, "layout": "walker"}) + self.assertEqual(first.layout.planes, 1) + with self.assertRaisesRegex(ValueError, "not a level of layout"): + space.design(walker, layout="other") + + +class TestUnorderedLevels(unittest.TestCase): + """ + Unit tests for the order of the items of unordered repetitions. + """ + + def test_level_order(self): + """Unordered items are in the order of the levels of their decisions + (not of their text, as 10.5 precedes 9.0).""" + space = DesignSpace( + parts=Repeat( + DesignSpace(size=Real(9.0, 10.5, step=1.5), kind=Categorical("ba")), + count=2, + ordered=False, + ) + ) + design = space.design( + {"parts": [{"size": 10.5, "kind": "b"}, {"size": 9.0, "kind": "a"}]} + ) + self.assertEqual( + design.decisions["parts"], + [{"size": 9.0, "kind": "a"}, {"size": 10.5, "kind": "b"}], + ) + # by the first decision that differs, in the order of declaration + tied = space.design( + {"parts": [{"size": 9.0, "kind": "a"}, {"size": 9.0, "kind": "b"}]} + ) + self.assertEqual([p.kind for p in tied.parts], ["b", "a"]) + # enumerations and samples give the same order + keys = {d.key for d in space.enumerate()} + self.assertIn(design.key, keys) + self.assertLessEqual({d.key for d in space.sample(20, seed=1)}, keys) + + +class TestScenarioOverrides(unittest.TestCase): + """ + Unit tests for the overrides of scenarios, which are checked against the + constraints of design spaces. + """ + + def setUp(self): + self.space = DesignSpace( + n=Integer(1, 4), + limit=Fixed(4), + u=Uncertain.uniform(0, 1), + constraints=[lambda d: d.n - d.limit], + ) + + def test_constraints(self): + """A design that violates a constraint with the overrides is infeasible.""" + design = self.space.design({"n": 3}) + self.assertEqual(design.realize(0, overrides={"limit": 3}).limit, 3) + with self.assertRaisesRegex(Infeasible, "constraint 0"): + design.realize(0, overrides={"limit": 2}) + + def test_nan(self): + """A constraint that is NaN is not satisfied.""" + space = DesignSpace( + n=Integer(1, 4), + u=Uncertain.uniform(0, 1), + constraints=[lambda d: d.n - 10 * d.u], + ) + self.assertEqual(space.size(), 0) + with self.assertRaisesRegex(Infeasible, "NaN") as context: + space.design({"n": 1}) + self.assertEqual(context.exception.violation, 1) + + def test_scenario_name(self): + """A realized design gives the name of its scenario.""" + design = self.space.design({"n": 1}) + self.assertIsNone(design.scenario) + self.assertIsNone(design.realize(0).scenario) + named = design.realize(0, overrides={"u": 0.5}, scenario="half") + self.assertEqual((named.scenario, named.u), ("half", 0.5)) + self.assertIn("scenario='half'", repr(named)) + + def test_checks(self): + """Paths of shifts and overrides are checked by the design space.""" + space = _planes_space() + space.check_uncertain(["planes[*].phase"]) + space.check_overrides({"planes[*].phase": 1.0}) + self.space.check_overrides({"limit": 1, "u": 0.5}) + for paths in (["planes[0].phase"], ["per_plane"], ["planes[*]"], [1]): + with self.subTest(paths=paths): + with self.assertRaisesRegex(ValueError, "not uncertain"): + space.check_uncertain(paths) + with self.assertRaisesRegex(ValueError, "not fixed values"): + self.space.check_overrides({"n": 2}) + + def test_seed(self): + """Seeds are non-negative integers.""" + design = self.space.design({"n": 1}) + for seed in (-1, 1.5, True): + with self.subTest(seed=seed): + with self.assertRaisesRegex(ValueError, "seed"): + design.realize(0, seed=seed) + + +class TestKeywords(unittest.TestCase): + """ + Unit tests for options given by keyword only. + """ + + def test_keywords(self): + """The options of samples and realizations are keywords.""" + space = _planes_space() + with self.assertRaises(TypeError): + space.sample(5, "random") # pylint: disable=too-many-function-args + with self.assertRaises(TypeError): + space.enumerate()[0].realize(0, 1) # pylint: disable=too-many-function-args + + +class TestDesignsOfSpaces(unittest.TestCase): + """ + Unit tests for designs given to the functions of trade studies. + """ + + def test_other_spaces(self): + """Designs of other design spaces are the designs of their decisions.""" + # pylint: disable=import-outside-toplevel,protected-access + from tatc.tradespace.space import _designs + + space = DesignSpace(n=Integer(1, 2), altitude=Fixed(500)) + higher = space.extend(altitude=Fixed(700)) + designs = _designs(higher, space.enumerate()) + self.assertTrue(all(d.space is higher for d in designs)) + self.assertEqual([d.altitude for d in designs], [700, 700]) + same = higher.enumerate() + self.assertTrue(all(a is b for a, b in zip(_designs(higher, same), same))) + + def test_frames(self): + """Designs rebuilt from frames read the frame's keys once, and a frame + that lacks their values gives the reason.""" + # pylint: disable=import-outside-toplevel,protected-access + from tatc.tradespace.space import _designs + + class Counted(pd.DataFrame): + """A data frame that counts the reads of its keys of designs.""" + + reads = 0 + + @property + def _constructor(self): + return Counted + + def __getitem__(self, key): + if isinstance(key, str) and key == "design": + Counted.reads += 1 + return super().__getitem__(key) + + space = DesignSpace(a=Integer(0, 99), b=Integer(0, 4)) + designs = space.enumerate() + rows = pd.DataFrame( + [ + {"design": d.key, "replicate": r, **d.flat()} + for d in designs + for r in (0, 1) + ] + ) + keys = [d.key for d in designs] + rebuilt = _designs(space, keys, Counted(rows)) + self.assertEqual([d.key for d in rebuilt], keys) + self.assertLess(Counted.reads, 10) + with self.assertRaisesRegex(ValueError, "not given") as context: + _designs(space, keys[:2], rows.drop(columns="b")) + self.assertIn("no value of b", str(context.exception.__cause__)) + + +class TestConfigure(unittest.TestCase): + """ + Unit tests for dataclasses configured from the values of designs. + """ + + def test_design(self): + """A dataclass is configured from a design, or a view of its values.""" + # pylint: disable=import-outside-toplevel + import dataclasses + + from tatc.tradespace.values import configure + + @dataclasses.dataclass(frozen=True) + class Policy: + """A policy of two fields.""" + + spares: int = 0 + years: float = 1.0 + + design = DesignSpace(spares=Integer(1, 2), other=Integer(0, 1)).enumerate()[-1] + self.assertEqual(configure(Policy(), design), Policy(spares=2)) + self.assertEqual(configure(Policy(), design.values), Policy(spares=2)) + self.assertEqual(configure(Policy(), design, years=2.0).years, 2.0) + with self.assertRaisesRegex(TypeError, "values of a design"): + configure(Policy(), 3) diff --git a/tests/tradespace/test_stages.py b/tests/tradespace/test_stages.py index 7d93d499..456ccf4c 100644 --- a/tests/tradespace/test_stages.py +++ b/tests/tradespace/test_stages.py @@ -7,6 +7,7 @@ import dataclasses import unittest +import numpy as np import pandas as pd from tatc.tradespace import ( @@ -20,7 +21,7 @@ Stage, walker_space, ) -from tatc.tradespace.histories import expected_missions +from tatc.tradespace.histories import exact_expectations from tatc.tradespace.mission import Capability, PhaseCache # three planes of two satellites @@ -76,6 +77,10 @@ def test_planned_delay(self): self.assertEqual(launched[1], (decided + 2 / 4 + 3, "replacement")) self.assertEqual(history.operating[2, 0][0][0], decided + 2 / 4) self.assertEqual(history.metrics()["stages deployed"], 1.0) + # the first generation is deployed with the stage + self.assertEqual(history.deployed, decided + 2 / 4) + self.assertEqual(deployment.deployed, decided + 2 / 4) + self.assertLess(SCHEDULE.plan(_layout()).deployed, deployment.deployed) def test_sustained(self): """A deployed stage of a sustained constellation is replaced after the @@ -103,6 +108,29 @@ def test_not_deployed(self): plain = SCHEDULE.plan(_layout()) self.assertLess(COSTS.estimate(never).total, COSTS.estimate(plain).total) self.assertNotIn("stages deployed", plain.simulate().metrics()) + self.assertEqual(never.deployed, history.deployed) + + def test_cost_of_the_option(self): + """A type of satellite whose planes are all staged costs its + development, whether or not they are deployed: the cost of the option.""" + plane = ( + DesignSpace(layout=walker_space(inclination=60, planes=1, per_plane=2)) + .enumerate()[0] + .layout + ) + model = CostModel( + { + "a": SatelliteCost(development=10, first_unit=1), + "b": SatelliteCost(development=50, first_unit=1), + } + ) + never = DeploymentSchedule(years=5, development_years=1).plan( + {"a": plane, "b": plane}, stages=[Stage(1, 0.0, lambda decision: False)] + ) + estimate = model.estimate(never) + self.assertEqual(never.simulate().stages, [None]) + self.assertEqual(estimate.units, {"a": 2}) + self.assertEqual(estimate.development, 10 + 50) def test_decisions(self): """Rules decide at their times, until they deploy, from what is known.""" @@ -238,6 +266,12 @@ def metric(observations): cached(["s0", "s1"]) cached(["s1", "s0"]) self.assertEqual((cache.hits, cache.misses), (1, 1)) + # which the cache gives by their keys (and the context) + keys = {"s0": "s0", "s1": "s1"} + self.assertEqual(cache.metrics_of(keys, OBSERVATIONS), {"observing": 2.0}) + self.assertEqual((cache.hits, cache.misses), (2, 1)) + cache.metrics_of(keys, OBSERVATIONS, context="other") + self.assertEqual((cache.hits, cache.misses), (2, 2)) def test_lead_and_launches(self): """A lead time delays production, and launch capacity splits launches.""" @@ -245,7 +279,7 @@ def test_lead_and_launches(self): years=5, development_years=1, production_rate=4, launch_capacity=1 ) deployment = schedule.plan( - _layout(), spares=1, stages=[Stage(2, 1.0, lead_years=0.5)] + _layout(), orbit_spares=1, stages=[Stage(2, 1.0, lead_years=0.5)] ) history = deployment.simulate() # the line is free by the end of the lead time @@ -262,7 +296,7 @@ def test_exact_expectations(self): """Exact expectations need a deployment that is not staged.""" deployment = SCHEDULE.plan(_layout(), stages=[Stage(2, 1.0)]) with self.assertRaises(ValueError): - expected_missions( + exact_expectations( deployment, FailureModel(life=Exponential(0.2)), Capability([], None, len), @@ -285,6 +319,16 @@ def test_invalid(self): with self.assertRaises(ValueError): Stage(1, lead_years=-1) + def test_numpy_values(self): + """Stages take integers and arrays of numpy as planes and times.""" + stage = Stage(np.int64(1), np.float64(0.5)) + self.assertEqual((stage.planes, stage.times), ((1,), (0.5,))) + stage = Stage(np.array([2, 1]), np.array([1.0, 0.0])) + self.assertEqual((stage.planes, stage.times), ((2, 1), (0.0, 1.0))) + self.assertEqual(Stage([1], range(3)).times, (0.0, 1.0, 2.0)) + deployment = SCHEDULE.plan(_layout(), stages=[Stage(np.int64(2), 1.0)]) + self.assertEqual(deployment.simulate().stages, [deployment.begin + 1.0]) + if __name__ == "__main__": unittest.main() diff --git a/tests/tradespace/test_store.py b/tests/tradespace/test_store.py index dbefd6a2..4e42cce8 100644 --- a/tests/tradespace/test_store.py +++ b/tests/tradespace/test_store.py @@ -201,6 +201,42 @@ def study(evaluate): self.assertEqual(current.prune(), 0) self.assertEqual(constant.prune(), 0) + def test_warning_location(self): + """The warning of evaluations with other code points at the run.""" + store = ResultStore(self.path, "where") + + def study(evaluate): + return Study(self.space, lambda d: d, evaluate, store=store) + + study(lambda d: {"value": d.a + 1}).run() + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always") + study(lambda d: {"value": d.a * 1}).run() + (warning,) = [w for w in caught if "other code" in str(w.message)] + self.assertEqual(Path(warning.filename).resolve(), Path(__file__).resolve()) + + def test_prune_definitions(self): + """Definitions kept without evaluations (of a study whose evaluations + all failed) are of the study's contexts, which pruning removes.""" + store = ResultStore(self.path, "failed") + + def study(evaluate, **kwargs): + return Study(self.space, lambda d: d, evaluate, store=store, **kwargs) + + broken = study(lambda d: {"value": d.a / 0}, errors="record") + with self.assertWarnsRegex(UserWarning, "none of the 4 designs"): + broken.run() + self.assertEqual(store.contexts(), {broken.fingerprint: 0}) + self.assertEqual(len(store), 0) + # the same study with other code (of the same constants) + fixed = study(lambda d: {"value": d.a * 0}) + with warnings.catch_warnings(): + warnings.simplefilter("error") # no evaluations to warn of + fixed.run() + self.assertEqual(fixed.prune(), 0) + self.assertEqual(store.contexts(), {fixed.fingerprint: 4}) + self.assertIsNone(store.definition(broken.fingerprint)) + def test_records_as_json(self): """Records are kept as JSON, and read as they were written.""" record = { diff --git a/tests/tradespace/test_study.py b/tests/tradespace/test_study.py index 47b9f456..a01989d1 100644 --- a/tests/tradespace/test_study.py +++ b/tests/tradespace/test_study.py @@ -24,6 +24,7 @@ ) from tatc.tradespace import ( DesignSpace, + Fixed, Infeasible, Integer, Real, @@ -436,3 +437,151 @@ def test_reserved_index(self): results = Study(space, lambda d: d, lambda d: renamed).run() self.assertEqual(list(results.a), [1, 2]) self.assertEqual(list(results.sensor), [0, 0]) + + +class TestDesignsOfOtherSpaces(unittest.TestCase): + """ + Unit tests for designs of other design spaces given to a study. + """ + + def test_evaluated_in_study_space(self): + """Designs of another design space are evaluated as the designs of the + study's design space, also with a store and new uncertain parameters.""" + space = DesignSpace(n=Integer(1, 2), altitude=Fixed(500)) + designs = space.enumerate() + higher = space.extend(altitude=Fixed(700)) + with tempfile.TemporaryDirectory() as directory: + store = ResultStore(Path(directory) / "results.sqlite") + study = Study( + higher, lambda d: d.altitude * d.n, lambda x: {"score": x}, store=store + ) + self.assertEqual(list(study.run(designs).score), [700, 1400]) + self.assertEqual(list(study.run().score), [700, 1400]) + self.assertEqual(study.realize(designs[0], 0).altitude, 700) + risky = space.extend(growth=Uncertain.uniform(1, 2)) + results = Study(risky, lambda d: d.n * d.growth, lambda x: {"s": x}).run( + designs + ) + self.assertTrue(results.growth.between(1, 2).all()) + + +class TestStudyScenarios(unittest.TestCase): + """ + Unit tests for the constraints of design spaces in the scenarios of a + study, and the names of scenarios of realized designs. + """ + + def test_infeasible_in_scenario(self): + """A design that violates a constraint in a scenario is infeasible in it.""" + space = DesignSpace( + n=Integer(1, 4), limit=Fixed(4), constraints=[lambda d: d.n - d.limit] + ) + study = Study( + space, + lambda d: d.n, + lambda x: {"score": x}, + scenarios={"strict": {"limit": 2}, "loose": {}}, + ) + results = study.run() + feasible = results.pivot(index="n", columns="scenario", values="feasible") + self.assertEqual(list(feasible.loose), [True] * 4) + self.assertEqual(list(feasible.strict), [True, True, False, False]) + errors = results[~results.feasible].error + self.assertTrue(errors.str.contains("constraint 0").all()) + # with the values of the design, from which designs are rebuilt + rebuilt = space.designs_of(results) + self.assertEqual(list(rebuilt.map(lambda d: d.n)), list(results.n)) + with self.assertRaises(Infeasible): + study.realize(space.design({"n": 4}), 0, "strict") + + def test_scenario_of_design(self): + """An evaluation is given the design realized in its scenario.""" + space = DesignSpace(n=Integer(1, 2), level=Fixed(1.0)) + study = Study( + space, + lambda d: d, + lambda d, design: {"named": design.scenario, "level": design.level}, + scenarios={"high": {"level": 3.0}, "low": {}}, + ) + results = study.run() + self.assertEqual(list(results.named), list(results.scenario)) + self.assertEqual(set(results[results.scenario == "high"].level), {3.0}) + self.assertEqual( + study.realize(space.enumerate()[0], 0, "high").scenario, "high" + ) + self.assertIsNone( + Study(space, lambda d: d, dict).realize(space.enumerate()[0]).scenario + ) + + +class TestArguments(unittest.TestCase): + """ + Unit tests for the arguments of studies. + """ + + def test_seed(self): + """A seed is a non-negative integer, checked by the study.""" + space = DesignSpace(n=Integer(1, 2), u=Uncertain.uniform(0, 1)) + with self.assertRaisesRegex(ValueError, "seed"): + Study(space, lambda d: d.u, lambda x: {"s": x}, seed=-1) + + def test_keywords(self): + """The settings of a study are keywords.""" + space = DesignSpace(n=Integer(1, 2)) + with self.assertRaises(TypeError): + Study(space, lambda d: d, dict, 3) # pylint: disable=too-many-function-args + + +class TestEmptyResults(unittest.TestCase): + """ + Unit tests for evaluations without records and runs without evaluations. + """ + + def setUp(self): + self.space = DesignSpace(n=Integer(0, 2)) + + @staticmethod + def _evaluate(n): + # a record per sensor, of which a design may have none + frame = pd.DataFrame({"sensor": list(range(n)), "score": [1.0] * n}) + return frame.set_index("sensor") + + def test_empty_frame(self): + """An evaluation that gives an empty data frame raises an error.""" + for errors in ("raise", "record"): + with self.subTest(errors=errors): + study = Study(self.space, lambda d: d.n, self._evaluate, errors=errors) + with self.assertRaisesRegex(ValueError, "empty data frame"): + study.run() + + def test_no_designs(self): + """A run of no designs gives the status columns of results.""" + results = Study(self.space, lambda d: d.n, self._evaluate).run([]) + self.assertEqual( + list(results.columns), + ["design", "replicate", "feasible", "error", "seconds"], + ) + self.assertEqual(len(results), 0) + scenarios = Study( + self.space, lambda d: d.n, self._evaluate, scenarios={"a": {}} + ).run([]) + self.assertEqual( + list(scenarios.columns)[:3], ["design", "replicate", "scenario"] + ) + + +class TestWarningLocation(unittest.TestCase): + """ + Unit tests for the location of the warnings of studies. + """ + + def test_no_feasible_designs(self): + """The warning of no feasible designs points at the run.""" + + def build(d): + raise Infeasible("never") + + study = Study(DesignSpace(a=Integer(1, 2)), build, dict) + with self.assertWarnsRegex(UserWarning, "none of the 2 designs") as context: + study.run() + self.assertEqual(Path(context.filename).resolve(), Path(__file__).resolve()) diff --git a/tests/tradespace/test_utility.py b/tests/tradespace/test_utility.py index 9cfff8c2..31537736 100644 --- a/tests/tradespace/test_utility.py +++ b/tests/tradespace/test_utility.py @@ -19,9 +19,12 @@ Probability, Quantile, Requirement, + StandardDeviation, + StandardError, Utility, aggregate, pareto_front, + summarize, ) @@ -187,6 +190,25 @@ def test_statistics(self): self.assertEqual(Mean(self.utility), Mean(self.utility)) self.assertEqual(len({Mean(self.utility), Mean(self.utility)}), 1) + def test_summarize(self): + """Summaries give the spread of the mean of a utility, as of a column.""" + criteria = Criteria( + {"utility": "max", "cost": "min"}, statistics=[Mean(self.utility)] + ) + summary = summarize(_results(), criteria).set_index("design") + for column in ("utility std", "utility se", "cost std", "cost se"): + self.assertIn(column, summary.columns) + spread = aggregate( + _results(), + criteria, + statistics={ + "utility std": StandardDeviation(self.utility), + "utility se": StandardError(self.utility), + }, + ).set_index("design") + pd.testing.assert_series_equal(summary["utility se"], spread["utility se"]) + self.assertEqual(summary.loc["y", "utility std"], 0.0) + def test_utility_against_cost(self): """Designs trade the utility of their metrics against cost.""" criteria = Criteria( From 28b6e2a567dfb3ca7d22ae75fc7a8b559104ea45 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Sat, 14 Nov 2026 09:28:28 -0700 Subject: [PATCH 48/52] give generate_points_fibonacci_lattice a count of points and a random orientation (count, rotate, and seed) in place of generate_points_rotated_lattice, whose rotated lattices now also sample masks that cross the antimeridian --- CHANGELOG.md | 2 +- docs/api_reference/generation/index.rst | 1 - .../tradespace/EvaluateTradeSpace.ipynb | 65 ++++--- .../tradespace/trade_space_example.py | 6 +- src/tatc/generation/__init__.py | 2 - src/tatc/generation/points.py | 172 +++++++++--------- src/tatc/tradespace/observations.py | 4 +- tests/generation/test_points.py | 70 +++++-- tests/tradespace/test_fingerprint.py | 8 +- tests/tradespace/test_observations.py | 24 ++- 10 files changed, 208 insertions(+), 146 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2fd9f938..d48d865d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,7 +11,7 @@ Added: - Field `blind_intervals` of `Attitude`: intervals of argument of latitude in which a space system's instruments do not observe, for example while the body or a mechanism moves. Observations in them are not valid, so point observations, ground tracks (`valid_obs`, and the swaths of `compute_ground_track`), orbit tracks, and ground pixels omit them, and the periods and swaths of region observations end at them. Method `is_observing` of attitudes, schedules, and instruments. - Field `is_swept` of `PointedInstrument`, for an instrument whose view sweeps along track: its footprint over a time step is the strip its cross-track line (the directions at an along-track angle of zero, which `collect_observations` checks) sweeps between the step's bounds, trimmed to blind intervals, so that ground track swaths (`compute_ground_track`) and region swaths do not depend on the time step, while its along-track field of view still sets the instantaneous view. Method `PointedInstrument.compute_swept_footprints`, utility method `compute_swept_footprints`, argument `time_step` of `collect_ground_track` and `compute_ground_track` (the span of each footprint, by default half the gap to the neighboring times on each side), and runtime configuration `swept_footprint_max_substep`. The default, `False`, leaves footprints unchanged. - Field `type` (`instrument`, `pointed`, or `conical`) of `Instrument`, `PointedInstrument`, and `ConicalInstrument`, which identifies the instrument class in serialized data. Data without a `type` loads as the class its fields imply. - - Function `generation.generate_points_rotated_lattice`, the points of a Fibonacci lattice in a random orientation: a stratified sample of the sphere (or of a mask), each point uniform by area, whose statistics have about 1.5 to 4 times less variance between replicates of trade studies than those of random points. + - Arguments `count`, `rotate`, and `seed` of `generation.generate_points_fibonacci_lattice`: a lattice of a number of points (about that many inside a mask) in place of a distance between them, and in a random orientation, drawn from a seed: a stratified sample of the sphere (or of a mask), each point uniform by area, whose statistics have about 1.5 to 4 times less variance between replicates of trade studies than those of random points. - Analysis methods of the statistical sufficiency of observations (module `analysis.sufficiency`): `estimate_sampling_error`, the error of estimating the mean of a field over a period from each target's samples, for a field with a standard deviation and an exponential correlation in time (exact, see `sampling_error_variance`), with the effective number of independent samples; `sample_field`, which samples a field (an xarray `DataArray`, such as a nature run) at the time and place of each observation, and `compare_sampled_means`, which measures the sampling error against it; `compute_revisit_statistics`, the quantiles of revisits and the longest gap of each target (including the edges of the period); and `compute_local_time_coverage`, the distribution of samples in local time of day. The decorrelation time of `estimate_sampling_error` may differ between targets. The validation notebook `ValidateSamplingErrorIMERG` compares its predictions with the errors of monthly means of IMERG precipitation sampled by four constellation designs, and the example notebook `AssessSamplingSufficiency` shows the qualities of the methods with a synthetic nature run. `estimate_sampling_error` and `compute_revisit_statistics` compute the statistics of every target at once (the sum of the correlations between pairs of samples by a recursion over their times, and the gaps and their quantiles from the samples in order), with the same results 3 to 12 times faster. - Module `tradespace` (prototype) for trade studies. A `DesignSpace` declares design variables (`Real`, `Integer`, `Categorical`), fixed and `Derived` values, and `Uncertain` parameters (drawn per replicate, not searched), grouped hierarchically with `Choice` (one of several branches) and `Repeat` (a variable number of items, such as orbit planes, optionally unordered). Bounds, derived values, and constraints are callables of the values decided before them. `DesignSpace.enumerate` gives every feasible design (a full factorial design, including variables that exist only in some designs), and `sample` a Latin hypercube or random sample. A `Design` has a `key` from its decisions and `flat` values by path, and `realize` draws a replicate's uncertain parameters, with common random numbers between designs by default. `Study` builds and evaluates designs in replicates into a data frame, in worker processes with `n_jobs` (or on an `executor`; idle workers wait two minutes for more evaluations before they exit), giving the realized design to an evaluation function with a parameter named `design`, recording as infeasible the designs that its functions reject with `Infeasible` or that fail the validation of TAT-C's schemas (other errors, including other `ValueError`s, are raised or recorded as failed), and raising an error for metrics that would replace its status columns or a design's values; `summarize` gives the mean, standard deviation, and standard error of metrics over replicates. - Class `tradespace.SatelliteCache`, which caches an analysis of single satellites by their content (orbit, instruments, and attitude, not their name, see `get_satellite_key`), in memory or on disk, so that designs that share satellites compute their results once. On disk, results are kept by namespace and by the definition of the function (see `get_definition`); a cache warns if its namespace has results only of its function with other code, naming what differs, `SatelliteCache.prune` removes the results of other definitions, and results that cannot be read are computed again. diff --git a/docs/api_reference/generation/index.rst b/docs/api_reference/generation/index.rst index 426605cd..475089a4 100644 --- a/docs/api_reference/generation/index.rst +++ b/docs/api_reference/generation/index.rst @@ -34,7 +34,6 @@ Weights for random points can be read from a GeoTIFF raster with Rotated Lattice --------------- -.. autofunction:: tatc.generation.generate_points_rotated_lattice Cells ===== diff --git a/docs/examples/tradespace/EvaluateTradeSpace.ipynb b/docs/examples/tradespace/EvaluateTradeSpace.ipynb index 0c6a515d..2362dc26 100644 --- a/docs/examples/tradespace/EvaluateTradeSpace.ipynb +++ b/docs/examples/tradespace/EvaluateTradeSpace.ipynb @@ -35,10 +35,10 @@ "id": "bc7b296c", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:03.292530Z", - "iopub.status.busy": "2026-11-14T15:43:03.292530Z", - "iopub.status.idle": "2026-11-14T15:43:05.430329Z", - "shell.execute_reply": "2026-11-14T15:43:05.430329Z" + "iopub.execute_input": "2026-11-14T16:16:57.069687Z", + "iopub.status.busy": "2026-11-14T16:16:57.069687Z", + "iopub.status.idle": "2026-11-14T16:16:59.395918Z", + "shell.execute_reply": "2026-11-14T16:16:59.395918Z" } }, "outputs": [], @@ -84,10 +84,10 @@ "id": "c05d366a", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:05.430329Z", - "iopub.status.busy": "2026-11-14T15:43:05.430329Z", - "iopub.status.idle": "2026-11-14T15:43:05.540746Z", - "shell.execute_reply": "2026-11-14T15:43:05.540746Z" + "iopub.execute_input": "2026-11-14T16:16:59.397926Z", + "iopub.status.busy": "2026-11-14T16:16:59.397926Z", + "iopub.status.idle": "2026-11-14T16:16:59.523326Z", + "shell.execute_reply": "2026-11-14T16:16:59.523326Z" } }, "outputs": [ @@ -147,11 +147,10 @@ "2. **observe** points on the Earth for a day (`Observations` of `Targets`);\n", "3. **measure** the observations: the share of points observed at least four times (`count_samples`).\n", "\n", - "The points are a random sample of the Earth, so a share is an estimate, with sampling error. The study therefore evaluates each design five times, in five **replicates**. Each replicate draws its own sample of points from the uncertain `points_seed`, and every design sees the same five samples, so that differences between designs are not differences between their samples. The points of a sample are a lattice in a random orientation (`generate_points_rotated_lattice`), which covers the Earth evenly.\n", + "The points are a random sample of the Earth, so a share is an estimate, with sampling error. The study therefore evaluates each design five times, in five **replicates**. Each replicate draws its own sample of points from the uncertain `points_seed`, and every design sees the same five samples, so that differences between designs are not differences between their samples. The points of a sample are a Fibonacci lattice in a random orientation (`generate_points_fibonacci_lattice` with `rotate=True`), which covers the Earth evenly.\n", "\n", - "`ObservationStudy` combines the three steps. Its other arguments:\n", + "`ObservationStudy` combines the three steps, and counts the satellites and planes of each design's `layout`. Its other arguments:\n", "\n", - "* `layout` names the decision whose satellites and planes the study counts;\n", "* `n_jobs=-1` evaluates designs in parallel, on every processor;\n", "* the `directory` of the `Observations` caches the observations of each satellite on disk, as many designs share satellites;\n", "* `store` keeps the results in a file: running the notebook again reads them rather than evaluating the designs again (unless the study changes)." @@ -163,10 +162,10 @@ "id": "374124d4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:05.540746Z", - "iopub.status.busy": "2026-11-14T15:43:05.540746Z", - "iopub.status.idle": "2026-11-14T15:43:05.556674Z", - "shell.execute_reply": "2026-11-14T15:43:05.556674Z" + "iopub.execute_input": "2026-11-14T16:16:59.525318Z", + "iopub.status.busy": "2026-11-14T16:16:59.525318Z", + "iopub.status.idle": "2026-11-14T16:16:59.539373Z", + "shell.execute_reply": "2026-11-14T16:16:59.539373Z" } }, "outputs": [], @@ -174,7 +173,7 @@ "import tempfile\n", "from pathlib import Path\n", "\n", - "from tatc.generation import generate_points_rotated_lattice\n", + "from tatc.generation import generate_points_fibonacci_lattice\n", "from tatc.schemas import Instrument\n", "from tatc.tradespace import ObservationStudy, Observations, ResultStore, Targets, build_constellation\n", "\n", @@ -196,7 +195,7 @@ "\n", "CACHE_DIRECTORY = Path(tempfile.gettempdir()) / \"tatc-trade-space\"\n", "# the points of each replicate: a lattice in a random orientation, from its seed\n", - "TARGETS = Targets(generate_points_rotated_lattice, N_POINTS, seed=\"points_seed\")\n", + "TARGETS = Targets(generate_points_fibonacci_lattice, count=N_POINTS, rotate=True, seed=\"points_seed\")\n", "OBSERVATIONS = Observations(TARGETS, START, DURATION, directory=CACHE_DIRECTORY)\n", "\n", "study = ObservationStudy(\n", @@ -226,10 +225,10 @@ "id": "8967e528", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:05.556674Z", - "iopub.status.busy": "2026-11-14T15:43:05.556674Z", - "iopub.status.idle": "2026-11-14T15:43:06.186322Z", - "shell.execute_reply": "2026-11-14T15:43:06.186322Z" + "iopub.execute_input": "2026-11-14T16:16:59.541361Z", + "iopub.status.busy": "2026-11-14T16:16:59.541361Z", + "iopub.status.idle": "2026-11-14T16:17:00.215515Z", + "shell.execute_reply": "2026-11-14T16:17:00.214520Z" } }, "outputs": [ @@ -376,10 +375,10 @@ "id": "9e23a64a", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:06.186322Z", - "iopub.status.busy": "2026-11-14T15:43:06.186322Z", - "iopub.status.idle": "2026-11-14T15:43:06.454940Z", - "shell.execute_reply": "2026-11-14T15:43:06.454940Z" + "iopub.execute_input": "2026-11-14T16:17:00.216514Z", + "iopub.status.busy": "2026-11-14T16:17:00.216514Z", + "iopub.status.idle": "2026-11-14T16:17:00.482788Z", + "shell.execute_reply": "2026-11-14T16:17:00.482788Z" } }, "outputs": [ @@ -522,10 +521,10 @@ "id": "6f877e2d", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:06.454940Z", - "iopub.status.busy": "2026-11-14T15:43:06.454940Z", - "iopub.status.idle": "2026-11-14T15:43:06.613586Z", - "shell.execute_reply": "2026-11-14T15:43:06.613586Z" + "iopub.execute_input": "2026-11-14T16:17:00.484781Z", + "iopub.status.busy": "2026-11-14T16:17:00.484781Z", + "iopub.status.idle": "2026-11-14T16:17:00.617407Z", + "shell.execute_reply": "2026-11-14T16:17:00.617407Z" } }, "outputs": [ @@ -582,10 +581,10 @@ "id": "523cddaa", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:06.613586Z", - "iopub.status.busy": "2026-11-14T15:43:06.613586Z", - "iopub.status.idle": "2026-11-14T15:43:06.754482Z", - "shell.execute_reply": "2026-11-14T15:43:06.754482Z" + "iopub.execute_input": "2026-11-14T16:17:00.617407Z", + "iopub.status.busy": "2026-11-14T16:17:00.617407Z", + "iopub.status.idle": "2026-11-14T16:17:00.776663Z", + "shell.execute_reply": "2026-11-14T16:17:00.776663Z" } }, "outputs": [ diff --git a/docs/examples/tradespace/trade_space_example.py b/docs/examples/tradespace/trade_space_example.py index b5ad9124..fdf454f6 100644 --- a/docs/examples/tradespace/trade_space_example.py +++ b/docs/examples/tradespace/trade_space_example.py @@ -11,7 +11,7 @@ from pathlib import Path from tatc.analysis import estimate_sampling_error -from tatc.generation import generate_points_rotated_lattice +from tatc.generation import generate_points_fibonacci_lattice from tatc.schemas import Instrument from tatc.tradespace import ( Categorical, @@ -84,7 +84,9 @@ def count_samples(observations, duration=DURATION): CACHE_DIRECTORY = Path(tempfile.gettempdir()) / "tatc-trade-space" # the points of each replicate: a lattice in a random orientation, from its seed -TARGETS = Targets(generate_points_rotated_lattice, N_POINTS, seed="points_seed") +TARGETS = Targets( + generate_points_fibonacci_lattice, count=N_POINTS, rotate=True, seed="points_seed" +) OBSERVATIONS = Observations(TARGETS, START, DURATION, directory=CACHE_DIRECTORY) study = ObservationStudy( diff --git a/src/tatc/generation/__init__.py b/src/tatc/generation/__init__.py index f493b2c9..8d634a75 100644 --- a/src/tatc/generation/__init__.py +++ b/src/tatc/generation/__init__.py @@ -9,7 +9,6 @@ from .points import ( generate_points_fibonacci_lattice, generate_points_random, - generate_points_rotated_lattice, generate_points_uniform_angular_distance, generate_points_uniform_spacing, ) @@ -19,7 +18,6 @@ "generate_cells_uniform_spacing", "generate_points_fibonacci_lattice", "generate_points_random", - "generate_points_rotated_lattice", "generate_points_uniform_angular_distance", "generate_points_uniform_spacing", ] diff --git a/src/tatc/generation/points.py b/src/tatc/generation/points.py index b4a3e987..d3870345 100644 --- a/src/tatc/generation/points.py +++ b/src/tatc/generation/points.py @@ -23,12 +23,17 @@ def generate_points_fibonacci_lattice( - distance: float, + distance: float | None = None, elevation: float = 0, mask: Polygon | MultiPolygon | None = None, + *, + count: int | None = None, + rotate: bool = False, + seed: int | np.random.Generator | None = None, ) -> gpd.GeoDataFrame: """ - Generates geodetic points following a Fibonacci lattice. + Generates geodetic points following a Fibonacci lattice, of points about + a `distance` apart, or of a `count` of points. See: Gonzalez (2010). "Measurement of areas on a sphere using Fibonacci and latitude-longitude lattices", Mathematical Geosciences 42(49). @@ -38,29 +43,70 @@ def generate_points_fibonacci_lattice( requires an odd number of points. This implementation allows any number of points. In agreement with Gonzalez, no points are placed at poles. + A lattice in a random orientation (`rotate`, drawn from `seed`) is a + stratified sample of the sphere (randomized quasi-Monte Carlo). Each + point is distributed uniformly by surface area, as are those of + `generate_points_random`, but the points cover the sphere evenly rather + than clustering by chance, so that statistics of samples of points (such + as the share of points sampled sufficiently, over the replicates of a + trade study) vary less between samples of the same size (with about 1.5 + to 4 times less variance for the shares of points that constellations + sample):: + + points = generate_points_fibonacci_lattice(count=100, rotate=True, seed=7) + + With a mask, a lattice of a `count` of points covers the sphere with + about `count` points inside the mask (from the mask's share of the + sphere's area), and the number of points inside varies slightly with the + orientation of a rotated lattice. + Args: - distance (float): The typical surface distance (meters) between points. + distance (float | None): The typical surface distance (meters) between + points, or `None` for a `count` of points. elevation (float): The elevation (meters) above the datum in the WGS 84 coordinate system. - mask (shapely.geometry.Polygon | shapely.geometry.MultiPolygon | None): An optional mask to constrain points - using WGS84 (EPSG:4326) geodetic coordinates in a Polygon or MultiPolygon. + mask (shapely.geometry.Polygon | shapely.geometry.MultiPolygon | None): + An optional mask to constrain points using WGS84 (EPSG:4326) + geodetic coordinates in a Polygon or MultiPolygon. + count (int | None): The number of points (about, with a mask), in + place of a `distance`. + rotate (bool): Whether to rotate the lattice into a random + orientation, uniform over the rotations of the sphere. + seed (int | numpy.random.Generator | None): An optional seed (or + generator) of the random orientation. Returns: geopandas.GeoDataFrame: the data frame of generated points, each identified by the hash of its geometry (`point_id`, see `tatc.utils.geometry.hash_geometry`) - """ - # determine the number of global samples to achieve average sample distance - samples = compute_number_samples(distance) + Raises: + ValueError: if neither or both of `distance` and `count` are given, + `count` is negative, a `seed` is given without `rotate`, or the + mask is not valid. + """ + if (distance is None) == (count is None): + raise ValueError("Give either a distance or a count of points.") + if seed is not None and not rotate: + raise ValueError("A seed draws a random orientation (rotate=True).") + if count is None: + # determine the number of global samples to achieve average sample distance + samples = compute_number_samples(distance) + elif count < 0: + raise ValueError(f"Count must not be negative, got {count}.") + else: + samples = count if mask is None else int(round(count / _share_of(mask))) index = np.arange(samples) - # compute latitudes, starting from the southern hemisphere and placing - # neither first nor last points at poles - latitudes = np.degrees(np.arcsin(2 * (index + 1) / (samples + 2) - 1)) - # compute longitudes on the interval [-180, 180] - phi = (1 + np.sqrt(5)) / 2 # golden ratio - longitudes = np.mod(360 * index / phi, 360) - longitudes = np.where(longitudes > 180, longitudes - 360, longitudes) + if rotate: + latitudes, longitudes = _rotated_lattice(index, np.random.default_rng(seed)) + else: + # compute latitudes, starting from the southern hemisphere and placing + # neither first nor last points at poles + latitudes = np.degrees(np.arcsin(2 * (index + 1) / (samples + 2) - 1)) + # compute longitudes on the interval [-180, 180] + phi = (1 + np.sqrt(5)) / 2 # golden ratio + longitudes = np.mod(360 * index / phi, 360) + longitudes = np.where(longitudes > 180, longitudes - 360, longitudes) if mask is not None: if isinstance(mask, (Polygon, MultiPolygon)): if not mask.is_valid: @@ -119,67 +165,38 @@ def _random_rotation(rng: np.random.Generator) -> np.ndarray: ) -def generate_points_rotated_lattice( - count: int, - elevation: float = 0, - mask: Polygon | MultiPolygon | None = None, - seed: int | np.random.Generator | None = None, -) -> gpd.GeoDataFrame: +def _share_of(mask: Polygon | MultiPolygon) -> float: """ - Generates geodetic points of a Fibonacci lattice (see - `generate_points_fibonacci_lattice`) in a random orientation: a - stratified sample of the sphere (randomized quasi-Monte Carlo). Each - point is distributed uniformly by surface area, as are those of - `generate_points_random`, but the points cover the sphere evenly rather - than clustering by chance, so that statistics of samples of points (such - as the share of points sampled sufficiently, over the replicates of a - trade study) vary less between samples of the same size (with about 1.5 - to 4 times less variance for the shares of points that constellations - sample). - - With a mask, the lattice covers the sphere with about `count` points - inside the mask (from the mask's share of the sphere's area), and the - number of points inside varies slightly with the orientation. + Gets a mask's share of the sphere, with its edges straight in longitude + and latitude (as clipped): its area in a cylindrical equal-area + projection (longitude and the sine of latitude, in radians) of the mask + with edges divided into short segments. + """ + if not isinstance(mask, (Polygon, MultiPolygon)) or not mask.is_valid: + raise ValueError("Mask is not a valid Polygon or MultiPolygon.") + dense = shapely.segmentize(mask, 0.5) + projected = shapely.transform( + dense, + lambda xy: np.column_stack( + [np.radians(xy[:, 0]), np.sin(np.radians(xy[:, 1]))] + ), + ) + share = projected.area / (4 * np.pi) + if share <= 0: + raise ValueError("Mask has no area.") + return min(share, 1.0) - Args: - count (int): The number of points (about, with a mask). - elevation (float): The elevation (meters) above the datum in the WGS 84 - coordinate system. - mask (shapely.geometry.Polygon | shapely.geometry.MultiPolygon | None): An - optional mask to constrain points using WGS84 (EPSG:4326) - geodetic coordinates in a Polygon or MultiPolygon. - seed (int | numpy.random.Generator | None): An optional seed (or - generator) of the orientation. - Returns: - geopandas.GeoDataFrame: the data frame of generated points, each - identified by the hash of its geometry (`point_id`, see - `tatc.utils.geometry.hash_geometry`) +def _rotated_lattice( + index: np.ndarray, rng: np.random.Generator +) -> tuple[np.ndarray, np.ndarray]: """ - if count < 0: - raise ValueError(f"Count must not be negative, got {count}.") - rng = np.random.default_rng(seed) - samples = count - if mask is not None: - if not isinstance(mask, (Polygon, MultiPolygon)) or not mask.is_valid: - raise ValueError("Mask is not a valid Polygon or MultiPolygon.") - # the mask's share of the sphere, with its edges straight in - # longitude and latitude (as clipped): its area in a cylindrical - # equal-area projection (longitude and the sine of latitude, in - # radians) of the mask with edges divided into short segments - dense = shapely.segmentize(mask, 0.5) - projected = shapely.transform( - dense, - lambda xy: np.column_stack( - [np.radians(xy[:, 0]), np.sin(np.radians(xy[:, 1]))] - ), - ) - share = projected.area / (4 * np.pi) - if share <= 0: - raise ValueError("Mask has no area.") - samples = int(round(count / min(share, 1.0))) - index = np.arange(samples) - # the lattice of generate_points_fibonacci_lattice, as unit vectors + Gets the latitudes and longitudes (degrees) of the points of a Fibonacci + lattice (see `generate_points_fibonacci_lattice`) in a random + orientation. + """ + samples = len(index) + # the lattice as unit vectors sin_latitude = 2 * (index + 1) / (samples + 2) - 1 longitude = 2 * np.pi * index / ((1 + np.sqrt(5)) / 2) cos_latitude = np.sqrt(1 - sin_latitude**2) @@ -193,16 +210,7 @@ def generate_points_rotated_lattice( vectors = vectors @ _random_rotation(rng).T latitudes = np.degrees(np.arcsin(np.clip(vectors[:, 2], -1, 1))) longitudes = np.degrees(np.arctan2(vectors[:, 1], vectors[:, 0])) - gdf = gpd.GeoDataFrame( - geometry=shapely.points( - longitudes, latitudes, np.full_like(longitudes, elevation) - ), - crs="EPSG:4326", - ) - if mask is not None: - gdf = clip_to_mask(gdf, mask) - gdf.insert(0, "point_id", _hash_geometries(gdf.geometry)) - return gdf + return latitudes, longitudes def generate_points_uniform_spacing( diff --git a/src/tatc/tradespace/observations.py b/src/tatc/tradespace/observations.py index 75d3da77..18512fb6 100644 --- a/src/tatc/tradespace/observations.py +++ b/src/tatc/tradespace/observations.py @@ -55,7 +55,7 @@ class Targets: """ The targets of observations (such as points): fixed (a data frame), or generated in each replicate by a function (such as - `tatc.generation.generate_points_rotated_lattice`) given the `arguments` + `tatc.generation.generate_points_fibonacci_lattice`) given the `arguments` and `keywords`, and a seed that is a value of the design (as its keyword `seed`, such as of `Uncertain.seed`), so that each replicate samples other targets. Generated targets are kept in memory by seed. @@ -473,7 +473,7 @@ class ObservationStudy(Study): study = ObservationStudy( space, build, # the satellites of a design - Observations(Targets(generate_points_rotated_lattice, 100, seed="seed"), START, DAY), + Observations(Targets(generate_points_fibonacci_lattice, count=100, rotate=True, seed="seed"), START, DAY), sample, # the metrics of observations plan=MissionPlan(SCHEDULE, COST_MODEL), phases=True, diff --git a/tests/generation/test_points.py b/tests/generation/test_points.py index ce0850e1..9bd940f8 100644 --- a/tests/generation/test_points.py +++ b/tests/generation/test_points.py @@ -15,7 +15,6 @@ from tatc.generation import ( generate_points_fibonacci_lattice, generate_points_random, - generate_points_rotated_lattice, generate_points_uniform_angular_distance, generate_points_uniform_spacing, ) @@ -501,34 +500,43 @@ def test_weights_invalid(self): class TestGeneratePointsRotatedLattice(unittest.TestCase): """ - Unit tests for randomly rotated Fibonacci lattices. + Unit tests for Fibonacci lattices of a number of points, in a random + orientation. """ def test_points(self): """Lattices have the number of points, reproducibly, uniform by area.""" - points = generate_points_rotated_lattice(500, seed=3) + points = generate_points_fibonacci_lattice(count=500, rotate=True, seed=3) self.assertEqual(len(points), 500) self.assertEqual(list(points.columns), ["point_id", "geometry"]) self.assertEqual(points.crs, "EPSG:4326") - same = generate_points_rotated_lattice(500, seed=3) + same = generate_points_fibonacci_lattice(count=500, rotate=True, seed=3) self.assertTrue(points.geometry.geom_equals(same.geometry).all()) - other = generate_points_rotated_lattice(500, seed=4) + other = generate_points_fibonacci_lattice(count=500, rotate=True, seed=4) self.assertFalse(points.geometry.geom_equals(other.geometry).all()) - self.assertEqual(len(generate_points_rotated_lattice(0, seed=1)), 0) + self.assertEqual( + len(generate_points_fibonacci_lattice(count=0, rotate=True, seed=1)), 0 + ) with self.assertRaises(ValueError): - generate_points_rotated_lattice(-1) + generate_points_fibonacci_lattice(count=-1) # uniform by area: the sine of latitude is uniform on [-1, 1] sines = np.concatenate( [ np.sin( - np.radians(generate_points_rotated_lattice(200, seed=k).geometry.y) + np.radians( + generate_points_fibonacci_lattice( + count=200, rotate=True, seed=k + ).geometry.y + ) ) for k in range(100) ] ) self.assertAlmostEqual(sines.mean(), 0, delta=0.01) self.assertAlmostEqual(sines.var(), 1 / 3, delta=0.01) - elevated = generate_points_rotated_lattice(10, elevation=100, seed=1) + elevated = generate_points_fibonacci_lattice( + count=10, rotate=True, elevation=100, seed=1 + ) self.assertTrue((elevated.geometry.z == 100).all()) def test_mask(self): @@ -539,14 +547,18 @@ def test_mask(self): Polygon([(-100, 20), (-80, 25), (-90, 45)]), ): counts = [ - len(generate_points_rotated_lattice(100, mask=mask, seed=k)) + len( + generate_points_fibonacci_lattice( + count=100, rotate=True, mask=mask, seed=k + ) + ) for k in range(50) ] self.assertAlmostEqual(np.mean(counts), 100, delta=2) self.assertLess(max(counts) - min(counts), 15) with self.assertRaises(ValueError): - generate_points_rotated_lattice( - 10, mask=Polygon([(0, 0), (1, 1), (0, 1), (1, 0)]) + generate_points_fibonacci_lattice( + count=10, mask=Polygon([(0, 0), (1, 1), (0, 1), (1, 0)]) ) def test_stratification(self): @@ -557,8 +569,40 @@ def share(points): return points.geometry.within(region).mean() lattices = [ - share(generate_points_rotated_lattice(200, seed=k)) for k in range(60) + share(generate_points_fibonacci_lattice(count=200, rotate=True, seed=k)) + for k in range(60) ] randoms = [share(generate_points_random(200, seed=k)) for k in range(60)] self.assertAlmostEqual(np.mean(lattices), np.mean(randoms), delta=0.02) self.assertLess(np.var(lattices), 0.5 * np.var(randoms)) + + def test_arguments(self): + """A lattice takes a distance or a count of points, and a seed of its + orientation only if it is rotated.""" + for kwargs in ({}, {"distance": 1e6, "count": 5}, {"count": 5, "seed": 1}): + with self.subTest(kwargs=kwargs), self.assertRaises(ValueError): + generate_points_fibonacci_lattice(**kwargs) + # the same lattice of a count, in its fixed orientation + fixed = generate_points_fibonacci_lattice(count=50) + self.assertEqual(len(fixed), 50) + self.assertTrue( + fixed.geometry.geom_equals( + generate_points_fibonacci_lattice(count=50).geometry + ).all() + ) + # a lattice of a distance, in a random orientation + rotated = generate_points_fibonacci_lattice(2000e3, rotate=True, seed=1) + self.assertEqual(len(rotated), len(generate_points_fibonacci_lattice(2000e3))) + + def test_antimeridian_mask(self): + """Rotated lattices sample masks that cross the antimeridian.""" + mask = box(170, -10, 190, 10) + counts = [ + len( + generate_points_fibonacci_lattice( + count=100, mask=mask, rotate=True, seed=k + ) + ) + for k in range(30) + ] + self.assertAlmostEqual(np.mean(counts), 100, delta=3) diff --git a/tests/tradespace/test_fingerprint.py b/tests/tradespace/test_fingerprint.py index 9145b199..d769fd20 100644 --- a/tests/tradespace/test_fingerprint.py +++ b/tests/tradespace/test_fingerprint.py @@ -24,7 +24,7 @@ from shapely.geometry import Point, box from tatc.analysis import collect_observations -from tatc.generation import generate_points_rotated_lattice +from tatc.generation import generate_points_fibonacci_lattice from tatc.schemas import Instrument from tatc.tradespace import fingerprint from tatc.tradespace import ( @@ -216,12 +216,14 @@ def test_values(self): get_fingerprint(pd.Series([1.0], name="a")), get_fingerprint(pd.Series([1.0], name="b")), ) - points = generate_points_rotated_lattice(5, seed=1) + points = generate_points_fibonacci_lattice(count=5, rotate=True, seed=1) moved = points.copy() moved.loc[0, "geometry"] = Point(0, 1e-9) self.assertEqual( get_fingerprint(points), - get_fingerprint(generate_points_rotated_lattice(5, seed=1)), + get_fingerprint( + generate_points_fibonacci_lattice(count=5, rotate=True, seed=1) + ), ) self.assertNotEqual(get_fingerprint(points), get_fingerprint(moved)) # other objects are described by their type only diff --git a/tests/tradespace/test_observations.py b/tests/tradespace/test_observations.py index 60c63b70..7180e0b1 100644 --- a/tests/tradespace/test_observations.py +++ b/tests/tradespace/test_observations.py @@ -20,7 +20,7 @@ import pandas as pd from tatc.analysis import collect_observations -from tatc.generation import generate_points_rotated_lattice +from tatc.generation import generate_points_fibonacci_lattice from tatc.schemas import Instrument from tatc.tradespace import ( Categorical, @@ -69,7 +69,9 @@ points_seed=Uncertain.seed(), failure_seed=Uncertain.seed(), ) -TARGETS = Targets(generate_points_rotated_lattice, N_POINTS, seed="points_seed") +TARGETS = Targets( + generate_points_fibonacci_lattice, count=N_POINTS, rotate=True, seed="points_seed" +) SCHEDULE = DeploymentSchedule(years=3, production_rate=4, launch_interval=0.5) COSTS = CostModel(SatelliteCost(development=10, first_unit=2)) PLAN = MissionPlan(SCHEDULE, COSTS, growth={"development": "growth"}) @@ -122,7 +124,10 @@ def test_generated(self): first, second = design.realize(0), design.realize(1) targets = TARGETS.of(first) pd.testing.assert_frame_equal( - targets, generate_points_rotated_lattice(N_POINTS, seed=first.points_seed) + targets, + generate_points_fibonacci_lattice( + count=N_POINTS, rotate=True, seed=first.points_seed + ), ) self.assertIs(TARGETS.of(first), targets) # kept in memory self.assertFalse(TARGETS.of(second).equals(targets)) @@ -132,11 +137,11 @@ def test_generated(self): def test_fixed(self): """Fixed targets are the same in every replicate.""" - points = generate_points_rotated_lattice(5, seed=1) + points = generate_points_fibonacci_lattice(count=5, rotate=True, seed=1) targets = Targets(points) self.assertIs(targets.of(), points) self.assertIsNone(targets.seed_of(None)) - same = Targets(generate_points_rotated_lattice, 5, seed=None) + same = Targets(generate_points_fibonacci_lattice, count=5, rotate=True) self.assertTrue(same.of().equals(same.of())) with self.assertRaises(ValueError): Targets(points, seed="points_seed") @@ -536,7 +541,9 @@ def test_metrics_of_uncertain_values(self): """The metrics of phases that read uncertain values of the design are those of its replicate, and shared by the designs of a replicate.""" space = SPACE.extend(u=Uncertain.uniform(0, 1)) - fixed = Targets(generate_points_rotated_lattice(N_POINTS, seed=1)) + fixed = Targets( + generate_points_fibonacci_lattice(count=N_POINTS, rotate=True, seed=1) + ) def metric(observations, design): del observations @@ -834,7 +841,10 @@ def analysis(source): " return found\n" ) more = Targets( - generate_points_rotated_lattice, N_POINTS + 5, seed="points_seed" + generate_points_fibonacci_lattice, + count=N_POINTS + 5, + rotate=True, + seed="points_seed", ) with tempfile.TemporaryDirectory() as directory: first = Observations(TARGETS, START, HOURS, plain, directory=directory) From 76a3ceea615e8c7dc7170af2abdedc312d3e2213 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Sat, 14 Nov 2026 17:15:53 -0700 Subject: [PATCH 49/52] review the trade space a fifth time: fingerprint objects by their __fingerprint__ (designs, and caches of satellites by their function and namespace), reject decisions that name no child, record errors of realizing designs, plan each deployment with its restoration policy (plan(policy=), Deployment.policy), launch ground spares at the next slot, give an infinite deployed time to deployments that outlast the mission, judge resamples of pareto_probability by their drawn replicates, charge refine's budget for every scenario, give the spread of statistics across scenarios, reject statistics named as columns of the results (P() histories), keep the caller's pymoo algorithm, compute the metrics of every satellite once, speed up exact expectations, generate targets only to observe them, keep contexts in caches of satellites, export configure, value_of, Statistic, and the classes of steps, make options keyword-only, and move shared helpers into Criteria and new modules tables, expectations, and memory --- CHANGELOG.md | 7 +- docs/api_reference/tradespace/define.rst | 27 +- docs/api_reference/tradespace/evaluate.rst | 17 +- docs/api_reference/tradespace/index.rst | 15 +- docs/api_reference/tradespace/judge.rst | 4 +- docs/api_reference/tradespace/missions.rst | 34 +- docs/api_reference/tradespace/search.rst | 19 +- docs/examples/tradespace/PlanDeployment.ipynb | 2 +- .../examples/tradespace/PlanForFailures.ipynb | 212 ++--- .../tradespace/RankUncertainDesigns.ipynb | 2 +- .../ValidateCostVarianceNSOSA.ipynb | 2 +- src/tatc/tradespace/__init__.py | 23 +- src/tatc/tradespace/alerts.py | 12 +- src/tatc/tradespace/attribution.py | 62 +- src/tatc/tradespace/cache.py | 122 ++- src/tatc/tradespace/comparison.py | 24 +- src/tatc/tradespace/confirmation.py | 25 +- src/tatc/tradespace/cost.py | 33 +- src/tatc/tradespace/criteria.py | 238 +++--- src/tatc/tradespace/deployment.py | 180 +++-- src/tatc/tradespace/dominance.py | 95 ++- src/tatc/tradespace/events.py | 133 +++- src/tatc/tradespace/expectations.py | 284 +++++++ src/tatc/tradespace/failures.py | 58 +- src/tatc/tradespace/fingerprint.py | 189 +++-- src/tatc/tradespace/hashing.py | 4 +- src/tatc/tradespace/histories.py | 372 +-------- src/tatc/tradespace/memory.py | 29 + src/tatc/tradespace/mission.py | 224 +++++- src/tatc/tradespace/nodes.py | 19 +- src/tatc/tradespace/observations.py | 152 ++-- src/tatc/tradespace/optimization.py | 85 +- src/tatc/tradespace/pareto.py | 72 +- src/tatc/tradespace/plans.py | 250 +----- src/tatc/tradespace/plotting.py | 12 +- src/tatc/tradespace/references.py | 138 +++- src/tatc/tradespace/refinement.py | 88 ++- src/tatc/tradespace/scenarios.py | 19 +- src/tatc/tradespace/screening.py | 6 +- src/tatc/tradespace/sensitivity.py | 30 +- src/tatc/tradespace/simulation.py | 163 ++-- src/tatc/tradespace/space.py | 245 ++++-- src/tatc/tradespace/statistics.py | 21 +- src/tatc/tradespace/store.py | 37 +- src/tatc/tradespace/study.py | 210 ++--- src/tatc/tradespace/summary.py | 675 ++++++++-------- src/tatc/tradespace/tables.py | 340 ++++++++ src/tatc/tradespace/values.py | 112 +-- src/tatc/tradespace/walks.py | 47 +- tests/tradespace/test_attribution.py | 4 +- tests/tradespace/test_cache.py | 68 +- tests/tradespace/test_comparison.py | 8 +- tests/tradespace/test_confirmation.py | 15 + tests/tradespace/test_cost.py | 15 +- tests/tradespace/test_criteria.py | 556 ++------------ tests/tradespace/test_deployment.py | 79 +- tests/tradespace/test_failures.py | 199 ++--- tests/tradespace/test_fingerprint.py | 155 +++- tests/tradespace/test_layering.py | 25 + tests/tradespace/test_observations.py | 103 ++- tests/tradespace/test_optimization.py | 57 +- tests/tradespace/test_pareto.py | 230 ++---- tests/tradespace/test_references.py | 129 ++++ tests/tradespace/test_refinement.py | 57 +- tests/tradespace/test_scenarios.py | 26 +- tests/tradespace/test_screening.py | 32 + tests/tradespace/test_sensitivity.py | 10 + tests/tradespace/test_space.py | 183 ++++- tests/tradespace/test_stages.py | 73 +- tests/tradespace/test_statistics.py | 103 +++ tests/tradespace/test_store.py | 40 +- tests/tradespace/test_study.py | 81 +- tests/tradespace/test_summary.py | 725 ++++++++++++++++++ tests/tradespace/test_tables.py | 114 +++ tests/tradespace/test_utility.py | 5 +- 75 files changed, 5268 insertions(+), 2993 deletions(-) create mode 100644 src/tatc/tradespace/expectations.py create mode 100644 src/tatc/tradespace/memory.py create mode 100644 src/tatc/tradespace/tables.py create mode 100644 tests/tradespace/test_references.py create mode 100644 tests/tradespace/test_statistics.py create mode 100644 tests/tradespace/test_summary.py create mode 100644 tests/tradespace/test_tables.py diff --git a/CHANGELOG.md b/CHANGELOG.md index d48d865d..b7c0d8d5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -29,19 +29,20 @@ Added: - The schedule and cost model of a `tradespace.MissionPlan` may be functions of the design (`schedule_of`, `cost_model_of`), which size them by its values with relationships of the study's own, such as the costs of a type of satellite from its payload or the capacity of launches to the design's altitude; launches limited in mass take the masses of the satellites from the cost model (`masses_of`, or the plan's `masses`). The `launch_mass_capacity` of a `DeploymentSchedule` may be a function of a plane (`mass_capacity_of`), for planes at different inclinations. - The start of the period of `tradespace.Observations` may be a value of the design (`start_of` and `end_of` give a design's period), such as an uncertain epoch drawn for each replicate over the mission, whose observations are cached apart, so that replicates average over the geometry and seasons of the mission that the one window of quasi-static phases misses (see `evaluate_phases`). The schedule of deployments states that a design life does not retire a satellite that is not replaced, and simulations that a planned replacement whose launch fails is not flown again. - Utilities of the metrics of designs (`tradespace.Utility`), for trade spaces of utility against cost: a single-attribute utility of each metric (`LinearUtility`, `ExponentialUtility` of a risk attitude, `PiecewiseUtility`, or any function), combined by weights additively or in Keeney and Raiffa's multiplicative form. A utility is a metric of any statistic (its `Mean` is the expected utility over the replicates, and a utility given as a statistic of `Criteria` is its mean), computed in each replicate, and gives the utility of each row of a data frame (such as a summary of the means of designs). Statistics name the columns they need (`Statistic.columns`). - - Staged deployments (`tradespace.Stage`, argument `stages` of `DeploymentSchedule.plan` and `MissionPlan`, which may give the stages of each design): planes that are produced and launched only if a rule decides to, at times during the mission, from what it knows then (`Decision`: the satellites operating, the history so far, and, through the design, its uncertain parameters and scenario), after a lead time and at the next launch slots, and replaced and restored as other planes. Rules may also read the capability of the satellites operating at a decision (`Decision.capability`, the study's metrics of their observations, as of a phase), which the evaluations of an `ObservationStudy` give each deployment (`Deployment.capability`, a `tradespace.Capability` of its satellites, observations, and cached phases, which also caches the phases of studies without failures), such as for a plane deployed only if those in orbit fall short. A stage that is not deployed is neither produced, launched, nor priced; `MissionHistory.stages` gives when each was deployed, and its metrics the `stages deployed`. Exact expectations of missions without restoration (`exact_expectations`) need deployments that are not staged, so that studies of staged deployments sample their histories. + - Staged deployments (`tradespace.Stage`, argument `stages` of `DeploymentSchedule.plan` and `MissionPlan`, which may give the stages of each design): planes that are produced and launched only if a rule decides to, at times during the mission, from what it knows then (`Decision`: the satellites operating, the history so far, and, through the design, its uncertain parameters and scenario), after a lead time and at the next launch slots, and replaced and restored as other planes. Rules may also read the capability of the satellites operating at a decision (`Decision.capability`, the study's metrics of their observations, as of a phase), which the evaluations of an `ObservationStudy` give each deployment (`Deployment.capability`, a `tradespace.Capability` of its satellites, observations, and cached phases, which also caches the phases of studies without failures), such as for a plane deployed only if those in orbit fall short. A stage that is not deployed is neither produced, launched, nor priced; `MissionHistory.decided` gives when each was deployed, and its metrics the `stages deployed`. Exact expectations of missions without restoration (`exact_expectations`) need deployments that are not staged, so that studies of staged deployments sample their histories. - Scenarios of studies (argument `scenarios` of `tradespace.Study`): conditions under which designs are compared rather than averaged over, each giving fixed values or uncertain parameters of the design space other values (`Design.realize` takes a `scenario`), so that each design is evaluated in each scenario (recorded as `scenario`, and judged in each with criteria `by` it). Each scenario's evaluations are stored by its values, so that a scenario added later is evaluated alone. Function `tradespace.robustness` gives each design's Pareto trace (the share of scenarios in which it is efficient) and its regret in each scenario (the improvement in every objective it would need to match the scenario's front) and the largest. The metrics of an `ObservationStudy` (and of `PhaseCache`, `evaluate_histories`, and `exact_expectations`) are given the realized design if they have a parameter named `design`. - Criteria across the scenarios of a study (`tradespace.Across`, argument `across` of `Criteria`), which judge each design once by its worst or its (weighted) mean statistics over the scenarios (or the groups of another column), so that searches find designs robust to scenarios; a requirement may be met in every scenario while objectives are means. - Function `tradespace.attribute_variance` (and class `Attribution`), which attributes the variance of metrics between the replicates of each design to its uncertain parameters (or groups of them): the share that each causes, alone or with others, and the share that knowing it would remove, with standard errors, by evaluating designs with one parameter drawn as in other replicates and the others held (which works for seeds, whose values do not order outcomes); `Attribution.summary` pools the shares of several designs, and `Attribution.differences` attributes the variance of the differences between pairs of designs, from the same evaluations (parameters that act alike on both cancel, with common random numbers). `Design.realize` and `Study.run` take a `shift`, which draws named parameters as in other replicates (kept apart in a `ResultStore` as a variant of the replicates), and `DesignSpace.uncertain_paths` lists the uncertain parameters. - Structured cost risk (after Maier, Yeakel, and Wendoloski, "Cost Variance Analysis in Constellation Architecture Studies," 2023): growth factors of each type of satellite (by kind, for development, production, and launches, in `CostModel.estimate` and `MissionPlan.growth`), and the costs of types of satellites as sums of their components (`tradespace.Component`, `SatelliteCost.components`), whose growth has a distribution by maturity (such as `tradespace.Triangular`), correlated between components (`CostModel.correlation`). `CostModel.draw` draws the growth of the components from standard normal scores of the components and a common score, which `tradespace.risk_space` declares as uncertain parameters of a design space (named by `MissionPlan.scores`, also of a nested group), so that common random numbers give the designs that share a component the same growth of it; without drawn growth, components cost their expected growth. Types of satellites that share a component (by name) develop it once in a deployment. Production in blocks (`SatelliteCost.block_size`): each block after the first develops its type again (a share of its development, `redevelopment`) before its first unit is produced, and restarts the learning curve; `CostEstimate.blocks` counts the blocks of each type. Function `tradespace.exceedance` gives the probability that a metric of each design exceeds that of each other in the same replicate (such as that one design costs more than another), and `plot_exceedance` plots them as a matrix. The validation notebook `ValidateCostVarianceNSOSA` reproduces the paper's example of two NSOSA constellations that share a configuration. - Searches with Optuna accept categorical options that depend on earlier decisions (a parameter for each set of options), use TPE with a constant liar in batches by default (which spreads the trials of a batch), and stop after `max_designs` designs evaluated (trials that suggest designs evaluated before are told their objectives without evaluating them again). A design infeasible in some of its replicates violates its feasibility by their share (`Evaluations.infeasibility`), and the first design evaluated in a search is evaluated alone, to check that evaluations give one record each. `Study` records errors of evaluations as infeasible, without storing them, with `errors="record"`. Enumeration walks the items of unordered repetitions in one order only, and `DesignSpace.size` counts designs without keeping them. Pareto fronts are found by a vectorized sweep in lexicographic order that compares designs only with the efficient designs before them, and fronts with tolerances by comparing designs only with the efficient designs without tolerances (which dominate every design that any design dominates within the tolerances), in blocks of bounded memory. - Studies of the observations of constellations (`tradespace.ObservationStudy`): the targets of each replicate (`Targets`, fixed or generated from a seed of the design), the observations of each satellite, cached on disk (`Observations`), the metrics of the observations, and, with a `MissionPlan`, the costs of the deployment and the summaries of its phases or of the histories of its `Failures`. Plots of the results of studies (`plot_designs`, `plot_progress`, and `plot_means`, with matplotlib, in the `tradespace` extra), and the hypervolume of a search as it proceeds (`hypervolume_progress`). - - The steps of trade studies share their arguments and outcomes: `tradespace.refine(study, criteria, results)`, `confirm(study, criteria, results)` (by default, the front of the results), `screen(studies, criteria, designs)` (with criteria for each stage), and `attribute_variance(study, metrics, designs)` take designs as `Design` objects, their keys, or rows of a summary or of results, and `Refinement`, `Confirmation`, `Screening`, and `Search` give their `results`, the `summary` of their designs, and the `designs`. `DesignSpace.designs_of` rebuilds designs from rows of their values, which summaries keep (also those of `pareto_probability`, `confirm`, and `screen`), and `DesignSpace.extend`, `DesignSpace.design(design, **overrides)`, and `Study.replace` make variants of design spaces, designs, and studies. `aggregate` takes criteria, a mapping of objectives, or metrics (as the other functions do), and other `statistics` by name; `pareto_front`, `pareto_ranks`, `hypervolume`, `sensitivity`, and `main_effects` raise an error given the results of a study (a row per replicate) instead of a summary. Studies with a mission plan record the years by which it is `deployed`, and the parts of observation studies that refer to values of designs are typed as a `Reference`. Columns: ` se`, ` mission` for the mean over the phases of a mission, ` histories p` and ` histories std` for statistics over the histories of failures, and `pareto_trace` and `max_regret`. Package `tradespace` exports the functions and classes of trade studies; the parts from which they are made (such as `PhaseCache`, `Layout`, `configure`, and the fingerprints) are imported from its modules. + - The steps of trade studies share their arguments and outcomes: `tradespace.refine(study, criteria, results)`, `confirm(study, criteria, results)` (by default, the front of the results), `screen(studies, criteria, designs)` (with criteria for each stage), and `attribute_variance(study, metrics, designs)` take designs as `Design` objects, their keys, or rows of a summary or of results, and `Refinement`, `Confirmation`, `Screening`, and `Search` give their `results`, the `summary` of their designs, and the `designs`. `DesignSpace.designs_of` rebuilds designs from rows of their values, which summaries keep (also those of `pareto_probability`, `confirm`, and `screen`), and `DesignSpace.extend`, `DesignSpace.design(design, **overrides)`, and `Study.replace` make variants of design spaces, designs, and studies. `aggregate` takes criteria, a mapping of objectives, or metrics (as the other functions do), and other `statistics` by name; `pareto_front`, `pareto_ranks`, `hypervolume`, `sensitivity`, and `main_effects` raise an error given the results of a study (a row per replicate) instead of a summary. Studies with a mission plan record the years by which it is `deployed`, and the parts of observation studies that refer to values of designs are typed as a `Reference`. Columns: ` se`, ` mission` for the mean over the phases of a mission, ` histories p`, ` histories std`, and `P() histories` for statistics over the histories of failures, and `pareto_trace` and `max_regret`. Package `tradespace` exports the functions and classes of trade studies; the parts from which they are made (such as `PhaseCache`, `Layout`, `configure`, and the fingerprints) are imported from its modules. - Values of `tradespace` designs by the paths of the columns of results (`d["layout.walker.planes"]`, also in the callables of design spaces and in references), choices equal to the names of their branches, and reserved names of children that views and designs give otherwise (such as `values` and `key`). `Repeat` counts may be `Integer`, `Categorical`, `Fixed`, or `Derived`; `DesignSpace.design` checks decisions against their domains; and the constructors of uncertain parameters (with `Uncertain.triangular`) take nominal values and name their distributions. Summaries of criteria give whether each design is efficient (`pareto`, also of `summarize`, which takes criteria, and of `confirm`, `screen`, and searches), designs with a missing objective are not efficient, and `aggregate` takes `statistics` by name. `Study.realize` realizes a design as a study does (in a scenario), and an `ObservationStudy` gives the mission of a design as its evaluation plans it (`mission_of`). `Study.prune` removes a study's evaluations with other code (and not those of other studies that share its store, `ResultStore.remove`), `Observations.prune` removes the results of its caches with other code, and caches warn of results of other code once, in the main process. Fingerprints describe geometries by their content, ignore docstrings, and describe the functions of a study's own modules (such as one next to a notebook) by their code. Missions restore failures by default, and `Failures` sample histories with importance sampling (`stress`), control variates (`controls`), and spreads over the histories. Layouts describe themselves (`Layout.describe`) and are built at their own altitude (the given one is for layouts without one; `soc_space` keeps the altitude its planes are derived at). `plot_designs` colors some designs over the others (`highlight`, `label`, `others`, `front_label`), and `COLORS`, `INK`, and `GRAY` name the colors of plots. Each design confirmed gives its ` optimism`, `robustness` keeps the values of designs, and `Search.summary` keeps the designs the search found feasible. The simulation of missions is in module `simulation`. - Decisions given to `tradespace.DesignSpace.design` by value are levels of their domains (`2.0` or `numpy.int64(2)` give the key of the enumerated design), designs and scopes tell whether they have a value (`"layout.walker.planes" in design`), and the items of a `Repeat` take slices. `DesignSpace.designs_of` gives a series of designs aligned to the rows of a data frame (`space.designs_of(summary).map(describe)`). Statistics given without names are named by convention (`Statistic.name`, such as `"cost p70"` for `Quantile("cost", 0.7)` and `"P(cost <= 150)"`), so that `statistics` may be a list, `summarize(results, criteria, statistics=...)` adds the means and spreads of other metrics to a summary of criteria, criteria `across` scenarios are summarized and aggregated as others, and `Requirement.met` tells which values meet a requirement. An `ObservationStudy` counts the satellites and planes of a design's `layout` by default, gives the histories of a design's failures (`mission_of(design).histories()`) and its satellites, targets, and observations (`satellites_of`, `targets_of`, `observations_of`) as its evaluation realizes them, and `MissionPlan.policy` refers to each design's restoration policy (such as of `policy_space`). Fingerprints describe the classes and callable objects of a study's own modules by their attributes and the code of their methods, and tell studies that differ in constants apart from the same study with other code; `Observations.prune` removes only the results of its own analyses with other code. `plot_designs` colors designs by a column or by values of their rows (`by`), `plot_shares` plots shares of variance (of `sensitivity` or `attribute_variance`) as grouped bars with their standard errors, and `use_style` applies the style of the plots of trade studies (with constrained layouts) to the figures of a session. `robustness` gives each objective of a design in each scenario (` `). `Deployment.planes` are `PlannedPlane`s (type, satellites, and spares in orbit), `DeploymentSchedule.next_slot` gives the next launch slot that keeps the launch interval, and `Capability.evaluate` evaluates phases with a deployment's cached observations. Searches with Optuna are seeded by default (`seed=0`), and lives of satellites are drawn from uniform numbers (`Lifetime.from_uniform`, which subclasses implement). - Designs of another design space (such as the space that a study's space extends) are evaluated in the study's space, and constraints are checked in each scenario: a design that violates them in a scenario is infeasible in it, and a constraint that gives `NaN` is violated. Children of design spaces may not take the names of the status columns of results (`design`, `feasible`, `error`, `seconds`, and `scenario`). `DesignSpace.design` takes the name of a branch for a choice (`space.design(base, layout="sso")`), unordered items are in the order of their levels, `Design.scenario` names the scenario of a realized design, `Design.realize` takes the `overrides` of a scenario, and `DesignSpace.check_uncertain` and `check_overrides` check the paths of uncertain parameters and of scenarios. The options of `Study` and `DesignSpace.sample` are keyword-only. Fingerprints describe the globals of a study's functions as they describe its given values (pydantic models, partials, objects of the study's own classes, containers by their content, and the functions of its own modules reached through them), and find the same study with other code alike in every version of Python. `Study.prune` also removes the definitions of a study without evaluations, warnings of studies and caches point at the code that runs them, and an evaluation that gives an empty data frame raises an error. - Summaries give the share of the replicates of each design that are feasible (`feasible`, which requirements may name, such as `Requirement("feasible", ">=", 1)`), and judge designs by their feasible replicates, as searches do. Statistics are in module `statistics`, and summaries (`aggregate`, `summarize`, and `pareto_probability`) in module `summary`. The tolerances of criteria are `Criteria.tolerances`. Each step gives the designs it selects for the next step (`designs`: the efficient designs of a refinement or a search, the survivors of a screening, and the designs confirmed) and its `criteria`, with `Refinement.candidates` and `Refinement.evaluations` (those it added), `Search.evaluated`, and `Screening.history` (the results of every stage; its `results` are those of the last stage, which other steps take). `robustness` takes the column of the scenarios from the criteria, gives ` ` for every objective that is not a value of designs, and gives an infinite regret for a missing objective. `optimize_pymoo` stops after `max_designs`, `screen` checks the share or number of designs it keeps (`keep`), `plot_designs` and `plot_means` draw the designs without a group (`by`) in gray, and `summarize` gives the spread of the mean of a `Utility`. - - The mission of each design of an observation study (module `plans`): `MissionPlan.policy` gives the restoration policy of each design (by default, restoring failed satellites; a policy, a function, or a reference to values that configure it, such as those of `policy_space`), with its spares in orbit (`RestorationPolicy.orbit_spares`, launched with their planes) and on the ground, and `MissionPlan.mission_of` and `ObservationStudy.mission_of` give the `Mission` of a design (its deployment, phases, cost estimate, and histories) as its evaluation plans it. `Failures(phases=...)` gives the time until each history meets requirements, and `Failures` checks its options when it is made. Exact expectations fall back to the means of the histories for missions with too many sets of satellites (`histories.MAX_SETS`). Planned replacements keep the launch interval, spares in orbit that are never used are not replaced at the end of their design life, launches are priced by the masses of the deployment, the phases of a mission are cached by the uncertain values of its replicate, and studies of staged deployments record the `stages deployed`. Simulations take a failure model (`Deployment.simulate(model)`), the options of `DeploymentSchedule.plan` and `ObservationStudy` are keyword-only, `layout_of` is exported, a layout names its pattern (`pattern`), `Stage` takes numpy values, and the development of a staged type that is never deployed is the cost of its option. References to values of designs are in module `references`. + - The mission of each design of an observation study (module `plans`): `MissionPlan.policy` gives the restoration policy of each design (by default, restoring failed satellites; a policy, a function, or a reference to values that configure it, such as those of `policy_space`), with its spares in orbit (`RestorationPolicy.orbit_spares`, launched with their planes) and on the ground, and `ObservationStudy.mission_of` gives the `Mission` of a design (its deployment, phases, cost estimate, and histories) as its evaluation plans it (`MissionPlan.plan_mission`). `Failures(phases=...)` gives the time until each history meets requirements, and `Failures` checks its options when it is made. Exact expectations fall back to the means of the histories for missions with too many sets of satellites (`expectations.MAX_SETS`). Planned replacements keep the launch interval, spares in orbit that are never used are not replaced at the end of their design life, launches are priced by the masses of the deployment, the phases of a mission are cached by the uncertain values of its replicate, and studies of staged deployments record the `stages deployed`. A deployment is planned with its restoration policy (`DeploymentSchedule.plan(policy=...)`, `Deployment.policy`), whose spares its planned history (`Deployment.planned`), its simulations (`Deployment.simulate(model)`), and its costs share, the options of `DeploymentSchedule.plan` and `ObservationStudy` are keyword-only, `layout_of` is exported, a layout names its pattern (`pattern`), `Stage` takes numpy values, and the development of a staged type that is never deployed is the cost of its option. References to values of designs are in module `references`. + - Fingerprints describe objects by what their `__fingerprint__()` returns (designs, and caches of satellites by their function and namespace), so that a study whose functions use them is evaluated again when they change. Decisions that name no child of a design space raise an error (also those of designs of another space, in a study's space), `errors="record"` records the errors of realizing a design, metrics may not be named `scenario`, replicates and shifts must not be negative, and a design space takes a single constraint. Module `references` reads designs: `configure` and `value_of` are exported, and functions given the design follow one convention (`takes_design`, `given_design`). `Design.uncertain_values()` gives the values of a design's uncertain parameters, and `Statistic` and the classes of the steps (`Refinement`, `Confirmation`, `Screening`, `Search`, `Attribution`) are exported. `summarize` gives the spread of the statistics it reports across scenarios (of the worst scenario, or of the weighted mean over the replicates that the scenarios share) and leaves out spreads that are zero for every design. Statistics may not take the names of columns of the results, and `summarize_histories` names the share of histories that meet a requirement `P() histories`. `refine` charges the evaluations of every scenario to its budget (`Refinement.rounds` gives its rounds), `pareto_probability` leaves out of a resample a design without a feasible replicate drawn, `main_effects` orders its bins, searches with pymoo leave the caller's algorithm unchanged, and Optuna's constraints of requirements have distinct names. `exceedance` gives the `shared_replicates` of two designs. A ground spare goes up at the next launch slot, the planes of a stage launch in the order they are ready, and `MissionHistory.deployed` is infinite for a deployment that outlasts the mission. `SatelliteCache` keeps a context with each namespace (`context`, `SatelliteCache.contexts`), `Observations` generates the targets of a replicate only to observe them, an `ObservationStudy` computes the metrics of all of a design's satellites once, exact expectations are faster (module `expectations`), and the options of `Study.run`, `designs_of`, `ResultStore`, `SatelliteCache`, and `Repeat` are keyword-only. - Trade space tutorial (`docs/examples/tradespace`): eight notebooks that follow one trade of constellations, each adding one idea to those before it: `EvaluateTradeSpace` (design space, study, and Pareto front), `ExplainTradeSpace` (sampling error, revisits, and sensitivity), `SearchTradeSpace` (hypervolume, screening, and optimizers), `RankUncertainDesigns` (probability of efficiency, refinement, confirmation, and requirements on statistics), `CompareScenarios` (scenarios, regret, and searches across scenarios), `TradeCostAndUtility` (costs with uncertain growth, budgets, and utility), `PlanDeployment` (phases and staging), and `PlanForFailures` (failures, restoration policies, and the attribution of variance). Each notebook defines what it introduces, and imports what earlier notebooks defined from `trade_space_example.py`. - The `RunOSSEMonsoon` example declares its constellation trade as a design space, caches the looks of each satellite, evaluates its replicates in parallel, and finds its Pareto-efficient designs. diff --git a/docs/api_reference/tradespace/define.rst b/docs/api_reference/tradespace/define.rst index 6b17cb03..b0ebaa42 100644 --- a/docs/api_reference/tradespace/define.rst +++ b/docs/api_reference/tradespace/define.rst @@ -12,7 +12,13 @@ Design Spaces and Designs :members: enumerate, size, sample, design, designs_of, extend, suggest, unit_paths, uncertain_paths, check_uncertain, check_overrides, encode, decode .. autoclass:: tatc.tradespace.Design - :members: flat, realize, values, decisions, scenario + :members: flat, uncertain_values, realize, values, decisions, scenario + +.. autodata:: tatc.tradespace.space.RESERVED_NAMES + :annotation: + +.. autodata:: tatc.tradespace.space.STATUS_COLUMNS + :annotation: Variables and Values ==================== @@ -80,4 +86,21 @@ and the values of designs are views of the values decided so far. .. autoclass:: tatc.tradespace.values.Scope -.. autofunction:: tatc.tradespace.values.configure +.. autofunction:: tatc.tradespace.values.generic_path + +Reading Designs +=============== + +.. automodule:: tatc.tradespace.references + :no-members: + +.. autodata:: tatc.tradespace.references.Reference + :annotation: + +.. autofunction:: tatc.tradespace.value_of + +.. autofunction:: tatc.tradespace.configure + +.. autofunction:: tatc.tradespace.references.takes_design + +.. autofunction:: tatc.tradespace.references.given_design diff --git a/docs/api_reference/tradespace/evaluate.rst b/docs/api_reference/tradespace/evaluate.rst index da04350c..91618b46 100644 --- a/docs/api_reference/tradespace/evaluate.rst +++ b/docs/api_reference/tradespace/evaluate.rst @@ -23,10 +23,9 @@ Observation Studies .. autoclass:: tatc.tradespace.Targets :members: of, seed_of -.. autodata:: tatc.tradespace.references.Reference - :annotation: - -.. autofunction:: tatc.tradespace.references.value_of +The parts of observation studies read the values of designs by references +(see :doc:`define` for :py:data:`tatc.tradespace.references.Reference` and +:py:func:`tatc.tradespace.value_of`). Missions of Designs =================== @@ -35,13 +34,13 @@ Missions of Designs :no-members: .. autoclass:: tatc.tradespace.MissionPlan - :members: schedule_of, cost_model_of, masses_of, growth_of, stages_of, policy_of, mission_of + :members: schedule_of, cost_model_of, masses_of, growth_of, stages_of, policy_of, plan_mission .. autoclass:: tatc.tradespace.Failures :members: seed_of, simulate, evaluate, summarize -.. autoclass:: tatc.tradespace.plans.Mission - :members: planned, phases, estimate, histories, metrics, summarize +.. autoclass:: tatc.tradespace.mission.Mission + :members: phases, estimate, histories, metrics, summarize Stores of Results ================= @@ -56,7 +55,7 @@ Caches of Satellites :no-members: .. autoclass:: tatc.tradespace.SatelliteCache - :members: get, prune, clear_memory, folder, __call__ + :members: get, prune, clear_memory, folder, context, contexts, __call__ .. autofunction:: tatc.tradespace.cache.get_satellite_key @@ -71,3 +70,5 @@ Fingerprints .. autofunction:: tatc.tradespace.fingerprint.get_definition .. autofunction:: tatc.tradespace.fingerprint.compare_definitions + +.. autofunction:: tatc.tradespace.fingerprint.describe diff --git a/docs/api_reference/tradespace/index.rst b/docs/api_reference/tradespace/index.rst index e7a5b47c..57e624b2 100644 --- a/docs/api_reference/tradespace/index.rst +++ b/docs/api_reference/tradespace/index.rst @@ -43,8 +43,9 @@ before:: design, and their Pareto efficiency. 4. **Settle** the uncertainty of the replicates, or **search** spaces too large to enumerate (:doc:`search`). Each of these steps takes a study and - criteria, and returns its `results`, the `summary` of its designs, and the - `designs` themselves, for the next step. + criteria, and returns its `results`, the `summary` of its designs, the + `designs` themselves, for the next step, and its `criteria` (as an outcome, + such as a `Refinement`, see :doc:`search`). Results and Summaries ===================== @@ -86,14 +87,16 @@ and columns that TAT-C defines are named in snake case: convention if given without names (see `Statistic.name`, such as `"cost p70"` for `Quantile("cost", 0.7)`), the means of metrics by their names, and ` std` and ` se` (by `summarize`, and the - standard error of each objective by `pareto_probability`), and of - confirmed designs, ` selected` (by the replicates that selected - them) and ` optimism`. + standard error of each objective by `pareto_probability`, left out where + they are zero for every design), and of confirmed designs, ` + selected` (by the replicates that selected them) and ` + optimism`. A statistic other than the mean of a metric must not have the + name of a column of the results. * statistics within a replicate, over the mission of a design (see `ObservationStudy`): ` mission` (the mean over the phases of the mission), ` time` (when the phases first meet a requirement), and, over the histories of its failures, ` histories p`, - ` histories std`, and `P()`. + ` histories std`, and `P() histories`. * columns of judgments: `violation`, `meets_requirements`, `pareto`, `pareto_rank`, `pareto_probability`, `requirements_probability`, `pareto_trace`, `max_regret`, and the ` regret` of each scenario. diff --git a/docs/api_reference/tradespace/judge.rst b/docs/api_reference/tradespace/judge.rst index abac481b..75acefe8 100644 --- a/docs/api_reference/tradespace/judge.rst +++ b/docs/api_reference/tradespace/judge.rst @@ -9,7 +9,7 @@ Criteria, Statistics, and Requirements :no-members: .. autoclass:: tatc.tradespace.Criteria - :members: names, metrics, statistic + :members: names, metrics, statistic, resolved, of, signs, costs, violation, combiners, tolerance_array .. autoclass:: tatc.tradespace.Requirement :members: met, violation @@ -34,7 +34,7 @@ Criteria, Statistics, and Requirements .. autoclass:: tatc.tradespace.Probability -.. autoclass:: tatc.tradespace.statistics.Statistic +.. autoclass:: tatc.tradespace.Statistic :members: name, metric, reduce, columns, values_of Summaries diff --git a/docs/api_reference/tradespace/missions.rst b/docs/api_reference/tradespace/missions.rst index 24855761..1d819963 100644 --- a/docs/api_reference/tradespace/missions.rst +++ b/docs/api_reference/tradespace/missions.rst @@ -51,13 +51,23 @@ Deployment .. autoclass:: tatc.tradespace.Stage .. autoclass:: tatc.tradespace.deployment.Deployment - :members: simulate, simulate_many, expected_metrics, planned, phases, begin, end, deployed, units, stages, capability + :members: simulate, simulate_many, expected_metrics, planned, phases, begin, end, deployed, units, stages, policy, capability + +.. automodule:: tatc.tradespace.events + :no-members: .. autoclass:: tatc.tradespace.events.PlannedPlane -.. autoclass:: tatc.tradespace.deployment.Launch +.. autoclass:: tatc.tradespace.events.Launch + +.. autoclass:: tatc.tradespace.events.Production + +.. autodata:: tatc.tradespace.events.PerType + :annotation: + +.. autofunction:: tatc.tradespace.events.per_type -.. autoclass:: tatc.tradespace.deployment.Production +.. autofunction:: tatc.tradespace.events.per_type_values .. autoclass:: tatc.tradespace.mission.Decision :members: time, since_launch, stage, satellites_operating, history, stages_deployed, capability @@ -92,7 +102,7 @@ Missions :no-members: .. autoclass:: tatc.tradespace.mission.MissionHistory - :members: phases, metrics, in_orbit, deployed + :members: phases, metrics, in_orbit, deployed, decided .. autoclass:: tatc.tradespace.mission.Phase :members: duration @@ -112,12 +122,17 @@ Missions :members: evaluate, metrics_of, clear .. autoclass:: tatc.tradespace.mission.Capability - :members: evaluate, at + :members: evaluate, at, position_names, names :special-members: __call__ .. automodule:: tatc.tradespace.simulation :no-members: +.. autofunction:: tatc.tradespace.simulation.simulate_histories + +.. autodata:: tatc.tradespace.simulation.SAMPLINGS + :annotation: + .. automodule:: tatc.tradespace.histories :no-members: @@ -127,9 +142,14 @@ Missions .. autofunction:: tatc.tradespace.histories.allocate_histories -.. autofunction:: tatc.tradespace.histories.exact_expectations +.. automodule:: tatc.tradespace.expectations + :no-members: + +.. autofunction:: tatc.tradespace.expectations.exact_expectations + +.. autoexception:: tatc.tradespace.expectations.ExactExpectationsError -.. autodata:: tatc.tradespace.histories.MAX_SETS +.. autodata:: tatc.tradespace.expectations.MAX_SETS :annotation: Costs diff --git a/docs/api_reference/tradespace/search.rst b/docs/api_reference/tradespace/search.rst index cdf85c57..40d61650 100644 --- a/docs/api_reference/tradespace/search.rst +++ b/docs/api_reference/tradespace/search.rst @@ -2,24 +2,25 @@ Refinement and Searches ======================== -Each of these steps takes a study and criteria (or metrics), and returns its -`results`, the `summary` of its designs, and the `designs` themselves, which -the next step takes. +Each of these steps takes a study and criteria (or metrics), and returns an +outcome (exported for type hints, such as `Refinement`) of its `results`, the +`summary` of its designs, the `designs` themselves, which the next step +takes, and its `criteria`. Adaptive Replication ==================== .. autofunction:: tatc.tradespace.refine -.. autoclass:: tatc.tradespace.refinement.Refinement - :members: results, summary, history, designs, candidates, criteria, evaluations, uncertain, indifferent +.. autoclass:: tatc.tradespace.Refinement + :members: results, summary, rounds, designs, candidates, criteria, evaluations, uncertain, indifferent Confirmation ============ .. autofunction:: tatc.tradespace.confirm -.. autoclass:: tatc.tradespace.confirmation.Confirmation +.. autoclass:: tatc.tradespace.Confirmation :members: results, summary, criteria, designs, optimism Screening @@ -27,7 +28,7 @@ Screening .. autofunction:: tatc.tradespace.screen -.. autoclass:: tatc.tradespace.screening.Screening +.. autoclass:: tatc.tradespace.Screening :members: results, summary, summaries, history, designs, criteria Attribution of Variance @@ -38,7 +39,7 @@ Attribution of Variance .. autofunction:: tatc.tradespace.attribute_variance -.. autoclass:: tatc.tradespace.attribution.Attribution +.. autoclass:: tatc.tradespace.Attribution :members: results, shares, summary, summary_of, differences, designs Optimizers @@ -51,7 +52,7 @@ Optimizers .. autofunction:: tatc.tradespace.optimize_pymoo -.. autoclass:: tatc.tradespace.optimization.Search +.. autoclass:: tatc.tradespace.Search :members: results, summary, designs, evaluated, criteria, state .. autofunction:: tatc.tradespace.optimization.make_pymoo_problem diff --git a/docs/examples/tradespace/PlanDeployment.ipynb b/docs/examples/tradespace/PlanDeployment.ipynb index de7f0343..a3554960 100644 --- a/docs/examples/tradespace/PlanDeployment.ipynb +++ b/docs/examples/tradespace/PlanDeployment.ipynb @@ -267,7 +267,7 @@ "fig, ax = plt.subplots(figsize=(8, 4))\n", "for color, (satellites, planes) in zip(COLORS, [(4, 1), (4, 2), (6, 2)]):\n", " key = leaders[(leaders.satellites == satellites) & (leaders.planes == planes)].index[0]\n", - " (design,) = cost_space.designs_of(summary, [key])\n", + " (design,) = cost_space.designs_of(summary, keys=[key])\n", " phases = cost_study.mission_of(design).phases() # the metrics of each phase of the planned deployment\n", " edges = [*phases.start, phases.end.iloc[-1]]\n", " ax.stairs(\n", diff --git a/docs/examples/tradespace/PlanForFailures.ipynb b/docs/examples/tradespace/PlanForFailures.ipynb index f4b457a9..10baacdd 100644 --- a/docs/examples/tradespace/PlanForFailures.ipynb +++ b/docs/examples/tradespace/PlanForFailures.ipynb @@ -35,10 +35,10 @@ "id": "e20ee309", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:44:01.748712Z", - "iopub.status.busy": "2026-11-14T15:44:01.748712Z", - "iopub.status.idle": "2026-11-14T15:44:03.435885Z", - "shell.execute_reply": "2026-11-14T15:44:03.435885Z" + "iopub.execute_input": "2026-11-15T00:10:38.284584Z", + "iopub.status.busy": "2026-11-15T00:10:38.284584Z", + "iopub.status.idle": "2026-11-15T00:10:40.023692Z", + "shell.execute_reply": "2026-11-15T00:10:40.023692Z" } }, "outputs": [ @@ -74,10 +74,10 @@ "id": "7c437e44", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:44:03.435885Z", - "iopub.status.busy": "2026-11-14T15:44:03.435885Z", - "iopub.status.idle": "2026-11-14T15:44:03.892354Z", - "shell.execute_reply": "2026-11-14T15:44:03.892354Z" + "iopub.execute_input": "2026-11-15T00:10:40.023692Z", + "iopub.status.busy": "2026-11-15T00:10:40.023692Z", + "iopub.status.idle": "2026-11-15T00:10:40.468161Z", + "shell.execute_reply": "2026-11-15T00:10:40.468161Z" } }, "outputs": [ @@ -141,10 +141,10 @@ "id": "35efa3e2", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:44:03.892354Z", - "iopub.status.busy": "2026-11-14T15:44:03.892354Z", - "iopub.status.idle": "2026-11-14T15:44:04.886661Z", - "shell.execute_reply": "2026-11-14T15:44:04.886661Z" + "iopub.execute_input": "2026-11-15T00:10:40.468161Z", + "iopub.status.busy": "2026-11-15T00:10:40.468161Z", + "iopub.status.idle": "2026-11-15T00:10:41.517904Z", + "shell.execute_reply": "2026-11-15T00:10:41.517904Z" } }, "outputs": [ @@ -203,7 +203,7 @@ "id": "8905ad94", "metadata": {}, "source": [ - "The table gives four of the designs, each with each policy: two satellites in two planes, four in two, six in three, and nine in three. Its columns are the means over the replicates of the share accurately sampled over the mission (`accurate`, on average over the histories, and `accurate p10`, in their worst 10%) and of the cost at 70% confidence (`cost p70`). The first column is the share of the full constellation, without deployment or failures, from `ExplainTradeSpace`." + "The table gives four of the designs, each with each policy: two satellites in two planes, four in two, six in three, and nine in three. Its columns are the means over the replicates of the share accurately sampled over the mission (`accurate mission`, on average over the histories, and `accurate p10`, in their worst 10%) and of the cost at 70% confidence (`cost p70`). The first column is the share of the full constellation, without deployment or failures, from `ExplainTradeSpace`." ] }, { @@ -212,10 +212,10 @@ "id": "4c9a47e8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:44:04.886661Z", - "iopub.status.busy": "2026-11-14T15:44:04.886661Z", - "iopub.status.idle": "2026-11-14T15:44:04.934016Z", - "shell.execute_reply": "2026-11-14T15:44:04.934016Z" + "iopub.execute_input": "2026-11-15T00:10:41.517904Z", + "iopub.status.busy": "2026-11-15T00:10:41.517904Z", + "iopub.status.idle": "2026-11-15T00:10:41.565279Z", + "shell.execute_reply": "2026-11-15T00:10:41.564567Z" } }, "outputs": [ @@ -242,7 +242,7 @@ " \n", " \n", " \n", - " accurate\n", + " accurate mission\n", " accurate p10\n", " cost p70\n", " \n", @@ -316,9 +316,9 @@ " \n", " \n", " spares in orbit and on ground\n", - " 69.0\n", + " 69.1\n", " 63.1\n", - " 260.7\n", + " 261.3\n", " \n", " \n", " 700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spacing 0)\n", @@ -348,9 +348,9 @@ " \n", " \n", " spares in orbit and on ground\n", - " 74.3\n", + " 74.4\n", " 66.9\n", - " 329.0\n", + " 329.5\n", " \n", " \n", " 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spacing 0)\n", @@ -382,35 +382,35 @@ " spares in orbit and on ground\n", " 76.9\n", " 71.6\n", - " 405.7\n", + " 405.9\n", " \n", " \n", "\n", "" ], "text/plain": [ - " accurate \\\n", - "description full constellation policy \n", - "800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spaci... 34.2 degrade 17.7 \n", - " produce 26.1 \n", - " spare in orbit 28.2 \n", - " spare on ground 28.9 \n", - " spares in orbit and on ground 28.5 \n", - "800 km, 60 deg FOR, SSO: 2 at 09:00, 2 at 15:00 85.4 degrade 50.6 \n", - " produce 68.3 \n", - " spare in orbit 68.4 \n", - " spare on ground 72.3 \n", - " spares in orbit and on ground 69.0 \n", - "700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spaci... 96.4 degrade 64.2 \n", - " produce 78.0 \n", - " spare in orbit 74.2 \n", - " spare on ground 79.6 \n", - " spares in orbit and on ground 74.3 \n", - "800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spaci... 97.8 degrade 79.3 \n", - " produce 82.8 \n", - " spare in orbit 76.8 \n", - " spare on ground 82.8 \n", - " spares in orbit and on ground 76.9 \n", + " accurate mission \\\n", + "description full constellation policy \n", + "800 km, 60 deg FOR, Walker 45 deg: 2 x 1 (spaci... 34.2 degrade 17.7 \n", + " produce 26.1 \n", + " spare in orbit 28.2 \n", + " spare on ground 28.9 \n", + " spares in orbit and on ground 28.5 \n", + "800 km, 60 deg FOR, SSO: 2 at 09:00, 2 at 15:00 85.4 degrade 50.6 \n", + " produce 68.3 \n", + " spare in orbit 68.4 \n", + " spare on ground 72.3 \n", + " spares in orbit and on ground 69.1 \n", + "700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spaci... 96.4 degrade 64.2 \n", + " produce 78.0 \n", + " spare in orbit 74.2 \n", + " spare on ground 79.6 \n", + " spares in orbit and on ground 74.4 \n", + "800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spaci... 97.8 degrade 79.3 \n", + " produce 82.8 \n", + " spare in orbit 76.8 \n", + " spare on ground 82.8 \n", + " spares in orbit and on ground 76.9 \n", "\n", " accurate p10 \\\n", "description full constellation policy \n", @@ -446,17 +446,17 @@ " produce 218.3 \n", " spare in orbit 246.8 \n", " spare on ground 235.4 \n", - " spares in orbit and on ground 260.7 \n", + " spares in orbit and on ground 261.3 \n", "700 km, 60 deg FOR, Walker 75 deg: 3 x 2 (spaci... 96.4 degrade 209.5 \n", " produce 278.8 \n", " spare in orbit 316.7 \n", " spare on ground 294.4 \n", - " spares in orbit and on ground 329.0 \n", + " spares in orbit and on ground 329.5 \n", "800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spaci... 97.8 degrade 253.5 \n", " produce 340.0 \n", " spare in orbit 394.6 \n", " spare on ground 355.7 \n", - " spares in orbit and on ground 405.7 " + " spares in orbit and on ground 405.9 " ] }, "execution_count": 4, @@ -485,7 +485,7 @@ "# the means over the replicates of the mean share over the histories, the share in their worst 10%, and the cost at\n", "# 70% confidence over the histories\n", "ROBUST = {\n", - " \"accurate\": \"accurate mission\",\n", + " \"accurate mission\": \"accurate mission\",\n", " \"accurate p10\": \"accurate mission histories p10\",\n", " \"cost p70\": \"cost histories p70\",\n", "}\n", @@ -532,10 +532,10 @@ "id": "a41c39e2", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:44:04.934016Z", - "iopub.status.busy": "2026-11-14T15:44:04.934016Z", - "iopub.status.idle": "2026-11-14T15:44:04.949712Z", - "shell.execute_reply": "2026-11-14T15:44:04.949712Z" + "iopub.execute_input": "2026-11-15T00:10:41.565279Z", + "iopub.status.busy": "2026-11-15T00:10:41.565279Z", + "iopub.status.idle": "2026-11-15T00:10:41.580602Z", + "shell.execute_reply": "2026-11-15T00:10:41.580602Z" } }, "outputs": [ @@ -562,7 +562,7 @@ " \n", " description\n", " policy\n", - " accurate\n", + " accurate mission\n", " accurate p10\n", " cost p70\n", " \n", @@ -755,27 +755,27 @@ "2b499d154a98 800 km, 60 deg FOR, Walker 75 deg: 4 x 2 (spac... \n", "a37619256b26 800 km, 60 deg FOR, Walker 75 deg: 3 x 3 (spac... \n", "\n", - " policy accurate accurate p10 cost p70 \n", - "design \n", - "c58eba60fcc8 degrade 3.2 0.4 110.2 \n", - "4098dd5b042f degrade 7.0 2.1 128.9 \n", - "bb0be3483708 produce 3.9 3.5 130.6 \n", - "638697713902 degrade 10.9 4.6 146.2 \n", - "8aca273a3613 produce 9.2 7.3 153.4 \n", - "ad99c42082ab produce 26.1 19.5 159.4 \n", - "cc2e14e787ff spare on ground 28.9 25.6 175.2 \n", - "77d5dc1d8f4f produce 46.4 35.9 193.5 \n", - "525acda84c60 produce 44.9 37.7 201.0 \n", - "3a902b976460 degrade 64.2 38.9 209.5 \n", - "d1a143db2a62 spare on ground 50.2 40.9 211.7 \n", - "7b247cdf0711 spare on ground 48.1 42.4 216.8 \n", - "170ca99f7e10 produce 68.3 56.3 218.3 \n", - "e84f662c5ca8 spare on ground 72.3 62.1 235.4 \n", - "46932f795a5a degrade 79.5 69.0 253.5 \n", - "6e4564d2ae2c produce 78.0 70.1 278.8 \n", - "570a452fdb8f spare on ground 79.6 71.5 294.4 \n", - "2b499d154a98 produce 81.2 73.8 326.4 \n", - "a37619256b26 produce 83.0 78.7 340.0 " + " policy accurate mission accurate p10 cost p70 \n", + "design \n", + "c58eba60fcc8 degrade 3.2 0.4 110.2 \n", + "4098dd5b042f degrade 7.0 2.1 128.9 \n", + "bb0be3483708 produce 3.9 3.5 130.6 \n", + "638697713902 degrade 10.9 4.6 146.2 \n", + "8aca273a3613 produce 9.2 7.3 153.4 \n", + "ad99c42082ab produce 26.1 19.5 159.4 \n", + "cc2e14e787ff spare on ground 28.9 25.6 175.2 \n", + "77d5dc1d8f4f produce 46.4 35.9 193.5 \n", + "525acda84c60 produce 44.9 37.7 201.0 \n", + "3a902b976460 degrade 64.2 38.9 209.5 \n", + "d1a143db2a62 spare on ground 50.2 40.9 211.7 \n", + "7b247cdf0711 spare on ground 48.1 42.4 216.8 \n", + "170ca99f7e10 produce 68.3 56.3 218.3 \n", + "e84f662c5ca8 spare on ground 72.3 62.1 235.4 \n", + "46932f795a5a degrade 79.5 69.0 253.5 \n", + "6e4564d2ae2c produce 78.0 70.1 278.8 \n", + "570a452fdb8f spare on ground 79.6 71.5 294.4 \n", + "2b499d154a98 produce 81.2 73.8 326.4 \n", + "a37619256b26 produce 83.0 78.7 340.0 " ] }, "execution_count": 5, @@ -785,7 +785,7 @@ ], "source": [ "chosen = traded[pareto_front(traded, {\"cost p70\": \"min\", \"accurate p10\": \"max\"})]\n", - "chosen.sort_values(\"cost p70\")[[\"description\", \"policy\", \"accurate\", \"accurate p10\", \"cost p70\"]].round(1)" + "chosen.sort_values(\"cost p70\")[[\"description\", \"policy\", \"accurate mission\", \"accurate p10\", \"cost p70\"]].round(1)" ] }, { @@ -802,16 +802,16 @@ "id": "58d5e989", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:44:04.949712Z", - "iopub.status.busy": "2026-11-14T15:44:04.949712Z", - "iopub.status.idle": "2026-11-14T15:44:05.297133Z", - "shell.execute_reply": "2026-11-14T15:44:05.297133Z" + "iopub.execute_input": "2026-11-15T00:10:41.580602Z", + "iopub.status.busy": "2026-11-15T00:10:41.580602Z", + "iopub.status.idle": "2026-11-15T00:10:41.928280Z", + "shell.execute_reply": "2026-11-15T00:10:41.928280Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -862,10 +862,10 @@ "id": "c687c0ed", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:44:05.297133Z", - "iopub.status.busy": "2026-11-14T15:44:05.297133Z", - "iopub.status.idle": "2026-11-14T15:44:05.595246Z", - "shell.execute_reply": "2026-11-14T15:44:05.595246Z" + "iopub.execute_input": "2026-11-15T00:10:41.928280Z", + "iopub.status.busy": "2026-11-15T00:10:41.928280Z", + "iopub.status.idle": "2026-11-15T00:10:42.227942Z", + "shell.execute_reply": "2026-11-15T00:10:42.227942Z" } }, "outputs": [ @@ -928,7 +928,7 @@ " cost_growth\n", " 0.0\n", " 0.0\n", - " 78.6\n", + " 78.7\n", " 0.0\n", " 0.0\n", " 19.0\n", @@ -936,8 +936,8 @@ " \n", " failure_seed\n", " 3.7\n", - " 65.4\n", - " 37.3\n", + " 65.5\n", + " 37.2\n", " 0.7\n", " 6.9\n", " 7.6\n", @@ -951,13 +951,13 @@ "parameter \n", "points_seed 88.7 35.9 \n", "cost_growth 0.0 0.0 \n", - "failure_seed 3.7 65.4 \n", + "failure_seed 3.7 65.5 \n", "\n", " cost histories p70 accurate mission se \\\n", "parameter \n", "points_seed 0.0 8.6 \n", - "cost_growth 78.6 0.0 \n", - "failure_seed 37.3 0.7 \n", + "cost_growth 78.7 0.0 \n", + "failure_seed 37.2 0.7 \n", "\n", " accurate mission histories p10 se cost histories p70 se \n", "parameter \n", @@ -978,7 +978,7 @@ "\n", "began = time.perf_counter()\n", "attribution = attribute_variance(\n", - " failure_study, list(ROBUST.values()), failure_space.designs_of(trades, chosen.index), sample_size=20\n", + " failure_study, list(ROBUST.values()), failure_space.designs_of(trades, keys=chosen.index), sample_size=20\n", ")\n", "print(f\"{len(attribution.results)} evaluations in {time.perf_counter() - began:.0f} s\")\n", "attribution.summary.mul(100).round(1)" @@ -998,16 +998,16 @@ "id": "608307dd", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:44:05.595246Z", - "iopub.status.busy": "2026-11-14T15:44:05.595246Z", - "iopub.status.idle": "2026-11-14T15:44:05.674082Z", - "shell.execute_reply": "2026-11-14T15:44:05.674082Z" + "iopub.execute_input": "2026-11-15T00:10:42.227942Z", + "iopub.status.busy": "2026-11-15T00:10:42.227942Z", + "iopub.status.idle": "2026-11-15T00:10:42.308254Z", + "shell.execute_reply": "2026-11-15T00:10:42.308254Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1041,7 +1041,7 @@ "id": "da3c8d4e", "metadata": {}, "source": [ - "The sample of points spreads the mean shares accurately sampled (89% of their variance between replicates), and the failures hardly do (4%), as each replicate averages 20 histories. The share in the worst 10% of the histories is spread mostly by the failures (65%, and 36% by the points), as a quantile of 20 histories is a noisy estimate. Both are noise of the estimates, with different remedies: more points would sharpen the means, and more histories the worst 10%, which is cheap.\n", + "The sample of points spreads the mean shares accurately sampled (89% of their variance between replicates), and the failures hardly do (4%), as each replicate averages 20 histories. The share in the worst 10% of the histories is spread mostly by the failures (66%, and 36% by the points), as a quantile of 20 histories is a noisy estimate. Both are noise of the estimates, with different remedies: more points would sharpen the means, and more histories the worst 10%, which is cheap.\n", "\n", "The cost at 70% confidence is spread by the growth of the cost of development (79%), a risk of the mission, and by the failures (37%), which cost replacements and spares. These shares are the least certain, with standard errors of 19 and 8 points. The total shares of each objective sum to about 100% within their errors, so the parameters hardly interact." ] @@ -1060,10 +1060,10 @@ "id": "d53fe0cc", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:44:05.674082Z", - "iopub.status.busy": "2026-11-14T15:44:05.674082Z", - "iopub.status.idle": "2026-11-14T15:44:05.958791Z", - "shell.execute_reply": "2026-11-14T15:44:05.958791Z" + "iopub.execute_input": "2026-11-15T00:10:42.308254Z", + "iopub.status.busy": "2026-11-15T00:10:42.308254Z", + "iopub.status.idle": "2026-11-15T00:10:42.593461Z", + "shell.execute_reply": "2026-11-15T00:10:42.593461Z" } }, "outputs": [ @@ -1127,8 +1127,8 @@ " \n", " failure_seed\n", " 2.5\n", - " 72.6\n", - " 106.0\n", + " 72.7\n", + " 105.9\n", " 0.5\n", " 8.6\n", " 4.4\n", @@ -1142,13 +1142,13 @@ "parameter \n", "points_seed 95.8 42.7 \n", "cost_growth 0.0 0.0 \n", - "failure_seed 2.5 72.6 \n", + "failure_seed 2.5 72.7 \n", "\n", " cost histories p70 accurate mission se \\\n", "parameter \n", "points_seed 0.0 9.7 \n", "cost_growth 0.0 0.0 \n", - "failure_seed 106.0 0.5 \n", + "failure_seed 105.9 0.5 \n", "\n", " accurate mission histories p10 se cost histories p70 se \n", "parameter \n", diff --git a/docs/examples/tradespace/RankUncertainDesigns.ipynb b/docs/examples/tradespace/RankUncertainDesigns.ipynb index ba01f6ca..9d423db6 100644 --- a/docs/examples/tradespace/RankUncertainDesigns.ipynb +++ b/docs/examples/tradespace/RankUncertainDesigns.ipynb @@ -509,7 +509,7 @@ "refinement = refine(study, CRITERIA, results, step=5, max_replicates=40, n_resamples=1000)\n", "added = refinement.evaluations\n", "print(f\"{added} evaluations added, {added / (len(designs) * 35):.1%} of those of 40 replicates of every design\")\n", - "refinement.history" + "refinement.rounds" ] }, { diff --git a/docs/validation/ValidateCostVarianceNSOSA.ipynb b/docs/validation/ValidateCostVarianceNSOSA.ipynb index 8f304565..4871a99b 100644 --- a/docs/validation/ValidateCostVarianceNSOSA.ipynb +++ b/docs/validation/ValidateCostVarianceNSOSA.ipynb @@ -1858,7 +1858,7 @@ " *moments(table, correlated=draws == \"common\")\n", " )[1],\n", " \"P(C2 > C1), replicates\": p,\n", - " \"standard error\": math.sqrt(p * (1 - p) / row.replicates),\n", + " \"standard error\": math.sqrt(p * (1 - p) / row.shared_replicates),\n", " \"mean difference\": row[\"cost difference\"],\n", " }\n", " )\n", diff --git a/src/tatc/tradespace/__init__.py b/src/tatc/tradespace/__init__.py index e3f7336f..f6d4435c 100644 --- a/src/tatc/tradespace/__init__.py +++ b/src/tatc/tradespace/__init__.py @@ -11,17 +11,18 @@ designs of spaces too large to enumerate (`screen`, `optimize_optuna`, `optimize_pymoo`). -This package exports the functions and classes of trade studies. The parts +This package exports the functions and classes of trade studies, and the +outcomes of their steps (such as `Refinement`), for type hints. The parts from which they are made (such as the layouts of constellations, the simulation of missions, and fingerprints) are in its modules. @author: Paul T. Grogan """ -from .attribution import attribute_variance +from .attribution import Attribution, attribute_variance from .cache import SatelliteCache from .comparison import exceedance -from .confirmation import confirm +from .confirmation import Confirmation, confirm from .constellations import ( build_constellation, count_planes, @@ -65,7 +66,7 @@ Uncertain, ) from .observations import ObservationStudy, Observations, Targets -from .optimization import optimize_optuna, optimize_pymoo +from .optimization import Search, optimize_optuna, optimize_pymoo from .pareto import hypervolume, hypervolume_progress, pareto_front, pareto_ranks from .plans import Failures, MissionPlan from .plotting import ( @@ -80,9 +81,10 @@ style_axes, use_style, ) -from .refinement import refine +from .references import configure, value_of +from .refinement import Refinement, refine from .scenarios import robustness -from .screening import screen +from .screening import Screening, screen from .sensitivity import main_effects, sensitivity from .space import Design, DesignSpace from .statistics import ( @@ -93,6 +95,7 @@ Quantile, StandardDeviation, StandardError, + Statistic, ) from .store import ResultStore from .study import Study @@ -113,6 +116,7 @@ "Repeat", "Uncertain", "build_constellation", + "configure", "count_planes", "count_satellites", "layout_of", @@ -121,6 +125,7 @@ "policy_space", "soc_space", "sso_planes_space", + "value_of", "walker_space", # studies "Bathtub", @@ -160,6 +165,7 @@ "Requirement", "StandardDeviation", "StandardError", + "Statistic", "Utility", "aggregate", "exceedance", @@ -173,6 +179,11 @@ "sensitivity", "summarize", # refinement and searches + "Attribution", + "Confirmation", + "Refinement", + "Screening", + "Search", "attribute_variance", "confirm", "optimize_optuna", diff --git a/src/tatc/tradespace/alerts.py b/src/tatc/tradespace/alerts.py index d971c2a2..a07a44e6 100644 --- a/src/tatc/tradespace/alerts.py +++ b/src/tatc/tradespace/alerts.py @@ -11,8 +11,8 @@ import sys import warnings -_PACKAGE = __name__.rpartition(".")[0] -"""The name of the package whose frames a warning skips.""" +_TRADESPACE = __name__.rpartition(".")[0] +"""The name of the package of trade studies, whose frames a warning skips.""" def _warn(message: str, category: type[Warning] = UserWarning) -> None: @@ -26,13 +26,13 @@ def _warn(message: str, category: type[Warning] = UserWarning) -> None: category (type[Warning]): The category of the warning. """ level, frame = 2, sys._getframe(1) # pylint: disable=protected-access - while frame is not None and _is_package(frame.f_globals.get("__name__")): + while frame is not None and _is_tradespace_module(frame.f_globals.get("__name__")): frame, level = frame.f_back, level + 1 warnings.warn(message, category, stacklevel=level) -def _is_package(module: object) -> bool: - """Whether a module name is of the package (or the package itself).""" +def _is_tradespace_module(module: object) -> bool: + """Whether a module name is of the package of trade studies or its modules.""" return isinstance(module, str) and ( - module == _PACKAGE or module.startswith(_PACKAGE + ".") + module == _TRADESPACE or module.startswith(_TRADESPACE + ".") ) diff --git a/src/tatc/tradespace/attribution.py b/src/tatc/tradespace/attribution.py index 26cd6e6d..5f0371ba 100644 --- a/src/tatc/tradespace/attribution.py +++ b/src/tatc/tradespace/attribution.py @@ -17,10 +17,9 @@ import pandas as pd from .space import Design, DesignSpace, _designs -from .statistics import _names from .study import Study -from .summary import _resamples -from .walks import _generic +from .tables import FEASIBLE, check_records, draw_resamples, feasible_records, names +from .values import generic_path _SHARES = ("first", "total") """The shares of variance of a parameter (see `attribute_variance`).""" @@ -198,15 +197,15 @@ def differences( if same: raise ValueError(f"pairs of a design with itself: {same}") metrics = list(pd.unique(self.shares["metric"])) - names = list(pd.unique(self.shares["parameter"])) + parameters = list(pd.unique(self.shares["parameter"])) n = self.resamples.shape[1] tables = { - key: _tables(self.results, key, metrics, names, self.by) + key: _tables(self.results, key, metrics, parameters, self.by) for key in dict.fromkeys(key for pair in keyed for key in pair) } frames = [] for first, other in keyed: - for name in [None, *names]: + for name in [None, *parameters]: a, b = tables[first].get(name), tables[other].get(name) if a is None and b is None: continue # neither design draws the parameter @@ -218,7 +217,7 @@ def differences( design=first, other=other, redrawn=name ) ) - columns = [*self.by, "replicate", *metrics, "feasible"] + columns = [*self.by, "replicate", *metrics, FEASIBLE] differences = ( pd.concat(frames, ignore_index=True) if frames @@ -228,7 +227,7 @@ def differences( differences, ("design", "other"), keyed, - names, + parameters, metrics, self.by, self.resamples, @@ -284,7 +283,7 @@ def _draws(design: Design, paths: Sequence[str]) -> bool: see `DesignSpace.uncertain_paths`), which those of branches it does not choose (or of the items of an empty repetition) it does not. """ - drawn = {_generic(path) for path in design.flat()} + drawn = {generic_path(path) for path in design.uncertain_values()} return any(path in drawn for path in paths) @@ -346,7 +345,7 @@ def _tables( results: pd.DataFrame, key: str, metrics: Sequence[str], - names: Sequence[str], + parameters: Sequence[str], by: Sequence[str], ) -> dict[str | None, pd.DataFrame]: """ @@ -359,16 +358,16 @@ def _tables( def table(part: pd.DataFrame) -> pd.DataFrame: indexed = part.set_index([*by, "replicate"]) - feasible = indexed["feasible"].astype(bool).to_numpy() + feasible = indexed[FEASIBLE].astype(bool).to_numpy() # a copy, as pandas may give a read-only view of the frame values = indexed.reindex(columns=list(metrics)).to_numpy(dtype=float, copy=True) values[~feasible] = np.nan frame = pd.DataFrame(values, index=indexed.index, columns=list(metrics)) - frame["feasible"] = feasible + frame[FEASIBLE] = feasible return frame tables: dict[str | None, pd.DataFrame] = {None: table(rows[rows["redrawn"].isna()])} - for name in names: + for name in parameters: part = rows[rows["redrawn"] == name] if len(part): tables[name] = table(part) @@ -391,8 +390,8 @@ def _difference( """ index = a.index.union(b.index) difference = a.reindex(index)[list(metrics)] - b.reindex(index)[list(metrics)] - difference["feasible"] = a["feasible"].reindex(index, fill_value=False) & b[ - "feasible" + difference[FEASIBLE] = a[FEASIBLE].reindex(index, fill_value=False) & b[ + FEASIBLE ].reindex(index, fill_value=False) return difference.reset_index() @@ -412,7 +411,7 @@ def _shares( results: pd.DataFrame, identity: Sequence[str], keys: Sequence[tuple], - names: Sequence[str], + parameters: Sequence[str], metrics: Sequence[str], by: Sequence[str], resamples: np.ndarray, @@ -426,7 +425,7 @@ def _shares( returns (see `Attribution.samples`). """ n = resamples.shape[1] - feasible = results[results["feasible"].astype(bool)] + feasible = feasible_records(results)[0] grouped = { key if isinstance(key, tuple) else (key,): group for key, group in feasible.groupby(list(identity), sort=False) @@ -447,7 +446,7 @@ def _shares( np.array( [ _by_replicate(group, metric, redrawn == name, n) - for name in names + for name in parameters ] ), n, @@ -465,11 +464,13 @@ def _shares( for share in ("first", "total", "first se", "total se") }, } - for i, name in enumerate(names) + for i, name in enumerate(parameters) ) for share in _SHARES: samples[share].extend(estimates[f"{share} samples"]) - samples["variance"].extend([estimates["variance samples"]] * len(names)) + samples["variance"].extend( + [estimates["variance samples"]] * len(parameters) + ) columns = [*identity, *by, "metric", "parameter", "variance"] shares = pd.DataFrame( rows, columns=[*columns, "first", "total", "first se", "total se"] @@ -566,19 +567,20 @@ def attribute_variance( n = study.replicates if sample_size is None else int(sample_size) if n < 2: raise ValueError("sample_size must be at least 2") - resamples = _resamples(n, n_resamples, seed) + drawn = draw_resamples(n, n_resamples, seed) groups = _groups_of(study.space, parameters) - metrics, by = _names(metrics), tuple(_names(by)) + metrics, by = names(metrics), tuple(names(by)) unique = _designs(study.space, designs) plain = study.run(unique, replicate_indices=range(2 * n)) missing = [column for column in (*metrics, *by) if column not in plain.columns] - if missing and plain["feasible"].any(): + if missing and plain[FEASIBLE].any(): raise ValueError(f"columns that are not in the results: {missing}") - keys = ["design", *by, "replicate"] - if not missing and plain.duplicated(keys).any(): - raise ValueError( - "the results have several records of an evaluation (a design in a " - + "replicate): give the columns that separate them as `by`" + if not missing: + check_records( + plain, + ["design", *by, "replicate"], + "give the columns that separate them as `by`", + metrics, ) frames = [plain.assign(redrawn=None)] for name, paths in groups.items(): @@ -597,13 +599,13 @@ def attribute_variance( list(groups), metrics, by, - resamples, + drawn, ) return Attribution( results=results, shares=shares, by=by, samples=samples, - resamples=resamples, + resamples=drawn, designs=unique, ) diff --git a/src/tatc/tradespace/cache.py b/src/tatc/tradespace/cache.py index 764428e8..79c835fb 100644 --- a/src/tatc/tradespace/cache.py +++ b/src/tatc/tradespace/cache.py @@ -26,13 +26,10 @@ import pandas as pd from ..schemas import Satellite -from .fingerprint import ( - _fingerprint_of, - _warn_other_code, - _with_other_code, - get_definition, -) -from .hashing import _canonical, _digest +from .fingerprint import _fingerprint_of, find_stale, get_definition, warn_stale +from .hashing import canonical, digest +from .memory import Forgetful +from .store import _decode, _encode def _write(path: Path, data: bytes, replace: bool = False) -> None: @@ -77,10 +74,10 @@ def get_satellite_key(satellite: Satellite) -> str: str: the key """ data = satellite.model_dump(mode="json", exclude={"name"}) - return _digest(_canonical({"type": type(satellite).__name__, **data})) + return digest(canonical({"type": type(satellite).__name__, **data})) -class SatelliteCache: +class SatelliteCache(Forgetful): """ A cache of an analysis of single satellites, keyed by their content (see `get_satellite_key`), in memory and optionally on disk. @@ -101,7 +98,8 @@ class SatelliteCache: the function reads, such as from files, and the code of other modules it calls, other than TAT-C's: change it whenever these change), and by the satellite, in a folder of each namespace (by a hash of it, with the - namespace in `namespace.txt`), and in it a folder of each fingerprint + namespace in `namespace.txt`, and a `context` that describes it in + `context.json`, see `contexts`), and in it a folder of each fingerprint (with the definition in `definition.json`). A cache warns if its namespace has results only of the same function @@ -119,17 +117,27 @@ class SatelliteCache: results, or `None` to keep them in memory only. namespace (str): An identifier of the analysis (of what the fingerprint of the function cannot see). + context (Any): A description of the namespace, such as the values + from which it is made, kept on disk beside its results (see + `contexts`): JSON data, or values that `ResultStore` encodes + (such as tuples and datetimes), or `None` for none. """ + _forgotten = ("_memory", "_unreadable") # (copies sent to parallel workers) + def __init__( self, function: Callable[[Satellite], Any], + *, directory: str | os.PathLike | None = None, namespace: str = "", + context: Any = None, ): self.function = function self.directory = None if directory is None else Path(directory) self.namespace = namespace + self.context = context + """Any: The description of the namespace, if any.""" self.fingerprint = "" """str: The fingerprint of the function, which keys results on disk.""" self.hits = 0 @@ -143,31 +151,72 @@ def __init__( if self.directory is not None: definition = get_definition(function=function) self.fingerprint = _fingerprint_of(definition) - space = _digest(namespace, 16) + space = digest(namespace, 16) self._folder = self.directory / space / self.fingerprint self._folder.mkdir(parents=True, exist_ok=True) _write(self._folder.parent / "namespace.txt", namespace.encode()) - _write(self._folder / "definition.json", _canonical(definition).encode()) + if context is not None: + data = json.dumps(_encode(context)).encode() + _write(self._folder.parent / "context.json", data) + _write(self._folder / "definition.json", canonical(definition).encode()) self._definition = definition self._warn_other_definitions() + @staticmethod + def contexts(directory: str | os.PathLike) -> dict[str, Any]: + """ + Gets the namespaces of the results in a directory (of the caches that + share it, see `SatelliteCache`) and their contexts, such as to find + the caches of a set of observations (see `Observations.prune`). + + Args: + directory (str | os.PathLike): The directory. + + Returns: + dict[str, Any]: the context of each namespace (`None` if it has + none, or if it cannot be read) + """ + directory = Path(directory) + if not directory.is_dir(): + return {} + contexts = {} + for folder in directory.iterdir(): + try: + namespace = (folder / "namespace.txt").read_text(encoding="utf-8") + except OSError: + continue + try: + context = _decode(json.loads((folder / "context.json").read_text())) + except Exception: # pylint: disable=broad-exception-caught + # none, or unreadable (such as pickled by other libraries) + context = None + contexts[namespace] = context + return contexts + @property def folder(self) -> Path | None: """pathlib.Path | None: The folder of the results of the function's definition on disk (in the folder of its namespace), if any.""" return self._folder - def __getstate__(self) -> dict: - # copies sent to parallel workers start with empty memories - state = self.__dict__.copy() - state["_memory"], state["_unreadable"] = {}, set() - return state + def __fingerprint__(self) -> dict: + """ + Gets what identifies the cache in a definition (see + `tatc.tradespace.fingerprint`), such as of a cache that a function of + a study refers to: its function and namespace, which identify its + results (not its directory, nor its counts of hits and misses, nor + the results it holds). + + Returns: + dict: the function and namespace + """ + return {"function": self.function, "namespace": self.namespace} def _stale(self) -> dict[Path, int]: """ Gets the folders of the results of the namespace by the function with - other code (the same values but for code, see `_with_other_code`), - the latest first, and their numbers of results (including folders of + other code (the same values but for code, see `find_stale`), the + latest first, and their numbers of results (including folders of definitions without results). """ folders = [ @@ -177,10 +226,11 @@ def _stale(self) -> dict[Path, int]: ] folders.sort(key=lambda folder: folder.stat().st_mtime, reverse=True) others = {folder: _read_definition(folder) for folder in folders} - return { - folder: sum(1 for _ in folder.glob("*.pkl")) - for folder in _with_other_code(self._definition, others) - } + return find_stale( + self._definition, + others, + lambda folder: sum(1 for _ in folder.glob("*.pkl")), + ) def _warn_other_definitions(self) -> None: """ @@ -190,21 +240,23 @@ def _warn_other_definitions(self) -> None: """ if next(self._folder.glob("*.pkl"), None) is not None: return - stale = {folder: count for folder, count in self._stale().items() if count} - if not stale: - return - try: + + def first() -> bool: # the first cache of the definition to warn marks its folder - with open(self._folder / "warned", "x", encoding="utf-8"): - pass - except FileExistsError: - return - _warn_other_code( - f"the cache in {self.directory} has {sum(stale.values())} results of " + try: + with open(self._folder / "warned", "x", encoding="utf-8"): + return True + except FileExistsError: + return False + + warn_stale( + self._stale(), + self._definition, + _read_definition, + lambda count: f"the cache in {self.directory} has {count} results of " + f"namespace {self.namespace!r} by its function", "prune removes them: Observations.prune for the observations of a study", - _read_definition(next(iter(stale))), - self._definition, + once=first, ) def prune(self) -> int: diff --git a/src/tatc/tradespace/comparison.py b/src/tatc/tradespace/comparison.py index 520d2797..bf5337ef 100644 --- a/src/tatc/tradespace/comparison.py +++ b/src/tatc/tradespace/comparison.py @@ -24,7 +24,7 @@ import pandas as pd from .space import Design, _keys_of -from .summary import _get_matrices, _groups +from .tables import feasible_records, groups, matrices, names def exceedance( @@ -75,13 +75,13 @@ def exceedance( design's less the other's, ` difference`), the probability that the design's metric exceeds the other's (`exceedance`), and the number of replicates in which both are - feasible (`replicates`) + feasible (`shared_replicates`) Raises: ValueError: if the results lack the metric or a design, or have several records of a design in a replicate (of a group). """ - by = (by,) if isinstance(by, str) else tuple(by) + by = tuple(names(by)) if metric not in results.columns: raise ValueError(f"no metric {metric!r} in the results") keys = None if designs is None else _keys_of(designs) @@ -91,17 +91,15 @@ def exceedance( if missing: raise ValueError(f"no results of designs {missing[:5]}") frames = [] - for group_key, positions in _groups(results, by): + for group_key, positions in groups(results, by): group = results.iloc[positions] index = pd.Index(group["design"].unique() if keys is None else keys) if index.empty: continue - if "feasible" in group: - group = group[group["feasible"].astype(bool)] - _, _, matrices = _get_matrices( + group = feasible_records(group)[0] + values = matrices( group, [metric], index, hint="give the columns that separate them as `by`" - ) - values = matrices[metric] + )[2][metric] valid = ~np.isnan(values) if keys is None: # by the mean of the metric, designs without feasible results last @@ -114,7 +112,7 @@ def exceedance( "other": [], "difference": [], "exceedance": [], - "replicates": [], + "shared_replicates": [], } for i, design in enumerate(index): both = valid[i] & valid @@ -127,7 +125,7 @@ def exceedance( parts["exceedance"].append((greater + 0.5 * ties) / counts) parts["design"].append(np.full(len(index), design, dtype=object)) parts["other"].append(np.asarray(index, dtype=object)) - parts["replicates"].append(counts) + parts["shared_replicates"].append(counts) frame = pd.DataFrame( { "design": np.concatenate(parts["design"]), @@ -135,7 +133,7 @@ def exceedance( **dict(zip(by, group_key)), f"{metric} difference": np.concatenate(parts["difference"]), "exceedance": np.concatenate(parts["exceedance"]), - "replicates": np.concatenate(parts["replicates"]), + "shared_replicates": np.concatenate(parts["shared_replicates"]), } ) frames.append(frame) @@ -147,7 +145,7 @@ def exceedance( *by, f"{metric} difference", "exceedance", - "replicates", + "shared_replicates", ] ) return pd.concat(frames, ignore_index=True) diff --git a/src/tatc/tradespace/confirmation.py b/src/tatc/tradespace/confirmation.py index ba4d2fc0..4c42e65d 100644 --- a/src/tatc/tradespace/confirmation.py +++ b/src/tatc/tradespace/confirmation.py @@ -13,10 +13,11 @@ import numpy as np import pandas as pd -from .criteria import Criteria, _as_criteria +from .criteria import Criteria from .space import Design, _designs from .study import Study -from .summary import _FEASIBLE, _JUDGMENT, aggregate +from .summary import aggregate +from .tables import FEASIBLE, JUDGMENT, efficient_keys @dataclass @@ -56,16 +57,23 @@ def optimism(self) -> pd.Series: """pandas.Series: The optimism of selection: the mean over the designs of their optimism in each objective of the criteria (see `summary`), in its units, positive if the selecting replicates made - them look better.""" + them look better (`NaN` without designs).""" return pd.Series( { - name: float(np.nanmean(self.summary[f"{name} optimism"])) + name: _mean(self.summary[f"{name} optimism"]) for name in self.criteria.objectives }, dtype=float, ) +def _mean(values: pd.Series) -> float: + """Gets the mean of the known values (`NaN` without any).""" + known = values.to_numpy(dtype=float) + known = known[~np.isnan(known)] + return float(known.mean()) if len(known) else float("nan") + + def confirm( study: Study, criteria: Criteria | Mapping[str, str], @@ -112,18 +120,17 @@ def confirm( Confirmation: the new results, the summary of each design, and the designs """ - criteria = _as_criteria(criteria) + criteria = Criteria.of(criteria) count = study.replicates if replicates is None else replicates if count < 1: raise ValueError("replicates must be at least 1") if designs is None: - summary = aggregate(results, criteria, design_columns=[]) - designs = summary[summary["pareto"]] + designs = efficient_keys(aggregate(results, criteria, design_columns=[])) designs = _designs(study.space, designs, results) keys = {design.key for design in designs} start = int(results["replicate"].max()) + 1 if len(results) > 0 else 0 fresh = study.run(designs, replicate_indices=range(start, start + count)) - names = [name for name in criteria.names if name != _FEASIBLE] + names = [name for name in criteria.names if name != FEASIBLE] columns = ["design", *criteria.by] confirmed = aggregate(fresh, criteria) selected = aggregate( @@ -139,7 +146,7 @@ def confirm( summary[f"{name} optimism"] = sign * ( summary[f"{name} selected"] - summary[name] ) - status = ["replicates", _FEASIBLE, *_JUDGMENT] + status = ["replicates", FEASIBLE, *JUDGMENT] values = [c for c in confirmed.columns if c not in {*columns, *names, *status}] summary = summary[ [ diff --git a/src/tatc/tradespace/cost.py b/src/tatc/tradespace/cost.py index 72b71d7f..82a0ca29 100644 --- a/src/tatc/tradespace/cost.py +++ b/src/tatc/tradespace/cost.py @@ -65,10 +65,11 @@ def evaluate(satellites, design): import pandas as pd from .deployment import Deployment -from .events import _per_type +from .events import per_type from .mission import MissionHistory from .nodes import Uncertain -from .space import _RESERVED_NAMES, DesignSpace +from .space import DesignSpace +from .values import is_number ELEMENTS = ("development", "production", "launch", "operations") """The elements of the cost of a constellation.""" @@ -145,10 +146,6 @@ def ppf(self, q: float) -> float: return high - math.sqrt((1 - q) * (high - low) * (high - mode)) -def _is_number(value: Any) -> bool: - return isinstance(value, numbers.Real) and not isinstance(value, bool) - - @dataclass(frozen=True) class Component: """ @@ -182,7 +179,7 @@ def __post_init__(self): raise ValueError("a component needs a name") if self.development < 0 or self.first_unit < 0: raise ValueError("costs must not be negative") - if _is_number(self.growth): + if is_number(self.growth): if self.growth < 0: raise ValueError("growth must not be negative") elif not (hasattr(self.growth, "ppf") and hasattr(self.growth, "mean")): @@ -193,7 +190,7 @@ def __post_init__(self): @property def uncertain(self) -> bool: """bool: Whether its growth is drawn from a distribution.""" - return not _is_number(self.growth) + return not is_number(self.growth) @property def factor(self) -> float: @@ -567,7 +564,7 @@ def satellite_cost_of(self, kind: Any = None) -> SatelliteCost: return self.satellites if kind is None: raise ValueError("a model of several types of satellites needs a type") - return _per_type(self.satellites, kind, "cost") + return per_type(self.satellites, kind, "cost") def _types(self) -> list[tuple[Any, SatelliteCost]]: """Gets the types of satellites: each type, and its cost.""" @@ -663,9 +660,11 @@ def estimate( self, deployment: Deployment | MissionHistory, growth: Growth = 1.0 ) -> CostEstimate: """ - Estimates the life-cycle cost of a deployment (as planned, without - failures) or of a simulated mission (see `Deployment.simulate`), with - the satellites and launches its failures and restorations take, + Estimates the life-cycle cost of a deployment (its history without + failures, with the stages that their rules deploy and the spares of + its policy, see `Deployment.planned`) or of a simulated mission (see + `Deployment.simulate`), with the satellites and launches its failures + and restorations take, dating its costs: the development of each type of satellite, spread over its development; the production of its units (including spares, replacements, and restorations) along its learning curve, spread over @@ -916,7 +915,7 @@ def _get_factor( factor = factors[element] if isinstance(factor, Mapping) and kind is None: raise ValueError(f"growth of {element} by type of satellite needs types") - return _per_type(factor, kind, f"growth of {element}") + return per_type(factor, kind, f"growth of {element}") def risk_space(*models: CostModel) -> DesignSpace: @@ -948,7 +947,7 @@ def risk_space(*models: CostModel) -> DesignSpace: Raises: ValueError: if a name has a character of paths (`.`, `[`, or `]`), or - is reserved (`index`, `count`, or `choice`). + is reserved (see `DesignSpace`, such as `index` or `count`). """ names = list( dict.fromkeys(name for model in models for name in model.score_names()) @@ -956,10 +955,4 @@ def risk_space(*models: CostModel) -> DesignSpace: invalid = [n for n in names if any(c in n for c in _PATH_CHARACTERS)] if invalid: raise ValueError(f"names of scores must not have '.', '[', or ']': {invalid}") - reserved = sorted(_RESERVED_NAMES.intersection(names)) - if reserved: - raise ValueError( - f"names of scores must not be those of values of groups ({sorted(_RESERVED_NAMES)}): " - + f"{reserved}" - ) return DesignSpace(**{name: Uncertain.normal(0.0, 1.0) for name in names}) diff --git a/src/tatc/tradespace/criteria.py b/src/tatc/tradespace/criteria.py index 20fab445..a04b4dae 100644 --- a/src/tatc/tradespace/criteria.py +++ b/src/tatc/tradespace/criteria.py @@ -20,6 +20,7 @@ import numpy as np +from . import tables from .statistics import _OPERATORS, Mean, Statistic, _named_statistics _DIRECTIONS = ("min", "max") @@ -38,9 +39,11 @@ class Requirement: A design that does not meet it violates it by the difference between the statistic and the value, relative to a `scale`: by default the magnitude of the value (or 1 if the value is 0), so that the violations of - requirements in different units are comparable, as they are added (see - `aggregate`, `screen`, and the constraint-aware optimizers of - `optimize_optuna` and `optimize_pymoo`). + requirements in different units are comparable. Summaries add them (the + `violation` of a design, see `aggregate`), by which the designs that miss + requirements are ranked (see `pareto_ranks` and `screen`), and the + constraint-aware optimizers of `optimize_optuna` and `optimize_pymoo` + keep each as a constraint of its own. Args: name (str): The statistic (or metric). @@ -136,15 +139,15 @@ class Across: ) The worst of a statistic needs its direction: that of the objective or - the requirements that name it, which must agree; other statistics (such - as those that `summarize` adds) are combined by their means, unless a - rule asks for their worst. Requirements and - tolerances apply to the combined statistics. A design is judged only if - it has feasible results in every group of the results (in each group of - the criteria's `by`). Statistics of the feasibility of replicates (such - as `feasible`, the share of a design's replicates that are feasible, see - `aggregate`) are not combined: they are over the evaluations of every - group together. + the requirements that name it, which must agree; other statistics are + combined by their means, unless a rule asks for their worst. The spreads + that `summarize` adds are those of the combined statistics (see + `summarize`). Requirements and tolerances apply to the combined + statistics. A design is judged only if it has feasible results in every + group of the results (in each group of the criteria's `by`). Statistics + of the feasibility of replicates (such as `feasible`, the share of a + design's replicates that are feasible, see `aggregate`) are not + combined: they are over the evaluations of every group together. Combining the statistics of the groups (such as the worst of the means) differs from a statistic of the worst group of each replicate (the mean @@ -205,13 +208,13 @@ def weights_of(self, groups: Sequence[Any]) -> np.ndarray: (a string of a percentage, such as `"5%"`).""" -def _get_tolerances( +def _tolerance_array( objectives: Mapping[str, str], tolerances: Mapping[str, Tolerance] ) -> np.ndarray: """ Gets the tolerances of the objectives (zero if not given): their absolute values (first row) and their shares of the values of the objectives - (second row). + (second row), checking them. """ unknown = set(tolerances) - set(objectives) if unknown: @@ -306,6 +309,12 @@ class Criteria: tolerances: Mapping[str, Tolerance] = field(default_factory=dict) by: Sequence[str] | str = () across: Across | None = None + tolerance_array: np.ndarray = field( + init=False, repr=False, compare=False, metadata={"fingerprint": False} + ) + """numpy.ndarray: The tolerances of the objectives (zero if not given), in + their order: their values in their units (first row), and their shares + of the values of the objectives (second row).""" def __post_init__(self): if not isinstance(self.objectives, Mapping): @@ -324,12 +333,13 @@ def __post_init__(self): if not isinstance(requirement, Requirement): raise TypeError(f"{requirement!r} is not a Requirement") tolerances = dict(self.tolerances) - _get_tolerances(objectives, tolerances) # checks the tolerances - by = (self.by,) if isinstance(self.by, str) else tuple(self.by) + tolerance_array = _tolerance_array(objectives, tolerances) + by = tuple(tables.names(self.by)) object.__setattr__(self, "objectives", objectives) object.__setattr__(self, "statistics", statistics) object.__setattr__(self, "requirements", requirements) object.__setattr__(self, "tolerances", tolerances) + object.__setattr__(self, "tolerance_array", tolerance_array) object.__setattr__(self, "by", by) if self.across is not None: if not isinstance(self.across, Across): @@ -341,7 +351,7 @@ def __post_init__(self): unknown = sorted(set(self.across.rules) - set(self.names)) if unknown: raise ValueError(f"rules of names that are not statistics: {unknown}") - _combiners(self) # checks that each statistic has a worst, if needed + _ = self.combiners # checks that each statistic has a worst, if needed @property def names(self) -> list[str]: @@ -378,99 +388,123 @@ def metrics(self) -> list[str]: {column for name in self.names for column in self.statistic(name).columns} ) + @classmethod + def of(cls, criteria: Criteria | Mapping[str, str]) -> Criteria: + """ + Gets criteria given as criteria, or as a mapping of objectives to their + directions (the criteria of the means of the metrics of their names). -def _as_criteria(criteria: Criteria | Mapping[str, str]) -> Criteria: - """ - Gets criteria, or the criteria of the means of objectives. - """ - if isinstance(criteria, Criteria): - return criteria - if isinstance(criteria, Mapping): - return Criteria(criteria) - raise TypeError( - "criteria must be Criteria or a mapping of objectives to their directions" - ) + Args: + criteria (Criteria | Mapping[str, str]): The criteria, or the + objectives and their directions (`"min"` or `"max"`). + Returns: + Criteria: the criteria -def _resolve(criteria: Criteria) -> dict[str, Statistic]: - """ - Gets the statistic of each name of criteria. - """ - return {name: criteria.statistic(name) for name in criteria.names} + Raises: + TypeError: if the criteria are neither. + """ + if isinstance(criteria, Criteria): + return criteria + if isinstance(criteria, Mapping): + return cls(criteria) + raise TypeError( + "criteria must be Criteria or a mapping of objectives to their directions" + ) + @property + def resolved(self) -> dict[str, Statistic]: + """dict[str, Statistic]: The statistic of each name (see `names` and + `statistic`).""" + return {name: self.statistic(name) for name in self.names} -def _signs(criteria: Criteria) -> np.ndarray: - """ - Gets the signs that make the objectives of criteria costs (to minimize). - """ - return np.array( - [ - 1.0 if direction == "min" else -1.0 - for direction in criteria.objectives.values() - ] - ) + @property + def signs(self) -> np.ndarray: + """numpy.ndarray: The sign of each objective that makes it a cost (to + minimize): 1 for an objective to minimize, and -1 for one to + maximize.""" + return np.array( + [ + 1.0 if direction == "min" else -1.0 + for direction in self.objectives.values() + ] + ) + def costs(self, values: Mapping[str, Any]) -> np.ndarray: + """ + Gets the objectives as costs (to minimize, see `signs`), from the + values of their statistics (by name, such as the columns of a + summary): maximized objectives are negated. -def _costs_of(values: Mapping[str, Any], criteria: Criteria) -> np.ndarray: - """ - Gets the objectives of criteria as costs (to minimize), from the values of - their statistics (by name, such as the columns of a summary): maximized - objectives are negated (missing values are `NaN`). - """ - columns = [ - np.asarray(values[name], dtype=float) * sign - for name, sign in zip(criteria.objectives, _signs(criteria)) - ] - count = len(columns[0]) if columns else 0 - return np.column_stack(columns) if count else np.empty((0, len(columns))) + Args: + values (Mapping[str, Any]): The values of the statistics of + designs, by name. + Returns: + numpy.ndarray: the costs (a row per design, and a column per + objective, `NaN` where a value is missing) + """ + columns = [ + np.asarray(values[name], dtype=float) * sign + for name, sign in zip(self.objectives, self.signs) + ] + count = len(columns[0]) if columns else 0 + return np.column_stack(columns) if count else np.empty((0, len(columns))) -def _violation_of( - values: Mapping[str, Any], requirements: Sequence[Requirement], count: int -) -> np.ndarray: - """ - Gets the total violation of requirements by `count` designs, from the - values of their statistics (by name, such as the columns of a summary; - `NaN` where a statistic is missing). - """ - violation = np.zeros(count) - for requirement in requirements: - statistic = np.asarray(values[requirement.name], dtype=float) - violation = violation + requirement.violation(statistic) - return violation + def violation(self, values: Mapping[str, Any], count: int) -> np.ndarray: + """ + Gets the total violation of the requirements by designs (the sum of + their violations, see `Requirement.violation`), from the values of + their statistics (by name, such as the columns of a summary). + Args: + values (Mapping[str, Any]): The values of the statistics of + designs, by name. + count (int): The number of designs. -def _combiners(criteria: Criteria) -> dict[str, str]: - """ - Gets how each statistic of criteria is combined across the groups of - their `across` (see `Across`): by its largest (`"max"`) or smallest - (`"min"`) value, its worst, or by its `"mean"`. - """ - across = criteria.across - worst: dict[str, set[str]] = {} - for name, direction in criteria.objectives.items(): - worst.setdefault(name, set()).add("max" if direction == "min" else "min") - for requirement in criteria.requirements: - sense = "min" if requirement.operator in (">=", ">") else "max" - worst.setdefault(requirement.name, set()).add(sense) - combiners = {} - for name in criteria.names: - rule = across.rules.get(name, across.rule) - if rule == "mean" or (name not in worst and name not in across.rules): - # statistics that are neither objectives nor required (such as - # others to compute with them) have no worst: their means - combiners[name] = "mean" - elif name not in worst: - raise ValueError( - f"statistic {name!r} has no worst across {across.column!r}: it is " - + "neither an objective nor required (combine it by its mean, " - + "see Across)" - ) - elif len(worst[name]) > 1: - raise ValueError( - f"the objective and requirements of statistic {name!r} disagree on " - + "its worst: give it another name (in the statistics) for each" - ) - else: - combiners[name] = next(iter(worst[name])) - return combiners + Returns: + numpy.ndarray: the violation of each design (0 if it meets every + requirement, and `NaN` where a statistic of a requirement is) + """ + total = np.zeros(count) + for requirement in self.requirements: + statistic = np.asarray(values[requirement.name], dtype=float) + total = total + requirement.violation(statistic) + return total + + @property + def combiners(self) -> dict[str, str]: + """dict[str, str]: How each statistic is combined across the groups of + `across` (see `Across`), by name: by its largest (`"max"`) or smallest + (`"min"`) value, its worst, or by its `"mean"` (empty without + `across`).""" + across = self.across + if across is None: + return {} + worst: dict[str, set[str]] = {} + for name, direction in self.objectives.items(): + worst.setdefault(name, set()).add("max" if direction == "min" else "min") + for requirement in self.requirements: + sense = "min" if requirement.operator in (">=", ">") else "max" + worst.setdefault(requirement.name, set()).add(sense) + combiners = {} + for name in self.names: + rule = across.rules.get(name, across.rule) + if rule == "mean" or (name not in worst and name not in across.rules): + # statistics that are neither objectives nor required (such as + # others to compute with them) have no worst: their means + combiners[name] = "mean" + elif name not in worst: + raise ValueError( + f"statistic {name!r} has no worst across {across.column!r}: it " + + "is neither an objective nor required (combine it by its " + + "mean, see Across)" + ) + elif len(worst[name]) > 1: + raise ValueError( + f"the objective and requirements of statistic {name!r} disagree " + + "on its worst: give it another name (in the statistics) for each" + ) + else: + combiners[name] = next(iter(worst[name])) + return combiners diff --git a/src/tatc/tradespace/deployment.py b/src/tatc/tradespace/deployment.py index 33d16d0b..d6b0632f 100644 --- a/src/tatc/tradespace/deployment.py +++ b/src/tatc/tradespace/deployment.py @@ -9,10 +9,11 @@ mission, the design life of satellites, the development and production of each type of satellite, and the launch cadence and capacity), from which each design's `Deployment` follows: a design of more satellites and planes -takes longer to produce and launch. A deployment simulates a mission +takes longer to produce and launch. A deployment is planned with a policy +that restores the failures of its satellites or not (see +`RestorationPolicy`), and its spares, and simulates a mission (`Deployment.simulate`) with the failures of its satellites and launches -(see `FailureModel`) and a policy that restores them or not (see -`RestorationPolicy`), drawn for each replicate: the `MissionHistory` of +(see `FailureModel`), drawn for each replicate: the `MissionHistory` of what is produced and launched, which a `CostModel` prices, and of the satellites that operate. Their changes divide the mission into phases (`MissionHistory.phases`) of constant sets of operating satellites, each @@ -42,6 +43,7 @@ from typing import Any import numpy as np +import pandas as pd from ..schemas import Satellite from .constellations import layout_of @@ -51,13 +53,12 @@ PlannedPlane, Production, _Manifest, - _per_type, - _per_type_values, + per_type, + per_type_values, ) from .failures import FailureModel, RestorationPolicy -from .histories import _expected_metrics, _simulate_many from .mission import Capability, Decision, MissionHistory, Phase -from .simulation import _Simulation +from .simulation import _Simulation, simulate_histories from .values import Values @@ -93,7 +94,8 @@ class Stage: Args: planes (Sequence[int] | int): The planes of the stage (their indices, in the order of the layouts' planes, such as integers of numpy), - produced and launched in this order. + produced in this order (on their types' lines) and launched in + the order they are ready. times (float | Sequence[float]): The times of the decisions, in years after the first launch (a number, or a sequence or array of them). @@ -136,7 +138,8 @@ class Deployment: """ The planned deployment of a constellation: its development, production, launches, and planned replacements (see `DeploymentSchedule.plan`), - without failures. + without failures, and the policy with which it restores the failures of + its satellites (see `simulate`). """ schedule: DeploymentSchedule @@ -162,6 +165,10 @@ class Deployment: stages: tuple[Stage, ...] = () """tuple[Stage, ...]: The stages deployed only if their rules decide to (whose planes the production and launches above do not include).""" + policy: RestorationPolicy = field(default_factory=RestorationPolicy) + """RestorationPolicy: The policy for failed satellites, whose spares in + orbit the planes above include (and whose spares on the ground its + simulations produce, see `simulate`).""" capability: Capability | None = field(default=None, repr=False, compare=False) """Capability | None: The capability of the satellites, which the rules of stages may read at their decisions (see `Decision.capability`) in @@ -183,19 +190,20 @@ def end(self) -> float: def deployed(self) -> float: """float: The time by which every satellite of the first generation is launched (years): of the planes that are not staged, and of the - stages that their rules deploy in the history of the mission without - failures (see `planned` and `MissionHistory.deployed`).""" - if self.stages: - return self.planned().deployed - return max( - launch.time for launch in self.launches if launch.purpose == "deployment" - ) + stages that their rules deploy, in the history of the mission without + failures (see `planned` and `MissionHistory.deployed`, which is + infinite if the deployment does not finish within the mission).""" + return self.planned().deployed @property def units(self) -> dict[Any, int]: - """dict: The satellites produced of each type (including replacements - and spares, and, of a sustained constellation, those in production - at the end of the mission).""" + """dict: The satellites of each type that the plan produces: of the + planes that are not staged (with their spares in orbit) and their + planned replacements (and, of a sustained constellation, those in + production at the end of the mission), but not the spares on the + ground of the policy, the planes of stages, or restorations, which + its simulations produce (see `planned`, whose production a + `CostModel` prices).""" units: dict[Any, int] = {} for batch in self.production: if not self.schedule.sustained or batch.begin < self.end: @@ -205,16 +213,18 @@ def units(self) -> dict[Any, int]: def simulate( self, model: FailureModel | None = None, - policy: RestorationPolicy | None = None, seed: int | Sequence[int] | None = None, ) -> MissionHistory: """ Simulates the mission: the deployment, with the failures of its satellites and launches (drawn from a seed of a replicate, such as an uncertain parameter, see `Uncertain.seed`) and the restoration of - failed satellites by a policy. Without a seed, nothing fails (but a - policy's spares on the ground are still produced). The spares in - orbit are those of the plan (see `DeploymentSchedule.plan`). + failed satellites by its policy (see `policy`, whose spares in orbit + the plan produces and launches with their planes, and whose spares + on the ground the simulation produces after the planes of the plan). + Without a seed, nothing fails (but the spares are still produced). + To simulate another policy, plan the deployment with it (see + `DeploymentSchedule.plan`). A satellite's life is drawn when it is launched (or takes the place of a failed one), from uniform numbers of a random number generator @@ -235,8 +245,6 @@ def simulate( Args: model (FailureModel | None): The failures, or `None` for none. - policy (RestorationPolicy | None): The policy for failed - satellites, or `None` to restore them by producing new ones. seed (int | Sequence[int] | None): The seed of the replicate (or a sequence of integers, such as the seed and the index of a history, see `simulate_many`), or `None` for no failures. @@ -244,26 +252,28 @@ def simulate( Returns: MissionHistory: the history of the mission """ - return _Simulation( - self, model or FailureModel(), policy or RestorationPolicy(), seed - ).run() + return _Simulation(self, model or FailureModel(), seed).run() def planned(self) -> MissionHistory: """ Gets the history of the mission without failures (see `simulate`), - simulated once (for its capability). + simulated once (for its policy and capability): its deployment, with + the stages that their rules deploy and the spares of its policy, + whose costs a `CostModel` estimates (see `CostModel.estimate`). Returns: MissionHistory: the history """ - if self._planned is None or self._planned[0] is not self.capability: - self._planned = (self.capability, self.simulate()) + key = (self.policy, self.capability) + if self._planned is None or any( + a is not b for a, b in zip(self._planned[0], key) + ): + self._planned = (key, self.simulate()) return self._planned[1] def simulate_many( self, model: FailureModel | None = None, - policy: RestorationPolicy | None = None, seed: int | None = None, *, histories: int = 1, @@ -307,9 +317,6 @@ def simulate_many( Args: model (FailureModel | None): The failures, or `None` for none. - policy (RestorationPolicy | None): The policy for failed - satellites, or `None` to restore them by producing new ones - (as `simulate`). seed (int | None): The seed of the replicate, or `None` for the one history without failures. histories (int): The number of histories. @@ -324,22 +331,20 @@ def simulate_many( if histories < 1: raise ValueError("histories must be at least 1") if seed is None: - return [self.simulate(model, policy, None)] - return _simulate_many( + return [self.simulate(model, None)] + return simulate_histories( self, model or FailureModel(), - policy, seed, - histories, - sampling, - stress, - launch_stress, + histories=histories, + sampling=sampling, + stress=stress, + launch_stress=launch_stress, ) def expected_metrics( self, model: FailureModel | None = None, - policy: RestorationPolicy | None = None, seed: int = 0, *, histories: int = 1000, @@ -355,8 +360,6 @@ def expected_metrics( Args: model (FailureModel | None): The failures, or `None` for none. - policy (RestorationPolicy | None): The policy for failed - satellites (see `simulate_many`). seed (int): The seed of the histories. histories (int): The number of histories. sampling (str): The sampling of their failures. @@ -364,9 +367,11 @@ def expected_metrics( Returns: dict[str, float]: the mean of each measure """ - return _expected_metrics( - self, model or FailureModel(), policy, seed, histories, sampling + simulated = self.simulate_many( + model, seed, histories=histories, sampling=sampling ) + rows = pd.DataFrame([history.metrics() for history in simulated]) + return {column: float(rows[column].mean()) for column in rows.columns} def phases(self, satellites: Sequence[Satellite | str]) -> list[Phase]: """ @@ -396,10 +401,11 @@ class DeploymentSchedule: every type, or one for each). * Its satellites are then produced on one line at `production_rate` satellites a year (or at once, if `None`), plane by plane, in the - order of the layouts' planes (or of `order`). The line also produces, - after the work before them, the planes of stages that are deployed, - the satellites that restore failed ones, and the spares of a policy - (see `Stage` and `RestorationPolicy`). + order of the layouts' planes (or of `order`), with the spares in orbit + of the deployment's policy. The line also produces, after the work + before them, the spares on the ground of the policy, the planes of + stages that are deployed, and the satellites that restore failed ones + (see `RestorationPolicy` and `Stage`). * Each plane is launched when its satellites are ready, in as many launches as its satellites need (given a `launch_capacity` in number or mass, or one per plane), at most one every `launch_interval` years, @@ -471,8 +477,7 @@ def __post_init__(self): if self.years <= 0: raise ValueError("years must be positive") if any( - life is not None and life <= 0 - for life in _per_type_values(self.design_life) + life is not None and life <= 0 for life in per_type_values(self.design_life) ): raise ValueError("design_life must be positive") if self.launch_interval < 0: @@ -481,10 +486,10 @@ def __post_init__(self): raise ValueError("launch_capacity must be at least 1") if any( rate is not None and rate <= 0 - for rate in _per_type_values(self.production_rate) + for rate in per_type_values(self.production_rate) ): raise ValueError("production_rate must be positive") - if any(years < 0 for years in _per_type_values(self.development_years)): + if any(years < 0 for years in per_type_values(self.development_years)): raise ValueError("development_years must not be negative") def design_life_of(self, kind: Any = None) -> float | None: @@ -498,7 +503,7 @@ def design_life_of(self, kind: Any = None) -> float | None: float | None: the design life (years), or `None` if they last the mission """ - return _per_type(self.design_life, kind, "design life") + return per_type(self.design_life, kind, "design life") def production_years(self, kind: Any, satellites: int) -> float: """ @@ -511,7 +516,7 @@ def production_years(self, kind: Any, satellites: int) -> float: Returns: float: the years (0 for production that takes no time) """ - rate = _per_type(self.production_rate, kind, "production rate") + rate = per_type(self.production_rate, kind, "production rate") return 0.0 if rate is None else satellites / rate def mass_capacity_of(self, plane: tuple[int, Any] | None = None) -> float | None: @@ -636,14 +641,19 @@ def plan( layout: Any, *, kind: Any = None, - orbit_spares: int | Mapping[Any, int] = 0, + policy: RestorationPolicy | None = None, masses: PerType | None = None, stages: Sequence[Stage] = (), ) -> Deployment: """ Plans the deployment of a constellation: the layout (or layouts) of its satellites, of one type (`kind`), or a mapping of types to - layouts (such as the shells of a mixed constellation). The planes of + layouts (such as the shells of a mixed constellation), with the + policy that restores the failures of its satellites (see + `Deployment.simulate`): its spares in orbit in each plane are + produced and launched with the plane, and wait in orbit to take the + place of failed satellites, and its spares on the ground are + produced after the planes (see `RestorationPolicy`). The planes of `stages` are deployed only if (and when) their rules decide to, in a simulation of the mission (see `Stage` and `Deployment.simulate`), and the others as planned. @@ -652,11 +662,10 @@ def plan( layout (Any): The layout (or layouts) of the satellites, or a mapping of types of satellites to layouts. kind (Any): The type of the satellites of a layout. - orbit_spares (int | Mapping[Any, int]): The spares in orbit in - each plane (of every type, or of each), produced and launched - with it, which wait in orbit to take the place of failed - satellites (see `RestorationPolicy`, whose `orbit_spares` a - `MissionPlan` plans). + policy (RestorationPolicy | None): The policy for failed + satellites, and its spares, or `None` to restore them by + producing new ones (see `RestorationPolicy`, and `MissionPlan`, + which plans the deployment of each design with its policy). masses (float | Mapping | None): The mass (kg) of the satellites (of each type), for a launch capacity in mass (and the price of launches by mass, see `CostModel.estimate`). @@ -668,12 +677,10 @@ def plan( Raises: ValueError: if a plane is in several stages or is not a plane of - the layouts, if no satellites are planned, or if spares are - negative. + the layouts, if no satellites are planned, or if the spares of + the policy lack a type of the layouts. """ - # pylint: disable=too-many-locals - if any(spares < 0 for spares in _per_type_values(orbit_spares)): - raise ValueError("orbit_spares must not be negative") + policy = RestorationPolicy() if policy is None else policy stages = tuple(stages) staged = [plane for stage in stages for plane in stage.planes] if len(set(staged)) != len(staged): @@ -683,25 +690,16 @@ def plan( fleets = dict(layout) else: fleets = {kind: layout} - deployment = Deployment(schedule=self, stages=stages) - manifest = _Manifest( - self, - deployment.planes, - deployment.masses, - deployment.plane_values, - {}, - [], - deployment.production, - ) - ready = [] # (ready, index) of the planes that are not staged + deployment = Deployment(schedule=self, stages=stages, policy=policy) + produced = [] # the planes that are not staged, in their order for name, item in fleets.items(): - developed = float(_per_type(self.development_years, name, "development")) - spares = int(_per_type(orbit_spares, name, "orbit spares")) + developed = float(per_type(self.development_years, name, "development")) + spares = policy.orbit_spares_of(name) + policy.ground_spares_of(name) # (raises if it lacks the type) deployment.development[name] = developed deployment.masses[name] = ( - None if masses is None else _per_type(masses, name, "mass") + None if masses is None else per_type(masses, name, "mass") ) - manifest.lines[name] = developed listed = [] for plane in layout_of(item).planes(): index = len(deployment.planes) @@ -715,21 +713,17 @@ def plan( listed.append((index, plane)) if self.order is not None: listed.sort(key=lambda item: self.order(item[0], item[1].values)) - for index, plane in listed: - count = plane.satellites + spares - ready.append((manifest.produce(developed, name, count), index)) + produced.extend(index for index, _ in listed) unknown = sorted(set(staged) - set(range(len(deployment.planes)))) if unknown: raise ValueError( f"stages of planes that the layouts do not have: {unknown}" ) - if not ready: + if not produced: raise ValueError("a deployment requires satellites (that are not staged)") - for time, index in sorted(ready, key=lambda item: item[0]): - deployment.launches.extend(manifest.launch(index, time)) - deployment.launches.extend( - manifest.replace(list(deployment.launches), deployment.end) - ) + # each type's planes produced on its line from the end of its development + manifest = _Manifest(deployment, deployment.production) + deployment.launches.extend(manifest.deploy(produced, 0.0)) deployment.production.sort(key=lambda batch: batch.begin) deployment.launches.sort(key=lambda launch: (launch.time, launch.plane)) return deployment diff --git a/src/tatc/tradespace/dominance.py b/src/tatc/tradespace/dominance.py index f7e07b62..3126863f 100644 --- a/src/tatc/tradespace/dominance.py +++ b/src/tatc/tradespace/dominance.py @@ -10,29 +10,38 @@ import numpy as np -_BLOCK_ELEMENTS = 2_000_000 +BLOCK_ELEMENTS = 2_000_000 """The most elements of the temporary arrays of a block of comparisons.""" -_CHUNK = 64 -"""The points of each chunk of a sweep (see `_dominated_plain`).""" +CHUNK = 64 +"""The points of each chunk of a sweep (see `dominated_plain`).""" -def _dominated_by( +def dominated_by( points: np.ndarray, others: np.ndarray, tolerances: np.ndarray | None = None ) -> np.ndarray: """ Finds the points dominated by any of others, even if the other is - penalized by the tolerances (see `_dominated`), comparing them in blocks + penalized by the tolerances (see `dominated`), comparing them in blocks whose temporary arrays are limited to a few million elements. + + Args: + points (numpy.ndarray): The points (a row each). + others (numpy.ndarray): The others (a row each). + tolerances (numpy.ndarray | None): The tolerances of the costs (see + `dominated`), or `None` for none. + + Returns: + numpy.ndarray: whether each point is dominated """ - dominated = np.zeros(len(points), dtype=bool) + beaten = np.zeros(len(points), dtype=bool) if len(points) == 0 or len(others) == 0: - return dominated + return beaten if tolerances is None: tolerances = np.zeros((2, points.shape[1])) absolute, relative = tolerances penalties = np.any(tolerances) - block = max(1, _BLOCK_ELEMENTS // max(len(others) * points.shape[1], 1)) + block = max(1, BLOCK_ELEMENTS // max(len(others) * points.shape[1], 1)) for start in range(0, len(points), block): part = points[start : start + block] # [i, j]: other j dominates point i of the block @@ -41,11 +50,11 @@ def _dominated_by( penalized = penalized + absolute + relative * np.abs(part[:, None, :]) no_worse = np.all(penalized <= part[:, None, :], axis=2) better = np.any(penalized < part[:, None, :], axis=2) - dominated[start : start + block] = np.any(no_worse & better, axis=1) - return dominated + beaten[start : start + block] = np.any(no_worse & better, axis=1) + return beaten -def _dominated_plain(costs: np.ndarray) -> np.ndarray: +def dominated_plain(costs: np.ndarray) -> np.ndarray: """ Finds the points dominated by another (without tolerances) by a sweep in lexicographic order, in which a point can only be dominated by points @@ -53,57 +62,81 @@ def _dominated_plain(costs: np.ndarray) -> np.ndarray: points before it (dominance is transitive). The sweep compares each chunk of points with the efficient points before it, then those it does not dominate with each other. + + Args: + costs (numpy.ndarray): The points (a row each). + + Returns: + numpy.ndarray: whether each point is dominated """ n = len(costs) order = np.lexsort(costs.T[::-1]) ordered = costs[order] - dominated = np.zeros(n, dtype=bool) - efficient = np.empty((0, costs.shape[1])) - for start in range(0, n, _CHUNK): - part = ordered[start : start + _CHUNK] - beaten = _dominated_by(part, efficient) + beaten_points = np.zeros(n, dtype=bool) + front = np.empty((0, costs.shape[1])) + for start in range(0, n, CHUNK): + part = ordered[start : start + CHUNK] + beaten = dominated_by(part, front) # a point that an earlier efficient point dominates dominates nothing # that it does not: compare only the others with each other survivors = part[~beaten] - beaten[~beaten] = _dominated_by(survivors, survivors) - dominated[order[start : start + _CHUNK]] = beaten - efficient = np.vstack([efficient, part[~beaten]]) - return dominated + beaten[~beaten] = dominated_by(survivors, survivors) + beaten_points[order[start : start + CHUNK]] = beaten + front = np.vstack([front, part[~beaten]]) + return beaten_points -def _dominated(costs: np.ndarray, tolerances: np.ndarray | None = None) -> np.ndarray: +def dominated(costs: np.ndarray, tolerances: np.ndarray | None = None) -> np.ndarray: """ Finds the points (rows of costs) dominated by another, even if the other is penalized by the tolerances: no worse in every cost, and better in at least one, by at least its tolerance (absolute, plus a share of the - magnitude of the cost of the point it would dominate, see - `_get_tolerances`). + magnitude of the cost of the point it would dominate: the rows of + `tolerances`, see `Criteria.tolerance_array`). A point that is dominated with tolerances is also dominated by a point that is efficient without them: the penalty depends only on the point dominated, so any point no worse than its dominator in every cost (as some efficient point is) dominates it too. Points are therefore compared - only with the efficient points (see `_dominated_plain`), which are few. + only with the efficient points (see `dominated_plain`), which are few. + + Args: + costs (numpy.ndarray): The points (a row each). + tolerances (numpy.ndarray | None): The absolute tolerances of the + costs (first row) and their shares of the magnitudes of the costs + (second row), or `None` for none. + + Returns: + numpy.ndarray: whether each point is dominated """ - plain = _dominated_plain(costs) + plain = dominated_plain(costs) if tolerances is None or not np.any(tolerances): return plain - return _dominated_by(costs, costs[~plain], tolerances) + return dominated_by(costs, costs[~plain], tolerances) -def _efficient( +def efficient( costs: np.ndarray, admissible: np.ndarray, tolerances: np.ndarray | None = None ) -> np.ndarray: """ Finds the efficient points (rows of costs) among the admissible ones (such as the designs that meet requirements): those that no other - admissible point dominates (see `_dominated`). Points with a missing cost + admissible point dominates (see `dominated`). Points with a missing cost (`NaN`) are neither efficient nor dominate others. + + Args: + costs (numpy.ndarray): The points (a row each). + admissible (numpy.ndarray): Whether each point is admissible. + tolerances (numpy.ndarray | None): The tolerances of the costs (see + `dominated`), or `None` for none. + + Returns: + numpy.ndarray: whether each point is efficient """ known = np.asarray(admissible, dtype=bool) if len(costs) > 0: known = known & ~np.isnan(costs).any(axis=1) - efficient = np.zeros(len(costs), dtype=bool) + found = np.zeros(len(costs), dtype=bool) if known.any(): - efficient[known] = ~_dominated(costs[known], tolerances) - return efficient + found[known] = ~dominated(costs[known], tolerances) + return found diff --git a/src/tatc/tradespace/events.py b/src/tatc/tradespace/events.py index 298ab341..abf00484 100644 --- a/src/tatc/tradespace/events.py +++ b/src/tatc/tradespace/events.py @@ -18,17 +18,28 @@ from typing import TYPE_CHECKING, Any, NamedTuple if TYPE_CHECKING: - from .deployment import DeploymentSchedule + from .deployment import Deployment PerType = float | Mapping[Any, float] """A value for every type of satellite, or for each (a mapping by type).""" -def _per_type(value: Any, kind: Any, name: str) -> Any: +def per_type(value: Any, kind: Any, name: str) -> Any: """ Gets the value of a type of satellite of a value for every type or a - mapping of each, raising a `ValueError` (naming the value) if the mapping - lacks the type. + mapping of each (see `PerType`). + + Args: + value (Any): The value for every type, or a mapping of each type to + its value. + kind (Any): The type of satellite. + name (str): The name of the value, for errors. + + Returns: + Any: the value of the type + + Raises: + ValueError: if the mapping lacks the type. """ if isinstance(value, Mapping): if kind not in value: @@ -37,8 +48,18 @@ def _per_type(value: Any, kind: Any, name: str) -> Any: return value -def _per_type_values(value: Any) -> list: - """Gets the values of every type of satellite (of a mapping), or the value.""" +def per_type_values(value: Any) -> list: + """ + Gets the values of every type of satellite of a value for every type or a + mapping of each (see `PerType`), such as to validate them. + + Args: + value (Any): The value for every type, or a mapping of each type to + its value. + + Returns: + list: the values of the mapping, or the value + """ return list(value.values()) if isinstance(value, Mapping) else [value] @@ -110,34 +131,59 @@ class _Manifest: added. Args: - schedule (DeploymentSchedule): The schedule. - planes (Sequence[PlannedPlane]): The planes of the deployment. - masses (Mapping): The mass of each type of satellite, if given. - values (Sequence): The values of each plane (see `Plane`). - lines (dict): The time from which each type's line is free. - booked (list[float]): The times of the launches booked, in order. + deployment (Deployment): The deployment: its schedule, planes, masses, + and values of planes, which a plan fills as it goes. production (list[Production]): The production, to which it adds. + lines (dict | None): The time from which each type's line is free, or + `None` for the end of its development. + booked (list[float] | None): The times of the launches booked, in + order, or `None` for none. """ - # pylint: disable=too-many-arguments,too-many-positional-arguments - def __init__( self, - schedule: DeploymentSchedule, - planes: Sequence[PlannedPlane], - masses: Mapping[Any, float | None], - values: Sequence[Any], - lines: dict[Any, float], - booked: list[float], + deployment: Deployment, production: list[Production], + lines: dict[Any, float] | None = None, + booked: list[float] | None = None, ): - self.schedule, self.planes, self.masses = schedule, planes, masses - self.values, self.lines, self.booked = values, lines, booked + self.deployment, self.schedule = deployment, deployment.schedule self.production = production + self.lines = dict(deployment.development) if lines is None else lines + self.booked = [] if booked is None else booked + + @classmethod + def resume(cls, deployment: Deployment, production: list[Production]) -> _Manifest: + """ + Gets the manifest of a planned deployment as its simulations continue + it: each type's line free after the production of its planes (or its + development), and the launches of the plan booked. + """ + lines = { + kind: max( + ( + batch.end + for batch in deployment.production + if batch.kind == kind and batch.purpose == "deployment" + ), + default=developed, + ) + for kind, developed in deployment.development.items() + } + booked = sorted(launch.time for launch in deployment.launches) + return cls(deployment, production, lines, booked) def plane(self, plane: int) -> tuple[int, Any]: """The index and values of a plane (see `DeploymentSchedule`).""" - return plane, self.values[plane] if plane < len(self.values) else None + values = self.deployment.plane_values + return plane, values[plane] if plane < len(values) else None + + def capacity(self, plane: int) -> float: + """The most satellites of a launch to a plane (see `per_launch`).""" + kind = self.deployment.planes[plane].kind + return self.schedule.per_launch( + self.deployment.masses.get(kind), self.plane(plane) + ) def produce( self, earliest: float, kind: Any, count: int, purpose: str = "deployment" @@ -152,12 +198,19 @@ def produce( self.production.append(Production(kind, begin, ready, count, purpose)) return ready + def next_slot(self, ready: float) -> float: + """ + Gets the earliest launch at or after a time that keeps the launch + interval (see `DeploymentSchedule.next_slot`), without booking it. + """ + return self.schedule.next_slot(self.booked, ready) + def slot(self, ready: float) -> float: """ Books the earliest launch at or after a time that keeps the launch interval (see `DeploymentSchedule.next_slot`), returning its time. """ - time = self.schedule.next_slot(self.booked, ready) + time = self.next_slot(ready) bisect.insort(self.booked, time) return time @@ -167,15 +220,39 @@ def launch(self, plane: int, ready: float) -> list[Launch]: they are ready: in as many launches as they need (see `DeploymentSchedule.split`), each at the next launch slot. """ - kind, size, spares = self.planes[plane] + kind, size, spares = self.deployment.planes[plane] launches, first = [], 0 for satellites in self.schedule.split( - size + spares, self.masses.get(kind), self.plane(plane) + size + spares, self.deployment.masses.get(kind), self.plane(plane) ): launches.append(Launch(self.slot(ready), plane, kind, first, satellites)) first += satellites return launches + def deploy( + self, planes: Sequence[int], earliest: float, end: float | None = None + ) -> list[Launch]: + """ + Deploys planes, as a plan deploys those that are not staged and a + simulation the planes of a stage: produces the satellites of each + (and its spares in orbit) on its type's line from a time (after the + work before them), in order; launches each plane when they are ready + (see `launch`), in the order the planes are ready; and adds the + planned replacements of their satellites (see `replace`). Returns + the launches, then the replacements. + """ + ready = [] + for plane in planes: + kind, size, spares = self.deployment.planes[plane] + if size + spares > 0: + ready.append((self.produce(earliest, kind, size + spares), plane)) + launches = [] + for time, plane in sorted(ready, key=lambda item: item[0]): + launches.extend(self.launch(plane, time)) + if end is None: # a mission that begins at the first launch + end = min(launch.time for launch in launches) + self.schedule.years + return launches + self.replace(launches, end) + def replace(self, launches: Sequence[Launch], end: float) -> list[Launch]: """ Adds the planned replacements of the satellites of launches at the end @@ -195,7 +272,7 @@ def replace(self, launches: Sequence[Launch], end: float) -> list[Launch]: order = itertools.count() for launch in launches: life = schedule.design_life_of(launch.kind) - built = self.planes[launch.plane].satellites + built = self.deployment.planes[launch.plane].satellites count = min(launch.first + launch.satellites, built) - launch.first if life is not None and count > 0: item = (launch.plane, launch.kind, launch.first, count, life) @@ -218,7 +295,7 @@ def replace(self, launches: Sequence[Launch], end: float) -> list[Launch]: schedule.sustained and begin < end - + float(_per_type(schedule.development_years, kind, "development")) + + float(per_type(schedule.development_years, kind, "development")) - 1e-9 ): following = need + life # produced after the end, not launched diff --git a/src/tatc/tradespace/expectations.py b/src/tatc/tradespace/expectations.py new file mode 100644 index 00000000..99434d08 --- /dev/null +++ b/src/tatc/tradespace/expectations.py @@ -0,0 +1,284 @@ +""" +Exact expectations of the capability of missions without restoration over +their failures (`exact_expectations`), rather than from samples of their +histories (see `Deployment.simulate_many`), as the failures of a study +take them where they apply (see `Failures`). + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +import itertools +import math +from typing import TYPE_CHECKING + +import numpy as np + +from .failures import FailureModel +from .mission import PHASE_COLUMNS, Capability + +if TYPE_CHECKING: + from .deployment import Deployment + +MAX_SETS = 200_000 +"""The most sets of satellites that exact expectations enumerate by default +(see `exact_expectations`), as those of the failures of a study do (see +`Failures`).""" + + +class ExactExpectationsError(ValueError): + """ + Raised if exact expectations do not apply to a mission (see + `exact_expectations`): of a staged deployment, of a deployment whose + policy restores failures, or of more sets of satellites than they + enumerate. Its histories are simulated instead. + """ + + +def _launch_groups( + deployment: Deployment, model: FailureModel, times: np.ndarray +) -> tuple[int, list[tuple]]: + """ + Gets the launch groups of a deployment without restoration: the + positions of each launch of the deployment (in order of the planes' + positions), which its planned replacements carry again. For each group, + at each time: the probability that each of its launches so far is the + latest that succeeded (`weights`, launches by times), the survival of + the satellites of each since its launch (`survival`, launches by times), + the probability that none has succeeded (`none`), and whether the group + has launched. + """ + offsets = np.cumsum([0] + [plane.satellites for plane in deployment.planes]) + launches: dict[tuple[int, int], list] = {} + for launch in sorted(deployment.launches, key=lambda l: l.time): + launches.setdefault((launch.plane, launch.first), []).append(launch) + p = model.launch + groups = [] + for (plane, first), sequence in launches.items(): + built = deployment.planes[plane].satellites + members = [ + int(offsets[plane]) + position + for position in range(first, min(first + sequence[0].satellites, built)) + ] + if not members: + continue + life = model.life_of(sequence[0].kind) + flown = np.array([[t >= launch.time for t in times] for launch in sequence]) + # launches after each one, up to each time + later = np.flip(np.cumsum(np.flip(flown, axis=0), axis=0), axis=0) - flown + weights = np.where(flown, (1 - p) * p**later, 0.0) + survival = np.array( + [ + ( + np.ones(len(times)) + if life is None + else life.survival(np.maximum(times - launch.time, 0.0)) + ) + for launch in sequence + ] + ) + none = p ** flown.sum(axis=0) + groups.append((members, weights, survival, none, flown.any(axis=0))) + return int(offsets[-1]), groups + + +def _group_operating(group: tuple, count: int) -> np.ndarray: + """ + Gets the probability at each time that exactly a given set of `count` + satellites of a launch group operates (see `_set_weight`). + """ + members, weights, survival, none, _ = group + probability = np.sum( + weights * survival**count * (1 - survival) ** (len(members) - count), axis=0 + ) + return probability + none if count == 0 else probability + + +def _set_weight(active: np.ndarray, groups: list) -> float: + """ + Gets the share of the mission's time in which exactly the active + positions operate, in expectation: at each time, the product over the + launch groups of the probability that exactly the active satellites of + the group operate, which (as they are of one type and launched together) + depends only on their number `a` of the `n` of the group: the sum over + its launches of the probability that the launch is the latest that + succeeded times `S ** a * (1 - S) ** (n - a)`, for the survival `S` of + its satellites, and the probability that none has succeeded if `a` is 0. + """ + probability = 1.0 + for group in groups: + probability = probability * _group_operating(group, int(active[group[0]].sum())) + return float(np.mean(probability)) + + +def _missing_levels(groups: list, count: int, tolerance: float) -> int: + """ + Gets the most positions missing of the sets that exact expectations + enumerate (see `exact_expectations`): the least number such that the + sets of that many missing positions or fewer operate all but `tolerance` + of the mission's time, in expectation. The distribution of the number + missing at each time is the convolution over the launch groups of the + distributions of theirs (each the probability of a set times the number + of sets of its size), cheap to compute without enumerating the sets. + """ + if not groups: + return count + distribution = np.zeros((count + 1, len(groups[0][3]))) + distribution[0] = 1.0 + for group in groups: + size = len(group[0]) + combined = np.zeros_like(distribution) + for gone in range(size + 1): + share = math.comb(size, gone) * _group_operating(group, size - gone) + combined[gone:] += share * distribution[: count + 1 - gone] + distribution = combined + covered = np.cumsum(distribution.mean(axis=1)) + reached = np.flatnonzero(covered >= 1 - tolerance - 1e-12) + return int(reached[0]) if len(reached) > 0 else count + + +def _sets(count: int, levels: int) -> int: + """The sets of `count` positions of which at most `levels` are missing.""" + return sum(math.comb(count, missing) for missing in range(levels + 1)) + + +def _exact_sets( + deployment: Deployment, + model: FailureModel, + tolerance: float = 1e-3, + steps: int = 400, +) -> int: + """ + Gets the number of sets of satellites that exact expectations of a + deployment enumerate (see `exact_expectations`), without enumerating + them: the sets of at most the number of positions missing that cover + all but `tolerance` of the mission's time. + """ + count, groups = _launch_groups(deployment, model, _times(deployment, steps)) + return _sets(count, _missing_levels(groups, count, tolerance)) + + +def _times(deployment: Deployment, steps: int) -> np.ndarray: + """The times at which exact expectations integrate probabilities.""" + begin, end = deployment.begin, deployment.end + return begin + (np.arange(steps) + 0.5) * (end - begin) / steps + + +def exact_expectations( + deployment: Deployment, + model: FailureModel, + capability: Capability, + *, + tolerance: float = 1e-3, + steps: int = 400, + max_sets: int = MAX_SETS, +) -> dict[str, float]: + """ + Computes the expected capability of a mission without restoration (of a + deployment whose policy does not restore failed satellites, see + `RestorationPolicy`, though they may be replaced as planned at the end + of their design life) over its failures: the expectation of the mean of + each metric over the phases of the mission (` mission`, as + `summarize_phases` gives for one history) and of its availability + (`availability`), exactly rather than from samples of histories (as + `Deployment.expected_metrics` estimates the measures of missions). + + Without restoration, the satellites fail independently (but for the + satellites of a launch, which a failed launch loses together), so that + the probability that a set of satellites operates at a time is a product + over the launches of their survival (see `Lifetime.survival`). The + expected mean of a metric is the sum over the sets of satellites of the + metric of each set (evaluated once, as with a `PhaseCache`) times the + share of the mission's time in which exactly that set operates, in + expectation (integrated over `steps` times). The sets are enumerated by + the number of satellites missing until their shares cover all but + `tolerance` of the mission's time (a number known before they are + enumerated, from the distribution of the number missing), and evaluated + in order of their shares until they do (`coverage`, the share covered, + and `sets`, the sets evaluated); the expectation is over the sets + evaluated. + + Without sampling error, an expectation estimates the mean of many + histories with none of their variance (see `Deployment.simulate_many`), + for missions of a few to a dozen or two satellites; for larger ones + (whose sets number more than `max_sets`, which is known before any is + enumerated), or with restoration (whose shared production and launches + make failures dependent), simulate histories. + + Args: + deployment (Deployment): The deployment, whose policy does not + restore failures. + model (FailureModel): The failures. + capability (Capability): The capability of the satellites (in the + order of the planes, see `MissionHistory.phases`): their + observations and metric (see `Capability.evaluate`). + tolerance (float): The share of the mission's time that the sets + evaluated may leave out. + steps (int): The times at which the probabilities are integrated. + max_sets (int): The most sets to enumerate. + + Returns: + dict[str, float]: the expected metrics + + Raises: + ExactExpectationsError: if the deployment is staged (see `Stage`), + whose launches depend on its rules, its policy restores failures, + or it has more sets to enumerate than `max_sets` (raised before + any is enumerated). + """ + # pylint: disable=too-many-locals + if deployment.stages: + raise ExactExpectationsError( + "exact expectations need a deployment that is not staged: " + + "simulate histories of a staged deployment instead" + ) + if deployment.policy.restore: + raise ExactExpectationsError( + "exact expectations need a deployment whose policy does not restore " + + "failures (RestorationPolicy(restore=False)): simulate histories instead" + ) + names = list(capability.position_names(deployment.planes).values()) + count, groups = _launch_groups(deployment, model, _times(deployment, steps)) + levels = _missing_levels(groups, count, tolerance) + if _sets(count, levels) > max_sets: + raise ExactExpectationsError( + "too many sets of satellites to enumerate: simulate histories" + ) + # availability: the expected years of operation of the positions, as a + # share of those of the planned deployment + operating = sum( + len(members) * float(np.mean(np.sum(weights * survival, axis=0))) + for members, weights, survival, _, _ in groups + ) + planned = sum( + len(members) * float(np.mean(launched)) for members, _, _, _, launched in groups + ) + availability = operating / planned if planned > 0 else math.nan + # enumerate the sets by the number of positions missing + weights: list[tuple[float, tuple[int, ...]]] = [] + for missing in range(levels + 1): + for gone in itertools.combinations(range(count), missing): + active = np.ones(count, dtype=bool) + active[list(gone)] = False + weight = _set_weight(active, groups) + if weight > 0: + weights.append((weight, tuple(np.flatnonzero(active)))) + weights.sort(key=lambda item: -item[0]) + totals: dict[str, float] = {} + evaluated, sets = 0.0, 0 + for weight, members in weights: + # the metrics of the set, as of a phase in which it operates + for name, value in capability(names[k] for k in members).items(): + if name in PHASE_COLUMNS: + continue + totals[f"{name} mission"] = totals.get( + f"{name} mission", 0.0 + ) + weight * float(value) + evaluated += weight + sets += 1 + if evaluated >= 1 - tolerance: + break + result = {name: total / evaluated for name, total in totals.items()} + result.update(availability=availability, coverage=evaluated, sets=float(sets)) + return result diff --git a/src/tatc/tradespace/failures.py b/src/tatc/tradespace/failures.py index 2469436a..a1365cc7 100644 --- a/src/tatc/tradespace/failures.py +++ b/src/tatc/tradespace/failures.py @@ -27,7 +27,7 @@ import numpy as np -from .events import _per_type, _per_type_values +from .events import per_type, per_type_values from .nodes import Categorical from .space import DesignSpace from .values import Scope @@ -349,7 +349,7 @@ def life_of(self, kind: Any) -> Lifetime | None: Returns: Lifetime | None: the life, or `None` if it does not fail """ - return _per_type(self.life, kind, "life") + return per_type(self.life, kind, "life") @dataclass(frozen=True) @@ -361,24 +361,29 @@ class RestorationPolicy: source available when the failure is known (`detection_years` after it): * a spare in orbit in the failed satellite's plane (`orbit_spares` in - each plane of every type, or of each, which a deployment plans: see - `DeploymentSchedule.plan`, and `MissionPlan`, which plans those of - the policy of each design), which takes its place after - `drift_years` (and is then replaced as planned, as the satellite it - replaces would have been); + each plane of every type, or of each, which a deployment planned with + the policy produces and launches with the plane: see + `DeploymentSchedule.plan`, and `MissionPlan`, which plans the + deployment of each design with its policy), which takes its place + after `drift_years` (and is then replaced as planned, as the satellite + it replaces would have been); * a spare on the ground (`ground_spares` of each type, produced after the first satellites and stored), launched at the next launch slot; * a satellite produced when needed, `procurement_years` after it is ordered (for long-lead items) and on its type's production line (after the work before it), then launched at the next launch slot. - A restoration of a plane joins a launch already booked for the plane, if - it has room (see the launch capacity of `DeploymentSchedule`); otherwise - it books one at the next launch slot after waiting `batch_years` for - others. With `replenish`, a spare that is used is produced again (and, - in orbit, launched to its plane), procured and produced as a satellite - produced when needed, which shares the production line with - restorations. + A restoration of a plane joins a launch already booked for the plane if + the launch has room (see the launch capacity of `DeploymentSchedule`) + and flies once the restoration is ready, but no later than a launch the + restoration would book; otherwise it books one at the next launch slot + after waiting `batch_years` for others. With `replenish`, a spare that + is used is produced again (and, in orbit, launched to its plane), + procured and produced as a satellite produced when needed, which shares + the production line with restorations. + + A deployment has one policy (see `DeploymentSchedule.plan`), with which + it simulates its missions (see `Deployment.simulate`). Args: restore (bool): `True` to restore failed satellites. @@ -389,7 +394,8 @@ class RestorationPolicy: start of its production. orbit_spares (int | Mapping[Any, int]): The spares in orbit in each plane of every type of satellite, or of each (by type, every type - of the deployment), which the deployment plans. + of the deployment), which a deployment planned with the policy + produces and launches. ground_spares (int | Mapping[Any, int]): The spares on the ground of every type of satellite, or of each (by type, every type of the deployment). @@ -417,7 +423,7 @@ def __post_init__(self): if getattr(self, name) < 0: raise ValueError(f"{name} must not be negative") for name in ("orbit_spares", "ground_spares"): - if any(value < 0 for value in _per_type_values(getattr(self, name))): + if any(value < 0 for value in per_type_values(getattr(self, name))): raise ValueError(f"{name} must not be negative") def orbit_spares_of(self, kind: Any) -> int: @@ -430,7 +436,7 @@ def orbit_spares_of(self, kind: Any) -> int: Returns: int: the number of spares """ - return int(_per_type(self.orbit_spares, kind, "orbit spares")) + return int(per_type(self.orbit_spares, kind, "orbit spares")) def ground_spares_of(self, kind: Any) -> int: """ @@ -442,7 +448,7 @@ def ground_spares_of(self, kind: Any) -> int: Returns: int: the number of spares """ - return int(_per_type(self.ground_spares, kind, "ground spares")) + return int(per_type(self.ground_spares, kind, "ground spares")) def _spares_restore(d: Scope) -> bool: @@ -465,18 +471,18 @@ def policy_space( `RestorationPolicy`), for trades of their cost against their robustness: whether to `restore` failed satellites (by default a variable, `False` or `True`), the spares in orbit in each plane - (`orbit_spares`, which a deployment plans, see - `DeploymentSchedule.plan`), the spares on the ground (`ground_spares`), - whether to `replenish` used spares, and other fields of the policy (such - as `drift_years`). Each is a node of a design space (such as a design - variable) or a value. + (`orbit_spares`, which a deployment planned with the policy produces and + launches, see `DeploymentSchedule.plan`), the spares on the ground + (`ground_spares`), whether to `replenish` used spares, and other fields + of the policy (such as `drift_years`). Each is a node of a design space + (such as a design variable) or a value. A design's policy is configured from the values of the fragment (see - `configure`), and its deployment planned with its spares in orbit:: + `configure`), and its deployment planned with the policy:: policy = configure(BASE_POLICY, d.policy) - deployment = SCHEDULE.plan(d.layout, orbit_spares=policy.orbit_spares) - history = deployment.simulate(FAILURE_MODEL, policy, d.failure_seed) + deployment = SCHEDULE.plan(d.layout, policy=policy) + history = deployment.simulate(FAILURE_MODEL, d.failure_seed) as an `ObservationStudy` does with a mission plan that names the fragment (see `MissionPlan.policy`), whose values configure the default diff --git a/src/tatc/tradespace/fingerprint.py b/src/tatc/tradespace/fingerprint.py index 4c6169e7..3f86cdd5 100644 --- a/src/tatc/tradespace/fingerprint.py +++ b/src/tatc/tradespace/fingerprint.py @@ -20,6 +20,11 @@ metadata has `"fingerprint": False` (such as directories of caches, which do not change results); - the nodes of design spaces, by their attributes; + - objects that describe themselves by a method `__fingerprint__()`, by + the value that it returns, which is described in their place: designs + (by their design space, decisions, replicate, and scenario) and caches + of satellites (by their function and namespace, not their counts of + hits and misses, nor what they hold); - partial functions (by their function and arguments), bound methods (by their function and object), and functions that decorators wrap (such as by `functools.lru_cache`, by the wrapped function). @@ -45,11 +50,13 @@ classes and built-in functions (but the study's own classes), and modules (but the attributes of the study's own modules that functions refer to). -- By type: other objects, such as those of installed classes (a cache, or a - connection), whose state does not change results. +- By type: other objects, such as those of installed classes (a connection, + or a lock) and those of TAT-C's classes that none of the rules above + describe, whose state a definition takes not to change results. - Not at all: data that functions read (such as from files) and the code of - installed modules other than TAT-C's. Identify them by a namespace (see + installed modules other than TAT-C's. Identify them, and the state of + objects described by type that changes results, by a namespace (see `ResultStore` and `SatelliteCache`). TAT-C is described by the source of the modules that the values depend on: @@ -89,7 +96,7 @@ from pydantic import BaseModel from .alerts import _warn -from .hashing import _canonical, _digest +from .hashing import canonical, digest from .nodes import Node _MAX_DEPTH = 24 @@ -98,8 +105,9 @@ _MAX_ITEMS = 1000 """The most items of a container (or array) described one by one.""" -_PACKAGE = "tatc" -"""The name of the package whose modules a definition describes by source.""" +_TATC = "tatc" +"""The name of the package (TAT-C) whose modules a definition describes by +source.""" _ROOT = Path(__file__).resolve().parents[1] """The directory of the package.""" @@ -117,10 +125,10 @@ def _name(value: Any) -> str: return f"{getattr(value, '__module__', None)}.{value.__qualname__}" -def _is_package_module(module: Any) -> bool: - """Whether a module name is of the package (TAT-C).""" +def _is_tatc_module(module: Any) -> bool: + """Whether a module name is of TAT-C (or is TAT-C's package).""" return isinstance(module, str) and ( - module == _PACKAGE or module.startswith(_PACKAGE + ".") + module == _TATC or module.startswith(_TATC + ".") ) @@ -129,6 +137,14 @@ def _is_dataclass(value: Any) -> bool: return dataclasses.is_dataclass(value) and not isinstance(value, type) +def _has_fingerprint(value: Any) -> bool: + """ + Whether a value is an object that describes itself (by a method + `__fingerprint__`, see `_Describer.fingerprinted`), not a class. + """ + return callable(getattr(type(value), "__fingerprint__", None)) + + @functools.lru_cache(maxsize=1) def _installed_directories() -> tuple[Path, ...]: """Gets the directories of installed modules (and the standard library).""" @@ -145,7 +161,7 @@ def _is_own_module(module: Any) -> bool: (such as `__main__`, or a module next to a notebook), so that its functions are described by their code (see the module). """ - if not isinstance(module, str) or _is_package_module(module): + if not isinstance(module, str) or _is_tatc_module(module): return False if module == "__main__": return True @@ -199,17 +215,17 @@ def _frame(value: pd.DataFrame | pd.Series) -> dict: a hash of its index and values. """ frame = value.to_frame() if isinstance(value, pd.Series) else value - digest = hashlib.sha1() - digest.update(pd.util.hash_pandas_object(frame.index).to_numpy().tobytes()) + hasher = hashlib.sha1() + hasher.update(pd.util.hash_pandas_object(frame.index).to_numpy().tobytes()) for i in range(frame.shape[1]): - digest.update(_hash_column(frame.iloc[:, i])) + hasher.update(_hash_column(frame.iloc[:, i])) return { **_type(value), "columns": [str(column) for column in frame.columns], "types": [str(dtype) for dtype in frame.dtypes], "index": str(frame.index.dtype), "shape": list(value.shape), - "data": digest.hexdigest(), + "data": hasher.hexdigest(), } @@ -309,7 +325,7 @@ def __init__(self): def note(self, module: Any) -> None: """Notes a module that a value refers to (if it is of the package).""" - if _is_package_module(module): + if _is_tatc_module(module): self.modules.add(module) def describe(self, value: Any, depth: int = 0, seen: set | None = None) -> Any: @@ -374,6 +390,21 @@ def dataclass(self, value: Any, depth: int, seen: set) -> dict: described["class"] = self.klass(type(value), depth + 1, seen) return described + def fingerprinted(self, value: Any, depth: int, seen: set) -> dict: + """ + Describes an object by the value that its method `__fingerprint__()` + returns (such as a design by its design space and decisions), which + identifies what of it changes results. + """ + self.note(type(value).__module__) + if id(value) in seen: + return {**_type(value), "recursive": True} + seen = seen | {id(value)} + return { + **_type(value), + "fingerprint": self.describe(value.__fingerprint__(), depth + 1, seen), + } + def model(self, value: BaseModel, depth: int, seen: set) -> dict: """Describes a pydantic model by its data.""" del depth, seen @@ -411,9 +442,7 @@ def collection(self, value: set | frozenset, depth: int, seen: set) -> Any: """Describes a set by its sorted items (or its length, if long).""" if len(value) > _MAX_ITEMS: return {**_type(value), "length": len(value)} - return sorted( - (self.describe(v, depth + 1, seen) for v in value), key=_canonical - ) + return sorted((self.describe(v, depth + 1, seen) for v in value), key=canonical) def mapping(self, value: dict, depth: int, seen: set) -> Any: """ @@ -428,7 +457,7 @@ def mapping(self, value: dict, depth: int, seen: set) -> Any: [self.describe(k, depth + 1, seen), self.describe(v, depth + 1, seen)] for k, v in value.items() ) - return sorted(pairs, key=_canonical) + return sorted(pairs, key=canonical) def node(self, value: Node, depth: int, seen: set) -> dict: """Describes a node of a design space by its attributes.""" @@ -642,6 +671,7 @@ def instance(self, value: Any, depth: int, seen: set) -> dict: ((bytes,), _Describer.binary), ((datetime, date, time), _Describer.moment), ((timedelta,), _Describer.duration), + (_has_fingerprint, _Describer.fingerprinted), (_is_dataclass, _Describer.dataclass), ((BaseModel,), _Describer.model), ((np.ndarray,), _Describer.array), @@ -681,12 +711,12 @@ def _module_files() -> dict[str, Path]: parts = path.relative_to(_ROOT).with_suffix("").parts if parts[-1] == "__init__": parts = parts[:-1] - found[".".join((_PACKAGE, *parts))] = path + found[".".join((_TATC, *parts))] = path return found -def _is_package(module: str) -> bool: - """Whether a module of the package is a package (an `__init__.py`).""" +def _is_init_module(module: str) -> bool: + """Whether a module of TAT-C is a package (an `__init__.py`).""" path = _module_files().get(module) return path is not None and path.name == "__init__.py" @@ -701,7 +731,7 @@ def _absolute(module: str, node: ast.ImportFrom) -> str: """Gets the absolute name of the module of an import from a module.""" if node.level == 0: return node.module or "" - package = module if _is_package(module) else module.rpartition(".")[0] + package = module if _is_init_module(module) else module.rpartition(".")[0] parts = package.split(".") parts = parts[: len(parts) - (node.level - 1)] return ".".join(parts + ([node.module] if node.module else [])) @@ -726,7 +756,7 @@ def _assigned(node: ast.stmt) -> tuple[list[str], ast.AST | None]: @functools.lru_cache(maxsize=None) -def _resolve(module: str, name: str) -> frozenset[tuple[str, str]]: +def _resolve_import(module: str, name: str) -> frozenset[tuple[str, str]]: """ Gets what a name imported from a module of the package depends on: a submodule of that name, or (from a package) the module that defines it, @@ -740,19 +770,20 @@ def _resolve(module: str, name: str) -> frozenset[tuple[str, str]]: return frozenset({("module", f"{module}.{name}")}) if module not in files: return frozenset() - if not _is_package(module): + if not _is_init_module(module): return frozenset({("module", module)}) for node in _tree(module).body: if isinstance(node, ast.ImportFrom): for alias in node.names: if (alias.asname or alias.name) == name: source = _absolute(module, node) - if not _is_package_module(source) or source == module: + if not _is_tatc_module(source) or source == module: return frozenset({("file", module)}) - return frozenset({("file", module)}) | _resolve(source, alias.name) + found = _resolve_import(source, alias.name) + return frozenset({("file", module)}) | found elif isinstance(node, ast.Import): for alias in node.names: - if alias.asname == name and _is_package_module(alias.name): + if alias.asname == name and _is_tatc_module(alias.name): return frozenset({("file", module), ("module", alias.name)}) elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)): if node.name == name: @@ -770,7 +801,7 @@ def _resolve(module: str, name: str) -> frozenset[tuple[str, str]]: def _imports(module: str) -> frozenset[tuple[str, str]]: """ Gets what the imports of a module of the package (anywhere in its code) - depend on (see `_resolve`). + depend on (see `_resolve_import`). """ found: set[tuple[str, str]] = set() for node in ast.walk(_tree(module)): @@ -778,17 +809,17 @@ def _imports(module: str) -> frozenset[tuple[str, str]]: found.update( ("module", alias.name) for alias in node.names - if _is_package_module(alias.name) + if _is_tatc_module(alias.name) ) elif isinstance(node, ast.ImportFrom): source = _absolute(module, node) - if not _is_package_module(source): + if not _is_tatc_module(source): continue for alias in node.names: if alias.name == "*": found.add(("module", source)) else: - found.update(_resolve(source, alias.name)) + found.update(_resolve_import(source, alias.name)) return frozenset(found) @@ -837,7 +868,7 @@ def _get_dependencies(modules: Iterable[str]) -> tuple[list[str], list[str]]: files = _module_files() whole: set[str] = set() sources: set[str] = set() - pending = [module for module in modules if _is_package_module(module)] + pending = [module for module in modules if _is_tatc_module(module)] while pending: module = pending.pop() if module in whole or module not in files: @@ -857,7 +888,7 @@ def _get_dependencies(modules: Iterable[str]) -> tuple[list[str], list[str]]: @functools.lru_cache(maxsize=None) def _hash_file(path: Path, modified: int, size: int) -> str: del modified, size # keys of the cache, so that a changed file is hashed again - return _digest(path.read_bytes(), 16) + return digest(path.read_bytes(), 16) def _hash(path: Path) -> str: @@ -866,6 +897,21 @@ def _hash(path: Path) -> str: return _hash_file(path, status.st_mtime_ns, status.st_size) +def describe(value: Any) -> Any: + """ + Describes a value as plain data, as a definition describes the values it + is given (see the module and `get_definition`), such as to identify the + overrides of a scenario by their content. + + Args: + value (Any): The value. + + Returns: + Any: the description, as plain data + """ + return _Describer().describe(value) + + def get_definition(*values: Any, **named: Any) -> dict: """ Gets the definition of values (such as a design space and the functions @@ -898,7 +944,7 @@ def get_definition(*values: Any, **named: Any) -> dict: def _fingerprint_of(definition: dict) -> str: """Gets the fingerprint of a definition (see `get_definition`).""" - return _digest(_canonical(definition), 16) + return digest(canonical(definition), 16) def get_fingerprint(*values: Any, **named: Any) -> str: @@ -993,7 +1039,7 @@ def visit(constant: Any) -> None: for item in constant["constants"]: visit(item) else: - found.setdefault(_canonical(constant), constant) + found.setdefault(canonical(constant), constant) for constant in constants: visit(constant) @@ -1042,19 +1088,76 @@ def _with_other_code(definition: dict, others: Mapping[Any, dict | None]) -> lis ] -def _warn_other_code(subject: str, remedy: str, latest: dict, definition: dict) -> None: +def find_stale( + definition: dict, + others: Mapping[Any, dict | None], + count: Callable[[Any], int], +) -> dict[Any, int]: + """ + Gets the results of the same study (or function) as a definition with + other code (of its functions, of TAT-C, or of Python), which are not + reused: the keys of the other definitions (such as the contexts of a + store, or the folders of a cache) that have the same values but other + code (see `_with_other_code`), in their order, with their numbers of + results. The results of other studies (such as variants of other + settings) are not stale, as studies share stores and caches freely. + + Args: + definition (dict): The definition (see `get_definition`). + others (Mapping[Any, dict | None]): The other definitions, by key + (`None` for a definition that is unknown, of no study). + count (Callable[[Any], int]): A function of a key that counts its + results (0 for a definition kept without results). + + Returns: + dict[Any, int]: the numbers of results, by key (in the order of + `others`) + """ + return {key: count(key) for key in _with_other_code(definition, others)} + + +def warn_stale( + found: Mapping[Any, int], + definition: dict, + definition_of: Callable[[Any], dict | None], + subject: Callable[[int], str], + remedy: str, + once: Callable[[], bool] | None = None, +) -> bool: """ - Warns (at the user's call) that results of the same study (or function) - with other code are not reused: `subject` says which (such as `"the - store has 12 evaluations of namespace 'a' by this study"`), and `remedy` - how to remove them, with the differences of the latest of their + Warns (at the user's call) that the results of the same study (or + function) as a definition with other code (see `find_stale`) are not + reused, if any are found, with the differences of the latest of their definitions from the definition (see `compare_definitions`). + + Args: + found (Mapping[Any, int]): The numbers of stale results, by the key + of their definition, the latest first (see `find_stale`). + definition (dict): The definition (see `get_definition`). + definition_of (Callable[[Any], dict | None]): A function of a key + that gives its definition. + subject (Callable[[int], str]): A function of the number of stale + results that says which they are (such as `"the store has 12 + evaluations of namespace 'a' by this study"`). + remedy (str): How to remove them. + once (Callable[[], bool] | None): A function called before warning + that gives whether to warn (such as only for the first of the + parallel workers of a study), or `None` to warn. + + Returns: + bool: whether it warned """ + # pylint: disable=too-many-arguments,too-many-positional-arguments + found = {key: number for key, number in found.items() if number} + if not found or (once is not None and not once()): + return False + latest = definition_of(next(iter(found))) or {} _warn( - f"{subject} with other code, which are not reused ({remedy}); the " - + "latest differs in: " + f"{subject(sum(found.values()))} with other code, which are not reused " + + f"({remedy}); the latest differs in: " + "; ".join(compare_definitions(latest, definition)) ) + return True def compare_definitions(before: dict, after: dict, limit: int = 5) -> list[str]: diff --git a/src/tatc/tradespace/hashing.py b/src/tatc/tradespace/hashing.py index e3f12b97..880259cb 100644 --- a/src/tatc/tradespace/hashing.py +++ b/src/tatc/tradespace/hashing.py @@ -24,7 +24,7 @@ def _json_default(value: Any) -> Any: return str(value) -def _canonical(value: Any) -> str: +def canonical(value: Any) -> str: """ Gets the canonical text of a plain value: its JSON, with the keys of mappings sorted (numpy scalars as Python's, and other values as their @@ -33,7 +33,7 @@ def _canonical(value: Any) -> str: return json.dumps(value, sort_keys=True, default=_json_default) -def _digest(data: str | bytes, length: int | None = None) -> str: +def digest(data: str | bytes, length: int | None = None) -> str: """Gets a hash of text (or bytes), as hexadecimal digits (the first `length`).""" raw = data.encode() if isinstance(data, str) else data text = hashlib.sha1(raw).hexdigest() diff --git a/src/tatc/tradespace/histories.py b/src/tatc/tradespace/histories.py index 083fe99e..47375e76 100644 --- a/src/tatc/tradespace/histories.py +++ b/src/tatc/tradespace/histories.py @@ -1,39 +1,26 @@ """ -Many histories of missions in a replicate (see `Deployment.simulate_many`): -their simulation (independent or stratified), evaluation with a cache of -the metrics of their phases (see `PhaseCache`), and summaries as the -records of evaluations, with control variates and the allocation of -evaluations between replicates and histories; and the exact expectations -of missions without restoration (`exact_expectations`). +Many histories of missions in a replicate (simulated by +`Deployment.simulate_many`): their evaluation with a cache of the metrics +of their phases (see `PhaseCache`), their summaries as the records of +evaluations, with control variates, and the allocation of evaluations +between replicates and histories. The exact expectations of missions +without restoration are in the module `expectations`. @author: Paul T. Grogan """ from __future__ import annotations -import itertools import math import warnings from collections.abc import Mapping, Sequence -from typing import TYPE_CHECKING, Any +from typing import Any import numpy as np import pandas as pd from .criteria import Requirement -from .failures import FailureModel, RestorationPolicy -from .mission import ( - PHASE_COLUMNS, - Capability, - MissionHistory, - Phase, - _position_names, - summarize_phases, -) -from .simulation import _Simulation - -if TYPE_CHECKING: - from .deployment import Deployment +from .mission import Capability, MissionHistory, summarize_phases def evaluate_histories( @@ -99,10 +86,12 @@ def summarize_histories( (by the same name), quantiles of columns over the histories (` histories p`, such as `"accurate mission histories p10"` for the 0.1 quantile, the risk of the mission), and the share of the histories - that meet each requirement on a column (`P( - )`). The quantiles (and standard deviations) over the histories - of a replicate are named apart from statistics over the replicates - (such as a `Quantile`, see `Criteria`), which are taken of these. + that meet each requirement on a column (`P( ) + histories`, such as `"P(accurate time <= 4) histories"`). The statistics + over the histories of a replicate (quantiles, probabilities, and + standard deviations) end in `histories`, apart from the statistics over + the replicates (such as a `Quantile` or a `Probability`, see + `Criteria`), which are taken of these. Missing values (`NaN`, such as the `restoration years` of a history without restorations) are left out of the statistics of their column, @@ -189,7 +178,9 @@ def summarize_histories( ) for requirement in requirements: met = requirement.met(histories[requirement.name].to_numpy(dtype=float)) - summary[f"P({requirement})"] = float(np.sum(weights * met) / np.sum(weights)) + summary[f"P({requirement}) histories"] = float( + np.sum(weights * met) / np.sum(weights) + ) return summary @@ -260,92 +251,6 @@ def _controlled_means( return means -class _Sampler: - """ - The uniform numbers of the failures of a history of a replicate, - stratified over the histories of the replicate (see - `Deployment.simulate_many`): a Latin hypercube in which, for each draw - (each life and launch), history `k` of `K` takes a uniform number in its - stratum of a permutation of the `K` strata of [0, 1). Each draw is keyed - by its key, so that the same draw of the same history of a replicate - takes the same number in every design (common random numbers). - """ - - def __init__(self, seed: int, index: int, histories: int): - self.seed, self.index, self.histories = seed, index, histories - - def __call__(self, key: tuple, dimensions: int) -> np.ndarray: - strata = np.random.default_rng([self.seed, 1, self.histories, *key]) - orders = [strata.permutation(self.histories) for _ in range(dimensions)] - jitter = np.random.default_rng([self.seed, 2, self.index, *key]) - offsets = jitter.random(dimensions) - return np.array( - [ - (order[self.index] + offset) / self.histories - for order, offset in zip(orders, offsets) - ] - ) - - -SAMPLINGS = ("random", "stratified") -"""The samplings of the failures of histories (see `Deployment.simulate_many`).""" - - -def _simulate_many( - deployment: Deployment, - model: FailureModel, - policy: RestorationPolicy | None, - seed: int, - histories: int, - sampling: str, - stress: float = 1.0, - launch_stress: float | None = None, -) -> list[MissionHistory]: - """ - Simulates the histories of a replicate (see `Deployment.simulate_many`). - """ - if sampling not in SAMPLINGS: - raise ValueError(f"sampling must be one of {SAMPLINGS}, not {sampling!r}") - if stress <= 0 or (launch_stress is not None and launch_stress <= 0): - raise ValueError("stress must be positive") - launch_stress = stress if launch_stress is None else launch_stress - return [ - _Simulation( - deployment, - model, - policy or RestorationPolicy(), - (seed, k), - _Sampler(seed, k, histories) if sampling == "stratified" else None, - stress, - launch_stress, - ).run() - for k in range(histories) - ] - - -def _expected_metrics( - deployment: Deployment, - model: FailureModel, - policy: RestorationPolicy | None, - seed: int, - histories: int, - sampling: str, -) -> dict[str, float]: - """ - Estimates the expected measures of a mission from many simulated - histories (see `Deployment.expected_metrics`). - """ - rows = pd.DataFrame( - [ - history.metrics() - for history in _simulate_many( - deployment, model, policy, seed, histories, sampling - ) - ] - ) - return {column: float(rows[column].mean()) for column in rows.columns} - - def allocate_histories( records: pd.DataFrame, metric: str, @@ -444,246 +349,3 @@ def allocate_histories( result.update(histories=float(count), **{"replicate seconds": cost}) result.update(replicates=float(replicates), seconds=replicates * cost) return result - - -def _launch_groups( - deployment: Deployment, model: FailureModel, times: np.ndarray -) -> tuple[int, list[tuple]]: - """ - Gets the launch groups of a deployment without restoration: the - positions of each launch of the deployment (in order of the planes' - positions), which its planned replacements carry again. For each group, - at each time: the probability that each of its launches so far is the - latest that succeeded (`weights`, launches by times), the survival of - the satellites of each since its launch (`survival`, launches by times), - the probability that none has succeeded (`none`), and whether the group - has launched. - """ - offsets = np.cumsum([0] + [plane.satellites for plane in deployment.planes]) - launches: dict[tuple[int, int], list] = {} - for launch in sorted(deployment.launches, key=lambda l: l.time): - launches.setdefault((launch.plane, launch.first), []).append(launch) - p = model.launch - groups = [] - for (plane, first), sequence in launches.items(): - built = deployment.planes[plane].satellites - members = [ - int(offsets[plane]) + position - for position in range(first, min(first + sequence[0].satellites, built)) - ] - if not members: - continue - life = model.life_of(sequence[0].kind) - flown = np.array([[t >= launch.time for t in times] for launch in sequence]) - # launches after each one, up to each time - later = np.flip(np.cumsum(np.flip(flown, axis=0), axis=0), axis=0) - flown - weights = np.where(flown, (1 - p) * p**later, 0.0) - survival = np.array( - [ - ( - np.ones(len(times)) - if life is None - else life.survival(np.maximum(times - launch.time, 0.0)) - ) - for launch in sequence - ] - ) - none = p ** flown.sum(axis=0) - groups.append((members, weights, survival, none, flown.any(axis=0))) - return int(offsets[-1]), groups - - -def _group_operating(group: tuple, count: int) -> np.ndarray: - """ - Gets the probability at each time that exactly a given set of `count` - satellites of a launch group operates (see `_set_weight`). - """ - members, weights, survival, none, _ = group - probability = np.sum( - weights * survival**count * (1 - survival) ** (len(members) - count), axis=0 - ) - return probability + none if count == 0 else probability - - -def _set_weight(active: np.ndarray, groups: list) -> float: - """ - Gets the share of the mission's time in which exactly the active - positions operate, in expectation: at each time, the product over the - launch groups of the probability that exactly the active satellites of - the group operate, which (as they are of one type and launched together) - depends only on their number `a` of the `n` of the group: the sum over - its launches of the probability that the launch is the latest that - succeeded times `S ** a * (1 - S) ** (n - a)`, for the survival `S` of - its satellites, and the probability that none has succeeded if `a` is 0. - """ - probability = 1.0 - for group in groups: - probability = probability * _group_operating(group, int(active[group[0]].sum())) - return float(np.mean(probability)) - - -def _missing_levels(groups: list, count: int, tolerance: float) -> int: - """ - Gets the most positions missing of the sets that exact expectations - enumerate (see `exact_expectations`): the least number such that the - sets of that many missing positions or fewer operate all but `tolerance` - of the mission's time, in expectation. The distribution of the number - missing at each time is the convolution over the launch groups of the - distributions of theirs (each the probability of a set times the number - of sets of its size), cheap to compute without enumerating the sets. - """ - if not groups: - return count - distribution = np.zeros((count + 1, len(groups[0][3]))) - distribution[0] = 1.0 - for group in groups: - size = len(group[0]) - combined = np.zeros_like(distribution) - for gone in range(size + 1): - share = math.comb(size, gone) * _group_operating(group, size - gone) - combined[gone:] += share * distribution[: count + 1 - gone] - distribution = combined - covered = np.cumsum(distribution.mean(axis=1)) - reached = np.flatnonzero(covered >= 1 - tolerance - 1e-12) - return int(reached[0]) if len(reached) > 0 else count - - -def _exact_sets( - deployment: Deployment, - model: FailureModel, - tolerance: float = 1e-3, - steps: int = 400, -) -> int: - """ - Gets the number of sets of satellites that exact expectations of a - deployment enumerate (see `exact_expectations`), without enumerating - them: the sets of at most the number of positions missing that cover - all but `tolerance` of the mission's time. - """ - times = _times(deployment, steps) - count, groups = _launch_groups(deployment, model, times) - levels = _missing_levels(groups, count, tolerance) - return sum(math.comb(count, missing) for missing in range(levels + 1)) - - -def _times(deployment: Deployment, steps: int) -> np.ndarray: - """The times at which exact expectations integrate probabilities.""" - begin, end = deployment.begin, deployment.end - return begin + (np.arange(steps) + 0.5) * (end - begin) / steps - - -MAX_SETS = 200_000 -"""The most sets of satellites that exact expectations enumerate by default -(see `exact_expectations`), as those of the failures of a study do (see -`Failures`).""" - - -def exact_expectations( - deployment: Deployment, - model: FailureModel, - capability: Capability, - *, - tolerance: float = 1e-3, - steps: int = 400, - max_sets: int = MAX_SETS, -) -> dict[str, float]: - """ - Computes the expected capability of a mission without restoration - (failed satellites are not restored, but may be replaced as planned at - the end of their design life) over its failures: the expectation of the - mean of each metric over the phases of the mission (` mission`, as - `summarize_phases` gives for one history) and of its availability - (`availability`), exactly rather than from samples of histories (as - `Deployment.expected_metrics` estimates the measures of missions). - - Without restoration, the satellites fail independently (but for the - satellites of a launch, which a failed launch loses together), so that - the probability that a set of satellites operates at a time is a product - over the launches of their survival (see `Lifetime.survival`). The - expected mean of a metric is the sum over the sets of satellites of the - metric of each set (evaluated once, as with a `PhaseCache`) times the - share of the mission's time in which exactly that set operates, in - expectation (integrated over `steps` times). The sets are enumerated by - the number of satellites missing until their shares cover all but - `tolerance` of the mission's time (a number known before they are - enumerated, from the distribution of the number missing), and evaluated - in order of their shares until they do (`coverage`, the share covered, - and `sets`, the sets evaluated); the expectation is over the sets - evaluated. - - Without sampling error, an expectation estimates the mean of many - histories with none of their variance (see `Deployment.simulate_many`), - for missions of a few to a dozen or two satellites; for larger ones - (whose sets number more than `max_sets`, which is known before any is - enumerated), or with restoration (whose shared production and launches - make failures dependent), simulate histories. - - Args: - deployment (Deployment): The deployment. - model (FailureModel): The failures. - capability (Capability): The capability of the satellites (in the - order of the planes, see `MissionHistory.phases`): their - observations and metric (see `Capability.evaluate`). - tolerance (float): The share of the mission's time that the sets - evaluated may leave out. - steps (int): The times at which the probabilities are integrated. - max_sets (int): The most sets to enumerate. - - Returns: - dict[str, float]: the expected metrics - - Raises: - ValueError: if the deployment is staged (see `Stage`), whose launches - depend on its rules, or has more sets to enumerate than - `max_sets` (raised before any is enumerated). - """ - # pylint: disable=too-many-locals - if deployment.stages: - raise ValueError( - "exact expectations need a deployment that is not staged: " - + "simulate histories of a staged deployment instead" - ) - names = list(_position_names(deployment.planes, capability.satellites).values()) - begin, end = deployment.begin, deployment.end - count, groups = _launch_groups(deployment, model, _times(deployment, steps)) - levels = _missing_levels(groups, count, tolerance) - if sum(math.comb(count, missing) for missing in range(levels + 1)) > max_sets: - raise ValueError("too many sets of satellites to enumerate: simulate histories") - # availability: the expected years of operation of the positions, as a - # share of those of the planned deployment - operating = sum( - len(members) * float(np.mean(np.sum(weights * survival, axis=0))) - for members, weights, survival, _, _ in groups - ) - planned = sum( - len(members) * float(np.mean(launched)) for members, _, _, _, launched in groups - ) - availability = operating / planned if planned > 0 else math.nan - # enumerate the sets by the number of positions missing - weights: list[tuple[float, tuple[int, ...]]] = [] - for missing in range(levels + 1): - for gone in itertools.combinations(range(count), missing): - active = np.ones(count, dtype=bool) - active[list(gone)] = False - weight = _set_weight(active, groups) - if weight > 0: - weights.append((weight, tuple(np.flatnonzero(active)))) - weights.sort(key=lambda item: -item[0]) - totals: dict[str, float] = {} - evaluated, sets = 0.0, 0 - for weight, members in weights: - phase = Phase(begin, end, tuple(names[k] for k in members)) - values = capability.evaluate([phase]).iloc[0] - for name, value in values.items(): - if name in PHASE_COLUMNS: - continue - totals[f"{name} mission"] = totals.get( - f"{name} mission", 0.0 - ) + weight * float(value) - evaluated += weight - sets += 1 - if evaluated >= 1 - tolerance: - break - result = {name: total / evaluated for name, total in totals.items()} - result.update(availability=availability, coverage=evaluated, sets=float(sets)) - return result diff --git a/src/tatc/tradespace/memory.py b/src/tatc/tradespace/memory.py new file mode 100644 index 00000000..3808751a --- /dev/null +++ b/src/tatc/tradespace/memory.py @@ -0,0 +1,29 @@ +""" +Objects that keep results in memory (such as caches of the metrics of the +phases of missions, the targets of replicates, and the caches of their +observations), whose copies sent to the parallel workers of a study start +with empty memories. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + + +class Forgetful: + """ + A mixin of objects that keep results in memory, in the attributes named + by `_forgotten` (each a container, such as a dictionary), which their + copies (such as those pickled for the parallel workers of a study) start + without: empty containers of the same types. + """ + + # pylint: disable=too-few-public-methods + + _forgotten: tuple[str, ...] = () + + def __getstate__(self) -> dict: + state = self.__dict__.copy() + for name in self._forgotten: + state[name] = type(state[name])() + return state diff --git a/src/tatc/tradespace/mission.py b/src/tatc/tradespace/mission.py index 938bb10a..2bee82ff 100644 --- a/src/tatc/tradespace/mission.py +++ b/src/tatc/tradespace/mission.py @@ -3,7 +3,10 @@ restorations (see `Deployment.simulate`, whose simulation is in the module `simulation`), the decisions of the rules of its stages, the phases of a mission in which constant sets of satellites operate, and their evaluation -over the study's representative period and combination over the mission. +over the study's representative period and combination over the mission; +and the mission of a replicate of a design of an observation study +(`Mission`), which an evaluation plans (see `MissionPlan`) and summarizes +into its record. @author: Paul T. Grogan """ @@ -22,11 +25,15 @@ from ..schemas import Satellite from .cache import get_satellite_key from .criteria import Requirement -from .events import Launch, Production -from .study import _takes_design +from .events import Launch, PlannedPlane, Production +from .memory import Forgetful +from .references import given_design if TYPE_CHECKING: + from .cost import CostEstimate, CostModel from .deployment import Deployment, DeploymentSchedule + from .plans import Failures + from .space import Design @dataclass(frozen=True) @@ -59,7 +66,7 @@ def _names(satellites: Sequence[Satellite | str]) -> list[str]: def _position_names( - planes: Sequence[tuple[Any, int, int]], satellites: Sequence[Satellite | str] + planes: Sequence[PlannedPlane], satellites: Sequence[Satellite | str] ) -> dict[tuple[int, int], str]: """ Gets the name of the satellite at each position of each plane (by plane @@ -156,9 +163,10 @@ class MissionHistory: weight: float = 1.0 """float: The likelihood ratio of the history, drawn from stressed failures (see `Deployment.simulate_many`), or 1.""" - stages: list[float | None] = field(default_factory=list) - """list: When each stage of the deployment was decided (years from the - start of development, see `Stage`), or `None` if it was not.""" + decided: list[float | None] = field(default_factory=list) + """list: When the rule of each stage of the deployment decided to deploy + it (years from the start of development, see `Stage`), or `None` if it + did not.""" @property def schedule(self) -> DeploymentSchedule: @@ -166,8 +174,8 @@ def schedule(self) -> DeploymentSchedule: return self.deployment.schedule @property - def planes(self) -> list[tuple[Any, int, int]]: - """list: The planes of the deployment.""" + def planes(self) -> list[PlannedPlane]: + """list[PlannedPlane]: The planes of the deployment.""" return self.deployment.planes @property @@ -195,7 +203,27 @@ def deployed(self) -> float: """float: The time by which the satellites of the first generation are launched (years), whether their launches succeed or not: of the planes that are not staged, and of the stages that this history - deployed (see `stages`).""" + deployed (see `decided`). It is infinite if the deployment does not + finish within the mission (a launch of the first generation booked at + or after its end), as is the time until the mission meets a + requirement that it never meets (see `summarize_phases`).""" + launched = [0] * len(self.planes) + for launch in self.launches: + if launch.purpose == "deployment": + launched[launch.plane] += launch.satellites + stage_of = { + plane: index + for index, stage in enumerate(self.deployment.stages) + for plane in stage.planes + } + for plane, (_, satellites, spares) in enumerate(self.planes): + index = stage_of.get(plane) + if index is not None and ( + index >= len(self.decided) or self.decided[index] is None + ): + continue # a stage that is not deployed + if launched[plane] < satellites + spares: + return math.inf return max( launch.time for launch in self.launches if launch.purpose == "deployment" ) @@ -301,7 +329,7 @@ def metrics(self) -> dict[str, float]: } if self.deployment.stages: metrics["stages deployed"] = float( - sum(time is not None for time in self.stages) + sum(time is not None for time in self.decided) ) return metrics @@ -405,7 +433,7 @@ def evaluate_phases( pandas.DataFrame: a row per phase: its `start`, `end`, `duration`, number of `satellites`, and metrics """ - given = _given_design(metric, design) + given = given_design(metric, design) return _evaluate_phases(phases, observations, lambda subset, _: given(subset())) @@ -484,20 +512,12 @@ def _subset(observations: pd.DataFrame, names: frozenset) -> pd.DataFrame: return observations.iloc[0:0] -def _given_design(metric: Callable, design: Any) -> Callable: - """ - Gets a metric of observations alone: the metric, given the design if it - has a parameter named `design` (see `Study`). - """ - return partial(metric, design=design) if _takes_design(metric) else metric - - def _as_cache(metric: Callable[..., Mapping[str, float]] | PhaseCache) -> PhaseCache: """Gets a cache of a metric (see `PhaseCache`), or the cache given.""" return metric if isinstance(metric, PhaseCache) else PhaseCache(metric) -class PhaseCache: +class PhaseCache(Forgetful): """ A cache of a metric of the phases of missions (see `evaluate_phases`), keyed by a context that identifies the observations (such as the seed of @@ -520,6 +540,8 @@ class PhaseCache: may be empty) that gives its metrics. """ + _forgotten = ("_memory",) + def __init__(self, metric: Callable[..., Mapping[str, float]]): self.metric = metric self.hits = 0 @@ -528,11 +550,6 @@ def __init__(self, metric: Callable[..., Mapping[str, float]]): """int: The phases evaluated.""" self._memory: dict = {} - def __getstate__(self) -> dict: - state = self.__dict__.copy() - state["_memory"] = {} - return state - def evaluate( self, phases: Sequence[Phase], @@ -610,7 +627,7 @@ def metrics_of( self.hits += 1 else: self.misses += 1 - metric = _given_design(self.metric, design) + metric = given_design(self.metric, design) self._memory[key] = dict(metric(_subset(observations, frozenset(keys)))) return dict(self._memory[key]) @@ -678,7 +695,9 @@ def __init__( """Any: The identifier of the observations, for a cache.""" self.design = design """Design | None: The (realized) design of the mission.""" - self._names = _names(self.satellites) + self.names = _names(self.satellites) + """list[str]: The names of the satellites, in the order of the + planes.""" @cached_property def _keys(self) -> dict[str, str]: @@ -723,7 +742,7 @@ def __call__(self, names: Iterable[str]) -> dict[str, float]: dict[str, float]: the metrics """ names = frozenset(names) - unknown = names - set(self._names) + unknown = names - set(self.names) if unknown: raise ValueError(f"satellites that are not given: {sorted(unknown)}") return self._cache.metrics_of( @@ -733,9 +752,28 @@ def __call__(self, names: Iterable[str]) -> dict[str, float]: design=self.design, ) + def position_names( + self, planes: Sequence[PlannedPlane] + ) -> dict[tuple[int, int], str]: + """ + Gets the name of the satellite at each position of each plane of a + deployment (see `Deployment.planes`), without spares, as the phases of + its missions name them (see `MissionHistory.phases`). + + Args: + planes (Sequence[PlannedPlane]): The planes. + + Returns: + dict[tuple[int, int], str]: the names, by plane and position + + Raises: + ValueError: if the planes have other numbers of satellites. + """ + return _position_names(planes, self.names) + def at( self, - planes: Sequence[tuple[Any, int, int]], + planes: Sequence[PlannedPlane], positions: Iterable[tuple[int, int]], ) -> dict[str, float]: """ @@ -743,13 +781,133 @@ def at( deployment (see `Deployment.planes`). Args: - planes (Sequence[tuple[Any, int, int]]): The planes: the type of - their satellites, and the number of satellites and of spares. + planes (Sequence[PlannedPlane]): The planes. positions (Iterable[tuple[int, int]]): The plane and position of each satellite. Returns: dict[str, float]: the metrics """ - named = _position_names(planes, self._names) + named = self.position_names(planes) return self(named[plane, position] for plane, position in positions) + + +@dataclass(frozen=True, eq=False) +class Mission: + """ + The mission of a replicate of a design, as the evaluation of an + observation study plans it (see `MissionPlan.plan_mission` and + `ObservationStudy.mission_of`): its planned deployment (with the policy + that restores the failures of its satellites, and the capability of its + satellites), its cost model and growth, and the capability of its + satellites (their observations, and the cache of the metrics of their + phases), from which follow the metrics of its phases (`phases`, of the + history of the mission without failures, see `Deployment.planned`), its + cost estimate (`estimate`), and the histories of its failures + (`histories`, with `failures`). + """ + + design: Design + """Design: The realized design.""" + deployment: Deployment + """Deployment: The planned deployment, with its policy (see + `Deployment.policy`) and the capability of its satellites (which the + rules of its stages read, see `Deployment.capability`).""" + cost_model: CostModel | None + """CostModel | None: The cost model (with the growth of its components + drawn), if any.""" + growth: Any + """Any: The growth of the costs (see `CostModel.estimate`).""" + capability: Capability + """Capability: The capability of the satellites.""" + failures: Failures | None = None + """Failures | None: The failures of the satellites, if any.""" + + def phases(self) -> pd.DataFrame: + """ + Gets the metrics of the phases of the mission without failures (see + `Deployment.phases` and `evaluate_phases`), which the evaluation of + a study with `phases` summarizes (see `summarize_phases`). + + Returns: + pandas.DataFrame: a row per phase: its `start`, `end`, + `duration`, number of `satellites`, and metrics + """ + satellites = self.capability.satellites + return self.capability.evaluate(self.deployment.phases(satellites)) + + def estimate(self) -> CostEstimate: + """ + Gets the cost estimate of the mission without failures (see + `CostModel.estimate` of its deployment), with its growth: the costs + of the evaluation of a study without failures (those of a study with + failures are the means of those of its histories, see `histories`). + + Returns: + CostEstimate: the estimate + + Raises: + ValueError: if the plan has no cost model. + """ + if self.cost_model is None: + raise ValueError("the mission plan has no cost model") + return self.cost_model.estimate(self.deployment, self.growth) + + def histories(self) -> pd.DataFrame: + """ + Gets the histories of the failures of the mission, which the + evaluation of a study with failures summarizes (see + `Failures.evaluate` and `evaluate_histories`): a row per history, + with the mean of each metric over its phases, the measures of its + mission, and its costs. + + Returns: + pandas.DataFrame: a row per history + + Raises: + ValueError: if the mission has no failures. + """ + if self.failures is None: + raise ValueError("the study has no failures") + return self.failures.evaluate(self) + + def metrics(self) -> dict[str, float]: + """ + Gets the metrics of the planned mission that its evaluation records: + `deployed` (see `Deployment.deployed`, of the history without + failures), `stages deployed` (of a staged deployment, the stages that + its rules deploy without failures), and, without failures, its costs + (see `estimate` and `CostEstimate.metrics`). + + Returns: + dict[str, float]: the metrics + """ + planned = self.deployment.planned() + record = {"deployed": planned.deployed} + if self.deployment.stages: + record["stages deployed"] = planned.metrics()["stages deployed"] + if self.cost_model is not None and self.failures is None: + record.update(self.estimate().metrics()) + return record + + def summarize( + self, phases: Sequence[Requirement] | None = None + ) -> dict[str, float]: + """ + Summarizes the mission as metrics of its evaluation: the histories of + its failures (see `Failures.summarize`), or else, with requirements + on its phases (or none, `()`), the phases of the mission without + failures (see `phases` and `summarize_phases`). + + Args: + phases (Sequence[Requirement] | None): The requirements on the + phases, or `None` not to summarize them. + + Returns: + dict[str, float]: the summary (empty without failures or phases) + """ + if self.failures is not None: + return self.failures.summarize(self) + if phases is not None: + return summarize_phases(self.phases(), requirements=phases) + return {} diff --git a/src/tatc/tradespace/nodes.py b/src/tatc/tradespace/nodes.py index de47f016..5d0c9da3 100644 --- a/src/tatc/tradespace/nodes.py +++ b/src/tatc/tradespace/nodes.py @@ -15,7 +15,7 @@ import numpy as np -from .hashing import _canonical, _digest +from .hashing import canonical, digest from .values import Scope @@ -53,7 +53,7 @@ class Node: """A bound of a variable: a value, or a callable of the values decided so far.""" -def _resolve(bound: Any, scope: Scope) -> Any: +def _resolve_bound(bound: Any, scope: Scope) -> Any: """ Resolves a bound that may be a callable of the values decided so far. """ @@ -119,7 +119,7 @@ def suggest(self, trial: Any, name: str) -> Any: """ if self.kind == "categorical": if self.dynamic: - name = f"{name}#{_digest(_canonical(self.levels), 8)}" + name = f"{name}#{digest(canonical(self.levels), 8)}" return trial.suggest_categorical(name, self.levels) if self.kind == "integer": return trial.suggest_int( @@ -194,7 +194,8 @@ def __init__( self.low, self.high, self.step, self.log = low, high, step, log def domain(self, scope: Scope) -> _Domain: - low, high = float(_resolve(self.low, scope)), float(_resolve(self.high, scope)) + low = float(_resolve_bound(self.low, scope)) + high = float(_resolve_bound(self.high, scope)) if high < low: raise Infeasible(f"empty range [{low}, {high}]") if self.step is not None: @@ -205,7 +206,8 @@ def domain(self, scope: Scope) -> _Domain: return _Domain(low=low, high=high, log=self.log, kind="real") def __repr__(self) -> str: - return f"Real({self.low!r}, {self.high!r}, step={self.step!r})" + log = ", log=True" if self.log else "" + return f"Real({self.low!r}, {self.high!r}, step={self.step!r}{log})" class Integer(Variable): @@ -225,7 +227,8 @@ def __init__(self, low: Bound, high: Bound, step: int = 1): self.low, self.high, self.step = low, high, step def domain(self, scope: Scope) -> _Domain: - low, high = int(_resolve(self.low, scope)), int(_resolve(self.high, scope)) + low = int(_resolve_bound(self.low, scope)) + high = int(_resolve_bound(self.high, scope)) if high < low: raise Infeasible(f"empty range [{low}, {high}]") levels = _levels(low, high, self.step, integer=True) @@ -253,7 +256,7 @@ def __init__(self, options: Sequence | Callable[[Scope], Sequence]): self.options = options if callable(options) else list(options) def domain(self, scope: Scope) -> _Domain: - options = list(_resolve(self.options, scope)) + options = list(_resolve_bound(self.options, scope)) if len(options) == 0: raise Infeasible("no options") return _Domain(levels=options, dynamic=callable(self.options)) @@ -472,7 +475,7 @@ class Repeat(Node): their items are the same. """ - def __init__(self, item: Any, count: Any, ordered: bool = True): + def __init__(self, item: Any, count: Any, *, ordered: bool = True): self.item = _as_node(item) if isinstance(count, bool) or not isinstance( count, (numbers.Integral, Integer, Categorical, Fixed, Derived) diff --git a/src/tatc/tradespace/observations.py b/src/tatc/tradespace/observations.py index 18512fb6..aec56896 100644 --- a/src/tatc/tradespace/observations.py +++ b/src/tatc/tradespace/observations.py @@ -5,16 +5,8 @@ deployment and costs, the histories of its failures, and the phases of its mission. -The parts refer to the values of designs by a `Reference` (see `value_of`): -a name (such as `"points_seed"` for `d.points_seed`, or a path of -`Design.flat`, such as `"layout.walker.planes"`), or a function of the -(realized) design (such as `lambda d: d.layout`). A string given where a -reference is expected is always a reference, never a value itself: give a -function that returns a string (or a number, where numbers are references) -to give a value:: - - MissionPlan(SCHEDULE, COST_MODEL, kind="field_of_regard") # d.field_of_regard - MissionPlan(SCHEDULE, COST_MODEL, kind=lambda d: "imager") # always "imager" +The parts refer to the values of designs as `tatc.tradespace.references` +describes. @author: Paul T. Grogan """ @@ -22,36 +14,33 @@ from __future__ import annotations import dataclasses -import json import os import warnings from collections.abc import Callable, Mapping, Sequence from datetime import datetime, timedelta from functools import partial -from pathlib import Path from typing import Any import pandas as pd from ..analysis import collect_observations from ..schemas import Satellite -from .cache import SatelliteCache, _write +from .cache import SatelliteCache from .constellations import count_planes from .criteria import Requirement -from .mission import Capability, PhaseCache, _given_design -from .plans import Failures, Mission, MissionPlan -from .references import Reference, value_of +from .memory import Forgetful +from .mission import Capability, Mission, PhaseCache +from .plans import Failures, MissionPlan +from .references import Reference, given_design, takes_design, value_of from .space import Design, DesignSpace -from .store import _decode, _encode -from .study import Study, _Case, _takes_design -from .walks import _generic +from .study import Study, _Case _MAX_TARGETS = 32 """The most sets of targets (of seeds) kept in memory.""" @dataclasses.dataclass(frozen=True, eq=False, init=False) -class Targets: +class Targets(Forgetful): """ The targets of observations (such as points): fixed (a data frame), or generated in each replicate by a function (such as @@ -74,6 +63,7 @@ class Targets: arguments: tuple keywords: dict seed: Reference | None + _forgotten = ("_memory",) # (copies sent to parallel workers) def __init__( self, @@ -95,12 +85,6 @@ def __init__( object.__setattr__(self, "seed", seed) object.__setattr__(self, "_memory", {}) - def __getstate__(self) -> dict: - # copies sent to parallel workers start with empty memories - state = self.__dict__.copy() - state["_memory"] = {} - return state - def seed_of(self, design: Design | None) -> Any: """ Gets the seed of the targets of a design (`None` if they are fixed). @@ -151,17 +135,23 @@ def _of_seed(self, seed: Any) -> pd.DataFrame: def _observe( analysis: Callable, - targets: Any, + targets: Targets, + seed: Any, start: datetime, end: datetime, satellite: Satellite, ) -> pd.DataFrame: - """The observations of the targets by a satellite (see `Observations`).""" - return analysis(targets, satellite, start, end) + """ + The observations of the targets of a seed by a satellite (see + `Observations`), generating them only if needed (and keeping them). + """ + # pylint: disable=too-many-arguments,too-many-positional-arguments + # pylint: disable-next=protected-access + return analysis(targets._of_seed(seed), satellite, start, end) @dataclasses.dataclass(frozen=True, eq=False) -class Observations: +class Observations(Forgetful): """ The observations of targets by satellites over a period, by an analysis of one satellite (such as `tatc.analysis.collect_observations`, called @@ -169,10 +159,13 @@ class Observations: (see `SatelliteCache`) and each set of targets (of a seed, see `Targets`), in memory, or on disk in a `directory` (shared by the parallel workers of a study, and between sessions). The results on disk - are keyed by the fingerprint of the analysis, which describes the - targets by their content: the `namespace` need only identify data that - the analysis reads (such as from files) and the code of other modules it - calls (other than TAT-C's). + are keyed by the fingerprint of the analysis, which describes fixed + targets by their content and generated targets by their recipe (see + `Targets`: their function, its arguments, and the seed's reference), + and in a namespace of the seed and the period, so that opening a cache + generates no targets: the `namespace` need only identify data that the + analysis (or the function of the targets) reads, such as from files, and + the code of other modules it calls (other than TAT-C's). The period is one window that represents the mission (see `evaluate_phases`): its start may be a value of the design (see @@ -208,18 +201,13 @@ class Observations: default=None, metadata={"fingerprint": False} ) namespace: str = "" + _forgotten = ("_caches",) # (copies sent to parallel workers) def __post_init__(self): if isinstance(self.targets, pd.DataFrame): object.__setattr__(self, "targets", Targets(self.targets)) object.__setattr__(self, "_caches", {}) - def __getstate__(self) -> dict: - # copies sent to parallel workers start without caches - state = self.__dict__.copy() - state["_caches"] = {} - return state - @property def end(self) -> datetime: """datetime: The end of the period (of a fixed start, see `end_of`).""" @@ -299,8 +287,9 @@ def _namespace(self, seed: Any, start: datetime) -> str: def _cache(self, seed: Any, start: datetime) -> SatelliteCache: """ Gets the cache of the observations of the targets of a seed from a - start (see `cache_of`), with the seed and start in its namespace's - folder (`context.json`), from which `prune` finds it. + start (see `cache_of`), with the seed and start as the context of its + namespace (see `SatelliteCache.contexts`), from which `prune` finds + it. Its function generates the targets only if it computes a result. """ if (seed, start) not in self._caches: if len(self._caches) >= _MAX_TARGETS: @@ -308,17 +297,17 @@ def _cache(self, seed: Any, start: datetime) -> SatelliteCache: function = partial( _observe, self.analysis, - self.targets._of_seed(seed), # pylint: disable=protected-access + self.targets, + seed, start, start + self.duration, ) - cache = SatelliteCache( - function, self.directory, self._namespace(seed, start) + self._caches[seed, start] = SatelliteCache( + function, + directory=self.directory, + namespace=self._namespace(seed, start), + context=(seed, start), ) - if self.directory is not None: - context = json.dumps(_encode([seed, start])).encode() - _write(cache.folder.parent / "context.json", context) - self._caches[seed, start] = cache return self._caches[seed, start] def prune(self) -> int: @@ -332,14 +321,14 @@ def prune(self) -> int: Returns: int: the number of results removed (0 without a directory) """ - if self.directory is None or not Path(self.directory).is_dir(): + if self.directory is None: return 0 removed = 0 - for folder in Path(self.directory).iterdir(): - try: - seed, start = _decode(json.loads((folder / "context.json").read_text())) - namespace = (folder / "namespace.txt").read_text(encoding="utf-8") - except (OSError, ValueError, TypeError): + for namespace, context in SatelliteCache.contexts(self.directory).items(): + if not isinstance(context, (tuple, list)) or len(context) != 2: + continue # of other caches + seed, start = context + if not isinstance(start, datetime): continue if namespace != self._namespace(seed, start): continue # of other observations @@ -378,11 +367,8 @@ def _uncertain_values(design: Design) -> tuple: Gets the values of the uncertain parameters of a realized design, by path (see `DesignSpace.uncertain_paths`), as a key. """ - paths = set(design.space.uncertain_paths()) return tuple( - (path, _hashable(value)) - for path, value in design.flat().items() - if _generic(path) in paths + (path, _hashable(value)) for path, value in design.uncertain_values().items() ) @@ -414,13 +400,19 @@ def __call__(self, satellites: Sequence[Satellite], design: Design) -> dict: layout = value_of(design, self.layout) if layout is not None: record["planes"] = count_planes(layout) - mission = None - if self.plan is not None: - mission = self.mission_of(satellites, observations, design) - record.update(mission.metrics()) - record.update(_given_design(self.metrics, design)(observations)) - if mission is not None: - record.update(mission.summarize(self.phases)) + if self.plan is None: + record.update(given_design(self.metrics, design)(observations)) + return record + mission = self.mission_from(satellites, observations, design) + record.update(mission.metrics()) + if "satellite" in observations.columns: + # those of every satellite by the capability, whose cache the + # phases of the mission (such as its last) share + capability = mission.capability + record.update(capability(capability.names)) + else: + record.update(given_design(self.metrics, design)(observations)) + record.update(mission.summarize(self.phases)) return record def context_of(self, design: Design) -> tuple: @@ -433,20 +425,20 @@ def context_of(self, design: Design) -> tuple: random numbers). """ context = self.observations.context_of(design) - if _takes_design(self.metrics): + if takes_design(self.metrics): context = (context, design.scenario, _uncertain_values(design)) return context - def mission_of( + def mission_from( self, satellites: Sequence[Satellite], observations: pd.DataFrame, design: Design, ) -> Mission: """ - Plans the mission of a realized design (see `MissionPlan.mission_of`), - with the capability of its satellites (and the cache of the metrics - of their phases). + Plans the mission of a realized design from its satellites and their + observations (see `MissionPlan.plan_mission`), with the capability of + its satellites (and the cache of the metrics of their phases). """ capability = Capability( satellites, @@ -455,7 +447,7 @@ def mission_of( context=self.context_of(design), design=design, ) - return self.plan.mission_of( + return self.plan.plan_mission( design, value_of(design, self.layout), capability, self.failures ) @@ -486,8 +478,9 @@ class ObservationStudy(Study): * the metrics of the observations of every satellite (by their names). * with a plan: `deployed`, the years from the start of development to the last launch of the first generation of the satellites in the history - of the mission without failures (see `Mission.planned`), including the - stages that their rules deploy then (see `Stage`); with stages, `stages + of the mission without failures (see `Deployment.planned`), including + the stages that their rules deploy then (see `Stage`), infinite if the + deployment does not finish within the mission; with stages, `stages deployed`, the number of stages that their rules deploy then (with failures, the mean over the histories); and, with a cost model, the costs of the deployment (`cost`, `cost development`, and so on, see @@ -505,8 +498,8 @@ class ObservationStudy(Study): costs, and of the times of each history that meets the requirements of the `phases` of the failures (` time`); and the `quantiles` of columns over the histories (` histories p`) and the - shares of the histories that meet `requirements` (`P()`), - see `summarize_histories`. + shares of the histories that meet `requirements` (`P() + histories`), see `summarize_histories`. Statistics over the replicates of these columns (see `Criteria`) judge designs: such as the mean over the replicates of `accurate mission`, or a @@ -690,10 +683,11 @@ def mission_of( ) -> Mission: """ Gets the mission of a replicate of a design, as its evaluation plans - it (see `MissionPlan.mission_of`), for analyses other than its + it (see `MissionPlan.plan_mission`), for analyses other than its metrics: its planned deployment (`Mission.deployment`, with the plan's schedule, type, policy and spares, masses, and stages, and the - capability of its satellites, which the rules of stages read), the + capability of its satellites, which the rules of stages read, whose + history without failures `Deployment.planned` gives), the metrics of its phases (`Mission.phases`, which a study with `phases` summarizes), its cost estimate (`Mission.estimate`, the costs of a study without failures), and the histories of its failures @@ -717,7 +711,7 @@ def mission_of( realized = self.realize(design, replicate, scenario) satellites = list(self.build(realized)) observations = self.observations(satellites, realized) - return self.evaluate.mission_of(satellites, observations, realized) + return self.evaluate.mission_from(satellites, observations, realized) def prune(self) -> int: """ diff --git a/src/tatc/tradespace/optimization.py b/src/tatc/tradespace/optimization.py index caeaf486..4d7699e1 100644 --- a/src/tatc/tradespace/optimization.py +++ b/src/tatc/tradespace/optimization.py @@ -39,17 +39,19 @@ from __future__ import annotations -from collections.abc import Mapping +import copy +from collections.abc import Mapping, Sequence from dataclasses import dataclass, field from typing import Any import numpy as np import pandas as pd -from .criteria import Criteria, _as_criteria, _signs +from .criteria import Criteria, Requirement from .space import Design, Infeasible from .study import Study from .summary import aggregate +from .tables import FEASIBLE, check_records, efficient_keys @dataclass @@ -71,11 +73,12 @@ class Search: criteria: Criteria """Criteria: The criteria of the search.""" summary: pd.DataFrame = field(default_factory=pd.DataFrame) - """pandas.DataFrame: A row per design that the search found feasible (in - any replicate, judged by its feasible replicates, see `aggregate`): the - summary of the criteria over its replicates, with whether it is - efficient among these designs (`pareto`, with the tolerances of the - criteria).""" + """pandas.DataFrame: A row per design that the search found feasible + (with a feasible replicate, in every scenario with criteria `across` + scenarios, as designs are judged by their feasible replicates, see + `aggregate`): the summary of the criteria over its replicates, with + whether it is efficient among these designs (`pareto`, with the + tolerances of the criteria).""" designs: list[Design] = field(default_factory=list) """list[Design]: The efficient designs that the search found (`pareto` of `summary`), for the next step.""" @@ -101,7 +104,7 @@ class Evaluations: """ def __init__(self, study: Study, criteria: Criteria | Mapping[str, str]): - self.study, self.criteria = study, _as_criteria(criteria) + self.study, self.criteria = study, Criteria.of(criteria) if self.criteria.by: raise ValueError( "searches need one record per evaluation: give criteria without `by`" @@ -166,21 +169,22 @@ def _run(self, designs: list[Design]) -> None: self._records.append(records) across = self.criteria.across keys = ["design", "replicate", *([] if across is None else [across.column])] - if records.groupby(keys).size().max() > 1: - if across is None and "scenario" in records.columns: - raise ValueError( - "a study with several scenarios gives a record per scenario: " - + "give criteria `across` the scenarios (see Across), or " - + "search a study with one scenario" - ) - raise ValueError( - "objectives need one record per evaluation: make the " - + "study's evaluate function return a mapping of metrics" + if across is None and "scenario" in records.columns: + hint = ( + "a study with several scenarios gives a record in each: give " + + "criteria `across` the scenarios (see Across), or search a study " + + "with one scenario" + ) + else: + hint = ( + "searches need one record per evaluation: make the study's evaluate " + + "function return a mapping of metrics" ) - self._checked = self._checked or bool(records["feasible"].any()) + check_records(records, keys, hint, self.criteria.metrics) + self._checked = self._checked or bool(records[FEASIBLE].any()) summary = aggregate(records, self.criteria, design_columns=[]) summary = summary.set_index("design") - shares = records.groupby("design")["feasible"].mean() + shares = records.groupby("design")[FEASIBLE].mean() for design in designs: key = design.key if key not in summary.index: @@ -209,12 +213,11 @@ def search(self, state: Any) -> Search: """ results = self.results summary = aggregate(results, self.criteria) - efficient = pd.unique(summary.loc[summary["pareto"].astype(bool), "design"]) return Search( results=results, criteria=self.criteria, summary=summary, - designs=[self.designs[key] for key in efficient], + designs=[self.designs[key] for key in efficient_keys(summary)], evaluated=list(self.designs.values()), state=state, ) @@ -273,11 +276,12 @@ def optimize_optuna( design prunes its trial. Each requirement of the criteria is a constraint of the trials (named by - its statement, `str(requirement)`, such as `"sufficient p10 >= 80"`), - whose value is its violation (see `Requirement.violation`), and which - requires `constraints`. A requirement on `feasible` (the share of a - design's replicates that are feasible) constrains the designs that are - infeasible in some of their replicates. + its statement, `str(requirement)`, such as `"sufficient p10 >= 80"`, or, + if requirements state themselves alike, by their values in full and + their order), whose value is its violation (see `Requirement.violation`), + and which requires `constraints`. A requirement on `feasible` (the share + of a design's replicates that are feasible) constrains the designs that + are infeasible in some of their replicates. Trials are asked in batches, whose designs are evaluated together (in parallel, if the study is) before they are told. A batch defaults to one @@ -344,7 +348,7 @@ def optimize_optuna( constrained = constraints and hasattr(optuna.trial.Trial, "set_constraint") if requirements and not constrained: raise ValueError("requirements need constraints (and Optuna 5 or later)") - names = [str(requirement) for requirement in requirements] + names = _constraint_names(requirements) def set_constraints(trial: Any, feasibility: float, violations) -> None: trial.set_constraint("feasibility", feasibility) @@ -393,6 +397,24 @@ def infeasible(trial: Any, violation: float) -> None: return evaluations.search(optuna_study) +def _constraint_names(requirements: Sequence[Requirement]) -> list[str]: + """ + Gets distinct names of the constraints of requirements (other than + `"feasibility"`): their statements (see `Requirement`), with their values + in full where statements are alike, and their order where these are too + (such as of requirements that differ only in their scales). + """ + names = [str(requirement) for requirement in requirements] + names = [ + (f"{r.name} {r.operator} {r.value!r}" if names.count(name) > 1 else name) + for r, name in zip(requirements, names) + ] + return [ + name if names[:i].count(name) == 0 else f"{name} ({names[:i].count(name) + 1})" + for i, name in enumerate(names) + ] + + def make_pymoo_problem(study: Study, criteria: Criteria | Mapping[str, str]) -> Any: """ Makes a pymoo problem of a study's design space: its variables are the @@ -439,7 +461,7 @@ def make_pymoo_problem(study: Study, criteria: Criteria | Mapping[str, str]) -> evaluations = Evaluations(study, criteria) n_requirements = len(evaluations.criteria.requirements) - signs = _signs(evaluations.criteria) + signs = evaluations.criteria.signs n_var = len(study.space.unit_paths()) def key_of(individual: Any) -> str | None: @@ -585,7 +607,8 @@ def optimize_pymoo( proposed or evaluated before (its initialization and mating, see `make_pymoo_problem`'s `duplicates`), unless `distinct` is `False`, so that each generation proposes as many new designs as it can: as many - generations then evaluate more designs, and find more of the front. + generations then evaluate more designs, and find more of the front. The + algorithm given is not changed: a distinct search changes a copy. The generations of a search (of the `termination`) are a poor measure of its cost if they propose designs evaluated before (without `distinct`), @@ -636,6 +659,8 @@ def optimize_pymoo( algorithm = NSGA2(pop_size=20) problem = make_pymoo_problem(study, criteria) if distinct: + # a copy, so that the caller's algorithm keeps its own elimination + algorithm = copy.deepcopy(algorithm) _eliminate_duplicates(algorithm, problem.duplicates) if max_designs is not None: termination = _designs_termination( diff --git a/src/tatc/tradespace/pareto.py b/src/tatc/tradespace/pareto.py index 94208762..3846e3d7 100644 --- a/src/tatc/tradespace/pareto.py +++ b/src/tatc/tradespace/pareto.py @@ -24,45 +24,36 @@ import numpy as np import pandas as pd -from .criteria import ( - Criteria, - Requirement, - _as_criteria, - _costs_of, - _get_tolerances, - _signs, - _violation_of, -) -from .dominance import _dominated, _efficient -from .summary import _check_summary, _groups, aggregate +from .criteria import Criteria +from .dominance import dominated, efficient +from .summary import aggregate +from .tables import check_summary, groups def _get_costs(frame: pd.DataFrame, criteria: Criteria) -> np.ndarray: """ Gets the objectives of criteria of a data frame (of their columns) as - costs (to minimize, see `_costs_of`). + costs (to minimize, see `Criteria.costs`). """ missing = [column for column in criteria.objectives if column not in frame] if missing: raise ValueError(f"no columns of the objectives {missing}") - return _costs_of(frame, criteria) + return criteria.costs(frame) -def _get_violation( - frame: pd.DataFrame, requirements: Sequence[Requirement] -) -> np.ndarray: +def _get_violation(frame: pd.DataFrame, criteria: Criteria) -> np.ndarray: """ - Gets the total violation of requirements by the rows of a data frame, - from the columns of their statistics (infinite where a statistic is - missing). + Gets the total violation of the requirements of criteria by the rows of a + data frame, from the columns of their statistics (infinite where a + statistic is missing). """ - missing = [r.name for r in requirements if r.name not in frame.columns] + missing = [r.name for r in criteria.requirements if r.name not in frame.columns] if missing: raise ValueError( f"no columns of the statistics {missing} of requirements: aggregate " + "the results with the criteria (see aggregate)" ) - violation = _violation_of(frame, requirements, len(frame)) + violation = criteria.violation(frame, len(frame)) return np.where(np.isnan(violation), np.inf, violation) @@ -103,16 +94,15 @@ def pareto_front( ValueError: if the summary has several rows of a design (in a group of the criteria's `by`), as the results of a study do. """ - criteria = _as_criteria(criteria) - _check_summary(summary, criteria.by) - tolerances = _get_tolerances(criteria.objectives, criteria.tolerances) - efficient = np.zeros(len(summary), dtype=bool) - for _, positions in _groups(summary, criteria.by): + criteria = Criteria.of(criteria) + check_summary(summary, criteria.by) + front = np.zeros(len(summary), dtype=bool) + for _, positions in groups(summary, criteria.by): group = summary.iloc[positions] - meets = _get_violation(group, criteria.requirements) == 0 + meets = _get_violation(group, criteria) == 0 costs = _get_costs(group, criteria) - efficient[positions] = _efficient(costs, meets, tolerances) - return pd.Series(efficient, index=summary.index, name="pareto") + front[positions] = efficient(costs, meets, criteria.tolerance_array) + return pd.Series(front, index=summary.index, name="pareto") def pareto_ranks( @@ -140,20 +130,20 @@ def pareto_ranks( ValueError: if the summary has several rows of a design (in a group of the criteria's `by`), as the results of a study do. """ - criteria = _as_criteria(criteria) - _check_summary(summary, criteria.by) - tolerances = _get_tolerances(criteria.objectives, criteria.tolerances) + criteria = Criteria.of(criteria) + check_summary(summary, criteria.by) + tolerances = criteria.tolerance_array ranks = np.full(len(summary), -1, dtype=int) - for _, positions in _groups(summary, criteria.by): + for _, positions in groups(summary, criteria.by): group = summary.iloc[positions] - violation = _get_violation(group, criteria.requirements) + violation = _get_violation(group, criteria) costs = _get_costs(group, criteria) known = ~np.isnan(costs).any(axis=1) meets = (violation == 0) & known remaining, costs = positions[meets], costs[meets] rank = 0 while len(remaining) > 0: - front = ~_dominated(costs, tolerances) + front = ~dominated(costs, tolerances) ranks[remaining[front]] = rank remaining, costs = remaining[~front], costs[~front] rank += 1 @@ -177,7 +167,7 @@ def _hypervolume(points: np.ndarray, reference: np.ndarray) -> float: return 0.0 if points.shape[1] == 1: return float(reference[0] - points[:, 0].min()) - points = points[~_dominated(points)] + points = points[~dominated(points)] order = np.argsort(points[:, -1], kind="stable") points = points[order] if points.shape[1] == 2: @@ -229,21 +219,21 @@ def hypervolume( results of a study do (see `hypervolume_progress` for those of a search). """ - criteria = _as_criteria(criteria) + criteria = Criteria.of(criteria) if criteria.by: raise ValueError( "a hypervolume is of the rows of one group: give criteria without `by`" ) - _check_summary(summary) + check_summary(summary) objectives = criteria.objectives if isinstance(reference, Mapping): reference = [reference[column] for column in objectives] if len(reference) != len(objectives): raise ValueError("the reference point needs a value for each objective") - bound = _signs(criteria) * np.asarray(reference, dtype=float) + bound = criteria.signs * np.asarray(reference, dtype=float) if len(summary) == 0: return 0.0 - summary = summary[_get_violation(summary, criteria.requirements) == 0] + summary = summary[_get_violation(summary, criteria) == 0] costs = _get_costs(summary, criteria) costs = costs[np.all(costs < bound, axis=1)] return _hypervolume(costs, bound) @@ -277,7 +267,7 @@ def hypervolume_progress( """ if step < 1: raise ValueError("step must be at least 1") - criteria = _as_criteria(criteria) + criteria = Criteria.of(criteria) summary = aggregate(results, criteria).set_index("design") order = results["design"].drop_duplicates().tolist() counts = list(range(step, len(order) + 1, step)) diff --git a/src/tatc/tradespace/plans.py b/src/tatc/tradespace/plans.py index 3cfb5bd5..66e447d6 100644 --- a/src/tatc/tradespace/plans.py +++ b/src/tatc/tradespace/plans.py @@ -2,15 +2,12 @@ The missions of the designs of an observation study (see `ObservationStudy`): the plan of each design's mission (`MissionPlan`: its deployment, the policy that restores the failures of its satellites, and its costs, from the -values of the design), the failures of its satellites (`Failures`), and the -mission of a replicate of a design (`Mission`), which an evaluation plans -and summarizes into its record, and which `ObservationStudy.mission_of` -gives for other analyses. +values of the design), and the failures of its satellites (`Failures`), +from which an evaluation plans the mission of a replicate of a design (see +`Mission`) and summarizes it into its record. -The parts refer to the values of designs by a `Reference` (see `value_of`), -such as the type of the satellites of a design:: - - MissionPlan(SCHEDULE, COST_MODEL, kind="field_of_regard") # d.field_of_regard +The parts refer to the values of designs as `tatc.tradespace.references` +describes. @author: Paul T. Grogan """ @@ -19,28 +16,22 @@ import dataclasses from collections.abc import Callable, Mapping, Sequence -from functools import cached_property from typing import Any import numpy as np import pandas as pd -from .cost import CostEstimate, CostModel +from .cost import CostModel from .criteria import Requirement -from .deployment import Deployment, DeploymentSchedule, Stage +from .deployment import DeploymentSchedule, Stage +from .expectations import ExactExpectationsError, exact_expectations from .failures import FailureModel, RestorationPolicy -from .histories import ( - MAX_SETS, - SAMPLINGS, - _exact_sets, - evaluate_histories, - exact_expectations, - summarize_histories, -) -from .mission import Capability, MissionHistory, summarize_phases -from .references import Reference, _number, value_of +from .histories import evaluate_histories, summarize_histories +from .mission import Capability, Mission, MissionHistory +from .references import Reference, _number, configure, value_of +from .simulation import SAMPLINGS from .space import Design -from .values import ChoiceValues, configure +from .values import ChoiceValues @dataclasses.dataclass(frozen=True) @@ -63,10 +54,11 @@ def schedule(d): PLAN = MissionPlan(schedule, COST_MODEL, kind="payload") - The policy of a design gives its spares: in orbit in each plane - (`RestorationPolicy.orbit_spares`, which its deployment plans) and on - the ground, which are produced (and cost) whether or not the study has - failures (see `Failures`). A policy may be a decision of each design, + The deployment of each design is planned with its policy (see + `DeploymentSchedule.plan`), which gives its spares: in orbit in each + plane (`RestorationPolicy.orbit_spares`) and on the ground, which are + produced (and cost) whether or not the study has failures (see + `Failures`). A policy may be a decision of each design, such as a group of `policy_space` whose values configure the default policy (see `configure`), or a function of the design that gives its policy (such as one that configures a base policy):: @@ -246,7 +238,7 @@ def growth_of(self, design: Design) -> Any: growth[element] = _number(design, value) return growth - def mission_of( + def plan_mission( self, design: Design, layout: Any, @@ -254,10 +246,9 @@ def mission_of( failures: Failures | None = None, ) -> Mission: """ - Plans the mission of a realized design: its deployment (with the - spares in orbit of its policy, and whose stages read the capability - of the satellites operating at their decisions), its policy, and its - costs. + Plans the mission of a realized design: its deployment (with its + policy and spares, and whose stages read the capability of the + satellites operating at their decisions) and its costs. Args: design (Design): The (realized) design. @@ -274,19 +265,13 @@ def mission_of( deployment = self.schedule_of(design).plan( layout, kind=value_of(design, self.kind), - orbit_spares=policy.orbit_spares, + policy=policy, masses=self.masses_of(design, cost_model), stages=self.stages_of(design), ) deployment.capability = capability return Mission( - design, - deployment, - policy, - cost_model, - self.growth_of(design), - capability, - failures, + design, deployment, cost_model, self.growth_of(design), capability, failures ) @@ -294,9 +279,10 @@ def mission_of( class Failures: """ The failures of the satellites of each design: histories of its mission - (see `Deployment.simulate_many`), restored by the policy of the design - (see `MissionPlan.policy`: by default by producing new satellites; with - `RestorationPolicy(restore=False)`, not restored), summarized over the + (see `Deployment.simulate_many`), restored by the policy of its + deployment (see `MissionPlan.policy`: by default by producing new + satellites; with `RestorationPolicy(restore=False)`, not restored), + summarized over the histories (see `summarize_histories`): the mean of each metric over the phases of the mission and the histories, `quantiles` and `requirements` of them, and their costs. With requirements on the metrics of the @@ -308,12 +294,12 @@ class Failures: Without restoration, the means of the metrics and the availability are the exact expectations over the failures (see `exact_expectations`) if - `exact`, if the histories have failures (with a `seed`), if the - deployment is not staged (see `Stage`, whose rules make its launches - depend on the history), and if it has at most `MAX_SETS` (200,000) sets - of satellites to enumerate, which is known before they are enumerated; - otherwise (such as for constellations of about 20 satellites or more) - they are the means of the histories. + `exact`, if the histories have failures (with a `seed`), and if + exact expectations apply: if the deployment is not staged (see `Stage`, + whose rules make its launches depend on the history) and has at most + `MAX_SETS` (200,000) sets of satellites to enumerate, which is known + before they are enumerated; otherwise (such as for constellations of + about 20 satellites or more) they are the means of the histories. With a `stress`, the failures are drawn from stressed distributions for importance sampling (see `Deployment.simulate_many`), each history @@ -410,7 +396,7 @@ def seed_of(self, design: Design) -> Any: def simulate(self, mission: Mission) -> list[MissionHistory]: """ Simulates the histories of a mission (see `Deployment.simulate_many`), - restored by its policy. + restored by the policy of its deployment. Args: mission (Mission): The mission. @@ -420,7 +406,6 @@ def simulate(self, mission: Mission) -> list[MissionHistory]: """ return mission.deployment.simulate_many( self.model, - mission.policy, self.seed_of(mission.design), histories=self.histories, sampling=self.sampling, @@ -469,7 +454,6 @@ def summarize(self, mission: Mission) -> dict[str, float]: other = int(np.random.default_rng([int(seed), 7]).integers(2**31)) expected = mission.deployment.expected_metrics( self.model, - mission.policy, other, histories=self.control_histories, sampling=self.sampling, @@ -488,10 +472,13 @@ def summarize(self, mission: Mission) -> dict[str, float]: controls=controls, spread=self.spread, ) - if self._exact(mission, seed): - exact = exact_expectations( - mission.deployment, self.model, mission.capability - ) + if self.exact and seed is not None: + try: + exact = exact_expectations( + mission.deployment, self.model, mission.capability + ) + except ExactExpectationsError: + exact = {} # the means of the histories instead record.update( { key: value @@ -500,156 +487,3 @@ def summarize(self, mission: Mission) -> dict[str, float]: } ) return record - - def _exact(self, mission: Mission, seed: Any) -> bool: - """ - Whether the means of the histories of a mission are exact - expectations (see `Failures`): of failures with a seed, without - restoration, of a deployment that is not staged and whose sets of - satellites are few enough. - """ - return ( - self.exact - and seed is not None - and not mission.policy.restore - and not mission.deployment.stages - and _exact_sets(mission.deployment, self.model) <= MAX_SETS - ) - - -@dataclasses.dataclass(frozen=True, eq=False) -class Mission: - """ - The mission of a replicate of a design, as the evaluation of an - observation study plans it (see `MissionPlan.mission_of` and - `ObservationStudy.mission_of`): its planned deployment, the policy that - restores the failures of its satellites, its cost model and growth, and - the capability of its satellites (their observations, and the cache of - the metrics of their phases), from which follow the history of the - mission without failures (`planned`), the metrics of its phases - (`phases`), its cost estimate (`estimate`), and the histories of its - failures (`histories`, with `failures`). - """ - - design: Design - """Design: The realized design.""" - deployment: Deployment - """Deployment: The planned deployment, with the capability of its - satellites (which the rules of its stages read, see - `Deployment.capability`).""" - policy: RestorationPolicy - """RestorationPolicy: The policy for failed satellites, and the spares.""" - cost_model: CostModel | None - """CostModel | None: The cost model (with the growth of its components - drawn), if any.""" - growth: Any - """Any: The growth of the costs (see `CostModel.estimate`).""" - capability: Capability - """Capability: The capability of the satellites.""" - failures: Failures | None = None - """Failures | None: The failures of the satellites, if any.""" - - @cached_property - def _planned(self) -> MissionHistory: - """The history of the mission without failures (simulated once).""" - return self.deployment.simulate(policy=self.policy) - - def planned(self) -> MissionHistory: - """ - Gets the history of the mission without failures (see - `Deployment.simulate`): its deployment, with the stages that their - rules deploy and the spares on the ground of its policy. - - Returns: - MissionHistory: the history - """ - return self._planned - - def phases(self) -> pd.DataFrame: - """ - Gets the metrics of the phases of the mission without failures (see - `planned` and `evaluate_phases`), which the evaluation of a study - with `phases` summarizes (see `summarize_phases`). - - Returns: - pandas.DataFrame: a row per phase: its `start`, `end`, - `duration`, number of `satellites`, and metrics - """ - satellites = self.capability.satellites - return self.capability.evaluate(self.planned().phases(satellites)) - - def estimate(self) -> CostEstimate: - """ - Gets the cost estimate of the mission without failures (see `planned` - and `CostModel.estimate`), with its growth: the costs of the - evaluation of a study without failures (those of a study with - failures are the means of those of its histories, see `histories`). - - Returns: - CostEstimate: the estimate - - Raises: - ValueError: if the plan has no cost model. - """ - if self.cost_model is None: - raise ValueError("the mission plan has no cost model") - return self.cost_model.estimate(self.planned(), self.growth) - - def histories(self) -> pd.DataFrame: - """ - Gets the histories of the failures of the mission, which the - evaluation of a study with failures summarizes (see - `Failures.evaluate` and `evaluate_histories`): a row per history, - with the mean of each metric over its phases, the measures of its - mission, and its costs. - - Returns: - pandas.DataFrame: a row per history - - Raises: - ValueError: if the mission has no failures. - """ - if self.failures is None: - raise ValueError("the study has no failures") - return self.failures.evaluate(self) - - def metrics(self) -> dict[str, float]: - """ - Gets the metrics of the planned mission that its evaluation records: - `deployed` (see `MissionHistory.deployed`, of the history without - failures), `stages deployed` (of a staged deployment, the stages that - its rules deploy without failures), and, without failures, its costs - (see `estimate` and `CostEstimate.metrics`). - - Returns: - dict[str, float]: the metrics - """ - planned = self.planned() - record = {"deployed": planned.deployed} - if self.deployment.stages: - record["stages deployed"] = planned.metrics()["stages deployed"] - if self.cost_model is not None and self.failures is None: - record.update(self.estimate().metrics()) - return record - - def summarize( - self, phases: Sequence[Requirement] | None = None - ) -> dict[str, float]: - """ - Summarizes the mission as metrics of its evaluation: the histories of - its failures (see `Failures.summarize`), or else, with requirements - on its phases (or none, `()`), the phases of the mission without - failures (see `phases` and `summarize_phases`). - - Args: - phases (Sequence[Requirement] | None): The requirements on the - phases, or `None` not to summarize them. - - Returns: - dict[str, float]: the summary (empty without failures or phases) - """ - if self.failures is not None: - return self.failures.summarize(self) - if phases is not None: - return summarize_phases(self.phases(), requirements=phases) - return {} diff --git a/src/tatc/tradespace/plotting.py b/src/tatc/tradespace/plotting.py index c7a94d2e..311195e3 100644 --- a/src/tatc/tradespace/plotting.py +++ b/src/tatc/tradespace/plotting.py @@ -24,6 +24,7 @@ from .criteria import Criteria from .pareto import pareto_front +from .tables import feasible_records COLORS = ( "#2a78d6", @@ -150,7 +151,7 @@ def _name(names: Mapping[Any, str] | Callable[[Any], str] | None, value: Any) -> return names.get(value, str(value)) -def _groups(values: pd.Series) -> list: +def _distinct(values: pd.Series) -> list: """Gets the distinct values (of a column), sorted if they can be.""" distinct = list(pd.unique(values.dropna())) try: @@ -262,7 +263,7 @@ def plot_designs( ) else: groups = _values_of(frame, by, "by") - for k, value in enumerate(_groups(groups)): + for k, value in enumerate(_distinct(groups)): selected = (groups == value).to_numpy() & shown ax.scatter( xs[selected], @@ -404,12 +405,13 @@ def plot_means( matplotlib.axes.Axes: the axes """ ax = _axes(ax, (6.5, 4.2)) - if "feasible" in results.columns: - results = results[results["feasible"].astype(bool)] + results = feasible_records(results)[0] groups = ( [(None, results)] if by is None - else [(value, results[results[by] == value]) for value in _groups(results[by])] + else [ + (value, results[results[by] == value]) for value in _distinct(results[by]) + ] ) missing = None if by is None else results[results[by].isna()] if missing is not None and len(missing) > 0: diff --git a/src/tatc/tradespace/references.py b/src/tatc/tradespace/references.py index 0a39d2c9..04a649c4 100644 --- a/src/tatc/tradespace/references.py +++ b/src/tatc/tradespace/references.py @@ -1,26 +1,46 @@ """ -References to the values of designs, by which the parts of observation -studies (see `ObservationStudy`, `Observations`, `MissionPlan`, and -`Failures`) read them: a name (such as `"points_seed"` for `d.points_seed`, -or a path of `Design.flat`, such as `"layout.walker.planes"`), or a function -of the (realized) design (such as `lambda d: d.layout`). A string given -where a reference is expected is always a reference, never a value itself: -give a function that returns a string (or a number, where numbers are -references) to give a value:: +Reading designs: references to their values, the dataclasses configured +from them, and the functions given them. + +A reference names a value of a design, by which the parts of studies (such +as `ObservationStudy`, `Observations`, `Targets`, `MissionPlan`, and +`Failures`) read the designs they are given (see `value_of`). It is either +a string, which names a value by its name (such as `"points_seed"` for +`d.points_seed`) or path (as the columns of the results of a study name +values, see `Design.flat`, such as `"layout.walker.planes"`, or of a group +of values, such as `"cost_risk"`), or a function of the (realized) design +that computes the value (such as `lambda d: d.layout`). A string given where +a reference is expected is always a reference, never a value itself: give a +function that returns a string to give a string. Where a number is also +expected (such as a growth of costs), a number is the value itself, and +other values are references:: MissionPlan(SCHEDULE, COST_MODEL, kind="field_of_regard") # d.field_of_regard MissionPlan(SCHEDULE, COST_MODEL, kind=lambda d: "imager") # always "imager" +A dataclass, such as a `RestorationPolicy` or a `DeploymentSchedule`, is +configured from the values of a design by `configure`. + +A function of a study's results (such as the evaluation function of a +`Study`, or the metrics of an `ObservationStudy`) that takes a keyword named +`design` is given the realized design as it (see `takes_design` and +`given_design`), as for a function that depends on values of the design +other than those it is given. + @author: Paul T. Grogan """ from __future__ import annotations +import dataclasses +import inspect import numbers -from collections.abc import Callable +from collections.abc import Callable, Mapping +from functools import partial from typing import Any from .space import Design +from .values import ChoiceValues, Values Reference = str | Callable[[Design], Any] """A reference to a value of a design: its name or path (see `Design.flat`), @@ -29,11 +49,12 @@ def value_of(design: Design, reference: Reference | None) -> Any: """ - Gets a value of a design that a reference names: a string names a value - by its name or path (`design[reference]`, see `Values`: such as - `"layout.walker.planes"`, the path of a column of results, see - `Design.flat`, or of a group of values, such as `"cost_risk"`), a - function computes it from the design, and `None` is `None`. + Gets a value of a design that a reference names (see the module): a + string names a value by its name or path (`design[reference]`, see + `Values`: such as `"layout.walker.planes"`, the path of a column of + results, see `Design.flat`, or of a group of values, such as + `"cost_risk"`), a function computes it from the design, and `None` is + `None`. Args: design (Design): The (realized) design. @@ -45,6 +66,7 @@ def value_of(design: Design, reference: Reference | None) -> Any: Raises: KeyError: if the design has no value of a name or path. + TypeError: if the reference is neither a string nor a function. """ if reference is None: return None @@ -60,3 +82,91 @@ def _number(design: Design, value: Any) -> Any: if isinstance(value, numbers.Real): return value return value_of(design, value) + + +def configure(base: Any, values: Any = None, **overrides: Any) -> Any: + """ + Configures a dataclass (such as a `RestorationPolicy` or a + `DeploymentSchedule`) from the values of a design: the fields of `base` + that the values name (such as those of `policy_space`, or design + variables named after fields) are replaced by them, as are those given + as keyword arguments. Values that name no field are ignored:: + + policy = configure(RestorationPolicy(), design.policy) + schedule = configure(SCHEDULE, design, years=6) + + Args: + base (Any): The dataclass instance, whose other fields are kept. + values (Any): The values of a design: a `Design`, the `Values` of + a group, a mapping, or the `ChoiceValues` of a choice (whose + branch is a group, or a fixed `None`), or `None`. + **overrides (Any): Other values of fields. + + Returns: + Any: a copy of `base` with the values of its fields + + Raises: + TypeError: if `base` is not a dataclass instance, or `values` are + not values of a design (or a choice's branch is not a group). + ValueError: if an override names no field of `base`. + """ + if not dataclasses.is_dataclass(base) or isinstance(base, type): + raise TypeError("configure requires a dataclass instance") + if isinstance(values, ChoiceValues): + branch = values.value + if branch is not None and not isinstance(branch, Values): + raise TypeError( + "configure requires the values of a group: the choice chose " + + f"{values.choice!r}, whose value is {branch!r}" + ) + values = branch + elif isinstance(values, Design): + values = values.values + elif values is not None and not isinstance(values, Mapping): + raise TypeError(f"configure requires the values of a design, not {values!r}") + names = {field.name for field in dataclasses.fields(base)} + changes = {name: values[name] for name in (values or {}) if name in names} + unknown = set(overrides) - names + if unknown: + raise ValueError(f"no fields named {sorted(unknown)}") + return dataclasses.replace(base, **changes, **overrides) + + +def takes_design(function: Callable[..., Any]) -> bool: + """ + Whether a function takes a keyword named `design`, by which the parts of + studies give it the realized design (see `given_design`). + + Args: + function (Callable): The function. + + Returns: + bool: `True` if the function has a parameter named `design` that + may be given by keyword + """ + try: + parameter = inspect.signature(function).parameters.get("design") + except (TypeError, ValueError): # such as of some built-in functions + return False + return parameter is not None and parameter.kind in ( + inspect.Parameter.POSITIONAL_OR_KEYWORD, + inspect.Parameter.KEYWORD_ONLY, + ) + + +def given_design(function: Callable[..., Any], design: Design) -> Callable[..., Any]: + """ + Gets a function of its other arguments: the function given the design + as its keyword `design`, if it takes one (see `takes_design`), or the + function itself:: + + outcome = given_design(evaluate, realized)(built) + + Args: + function (Callable): The function. + design (Design): The (realized) design. + + Returns: + Callable: the function of its other arguments + """ + return partial(function, design=design) if takes_design(function) else function diff --git a/src/tatc/tradespace/refinement.py b/src/tatc/tradespace/refinement.py index 032b9f79..541152f0 100644 --- a/src/tatc/tradespace/refinement.py +++ b/src/tatc/tradespace/refinement.py @@ -7,17 +7,18 @@ from __future__ import annotations -import warnings from collections.abc import Mapping, Sequence from dataclasses import dataclass, field import numpy as np import pandas as pd -from .criteria import Criteria, _as_criteria, _get_tolerances +from .alerts import _warn +from .criteria import Criteria from .space import Design, _designs from .study import Study from .summary import pareto_probability +from .tables import efficient_keys @dataclass @@ -50,11 +51,12 @@ class Refinement: objectives are known to within the precision of their tolerances).""" criteria: Criteria """Criteria: The criteria of the refinement.""" - history: pd.DataFrame = field(default_factory=pd.DataFrame) - """pandas.DataFrame: For each round (`round`, from 0), the number of + rounds: pd.DataFrame = field(default_factory=pd.DataFrame) + """pandas.DataFrame: A row per round (`round`, from 0): the number of designs whose efficiency is uncertain (`uncertain`), of these, those that are indifferent (`indifferent`), the number to which replicates were - added (`refined`), and the evaluations added (`evaluations`).""" + added (`refined`), and the evaluations added (`evaluations`, a design in + a replicate in each scenario of a study with scenarios).""" designs: list[Design] = field(default_factory=list) """list[Design]: The designs efficient after the last round (`pareto` of `summary`, in any group of the criteria's `by`), for the next step.""" @@ -64,11 +66,12 @@ class Refinement: @property def evaluations(self) -> int: - """int: The number of evaluations added (a design in a replicate, in - each scenario of a study with scenarios), over every round.""" - if "evaluations" not in self.history: + """int: The number of evaluations added over every round (a design in + a replicate in a scenario: a study with scenarios evaluates each + replicate in each scenario).""" + if "evaluations" not in self.rounds: return 0 - return int(self.history["evaluations"].sum()) + return int(self.rounds["evaluations"].sum()) @property def uncertain(self) -> pd.DataFrame: @@ -95,14 +98,18 @@ def _precise( of their tolerances: the standard error of each objective that varies between replicates is less than `precision` times its tolerance (at the design's value). Designs whose varying objectives lack a tolerance are - not precise. + not precise. An objective without a standard error (which + `pareto_probability` leaves out where it is zero for every design) does + not vary. """ precise = np.zeros(len(probability), dtype=bool) if precision is None or not criteria.tolerances: return precise - tolerances = _get_tolerances(criteria.objectives, criteria.tolerances) + tolerances = criteria.tolerance_array precise[:] = True for i, name in enumerate(criteria.objectives): + if f"{name} se" not in probability: + continue error = probability[f"{name} se"].to_numpy(dtype=float) value = np.abs(probability[name].to_numpy(dtype=float)) tolerance = tolerances[0, i] + tolerances[1, i] * value @@ -138,7 +145,9 @@ def refine( refined), when the `budget` of evaluations is spent, or after `max_rounds`. If a round would spend more than is left of the budget, the designs with the fewest replicates (below `min_replicates`) are refined - first, and then those whose probability is nearest 0.5. + first, and then those whose probability is nearest 0.5. A study with + scenarios evaluates each replicate in each scenario, which spends an + evaluation of the budget in each. A bootstrap of few replicates has few distinct resamples, and can find a design surely inefficient (or efficient) by the luck of its replicates: @@ -175,8 +184,9 @@ def refine( The refinement selects the designs efficient after its last round for the next step (`Refinement.designs`, such as of `confirm`), and keeps - those that could be refined (`Refinement.candidates`) and the number of - evaluations it added (`Refinement.evaluations`). + those that could be refined (`Refinement.candidates`), its rounds + (`Refinement.rounds`), and the number of evaluations it added + (`Refinement.evaluations`). Args: study (Study): The study that evaluates designs. @@ -205,16 +215,16 @@ def refine( indifferent, or `None` to refine uncertain designs until `max_replicates`. budget (int | None): The most evaluations to add (a design in a - replicate, which a study with scenarios evaluates in each), if - limited. + replicate in a scenario: a replicate of a study with scenarios + takes an evaluation in each), if limited. n_resamples (int): The number of resamples of each bootstrap. seed (int): The seed of the bootstraps. Returns: - Refinement: the results, the final probabilities, the history, the + Refinement: the results, the final probabilities, the rounds, the efficient designs, and the candidates """ - criteria = _as_criteria(criteria) + criteria = Criteria.of(criteria) low, high = bounds if not 0 <= low < high <= 1: raise ValueError("bounds must satisfy 0 <= low < high <= 1") @@ -229,7 +239,9 @@ def refine( raise ValueError("budget must not be negative") refined = _designs(study.space, results if designs is None else designs, results) by_key = {design.key: design for design in refined} - combined, history, spent = results, [], 0 + # the evaluations of a replicate of a design: one in each scenario + cost = len(study.scenarios or [None]) + combined, rounds, spent = results, [], 0 def estimate(round_: int) -> pd.DataFrame: probability = pareto_probability( @@ -258,6 +270,7 @@ def estimate(round_: int) -> pd.DataFrame: min_replicates=min_replicates, max_replicates=max_replicates, budget=None if budget is None else budget - spent, + cost=cost, ) record = { "round": round_, @@ -267,34 +280,30 @@ def estimate(round_: int) -> pd.DataFrame: "evaluations": 0, } if not added_to: - history.append(record) + rounds.append(record) break added = _evaluate_added(study, by_key, following, added_to) combined = pd.concat([combined, *added], ignore_index=True) - record["evaluations"] = sum( - new.groupby(["design", "replicate"]).ngroups for new in added - ) + record["evaluations"] = sum(_count_evaluations(new) for new in added) spent += record["evaluations"] - history.append(record) + rounds.append(record) else: probability = estimate(max_rounds) remaining = probability.loc[ probability["uncertain"] & ~probability["indifferent"], "design" ].nunique() if remaining > 0 and not criteria.tolerances: - warnings.warn( + _warn( f"{remaining} designs remain uncertain: designs that differ by less " + "than replicates separate stay uncertain without a tolerance of " - + "the objectives (see Criteria)", - stacklevel=2, + + "the objectives (see Criteria)" ) - efficient = probability.loc[probability["pareto"].astype(bool), "design"] - selected = [by_key.get(key, key) for key in pd.unique(efficient)] + selected = [by_key.get(key, key) for key in efficient_keys(probability)] return Refinement( results=combined, summary=probability, criteria=criteria, - history=pd.DataFrame(history), + rounds=pd.DataFrame(rounds), designs=_designs(study.space, selected, combined), candidates=refined, ) @@ -326,12 +335,14 @@ def _allocate( min_replicates: int, max_replicates: int | None, budget: int | None, + cost: int = 1, ) -> dict[str, int]: """ Gets the replicates to add to designs whose efficiency more replicates would settle (by key), for a round of `refine`: `step` each (up to `max_replicates`), the fewest replicates and the least settled first - (nearest a probability of 0.5), within a budget (if any). + (nearest a probability of 0.5), within a budget of evaluations (if any), + of which each replicate spends `cost` (one in each scenario). """ grouped = probability.groupby("design") distance = (probability["pareto_probability"] - 0.5).abs() @@ -356,17 +367,26 @@ def _allocate( if max_replicates is not None: count = min(count, max_replicates - int(following[key])) if left is not None: - count = min(count, left) + count = min(count, left // cost) if count <= 0: continue added[key] = count if left is not None: - left -= count - if left == 0: + left -= count * cost + if left < cost: break return added +def _count_evaluations(results: pd.DataFrame) -> int: + """ + Counts the evaluations of results: a design in a replicate (in a + scenario, with scenarios), whatever the number of records of each. + """ + keys = ["design", "replicate", *(["scenario"] if "scenario" in results else [])] + return results.groupby(keys).ngroups + + def _evaluate_added( study: Study, designs: dict[str, Design], diff --git a/src/tatc/tradespace/scenarios.py b/src/tatc/tradespace/scenarios.py index 48964d2d..f595424b 100644 --- a/src/tatc/tradespace/scenarios.py +++ b/src/tatc/tradespace/scenarios.py @@ -14,8 +14,9 @@ import numpy as np import pandas as pd -from .criteria import Criteria, _as_criteria, _get_tolerances, _resolve, _signs -from .summary import _feasible_records, _value_columns, _with_values, aggregate +from .criteria import Criteria +from .summary import aggregate +from .tables import design_values, value_columns def _scales(criteria: Criteria, scale: Mapping[str, float] | None) -> np.ndarray: @@ -28,7 +29,7 @@ def _scales(criteria: Criteria, scale: Mapping[str, float] | None) -> np.ndarray unknown = sorted(set(scale) - set(objectives)) if unknown: raise ValueError(f"scales of names that are not objectives: {unknown}") - absolute = _get_tolerances(criteria.objectives, criteria.tolerances)[0] + absolute = criteria.tolerance_array[0] values = np.array( [ float(scale[name]) if name in scale else (absolute[i] or 1.0) @@ -110,7 +111,7 @@ def robustness( records by several columns or combine them across scenarios (see `Across`, by which searches find robust designs). """ - criteria = _as_criteria(criteria) + criteria = Criteria.of(criteria) if criteria.across is not None: raise ValueError( "robustness judges designs in each scenario: give criteria without " @@ -130,7 +131,7 @@ def robustness( judged = dataclasses.replace(criteria, by=(scenario,)) objectives = list(criteria.objectives) # each objective in units of its scale, larger being better - units = -_signs(criteria) / _scales(criteria, scale) + units = -criteria.signs / _scales(criteria, scale) summary = aggregate(results, judged, design_columns=[]) efficient = summary["pareto"].to_numpy(dtype=bool) scenarios = list(pd.unique(results[scenario])) @@ -157,9 +158,8 @@ def robustness( # the values of the designs (of their first records, as of a summary), and # the objectives that are values of the designs, which are the same in # every scenario - statistics = _resolve(judged) - feasible, _ = _feasible_records(results) - every = _value_columns(feasible, {}, (scenario,), None, design_columns) + statistics = judged.resolved + every = value_columns(results, {}, (scenario,), design_columns) metrics = {column for s in statistics.values() for column in s.columns} columns = [c for c in every if c not in metrics and c not in statistics] collapsed = { @@ -167,8 +167,7 @@ def robustness( for name in objectives if name in every and set(statistics[name].columns) <= set(every) } - frame = pd.DataFrame({"design": designs}) - _with_values(frame, results, designs, columns) + frame = design_values(results, designs, columns) for name in objectives: table = summary.pivot(index="design", columns=scenario, values=name) table = table.reindex(index=designs, columns=scenarios) diff --git a/src/tatc/tradespace/screening.py b/src/tatc/tradespace/screening.py index 1d9927e0..fe87cd1d 100644 --- a/src/tatc/tradespace/screening.py +++ b/src/tatc/tradespace/screening.py @@ -15,7 +15,7 @@ import pandas as pd -from .criteria import Criteria, _as_criteria +from .criteria import Criteria from .pareto import pareto_ranks from .space import Design, _designs from .study import Study @@ -158,10 +158,10 @@ def screen( for amount in keeps: _check_keep(amount) if isinstance(criteria, (Criteria, Mapping)): - stages = [_as_criteria(criteria)] * len(studies) + stages = [Criteria.of(criteria)] * len(studies) else: stages = [ - _as_criteria(c) for c in _per_stage(criteria, len(studies), "criteria") + Criteria.of(c) for c in _per_stage(criteria, len(studies), "criteria") ] for criteria in stages: if criteria.by: diff --git a/src/tatc/tradespace/sensitivity.py b/src/tatc/tradespace/sensitivity.py index 3ca5495f..8b90ccef 100644 --- a/src/tatc/tradespace/sensitivity.py +++ b/src/tatc/tradespace/sensitivity.py @@ -13,24 +13,17 @@ import numpy as np import pandas as pd -from .statistics import _names -from .summary import _check_summary - -_ONE_ROW = ( - "summarize the results of a study (a row per replicate) first, with a row " - + "per design (see aggregate), or select the rows of one group (such as those " - + "of a scenario)" -) -"""How to give designs a row each.""" +from .tables import check_summary, names def _levels(values: pd.Series, max_levels: int) -> pd.Series: """ Gets the levels of a variable: its values, or (for a numeric variable - with more than `max_levels` values) equal-count bins of them. + with more than `max_levels` values) equal-count bins of them (intervals, + in order). """ if pd.api.types.is_numeric_dtype(values) and values.nunique() > max_levels: - return pd.qcut(values, max_levels, duplicates="drop").astype(str) + return pd.qcut(values, max_levels, duplicates="drop") return values @@ -53,13 +46,16 @@ def main_effects( its values are grouped in bins of equal counts. Returns: - pandas.DataFrame: a row per level: the `mean`, `std`, and `count` of + pandas.DataFrame: a row per level (in order, of the values or of the + bins of a numeric variable): the `mean`, `std`, and `count` of the metric """ - _check_summary(summary, hint=_ONE_ROW) + check_summary(summary) active = summary.dropna(subset=[variable, metric]) levels = _levels(active[variable], max_levels) - return active.groupby(levels, sort=True)[metric].agg(["mean", "std", "count"]) + return active.groupby(levels, sort=True, observed=True)[metric].agg( + ["mean", "std", "count"] + ) def sensitivity( @@ -112,8 +108,8 @@ def sensitivity( variance it explains, and the share of designs in which it is `active`, sorted by the share of the first metric """ - _check_summary(summary, hint=_ONE_ROW) - variables, metrics = _names(variables), _names(metrics) + check_summary(summary) + variables, metrics = names(variables), names(metrics) rows = [] for variable in variables: row: dict = {"variable": variable} @@ -127,7 +123,7 @@ def sensitivity( row[metric] = np.nan continue levels = _levels(subset[variable], max_levels) - means = values.groupby(levels).transform("mean") + means = values.groupby(levels, observed=True).transform("mean") between = float(((means - values.mean()) ** 2).sum()) if not adjusted: row[metric] = between / total diff --git a/src/tatc/tradespace/simulation.py b/src/tatc/tradespace/simulation.py index d0158f90..d7f39424 100644 --- a/src/tatc/tradespace/simulation.py +++ b/src/tatc/tradespace/simulation.py @@ -1,9 +1,10 @@ """ The discrete-event simulation of missions (see `Deployment.simulate`): the deployment of a constellation with the failures of its satellites and -launches, the restoration of failed satellites by a policy, and the +launches, the restoration of failed satellites by its policy, and the decisions of the rules of its stages, into the history of the mission (see -`MissionHistory`). +`MissionHistory`); and many histories of a replicate, independent or +stratified (see `Deployment.simulate_many`). @author: Paul T. Grogan """ @@ -21,7 +22,7 @@ import numpy as np from .events import Launch, _Manifest -from .failures import FailureModel, RestorationPolicy +from .failures import FailureModel from .mission import Decision, Failure, MissionHistory, Restoration if TYPE_CHECKING: @@ -111,9 +112,90 @@ def launch_fails(self, probability: float, key: tuple) -> bool: return failed +class _Sampler: + """ + The uniform numbers of the failures of a history of a replicate, + stratified over the histories of the replicate (see + `Deployment.simulate_many`): a Latin hypercube in which, for each draw + (each life and launch), history `k` of `K` takes a uniform number in its + stratum of a permutation of the `K` strata of [0, 1). Each draw is keyed + by its key, so that the same draw of the same history of a replicate + takes the same number in every design (common random numbers). + """ + + def __init__(self, seed: int, index: int, histories: int): + self.seed, self.index, self.histories = seed, index, histories + + def __call__(self, key: tuple, dimensions: int) -> np.ndarray: + strata = np.random.default_rng([self.seed, 1, self.histories, *key]) + orders = [strata.permutation(self.histories) for _ in range(dimensions)] + jitter = np.random.default_rng([self.seed, 2, self.index, *key]) + offsets = jitter.random(dimensions) + return np.array( + [ + (order[self.index] + offset) / self.histories + for order, offset in zip(orders, offsets) + ] + ) + + +SAMPLINGS = ("random", "stratified") +"""The samplings of the failures of histories (see `Deployment.simulate_many`).""" + + +def simulate_histories( + deployment: Deployment, + model: FailureModel, + seed: int, + *, + histories: int = 1, + sampling: str = "stratified", + stress: float = 1.0, + launch_stress: float | None = None, +) -> list[MissionHistory]: + """ + Simulates the histories of a mission in a replicate (see + `Deployment.simulate_many`), history `k` from the seed and `k`. + + Args: + deployment (Deployment): The deployment, with its policy. + model (FailureModel): The failures. + seed (int): The seed of the replicate. + histories (int): The number of histories. + sampling (str): `"stratified"` or `"random"`. + stress (float): The factor of the hazards of stressed failures. + launch_stress (float | None): The factor of the probability that a + launch fails, or `None` for the stress. + + Returns: + list[MissionHistory]: the histories + + Raises: + ValueError: if the sampling is unknown or a stress is not positive. + """ + # pylint: disable=too-many-arguments + if sampling not in SAMPLINGS: + raise ValueError(f"sampling must be one of {SAMPLINGS}, not {sampling!r}") + if stress <= 0 or (launch_stress is not None and launch_stress <= 0): + raise ValueError("stress must be positive") + launch_stress = stress if launch_stress is None else launch_stress + return [ + _Simulation( + deployment, + model, + (seed, k), + _Sampler(seed, k, histories) if sampling == "stratified" else None, + stress, + launch_stress, + ).run() + for k in range(histories) + ] + + class _Simulation: """ - A discrete-event simulation of a mission (see `Deployment.simulate`). + A discrete-event simulation of a mission (see `Deployment.simulate`), + with the policy of its deployment. """ # pylint: disable=too-many-instance-attributes @@ -122,13 +204,13 @@ def __init__( self, deployment: Deployment, model: FailureModel, - policy: RestorationPolicy, seed: int | Sequence[int] | None, uniforms: Callable[[tuple, int], np.ndarray] | None = None, stress: float = 1.0, launch_stress: float = 1.0, ): - self.deployment, self.model, self.policy = deployment, model, policy + self.deployment, self.model = deployment, model + self.policy = deployment.policy self.draws = _Draws(seed, uniforms, stress, launch_stress) self.end = deployment.end self.history = MissionHistory( @@ -144,28 +226,8 @@ def __init__( self.spares = dict.fromkeys(range(len(deployment.planes)), 0) self.spares_since: dict[int, float] = {} self.ground: dict[Any, int] = {} - # the production lines (free after the deployment's production) and - # the launches booked, shared with the plan's routine - lines = { - kind: max( - ( - b.end - for b in deployment.production - if b.kind == kind and b.purpose == "deployment" - ), - default=developed, - ) - for kind, developed in deployment.development.items() - } - self.manifest = _Manifest( - deployment.schedule, - deployment.planes, - deployment.masses, - deployment.plane_values, - lines, - sorted(launch.time for launch in deployment.launches), - self.history.production, - ) + # the production lines and the launches booked, after the plan's + self.manifest = _Manifest.resume(deployment, self.history.production) self.open: dict[int, list[_Booking]] = {} self.launches_of_plane: dict[int, int] = {} self.decided: dict[int, float] = {} @@ -193,7 +255,7 @@ def run(self) -> MissionHistory: for kind in self.deployment.development: count = self.policy.ground_spares_of(kind) if count > 0: - ready = self._produce(0.0, kind, count, "spare") + ready = self.manifest.produce(0.0, kind, count, "spare") self.ground.setdefault(kind, 0) self._push(ready, "stock", kind, count) for launch in self.deployment.launches: @@ -217,7 +279,7 @@ def run(self) -> MissionHistory: if self.spares[plane] > 0: self.history.parked.append((since, self.end, self.spares[plane])) self.history.weight = self.draws.weight - self.history.stages = [ + self.history.decided = [ self.decided.get(index) for index in range(len(self.deployment.stages)) ] self.history.production.sort(key=lambda batch: batch.begin) @@ -306,7 +368,7 @@ def _on_request(self, time: float, plane: int, position: int) -> None: time + self.policy.drift_years, "activate", plane, position, "orbit" ) if self.policy.replenish: - ready = self._produce( + ready = self.manifest.produce( time + self.policy.procurement_years, kind, 1, "spare" ) self._book(plane, kind, ready, ("spare",)) @@ -314,12 +376,12 @@ def _on_request(self, time: float, plane: int, position: int) -> None: self.ground[kind] -= 1 self._book(plane, kind, time, ("slot", position, "ground")) if self.policy.replenish: - ready = self._produce( + ready = self.manifest.produce( time + self.policy.procurement_years, kind, 1, "spare" ) self._push(ready, "stock", kind, 1) else: - ready = self._produce( + ready = self.manifest.produce( time + self.policy.procurement_years, kind, 1, "restoration" ) self._book(plane, kind, ready, ("slot", position, "production")) @@ -413,36 +475,21 @@ def _deploy(self, time: float, stage: Any) -> None: type's line), launched at the next launch slots, and replaced at the end of their design life. """ - launches = [] - for plane in stage.planes: - kind, size, spares = self.deployment.planes[plane] - if size + spares == 0: - continue - ready = self._produce(time + stage.lead_years, kind, size + spares) - launches.extend(self.manifest.launch(plane, ready)) - for launch in launches + self.manifest.replace(launches, self.end): + start = time + stage.lead_years + for launch in self.manifest.deploy(stage.planes, start, self.end): self._push(launch.time, "planned", launch) - def _produce( - self, earliest: float, kind: Any, count: int, purpose: str = "deployment" - ) -> float: + def _book(self, plane: int, kind: Any, ready: float, item: tuple) -> None: """ - Produces satellites on their type's line, from a time (after the work - before them), returning when they are ready. + Books an item that is ready at a time on a launch of a plane: an open + one that has room and flies once the item is ready, but no later + than a new one would (at the next launch slot after waiting the + batch years), or else a new one. """ - return self.manifest.produce(earliest, kind, count, purpose) - - def _capacity(self, plane: int, kind: Any) -> float: - return self.deployment.schedule.per_launch( - self.deployment.masses.get(kind), self.manifest.plane(plane) - ) - - def _book(self, plane: int, kind: Any, ready: float, item: tuple) -> None: - """Books an item on a launch of a plane: an open one, or a new one.""" + latest = self.manifest.next_slot(ready + self.policy.batch_years) + capacity = self.manifest.capacity(plane) for booking in self.open.get(plane, []): - if booking.time >= ready and len(booking.items) < self._capacity( - plane, kind - ): + if ready <= booking.time <= latest and len(booking.items) < capacity: booking.items.append(item) return time = self.manifest.slot(ready + self.policy.batch_years) diff --git a/src/tatc/tradespace/space.py b/src/tatc/tradespace/space.py index 16367c41..9bc199d0 100644 --- a/src/tatc/tradespace/space.py +++ b/src/tatc/tradespace/space.py @@ -31,7 +31,7 @@ import numpy as np import pandas as pd -from .hashing import _canonical, _digest +from .hashing import canonical, digest from .nodes import ( Choice, Fixed, @@ -41,12 +41,11 @@ _as_node, _Domain, ) -from .values import Scope, Values +from .values import Scope, Values, generic_path from .walks import ( _Context, _decided, _flatten, - _generic, _leaf_paths, _level_of, _node_at, @@ -55,32 +54,41 @@ _walk, ) -_RESERVED_NAMES = { - # names that the views of values give otherwise (see `Values`) - "index", - "count", - "choice", - "get", - "items", - "keys", - "values", - # attributes of designs (see `Design`) - "decisions", - "flat", - "key", - "realize", - "replicate", - "scenario", - "space", - # columns of the results of a study (see `Study.run`) - "design", - "error", - "feasible", - "seconds", -} -"""Names that cannot be given to the children of a design space, as the views -of the values of designs (and designs) give them otherwise, or as the columns -of the results of a study that are not values of designs.""" +STATUS_COLUMNS = ("design", "replicate", "scenario", "feasible", "error", "seconds") +"""tuple[str, ...]: The columns of the results of a study (see `Study.run`) +that are neither values of designs nor metrics, in their order: the key of +the design, the replicate, the name of the scenario (of a study with +scenarios only), whether the evaluation is feasible (and its error if not), +and the seconds it took to build and evaluate the design. Neither metrics +nor the children of design spaces may be named as them.""" + +RESERVED_NAMES = frozenset( + { + # names that the views of values give otherwise (see `Values`) + "index", + "count", + "choice", + "get", + "items", + "keys", + "values", + # attributes of designs (see `Design`) + "decisions", + "flat", + "key", + "realize", + "replicate", + "scenario", + "space", + "uncertain_values", + # columns of the results of a study + *STATUS_COLUMNS, + } +) +"""frozenset[str]: The names that the children of a design space may not +have: those that designs and the views of their values give otherwise (as +attributes, such as `key`, `items`, or `index`), and the columns of the +results of a study that are not values of designs (see `STATUS_COLUMNS`).""" # --------------------------------------------------------------------------- @@ -119,7 +127,7 @@ def __init__( levels of their decisions (see `Repeat`).""" self._values = values self._scenario = scenario - self.key = _digest(_canonical(decisions), 12) + self.key = digest(canonical(decisions), 12) """str: An identifier of the design, from its decisions only (not from its derived values or uncertain parameters).""" @@ -152,10 +160,28 @@ def __eq__(self, other: object) -> bool: isinstance(other, Design) and self.key == other.key and self.replicate == other.replicate + and self._scenario == other._scenario ) def __hash__(self) -> int: - return hash((self.key, self.replicate)) + return hash((self.key, self.replicate, self._scenario)) + + def __fingerprint__(self) -> dict: + """ + Gets what identifies the design in a definition (see + `tatc.tradespace.fingerprint`), such as of a design that a function + of a study refers to: its design space, its decisions, and its + replicate and scenario (if it is realized). + + Returns: + dict: the design space, decisions, replicate, and scenario + """ + return { + "space": self.space, + "decisions": self.decisions, + "replicate": self.replicate, + "scenario": self._scenario, + } def flat(self) -> dict[str, Any]: """ @@ -172,6 +198,28 @@ def flat(self) -> dict[str, Any]: _flatten(self.space, self._values, "", out) return out + def uncertain_values(self) -> dict[str, Any]: + """ + Gets the values of the uncertain parameters of the design (see + `Uncertain`) by path (as of `flat`), in the order they are drawn: + those of the branches that it chooses and of the items of its + repetitions, as drawn in its replicate (or given by its scenario) if + it is realized (see `realize`), and their nominal values otherwise. + Their paths with `[*]` for the indices of items (see + `generic_path`) are those of `DesignSpace.uncertain_paths`:: + + design.realize(3).uncertain_values() # {"planes[0].phase": 41.2, ...} + + Returns: + dict[str, Any]: the values, by path + """ + paths = set(self.space.uncertain_paths()) + return { + path: value + for path, value in self.flat().items() + if generic_path(path) in paths + } + def realize( self, replicate: int, @@ -215,12 +263,13 @@ def realize( design is of the scenario named `scenario` (see `Design.scenario`). Args: - replicate (int): The replicate. + replicate (int): The replicate (a non-negative integer). seed (int): The seed of the trade study (a non-negative integer). common_random_numbers (bool): `True` to use common random numbers between designs. shift (Mapping[str, int] | None): The offsets of the replicates - as in which the named uncertain parameters are drawn, if any. + as in which the named uncertain parameters are drawn (each a + non-negative integer), if any. overrides (Mapping[str, Any] | None): The values of fixed values and uncertain parameters in a scenario (by path), if any. scenario (str | None): The name of the scenario of the overrides, @@ -232,31 +281,33 @@ def realize( Raises: Infeasible: if the design violates a constraint with the overrides. - ValueError: if `seed` is negative, `shift` names a path that is - not of an uncertain parameter of the design space, or + ValueError: if `replicate`, `seed`, or an offset of `shift` is + not a non-negative integer, `shift` names a path that is not + of an uncertain parameter of the design space, or `overrides` one that is not of a fixed value or an uncertain parameter. """ # pylint: disable=too-many-arguments _check_seed(seed) - shift = dict(shift or {}) + replicate = _check_replicate(replicate) + shift = _check_shift(shift) self.space.check_uncertain(shift) overrides = dict(overrides or {}) self.space.check_overrides(overrides) tail = [] if common_random_numbers else [int(self.key, 16)] def draw(path: str, node: Uncertain) -> Any: - name = _generic(path) + name = generic_path(path) if name in overrides: return overrides[name] - drawn_in = replicate + int(shift.get(name, 0)) + drawn_in = replicate + shift.get(name, 0) rng = np.random.default_rng( [seed, drawn_in, *tail, zlib.crc32(path.encode())] ) return node.sampler(rng) def fix(path: str, node: Fixed) -> Any: - return overrides.get(_generic(path), node.value) + return overrides.get(generic_path(path), node.value) ctx = _Context( draw=draw, @@ -273,17 +324,59 @@ def __repr__(self) -> str: return f"Design({self.key}{replicate}{scenario}: {self.flat()})" -def _check_seed(seed: Any) -> None: +def _check_index(value: Any, what: str) -> int: """ - Checks that a seed of uncertain parameters is a non-negative integer (as - numpy's generators require), raising a `ValueError` if not. + Checks that a value that seeds uncertain parameters (a seed, a replicate, + or the offset of a shift) is a non-negative integer, as numpy's + generators require, raising a `ValueError` if not (naming it `what`), + and returns it as a Python integer. """ if ( - isinstance(seed, (bool, np.bool_)) - or not isinstance(seed, numbers.Integral) - or seed < 0 + isinstance(value, (bool, np.bool_)) + or not isinstance(value, numbers.Integral) + or value < 0 ): - raise ValueError(f"the seed must be a non-negative integer, not {seed!r}") + raise ValueError(f"{what} must be a non-negative integer, not {value!r}") + return int(value) + + +def _check_seed(seed: Any) -> None: + """ + Checks that a seed of uncertain parameters is a non-negative integer (see + `_check_index`). + """ + _check_index(seed, "the seed") + + +def _check_replicate(replicate: Any) -> int: + """ + Checks that a replicate is a non-negative integer (see `_check_index`), + returning it. + """ + return _check_index(replicate, "a replicate") + + +def _check_shift(shift: Mapping[str, Any] | None) -> dict[str, int]: + """ + Checks that the offsets of a shift (see `Design.realize`) are + non-negative integers (see `_check_index`), returning them. + """ + return { + name: _check_index(offset, f"the offset of {name!r} in a shift") + for name, offset in (shift or {}).items() + } + + +def _as_constraints(constraints: Any) -> list[Callable[[Scope], Any]]: + """ + Gets the constraints of a design space given as a constraint or a + sequence of them, raising a `TypeError` if one is not callable. + """ + found = [constraints] if callable(constraints) else list(constraints) + for constraint in found: + if not callable(constraint): + raise TypeError(f"a constraint is a callable, not {constraint!r}") + return found def _lhs_column(n: int, rng: np.random.Generator) -> np.ndarray: @@ -300,9 +393,9 @@ class DesignSpace(Group): as the design of each orbit plane). Children are given by name, in the order they are decided; plain values are fixed values. Children may not be named as the attributes of designs and of the views of their values - (such as `key`, `values`, or `index`), nor as the columns of the results - of a study that are not values of designs (`design`, `replicate`, - `scenario`, `feasible`, `error`, and `seconds`). + (such as `key`, `items`, or `index`), nor as the columns of the results + of a study that are not values of designs (see `STATUS_COLUMNS`): see + `RESERVED_NAMES`. Constraints are callables of the group's values (and those of enclosing groups), checked once the group's values are decided, that return @@ -314,18 +407,26 @@ class DesignSpace(Group): They must not depend on uncertain parameters. Args: - constraints (Sequence[Callable]): The constraints. + constraints (Callable | Sequence[Callable]): A constraint, or the + constraints. **children (Any): The nodes, by name. """ def __init__( - self, constraints: Sequence[Callable[[Scope], bool]] = (), **children: Any + self, + constraints: Callable[[Scope], Any] | Sequence[Callable[[Scope], Any]] = (), + **children: Any, ): - reserved = _RESERVED_NAMES.intersection(children) + reserved = RESERVED_NAMES.intersection(children) if reserved: - raise ValueError(f"reserved names: {sorted(reserved)}") + raise ValueError( + f"children may not be named {sorted(reserved)}: designs and the " + + "views of their values give these names otherwise (as attributes, " + + "such as `key` and `items`), as do the results of a study (as " + + f"columns); the reserved names are {sorted(RESERVED_NAMES)}" + ) self.children = {name: _as_node(node) for name, node in children.items()} - self.constraints = list(constraints) + self.constraints = _as_constraints(constraints) def __repr__(self) -> str: return f"DesignSpace({', '.join(self.children)})" @@ -366,8 +467,9 @@ def design( Raises: Infeasible: if the design violates a constraint. - ValueError: if an override names no child of the design space, or - a decision is not a value of its variable's domain. + ValueError: if an override names no child of the design space, + the decisions of a group name others than its children, or a + decision is not a value of its variable's domain. """ if isinstance(decisions, Design): decisions = decisions.decisions @@ -392,7 +494,9 @@ def design( return Design(self, merged, values) def extend( - self, constraints: Sequence[Callable[[Scope], Any]] = (), **children: Any + self, + constraints: Callable[[Scope], Any] | Sequence[Callable[[Scope], Any]] = (), + **children: Any, ) -> DesignSpace: """ Gets a design space with other children: those named as children of @@ -406,18 +510,20 @@ def extend( decisions of its new children (see `design`). Args: - constraints (Sequence[Callable]): Other constraints. + constraints (Callable | Sequence[Callable]): Another constraint, + or other constraints. **children (Any): The nodes, by name. Returns: DesignSpace: the design space """ return DesignSpace( - [*self.constraints, *constraints], **{**self.children, **children} + [*self.constraints, *_as_constraints(constraints)], + **{**self.children, **children}, ) def designs_of( - self, frame: pd.DataFrame, keys: Iterable[str] | None = None + self, frame: pd.DataFrame, *, keys: Iterable[str] | None = None ) -> pd.Series: """ Rebuilds designs from the rows of a data frame of their values by path @@ -757,6 +863,21 @@ def _keys_of(designs: Iterable[Design | str] | pd.DataFrame) -> list[str]: return list(dict.fromkeys(keys)) +def _in_space(space: DesignSpace, design: Design) -> Design: + """ + Gets the design of a design space of the decisions of a design of + another (see `DesignSpace.design`), raising a `ValueError` if they are + not decisions of the design space. + """ + try: + return space.design(design) + except ValueError as error: + raise ValueError( + f"design {design.key} is of another design space, whose decisions are " + + f"not those of a design of this one: {error}" + ) from error + + def _designs( space: DesignSpace, designs: Iterable[Design | str] | pd.DataFrame, @@ -776,7 +897,7 @@ def _designs( found: dict[str, Design | None] = {} for item in _design_items(designs): if isinstance(item, Design): - design = item if item.space is space else space.design(item) + design = item if item.space is space else _in_space(space, item) found[design.key] = design else: found.setdefault(item, None) @@ -791,7 +912,7 @@ def _designs( keys = set(rows["design"]) present = [key for key in missing if key in keys] try: - for design in space.designs_of(rows, present): + for design in space.designs_of(rows, keys=present): found[design.key] = design except ValueError as failure: error = failure # the frame lacks values of the designs: try the next diff --git a/src/tatc/tradespace/statistics.py b/src/tatc/tradespace/statistics.py index 88d14b18..8b3d38c6 100644 --- a/src/tatc/tradespace/statistics.py +++ b/src/tatc/tradespace/statistics.py @@ -13,7 +13,7 @@ from __future__ import annotations import operator as op -from collections.abc import Mapping, Sequence +from collections.abc import Mapping from typing import Any import numpy as np @@ -21,11 +21,6 @@ _OPERATORS = {">=": op.ge, ">": op.gt, "<=": op.le, "<": op.lt} -def _names(value: str | Sequence[str]) -> list[str]: - """Gets names given as a name or a sequence of names.""" - return [value] if isinstance(value, str) else list(value) - - def _is_derived(metric: Any) -> bool: """ Whether a metric is computed from others in each replicate (such as a @@ -100,11 +95,15 @@ def metric(self) -> str: @property def name(self) -> str: - """str: The conventional name of the statistic (the suffixes of which - are those of `summarize` and `summarize_histories`): such as `cost` - (a mean), `cost std`, `cost se`, `cost min`, `cost max`, `cost p70` - (a quantile), or `P(cost <= 150)`, by which criteria name the - statistics given without names.""" + """str: The conventional name of the statistic, by which criteria name + the statistics given without names: such as `cost` (a mean), `cost + std`, `cost se` (as of `summarize`), `cost min`, `cost max`, `cost + p70` (a quantile), or `P(cost <= 150)`. The statistics within a + replicate over the histories of a mission (see `summarize_histories`) + are named apart from these, as ` histories p10`, ` + histories std`, and `P() histories`, and a statistic + other than the mean of a metric must not have the name of a column of + the results (see `aggregate`).""" return self.metric @property diff --git a/src/tatc/tradespace/store.py b/src/tatc/tradespace/store.py index 7438a9ad..d47f6a61 100644 --- a/src/tatc/tradespace/store.py +++ b/src/tatc/tradespace/store.py @@ -22,7 +22,7 @@ import numpy as np -from .hashing import _canonical +from .hashing import canonical _RESULTS_TABLE = ( "CREATE TABLE IF NOT EXISTS results (namespace TEXT, context TEXT, " @@ -107,21 +107,17 @@ class ResultStore: a scenario are those of any scenario of the same overrides, and a scenario without overrides shares the evaluations of plain replicates. - Records are also keyed by a `context`: a study gives its fingerprint - (see `Study.fingerprint`), which changes with its seed, its use of - common random numbers, the definitions of its design space and its build - and evaluation functions (their code, and the plain values they refer - to), and the source of the modules of TAT-C they depend on, so that - records computed with other definitions are not reused. The store keeps - the definition of each context (see `define`), from which a study - explains why it does not reuse records (see `compare_definitions`). A - fingerprint describes the data that the functions are given (such as - data frames of targets they close over or refer to, by their content), - but not data that they read (such as from files) nor the code of other - modules they call (other than TAT-C's): a `namespace` identifies these, - and must change whenever they do. Studies of other definitions (such as - variants of a study) may share a namespace, as their fingerprints keep - their records apart, and several namespaces may share a file. + Records are also keyed by a `context`: a study gives its fingerprint, + which changes with its definition (see `Study.fingerprint` for what it + describes), so that records computed with other definitions are not + reused. The store keeps the definition of each context (see `define`), + from which a study explains why it does not reuse records (see + `compare_definitions`). What a fingerprint cannot describe (such as data + that the functions read from files, and the code of modules other than + TAT-C's that they call) a `namespace` identifies, which must change + whenever it does. Studies of other definitions (such as variants of a + study) may share a namespace, as their fingerprints keep their records + apart, and several namespaces may share a file. Records are kept as JSON (in the column `records` of the table `results`, a list of records per evaluation), which other tools can read: numbers @@ -136,7 +132,7 @@ class ResultStore: studies cannot see (such as data they read from files), if any. """ - def __init__(self, path: str | os.PathLike, namespace: str = ""): + def __init__(self, path: str | os.PathLike, *, namespace: str = ""): self.path, self.namespace = Path(path), namespace self.path.parent.mkdir(parents=True, exist_ok=True) with closing(self._connect()) as connection: @@ -259,7 +255,7 @@ def define(self, context: str, definition: dict) -> None: [ self.namespace, context, - _canonical(definition), + canonical(definition), defined, ], ) @@ -351,4 +347,7 @@ def clear(self) -> None: ) def __repr__(self) -> str: - return f"ResultStore({str(self.path)!r}, {self.namespace!r}: {len(self)} evaluations)" + return ( + f"ResultStore({str(self.path)!r}, namespace={self.namespace!r}: " + + f"{len(self)} evaluations)" + ) diff --git a/src/tatc/tradespace/study.py b/src/tatc/tradespace/study.py index 27e593b5..43c9c6a0 100644 --- a/src/tatc/tradespace/study.py +++ b/src/tatc/tradespace/study.py @@ -7,7 +7,6 @@ from __future__ import annotations -import inspect import math import os import time @@ -20,20 +19,26 @@ from .alerts import _warn from .fingerprint import ( - _Describer, _fingerprint_of, - _warn_other_code, - _with_other_code, + describe, + find_stale, get_definition, + warn_stale, ) -from .hashing import _canonical, _digest +from .hashing import canonical, digest from .nodes import Infeasible -from .space import Design, DesignSpace, _check_seed, _designs +from .references import given_design +from .space import ( + STATUS_COLUMNS, + Design, + DesignSpace, + _check_replicate, + _check_seed, + _check_shift, + _designs, +) from .store import ResultStore -_STATUS_COLUMNS = ["design", "replicate", "feasible", "error", "seconds"] -"""Columns of the results of a study that are neither design values nor metrics.""" - _UNSTORED = "_unstored" """A key of the records of evaluations that are not stored: those that failed (with `errors="record"`) and designs that failed validation, which may be @@ -95,9 +100,10 @@ class Study: `errors` is: give a record of no sensors, for example, with missing metrics). Designs given of another design space (such as of a design space that the study's extends) are evaluated as the designs of the - study's design space of their decisions. An `evaluate` function - with a parameter named `design` is also given the realized design (with - the uncertain parameters of the replicate), as for an evaluation that + study's design space of their decisions, which must be decisions of a + design of it. An `evaluate` function that takes a keyword named `design` + is also given the realized design (with the uncertain parameters of the + replicate, see `tatc.tradespace.references`), as for an evaluation that depends on values of the design other than those it builds:: def build(d): @@ -111,10 +117,12 @@ def evaluate(satellites, design): if `build` or `evaluate` rejects it by raising `Infeasible`, or if `build` fails the validation of TAT-C's schemas (a pydantic `ValidationError`, such as of an orbit too high to be sun-synchronous). - Other errors (including other `ValueError`s, which are as likely - mistakes in the functions as properties of designs) are raised, which - stops the study, unless `errors` is `"record"`: then the evaluation is - recorded as infeasible, with the type of the error and its message. + Other errors of `build` and `evaluate`, and of the realization of a + design (such as of a derived value of a drawn uncertain parameter), + including other `ValueError`s, which are as likely mistakes in the + functions as properties of designs, are raised, which stops the study, + unless `errors` is `"record"`: then the evaluation is recorded as + infeasible, with the type of the error and its message. Evaluations that fail and designs that fail validation are not kept in the study's store, so that a later run evaluates them again (as after fixing a mistake in code that the study's fingerprint cannot see, see @@ -122,11 +130,12 @@ def evaluate(satellites, design): is feasible. The metrics must not be named as the columns of the results that - identify an evaluation (`design`, `replicate`, `feasible`, `error`, and - `seconds`), and a metric named as a value of the design (see - `Design.flat`) must equal it (restating it, as a design variable that is - also an objective): metrics that would replace these columns raise a - `ValueError`, whatever `errors` is. + identify an evaluation (see `STATUS_COLUMNS`: `design`, `replicate`, + `scenario`, `feasible`, `error`, and `seconds`, also `scenario` in a + study without scenarios), and a metric named as a value of the design + (see `Design.flat`) must equal it (restating it, as a design variable + that is also an objective): metrics that would replace these columns + raise a `ValueError`, whatever `errors` is. A study may evaluate designs in `scenarios`: conditions under which designs are compared rather than averaged over (as uncertain parameters @@ -140,13 +149,14 @@ def evaluate(satellites, design): design also gives, see `Design.scenario`). A design that violates a constraint of the design space with the values of a scenario is recorded as infeasible in that scenario. Judge designs in each scenario - with criteria `by` the scenario (see `Criteria`), and across them with - `robustness`. Scenarios - are not part of the study's fingerprint: the evaluations of each are - stored by its values (as a variant of the replicates, see - `ResultStore`), so that a scenario added later is evaluated alone, and - one without values shares the evaluations of the study without - scenarios. + with criteria `by` the scenario (see `Criteria`), once across the + scenarios with criteria that combine their statistics `Across` them + (such as their worst or mean), and by their efficiency in each with + `robustness`. Scenarios are not part of the study's fingerprint: the + evaluations of each are stored by its values (as a variant of the + replicates, see `ResultStore`), so that a scenario added later is + evaluated alone, and one without values shares the evaluations of the + study without scenarios. Evaluations run in parallel with `n_jobs` worker processes (or an `executor` with the interface of `concurrent.futures.Executor`). They are @@ -166,7 +176,7 @@ def evaluate(satellites, design): build (Callable): A function of a realized design that builds the object to evaluate (for example, a list of satellites). evaluate (Callable): A function of a built object that evaluates it - (and of the realized design, if it has a parameter named + (and of the realized design, if it takes a keyword named `design`). replicates (int): The number of replicates of each design. seed (int): The seed of the uncertain parameters (a non-negative @@ -182,7 +192,8 @@ def evaluate(satellites, design): chunks_per_job (int): The number of chunks of evaluations per worker. errors (str): `"raise"` to raise the errors of evaluations (other than those of designs that `build` rejects), or `"record"` to record - them as infeasible evaluations. + them as infeasible evaluations (also those of the realization of + designs). store (ResultStore | None): A store of the records of evaluations, from which evaluations stored before (by a study of the same fingerprint, see `fingerprint`) are taken rather than evaluated @@ -259,6 +270,11 @@ def _evaluate( except Infeasible as error: # the scenario's values violate a constraint of the design return [{**base, **design.flat(), "feasible": False, "error": str(error)}] + except Exception as error: # pylint: disable=broad-exception-caught + # such as of a derived value of a drawn uncertain parameter + if self.errors == "raise": + raise + return [self._failure({**base, **design.flat()}, error)] base.update(realized.flat()) began = time.perf_counter() try: @@ -272,10 +288,7 @@ def _evaluate( raise return [self._failure(base, error)] try: - if _takes_design(self.evaluate): - outcome = self.evaluate(built, design=realized) - else: - outcome = self.evaluate(built) + outcome = given_design(self.evaluate, realized)(built) except Infeasible as error: return [{**base, "feasible": False, "error": str(error)}] except Exception as error: # pylint: disable=broad-exception-caught @@ -514,18 +527,22 @@ def fingerprint(self) -> str: changes if it does: if its seed or use of common random numbers changes, or its design space, or the code of its functions, the values they close over or take as defaults, or the globals they - refer to (plain values and their containers, models, data, and the - functions, classes, and objects of the study's own modules, which - are described by content or code, see `tatc.tradespace.fingerprint`), + refer to (plain values and their containers, dataclasses, models, + data, designs, caches of satellites, and the functions, classes, and + objects of the study's own modules, which are described by content + or code, see `tatc.tradespace.fingerprint`), or the source of the modules of TAT-C they depend on, or the version of Python. It does not change with the study's scenarios (whose evaluations a store keeps apart, see `ResultStore`), nor its other settings (such as its number of replicates or workers). It keys the records of a store (see `ResultStore`); what it cannot describe (data that the functions read, such as from files, the code of - installed modules other than TAT-C's, and objects of installed - classes, which are described by type) must be identified by the - store's namespace.""" + installed modules other than TAT-C's, and the state of objects + described by type: those of installed classes, and those of TAT-C's + classes that are neither dataclasses, models, nor nodes, nor + describe themselves, as designs and caches of satellites do, see + `tatc.tradespace.fingerprint`) must be identified by the store's + namespace.""" return _fingerprint_of(self.definition) def prune(self) -> int: @@ -557,8 +574,8 @@ def workers(self) -> int: def run( self, designs: Iterable[Design] | pd.DataFrame | None = None, - progress: Callable[[int, int], None] | None = None, *, + progress: Callable[[int, int], None] | None = None, replicate_indices: Iterable[int] | None = None, shift: Mapping[str, int] | None = None, ) -> pd.DataFrame: @@ -587,11 +604,12 @@ def run( complete with the number completed and the number of evaluations (not counting those taken from the store). replicate_indices (Iterable[int] | None): The replicates (their - indices, which seed their uncertain parameters), or `None` for - the study's (`range(replicates)`). + indices, non-negative integers, which seed their uncertain + parameters), or `None` for the study's (`range(replicates)`). shift (Mapping[str, int] | None): The offsets of the replicates as in which the named uncertain parameters are drawn (by their - paths, see `DesignSpace.uncertain_paths`), if any. + paths, see `DesignSpace.uncertain_paths`; non-negative + integers), if any. Returns: pandas.DataFrame: The outcomes, a record per evaluation (or per @@ -601,10 +619,20 @@ def run( values of the design by path (see `Design.flat`), whether it is `feasible` (and the `error` if not), the time to build and evaluate it (`seconds`), and the metrics (the status columns - alone, without evaluations). + alone, without evaluations, see `STATUS_COLUMNS`). + + Raises: + ValueError: if a replicate index or an offset of `shift` is not + a non-negative integer, or `shift` names a path that is not of + an uncertain parameter of the design space. """ - shift = {name: int(offset) for name, offset in (shift or {}).items() if offset} + shift = {name: offset for name, offset in _check_shift(shift).items() if offset} self.space.check_uncertain(shift) + replicates = ( + range(self.replicates) + if replicate_indices is None + else sorted({_check_replicate(r) for r in replicate_indices}) + ) cases = self._cases(shift) unique = ( self.space.enumerate() if designs is None else _designs(self.space, designs) @@ -613,11 +641,7 @@ def run( # uncertain values tasks = [ _Task(i, design, replicate, case) - for replicate in ( - range(self.replicates) - if replicate_indices is None - else sorted(set(replicate_indices)) - ) + for replicate in replicates for case in range(len(cases)) for i, design in enumerate(unique) ] @@ -628,6 +652,10 @@ def run( self._prepare(first.design, first.replicate, shift, cases[first.case]) except Infeasible: pass # infeasible in its scenario, which its evaluation records + except Exception: # pylint: disable=broad-exception-caught + if self.errors == "raise": + raise + # such as of its realization, which its evaluation records results.extend(self._execute(tasks, context, shift, cases, progress)) results.sort(key=lambda outcome: outcome[:3]) records = [ @@ -636,9 +664,12 @@ def run( for record in records ] if not records: - scenario = [] if self.scenarios is None else ["scenario"] return pd.DataFrame( - columns=[*_STATUS_COLUMNS[:2], *scenario, *_STATUS_COLUMNS[2:]] + columns=[ + column + for column in STATUS_COLUMNS + if column != "scenario" or self.scenarios + ] ) frame = pd.DataFrame.from_records(records) _check_feasible(frame) @@ -808,7 +839,7 @@ def _describe_overrides(values: Mapping[str, Any]) -> str: """ if not values: return "" - return _canonical(_Describer().describe(dict(values))) + return canonical(describe(dict(values))) def _variant_of(shift: Mapping[str, int], scenario: str = "") -> str: @@ -820,25 +851,10 @@ def _variant_of(shift: Mapping[str, int], scenario: str = "") -> str: """ parts: dict[str, Any] = {} if scenario: - parts["scenario"] = _digest(scenario, 16) + parts["scenario"] = digest(scenario, 16) if shift: parts["shift"] = shift - return _canonical(parts) if parts else "" - - -def _takes_design(function: Callable) -> bool: - """ - Whether a function has a parameter named `design`, which a study gives - the realized design (see `Study`). - """ - try: - parameter = inspect.signature(function).parameters.get("design") - except (TypeError, ValueError): # such as of some built-in functions - return False - return parameter is not None and parameter.kind in ( - inspect.Parameter.POSITIONAL_OR_KEYWORD, - inspect.Parameter.KEYWORD_ONLY, - ) + return canonical(parts) if parts else "" def _stale_contexts( @@ -847,37 +863,33 @@ def _stale_contexts( """ Gets the contexts of a store's namespace (and their numbers of evaluations) of the same study with other code (its functions', TAT-C's, - or Python's: the same values but for the code of functions, see - `_with_other_code`), the latest first, including those whose definitions - are kept without evaluations. + or Python's, see `find_stale`), the latest first, including those whose + definitions are kept without evaluations. """ contexts = store.contexts() - others = {other: store.definition(other) for other in reversed(contexts)} - others.pop(context, None) - return {other: contexts[other] for other in _with_other_code(definition, others)} + others = { + other: store.definition(other) + for other in reversed(contexts) + if other != context + } + return find_stale(definition, others, contexts.__getitem__) def _warn_other_definitions(store: ResultStore, context: str, definition: dict) -> None: """ Warns if a store has evaluations of its namespace by the same study with other code (see `_stale_contexts`), which a study does not reuse, with - the differences from the latest (see `compare_definitions`). Studies of - other values (such as other settings) share a namespace without a - warning, as their fingerprints keep their evaluations apart. + the differences from the latest (see `warn_stale`). Studies of other + values (such as other settings) share a namespace without a warning, as + their fingerprints keep their evaluations apart. """ - stale = { - other: count - for other, count in _stale_contexts(store, context, definition).items() - if count - } - if not stale: - return - _warn_other_code( - f"the store has {sum(stale.values())} evaluations of namespace " + warn_stale( + _stale_contexts(store, context, definition), + definition, + store.definition, + lambda count: f"the store has {count} evaluations of namespace " + f"{store.namespace!r} by this study", "see Study.fingerprint; Study.prune removes them", - store.definition(next(iter(stale))), - definition, ) @@ -903,20 +915,24 @@ def _same(value: Any, other: Any) -> bool: def _check_metrics(metrics: dict, base: dict) -> None: """ Checks that the metrics of a record do not replace the columns of the - results of a study: they must not be named as its status columns, and - a metric named as a value of the design (a key of `base`) must equal it. + results of a study: they must not be named as its status columns (see + `STATUS_COLUMNS`, also `scenario` in a study without scenarios) nor as + the marker of unstored records (see `_UNSTORED`), and a metric named as + a value of the design (a key of `base`) must equal it. """ clashes = [ str(name) for name, value in metrics.items() - if name in _STATUS_COLUMNS or (name in base and not _same(value, base[name])) + if name in STATUS_COLUMNS + or name == _UNSTORED + or (name in base and not _same(value, base[name])) ] if clashes: raise ValueError( f"metrics named as columns of the results of a study: {sorted(clashes)}; " - + f"rename them (the results have the columns {_STATUS_COLUMNS}, and " - + "the values of each design, see Design.flat, which a metric of the " - + "same name must equal)" + + f"rename them (the results have the columns {list(STATUS_COLUMNS)}, " + + "and the values of each design, see Design.flat, which a metric of " + + "the same name must equal)" ) diff --git a/src/tatc/tradespace/summary.py b/src/tatc/tradespace/summary.py index a44bf6ff..03734578 100644 --- a/src/tatc/tradespace/summary.py +++ b/src/tatc/tradespace/summary.py @@ -22,18 +22,8 @@ import numpy as np import pandas as pd -from .criteria import ( - Across, - Criteria, - Requirement, - _as_criteria, - _combiners, - _costs_of, - _get_tolerances, - _resolve, - _violation_of, -) -from .dominance import _efficient +from .criteria import Across, Criteria +from .dominance import efficient from .statistics import ( Mean, StandardDeviation, @@ -41,40 +31,22 @@ Statistic, _named_statistics, ) -from .study import _STATUS_COLUMNS - -_FEASIBLE = "feasible" -"""The statistic (and column of summaries) of the share of a design's -replicates that are feasible, and the column of the results of a study of -whether each record is feasible.""" - -_JUDGMENT = ("violation", "meets_requirements", "pareto") -"""The columns of the judgment of designs by criteria in their summaries (see -`aggregate`).""" - -_SEPARATE = ( - "give the columns that separate them as `by` (of the criteria), or combine " - + "their groups `across` (see Across)" -) -"""How to separate several records of an evaluation for criteria.""" - -_SUMMARIZE = ( - "summarize the results of a study (a row per replicate) first, with a row " - + "per design (see aggregate), or judge designs in groups (see Criteria's " - + "`by`)" +from .tables import ( + FEASIBLE, + JUDGMENT, + draw_resamples, + feasible_records, + groups, + matrices, + names, + value_columns, + with_values, ) -"""How to judge the results of a study (a row per replicate) by criteria.""" - -def _resamples(count: int, n_resamples: int, seed: Any) -> np.ndarray: - """ - Gets the replicates of each resample of a bootstrap: a row per resample of - `count` replicates (their positions) drawn with replacement, from a seed - (or a random number generator, which draws them). - """ - if n_resamples < 2: - raise ValueError("n_resamples must be at least 2") - return np.random.default_rng(seed).integers(count, size=(n_resamples, count)) +_NEGLIGIBLE = 1e-12 +"""The share of the sum of the magnitudes of its terms below which a variance +combined from the covariances of groups is zero (rather than the error of +rounding of terms that cancel).""" def _bootstrap_error(sums: np.ndarray, squares: np.ndarray, n: int) -> np.ndarray: @@ -87,96 +59,6 @@ def _bootstrap_error(sums: np.ndarray, squares: np.ndarray, n: int) -> np.ndarra return np.sqrt(np.maximum(squares - n * mean**2, 0.0) / max(n - 1, 1)) -def _feasible_records(results: pd.DataFrame) -> tuple[pd.DataFrame, pd.DataFrame]: - """ - Gets the feasible and the infeasible records of results (every record is - feasible without a column `feasible`). - """ - if _FEASIBLE not in results.columns: - return results, results.iloc[:0] - status = results[_FEASIBLE].astype(bool).to_numpy() - return results[status], results[~status] - - -def _groups(frame: pd.DataFrame, by: Sequence[str]) -> Iterator[tuple[tuple, Any]]: - """ - Iterates over the groups of a data frame by columns (or the frame, if - none): the values of the columns, and the positions of the group's rows. - """ - if not by: - yield (), np.arange(len(frame)) - return - missing = [column for column in by if column not in frame.columns] - if missing: - raise ValueError(f"no columns {missing} to group by") - for key, positions in frame.groupby(list(by), sort=False).indices.items(): - yield (key if isinstance(key, tuple) else (key,)), positions - - -def _check_summary( - summary: pd.DataFrame, by: Sequence[str] = (), hint: str = _SUMMARIZE -) -> None: - """ - Checks that a data frame is a summary of designs (a row per design, in - each group of the columns `by`), not the results of a study (a row per - replicate), which the functions of summaries would judge as if each - replicate were a design, raising a `ValueError` with a hint of what to do - if not. - """ - if "design" in summary.columns: - keys = summary[["design", *(c for c in by if c in summary.columns)]] - elif summary.index.name == "design" and not by: - keys = summary.index.to_frame() - else: - return - if keys.duplicated().any(): - raise ValueError(f"the data frame has several rows of a design: {hint}") - - -def _get_matrices( - group: pd.DataFrame, - columns: Sequence[str], - designs: pd.Index | None = None, - replicates: pd.Index | None = None, - hint: str = _SEPARATE, -) -> tuple[pd.Index, pd.Index, dict[str, np.ndarray]]: - """ - Gets the values of metrics of each design (rows) in each replicate - (columns) of the results of a group, which must have one record per - evaluation (a design in a replicate, or a `ValueError` with a hint of - how to separate them): of the designs and replicates of the group, or of - those given (`NaN` without a record). - """ - missing = [column for column in columns if column not in group.columns] - if missing: - raise ValueError(f"metrics that are not in the results: {missing}") - keys = ["design", "replicate"] - if group.duplicated(keys).any(): - candidates = [ - column - for column in group.columns - if column not in (*_STATUS_COLUMNS, *columns) - ] - counts = group.groupby(keys)[candidates].nunique(dropna=False).max() - varying = list(counts.index[counts > 1]) - raise ValueError( - "the results have several records of an evaluation (a design in a " - + f"replicate): {hint}" - + (f", such as {varying}" if varying else "") - ) - if designs is None: - designs = pd.Index(group["design"].drop_duplicates()) - if replicates is None: - replicates = pd.Index(sorted(group["replicate"].unique())) - matrices = {} - for column in columns: - table = group.pivot(index="design", columns="replicate", values=column) - matrices[column] = table.reindex(index=designs, columns=replicates).to_numpy( - dtype=float - ) - return designs, replicates, matrices - - def _replicates_of(feasible: pd.DataFrame, infeasible: pd.DataFrame) -> pd.Index: """Gets the replicates of feasible and infeasible records, in order.""" return pd.Index(sorted({*feasible["replicate"], *infeasible["replicate"]})) @@ -204,22 +86,20 @@ def _feasibility( def _evaluate( statistics: Mapping[str, Statistic], - requirements: Sequence[Requirement], - matrices: Mapping[str, np.ndarray], + values: Mapping[str, np.ndarray], columns: np.ndarray | None = None, -) -> tuple[dict[str, np.ndarray], np.ndarray]: +) -> dict[str, np.ndarray]: """ - Computes statistics (of the replicates `columns` of the matrices, or all) - and the total violation of the requirements of each design. + Computes statistics of each design from the values of the columns of the + results in its replicates (of the replicates `columns`, or all). """ - values = {} + computed = {} for name, statistic in statistics.items(): - matrix = statistic.values_of(matrices) - values[name] = statistic.reduce( + matrix = statistic.values_of(values) + computed[name] = statistic.reduce( matrix if columns is None else matrix[:, columns] ) - n = len(next(iter(matrices.values()))) if matrices else 0 - return values, _violation_of(values, requirements, n) + return computed def _across_groups(results: pd.DataFrame, across: Across | None) -> list | None: @@ -254,6 +134,57 @@ def _attributed( return infeasible[mask] +def _covariances( + a: np.ndarray, b: np.ndarray +) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: + """ + Gets the sample covariance of the values of each design (rows) in two + groups over the replicates (columns) in which both have values, and the + numbers of these replicates and of the values of each group (the + covariance is `NaN` with fewer than two shared replicates). + """ + both = ~np.isnan(a) & ~np.isnan(b) + shared = both.sum(axis=1) + counts = (~np.isnan(a)).sum(axis=1), (~np.isnan(b)).sum(axis=1) + x, y = np.where(both, a, 0.0), np.where(both, b, 0.0) + with np.errstate(invalid="ignore", divide="ignore"): + mx = x.sum(axis=1) / shared + my = y.sum(axis=1) / shared + products = np.where(both, (x - mx[:, None]) * (y - my[:, None]), 0.0) + covariance = products.sum(axis=1) / (shared - 1) + covariance = np.where(shared > 1, covariance, np.nan) + return covariance, shared, *counts + + +def _spread_of_mean( + parts: Sequence[np.ndarray], weights: np.ndarray +) -> tuple[np.ndarray, np.ndarray]: + """ + Gets the spread of the weighted mean of the means of the values of each + design (rows) in groups (`parts`) over their replicates (columns), from + the covariances of the groups over the replicates they share (none + between groups without shared replicates): the standard deviation of the + weighted sum of the values of a replicate, and the standard error of the + weighted mean of the groups' means. + """ + # the variance of the weighted sum, and the squared standard error, from + # terms whose magnitudes tell rounding from a variance + totals = np.zeros((2, len(parts[0]))) + magnitudes = np.zeros((2, len(parts[0]))) + for s, a in enumerate(parts): + for t, b in enumerate(parts): + covariance, shared, n_a, n_b = _covariances(a, b) + if s != t: + covariance = np.nan_to_num(covariance) + weighted = weights[s] * weights[t] * covariance + with np.errstate(invalid="ignore", divide="ignore"): + terms = np.vstack([weighted, weighted * shared / (n_a * n_b)]) + totals += terms + magnitudes += np.abs(terms) + totals = np.where(totals <= _NEGLIGIBLE * magnitudes, 0.0, totals) + return np.sqrt(totals[0]), np.sqrt(totals[1]) + + class _Statistics: """ The statistics of the designs of the feasible results of a group (of the @@ -270,13 +201,10 @@ class _Statistics: Args: results (pandas.DataFrame): The feasible results of a group. statistics (Mapping[str, Statistic]): The statistics, by name. - requirements (Sequence[Requirement]): The requirements. - across (Across | None): The rule that combines the groups of a - column, if any. - combiners (Mapping[str, str] | None): How each statistic is combined - (see `_combiners`), with a rule. - groups (Sequence | None): The groups of the column (of every result), - with a rule. + criteria (Criteria | None): The criteria (of the requirements, and + of the rule that combines the groups of a column), if any. + levels (Sequence | None): The groups of the column (of every result) + that the criteria combine, if any. infeasible (pandas.DataFrame | None): The infeasible results of the group, if any. """ @@ -285,33 +213,31 @@ def __init__( self, results: pd.DataFrame, statistics: Mapping[str, Statistic], - requirements: Sequence[Requirement] = (), - across: Across | None = None, - combiners: Mapping[str, str] | None = None, - groups: Sequence | None = None, + criteria: Criteria | None = None, + levels: Sequence | None = None, infeasible: pd.DataFrame | None = None, ): - self.statistics, self.requirements = statistics, requirements - self.combiners = combiners + self.statistics, self.criteria = statistics, criteria + across = None if criteria is None else criteria.across + self.combiners = None if across is None else criteria.combiners infeasible = results.iloc[:0] if infeasible is None else infeasible columns = {c for statistic in statistics.values() for c in statistic.columns} - metrics = sorted(columns - {_FEASIBLE}) + metrics = sorted(columns - {FEASIBLE}) # statistics of the feasibility alone are over every group together self.pooled = { name for name, statistic in statistics.items() - if set(statistic.columns) == {_FEASIBLE} + if set(statistic.columns) == {FEASIBLE} } if across is None: self.designs = pd.Index(results["design"].drop_duplicates()) infeasible = infeasible[infeasible["design"].isin(self.designs)] self.replicates = _replicates_of(results, infeasible) - matrices = _get_matrices(results, metrics, self.designs, self.replicates)[2] - if _FEASIBLE in columns: - matrices[_FEASIBLE] = _feasibility( - results, infeasible, self.designs, self.replicates - ) - self.matrices = [matrices] + values = matrices(results, metrics, self.designs, self.replicates)[2] + values[FEASIBLE] = _feasibility( + results, infeasible, self.designs, self.replicates + ) + self.matrices = [values] self.counts = ( results.groupby("design")["replicate"] .nunique() @@ -321,12 +247,12 @@ def __init__( return combined = [name for name in statistics if name not in self.pooled] self.weights = ( - across.weights_of(groups) - if any(combiners[name] == "mean" for name in combined) + across.weights_of(levels) + if any(self.combiners.get(name, "mean") == "mean" for name in combined) else None ) parts = [ - results[(results[across.column] == group).to_numpy()] for group in groups + results[(results[across.column] == group).to_numpy()] for group in levels ] complete = set.intersection(*(set(part["design"]) for part in parts)) designs = results["design"].drop_duplicates() @@ -334,14 +260,11 @@ def __init__( infeasible = infeasible[infeasible["design"].isin(self.designs)] self.replicates = _replicates_of(results, infeasible) self.matrices = [] - for group, part in zip(groups, parts): - matrices = _get_matrices(part, metrics, self.designs, self.replicates)[2] - if _FEASIBLE in columns: - failed = infeasible[(infeasible[across.column] == group).to_numpy()] - matrices[_FEASIBLE] = _feasibility( - part, failed, self.designs, self.replicates - ) - self.matrices.append(matrices) + for group, part in zip(levels, parts): + values = matrices(part, metrics, self.designs, self.replicates)[2] + failed = infeasible[(infeasible[across.column] == group).to_numpy()] + values[FEASIBLE] = _feasibility(part, failed, self.designs, self.replicates) + self.matrices.append(values) self.counts = ( results.groupby(["design", across.column])["replicate"] .nunique() @@ -364,6 +287,12 @@ def _pooled(self, statistic: Statistic, columns: np.ndarray | None) -> np.ndarra ] return statistic.reduce(matrix) + def _violation(self, values: Mapping[str, np.ndarray]) -> np.ndarray: + """Gets the total violation of the requirements of the criteria.""" + if self.criteria is None: + return np.zeros(len(self.designs)) + return self.criteria.violation(values, len(self.designs)) + def evaluate( self, columns: np.ndarray | None = None ) -> tuple[dict[str, np.ndarray], np.ndarray]: @@ -372,88 +301,86 @@ def evaluate( of the matrices, or all) and the total violation of the requirements. """ if self.combiners is None: - return _evaluate( - self.statistics, self.requirements, self.matrices[0], columns - ) + values = _evaluate(self.statistics, self.matrices[0], columns) + return values, self._violation(values) combined = { name: statistic for name, statistic in self.statistics.items() if name not in self.pooled } - parts = [_evaluate(combined, (), m, columns)[0] for m in self.matrices] + parts = [_evaluate(combined, m, columns) for m in self.matrices] values = {} for name, statistic in self.statistics.items(): if name in self.pooled: values[name] = self._pooled(statistic, columns) continue stacked = np.vstack([part[name] for part in parts]) - how = self.combiners[name] + how = self.combiners.get(name, "mean") if how == "max": values[name] = stacked.max(axis=0) elif how == "min": values[name] = stacked.min(axis=0) else: values[name] = self.weights @ stacked - return values, _violation_of(values, self.requirements, len(self.designs)) - + return values, self._violation(values) -def _design_columns(results: pd.DataFrame, excluded: set[str]) -> list[str]: - """ - Gets the columns of the values of designs: those (other than `excluded`) - that are the same in every record of each design. - """ - candidates = [column for column in results.columns if column not in excluded] - if not candidates or len(results) == 0: - return [] - constant = results.groupby("design")[candidates].nunique(dropna=False) - return [column for column in candidates if (constant[column] <= 1).all()] - - -def _value_columns( - feasible: pd.DataFrame, - statistics: Mapping[str, Statistic], - by: Sequence[str], - across: Across | None, - design_columns: Sequence[str] | None, -) -> list[str]: - """ - Gets the columns of the values of designs that a summary keeps: those - given, or those that are the same in every record of each design (but - the metrics of the statistics, the columns of groups, and status - columns). - """ - combined = [] if across is None else [across.column] - if design_columns is None: - metrics = { - column for statistic in statistics.values() for column in statistic.columns - } - design_columns = _design_columns( - feasible, {*_STATUS_COLUMNS, *metrics, *by, *combined} - ) - return [ - c for c in design_columns if c not in statistics and c not in (*by, *combined) - ] + def judged(self, columns: np.ndarray) -> np.ndarray: + """ + Gets whether each design has a feasible record among some replicates + (`columns`) in every group, without which it is not judged by them. + """ + found = np.ones(len(self.designs), dtype=bool) + for values in self.matrices: + found &= np.any(values[FEASIBLE][:, columns] == 1, axis=1) + return found + def recorded(self, columns: np.ndarray) -> np.ndarray: + """ + Gets whether each design has a record (feasible or not) among some + replicates (`columns`), in any group. + """ + found = np.zeros(len(self.designs), dtype=bool) + for values in self.matrices: + found |= np.any(~np.isnan(values[FEASIBLE][:, columns]), axis=1) + return found -def _with_values( - frame: pd.DataFrame, group: pd.DataFrame, designs: Any, columns: Sequence[str] -) -> None: - """ - Adds the values of designs (columns of the first record of each design of - a group of results) to the rows of a summary of the designs. - """ - first = group.drop_duplicates("design").set_index("design") - for column in columns: - frame[column] = first.loc[designs, column].to_numpy() + def spread(self, name: str, statistic: Statistic) -> tuple[np.ndarray, np.ndarray]: + """ + Computes the spread of a mean of a metric (of a name) over the + replicates of each design: its standard deviation and standard error + (see `summarize`), and, across groups, those of the statistic of the + groups that it combines into. + """ + deviation = StandardDeviation(statistic.column) + error = StandardError(statistic.column) + if self.combiners is None: + values = statistic.values_of(self.matrices[0]) + return deviation.reduce(values), error.reduce(values) + parts = [statistic.values_of(m) for m in self.matrices] + how = self.combiners.get(name, "mean") + if how in ("max", "min"): + # the spread of the group of the worst value + means = np.vstack([statistic.reduce(part) for part in parts]) + deviations = np.vstack([deviation.reduce(part) for part in parts]) + errors = np.vstack([error.reduce(part) for part in parts]) + filled = np.where( + np.isnan(means), -np.inf if how == "max" else np.inf, means + ) + chosen = filled.argmax(axis=0) if how == "max" else filled.argmin(axis=0) + rows = np.arange(len(self.designs)) + missing = np.isnan(means).any(axis=0) + return ( + np.where(missing, np.nan, deviations[chosen, rows]), + np.where(missing, np.nan, errors[chosen, rows]), + ) + return _spread_of_mean(parts, self.weights) def _summary_groups( results: pd.DataFrame, statistics: Mapping[str, Statistic], by: Sequence[str], - requirements: Sequence[Requirement] = (), - across: Across | None = None, - combiners: Mapping[str, str] | None = None, + criteria: Criteria | None = None, design_columns: Sequence[str] | None = None, ) -> Iterator[tuple[pd.DataFrame, _Statistics]]: """ @@ -463,21 +390,21 @@ def _summary_groups( see `aggregate`), and their statistics (see `_Statistics`). Results without a feasible record have no groups. """ - feasible, infeasible = _feasible_records(results) + feasible, infeasible = feasible_records(results) if feasible.empty: return - groups = _across_groups(results, across) - columns = _value_columns(feasible, statistics, by, across, design_columns) - for key, positions in _groups(feasible, by): + across = None if criteria is None else criteria.across + combined = _across_groups(results, across) + grouped = [*by, *([] if across is None else [across.column])] + columns = value_columns(results, statistics, grouped, design_columns) + for key, positions in groups(feasible, by): group = feasible.iloc[positions] failed = _attributed(infeasible, by, key) - table = _Statistics( - group, statistics, requirements, across, combiners, groups, failed - ) + table = _Statistics(group, statistics, criteria, combined, failed) frame = pd.DataFrame({"design": table.designs}) for name, value in zip(by, key): frame[name] = value - _with_values(frame, group, table.designs, columns) + with_values(frame, group, table.designs, columns) yield frame, table @@ -490,7 +417,7 @@ def _criteria_of( Gets the criteria (if any) of the arguments of `aggregate`, the statistics to compute (by name), and the columns that group records. """ - by = (by,) if isinstance(by, str) else tuple(by) + by = tuple(names(by)) extra = _named_statistics(statistics) if isinstance(criteria, Mapping) and not set(criteria.values()) <= {"min", "max"}: raise ValueError( @@ -502,7 +429,7 @@ def _criteria_of( raise ValueError( "criteria group records by their own `by`: give it to the criteria" ) - judged = _as_criteria(criteria) + judged = Criteria.of(criteria) if by: judged = replace(judged, by=by) if extra: @@ -516,8 +443,8 @@ def _criteria_of( f"statistics that the criteria name otherwise: {clashes}" ) judged = replace(judged, statistics={**judged.statistics, **extra}) - return judged, _resolve(judged), judged.by - metrics = [criteria] if isinstance(criteria, str) else list(criteria) + return judged, judged.resolved, judged.by + metrics = names(criteria) resolved: dict[str, Statistic] = {name: Mean(name) for name in metrics} resolved.update(extra) if not resolved: @@ -532,9 +459,38 @@ def _with_feasibility(statistics: Mapping[str, Statistic]) -> dict[str, Statisti Gets statistics with the share of the replicates of each design that are feasible (`feasible`), unless a statistic has the name. """ - if _FEASIBLE in statistics: + if FEASIBLE in statistics: return dict(statistics) - return {**statistics, _FEASIBLE: Mean(_FEASIBLE)} + return {**statistics, FEASIBLE: Mean(FEASIBLE)} + + +def _check_names( + statistics: Mapping[str, Statistic], + results: pd.DataFrame, + added: Sequence[str] = (), +) -> None: + """ + Checks that no statistic but the mean of a metric (of its name), and no + column `added` to a summary (such as a standard error), has the name of + a column of the results, which it would be taken for (such as a + probability over the replicates for the share of the histories of a + replicate that meet a requirement, see `summarize_histories`). + """ + clashes = sorted( + { + *( + name + for name, statistic in statistics.items() + if name in results.columns and statistic != Mean(name) + ), + *(name for name in added if name in results.columns), + } + ) + if clashes: + raise ValueError( + f"statistics with the names of columns of the results: {clashes} (a " + + "statistic of a column's name is its mean): give them other names" + ) def _judge( @@ -551,11 +507,10 @@ def _judge( those that do (`pareto`). """ meets = violation == 0 - tolerances = _get_tolerances(criteria.objectives, criteria.tolerances) - violations, requirements, efficient = _JUDGMENT + violations, requirements, front = JUDGMENT frame[violations] = violation frame[requirements] = meets - frame[efficient] = _efficient(_costs_of(values, criteria), meets, tolerances) + frame[front] = efficient(criteria.costs(values), meets, criteria.tolerance_array) def _assemble( @@ -573,12 +528,12 @@ def _assemble( (`feasible`), and their judgment by criteria (if any, see `_judge`). """ for name, value in values.items(): - if name != _FEASIBLE: + if name != FEASIBLE: frame[name] = value for name, value in (extra or {}).items(): frame[name] = value frame["replicates"] = table.counts - frame[_FEASIBLE] = values[_FEASIBLE] + frame[FEASIBLE] = values[FEASIBLE] if criteria is not None: _judge(frame, values, violation, criteria) return frame @@ -587,36 +542,104 @@ def _assemble( def _summaries( frames: Sequence[pd.DataFrame], by: Sequence[str], - statistics: Mapping[str, Statistic], + columns: Sequence[str], criteria: Criteria | None, - extra: Sequence[str] = (), after: Sequence[str] = (), ) -> pd.DataFrame: """ Gets a summary of the frames of its groups (see `_assemble`), or an empty one of its columns (without the values of designs) if there are none, - such as of results without a feasible record: the statistics, `extra` - columns, `replicates`, `feasible`, the judgment (with criteria), and the - columns `after`. + such as of results without a feasible record: the `columns` of + statistics, `replicates`, `feasible`, the judgment (with criteria), and + the columns `after`. """ if frames: return pd.concat(frames, ignore_index=True) - names = [name for name in statistics if name != _FEASIBLE] dtypes = { "design": object, **{column: object for column in by}, - **{name: float for name in [*names, *extra]}, + **{name: float for name in columns if name != FEASIBLE}, "replicates": int, - _FEASIBLE: float, + FEASIBLE: float, } if criteria is not None: - dtypes.update(zip(_JUDGMENT, (float, bool, bool))) + dtypes.update(zip(JUDGMENT, (float, bool, bool))) dtypes.update({column: float for column in after}) return pd.DataFrame( {column: pd.Series(dtype=dtype) for column, dtype in dtypes.items()} ) +def _without_constant(summary: pd.DataFrame, columns: Sequence[str]) -> pd.DataFrame: + """ + Removes the columns of spreads (such as standard errors) of a summary + that are zero (or `NaN`) for every design, such as of a metric that is + the same in every replicate of each design (a summary without designs + keeps them). + """ + if summary.empty: + return summary + constant = [ + column + for column in columns + if column in summary.columns + and (summary[column].fillna(0.0).to_numpy(dtype=float) == 0).all() + ] + return summary.drop(columns=constant) + + +def _summarize( + results: pd.DataFrame, + judged: Criteria | None, + resolved: Mapping[str, Statistic], + by: Sequence[str], + design_columns: Sequence[str] | None, + spread: Sequence[str] = (), +) -> pd.DataFrame: + """ + Summarizes results by the statistics of their designs (see `aggregate`), + with the spread of the means of metrics (by name) of `spread` (see + `summarize`): after each mean without criteria, and after the + statistics with criteria. + """ + statistics = _with_feasibility(resolved) + spreads = [ + f"{name} {suffix}" + for name in spread + for suffix in ("std", "se") + if f"{name} {suffix}" not in statistics + ] + _check_names(statistics, results, spreads) + order: list[str] = [] + for name in statistics: + order.append(name) + if judged is None: + order.extend(c for c in (f"{name} std", f"{name} se") if c in spreads) + if judged is not None: + order.extend(spreads) + frames = [] + for frame, table in _summary_groups( + results, statistics, by, judged, design_columns + ): + values, violation = table.evaluate() + for name in spread: + deviation, error = table.spread(name, statistics[name]) + values.update( + { + column: value + for column, value in ( + (f"{name} std", deviation), + (f"{name} se", error), + ) + if column in spreads + } + ) + ordered = {name: values[name] for name in order} + frames.append(_assemble(frame, table, ordered, violation, judged)) + summary = _summaries(frames, by, order, judged) + return _without_constant(summary, spreads) + + def aggregate( results: pd.DataFrame, criteria: Criteria | Mapping[str, str] | Sequence[str] | str = (), @@ -646,6 +669,10 @@ def aggregate( aggregate(results, statistics=[Quantile("cost", 0.7)]) # cost p70 aggregate(results, COST, statistics=["cost development"]) + A statistic of the name of a column of the results is the mean of the + column: any other statistic of the name raises an error, as its values + would be taken for those of the column. + With criteria, the summary also gives the `violation` of their requirements (the sum of the violations, see `Requirement`, 0 if the design meets them all), whether the design meets them @@ -686,20 +713,14 @@ def aggregate( Returns: pandas.DataFrame: a row per feasible design (and group) + + Raises: + ValueError: if a statistic other than the mean of a column has the + column's name, or the results have several records of an + evaluation (in a group). """ judged, resolved, by = _criteria_of(criteria, statistics, by) - statistics = _with_feasibility(resolved) - across, combiners, requirements = None, None, () - if judged is not None: - requirements, across = judged.requirements, judged.across - combiners = None if across is None else _combiners(judged) - frames = [ - _assemble(frame, table, *table.evaluate(), judged) - for frame, table in _summary_groups( - results, statistics, by, requirements, across, combiners, design_columns - ) - ] - return _summaries(frames, by, statistics, judged) + return _summarize(results, judged, resolved, by, design_columns) def summarize( @@ -728,6 +749,25 @@ def summarize( front = summary[summary.pareto] summarize(results, ACCURACY, statistics=["sufficient"]) # and its mean + The spread of a mean that is zero for every design (of a metric that is + the same in every replicate of each design, such as a number of + satellites, or a design with one replicate) is left out of the summary + (but that of a summary without designs). + + With criteria `across` the groups of a column (such as scenarios, see + `Across`), the spread is that of the statistic combined from the groups: + of the worst, the spread in the group of the worst value; of a weighted + mean, the standard deviation of the weighted sum of the values of a + replicate in each group, and the standard error of the weighted mean of + the groups' means, from the covariances of the groups over the + replicates they share (the same replicate in every group, in which it + has the same uncertain parameters, see `Study`), so that what the groups + share cancels. Groups without shared replicates are independent: the + standard error is then the square root of the weighted sum of the + squared standard errors of the groups (by the squared weights). These + are of the same kind as the standard errors of the bootstrap of + `pareto_probability`, of the combined statistic. + Args: results (pandas.DataFrame): The results (see `Study.run`). criteria (Criteria | Mapping[str, str] | Sequence[str] | str): The @@ -745,25 +785,12 @@ def summarize( pandas.DataFrame: the summary, a row per feasible design (and group) """ judged, resolved, by = _criteria_of(criteria, statistics, by) - summarized: dict[str, Statistic] = {} - spread: dict[str, Statistic] = {} - for name, statistic in resolved.items(): - summarized[name] = statistic - if type(statistic) is Mean and _FEASIBLE not in statistic.columns: - spread[f"{name} std"] = StandardDeviation(statistic.column) - spread[f"{name} se"] = StandardError(statistic.column) - summarized.update( - { - f"{name} std": spread[f"{name} std"], - f"{name} se": spread[f"{name} se"], - } - ) - if judged is None: - # each mean of a metric followed by its spread - return aggregate( - results, statistics=summarized, by=by, design_columns=design_columns - ) - return aggregate(results, judged, statistics=spread, design_columns=design_columns) + spread = [ + name + for name, statistic in resolved.items() + if type(statistic) is Mean and FEASIBLE not in statistic.columns + ] + return _summarize(results, judged, resolved, by, design_columns, spread) def pareto_probability( @@ -792,17 +819,20 @@ def pareto_probability( within the tolerances of the front are efficient (see `pareto_front`). With few replicates, the bootstrap has few distinct resamples and understates the uncertainty. Designs may have different replicates (as - after `refine`): replicates are drawn from all of them, and each design's - statistics are those of its drawn replicates (or of all of its - replicates, if none is drawn). With criteria `across` the scenarios of a - study (see `Across`), a drawn replicate is drawn in every scenario, in - which it has the same uncertain parameters. + after `refine`): replicates are drawn from all of them, each design's + statistics are those of its drawn replicates, and a design none of whose + replicates is drawn keeps the statistics of all of them. With criteria + `across` the scenarios of a study (see `Across`), a drawn replicate is + drawn in every scenario, in which it has the same uncertain parameters. Designs are judged by their feasible replicates, and the replicates in which a design is infeasible are drawn too: the statistics of a resample - are those of its feasible replicates, and the share of its replicates - that are feasible (`feasible`, see `aggregate`) is that of the drawn - replicates. + are those of the drawn replicates in which the design is feasible, and + the share of its replicates that are feasible (`feasible`, see + `aggregate`) is that of the drawn replicates. A design whose drawn + replicates are all infeasible (in a scenario, with criteria `across` + scenarios) is not judged in the resample: it neither meets the + requirements nor is efficient. Args: results (pandas.DataFrame): The results of a study (see @@ -822,29 +852,29 @@ def pareto_probability( without one: the summary of the criteria over every replicate (see `aggregate`: the values of the design, the statistics, the standard error of each objective, ` se`, its standard - deviation over the resamples, the number of feasible + deviation over the resamples, left out if it is zero for every + design, as `summarize` leaves out spreads, the number of feasible `replicates`, the share of the replicates that are `feasible`, the `violation` of the requirements, whether the design meets them, `meets_requirements`, and whether it is efficient among those that do, `pareto`), the probability that it is efficient (`pareto_probability`), and the probability that it meets the requirements (`requirements_probability`) + + Raises: + ValueError: if a statistic other than the mean of a column has the + column's name, or the results have several records of an + evaluation (in a group). """ - criteria = _as_criteria(criteria) - statistics = _with_feasibility(_resolve(criteria)) - tolerances = _get_tolerances(criteria.objectives, criteria.tolerances) - combiners = None if criteria.across is None else _combiners(criteria) + criteria = Criteria.of(criteria) + statistics = _with_feasibility(criteria.resolved) errors = [f"{name} se" for name in criteria.objectives] + _check_names(statistics, results, errors) + tolerances = criteria.tolerance_array rng = np.random.default_rng(seed) frames = [] for frame, table in _summary_groups( - results, - statistics, - criteria.by, - criteria.requirements, - criteria.across, - combiners, - design_columns, + results, statistics, criteria.by, criteria, design_columns ): values, violation = table.evaluate() counts = np.zeros(len(table.designs)) @@ -852,16 +882,17 @@ def pareto_probability( # the sums of the objectives (and of their squares) over the resamples sums = {name: np.zeros(len(table.designs)) for name in criteria.objectives} squares = {name: np.zeros(len(table.designs)) for name in criteria.objectives} - for drawn in _resamples(len(table.replicates), n_resamples, rng): + for drawn in draw_resamples(len(table.replicates), n_resamples, rng): sample, sample_violation = table.evaluate(drawn) - # designs without a drawn replicate keep the statistics of all of theirs + # designs without a drawn replicate keep the statistics of all of + # theirs, and those without a feasible one are not judged + undrawn = ~table.recorded(drawn) for name in sample: - missing = np.isnan(sample[name]) & ~np.isnan(values[name]) - sample[name][missing] = values[name][missing] - missing = np.isnan(sample_violation) - sample_violation[missing] = violation[missing] - meets = sample_violation == 0 - counts += _efficient(_costs_of(sample, criteria), meets, tolerances) + sample[name][undrawn] = values[name][undrawn] + sample_violation[undrawn] = violation[undrawn] + judged = table.judged(drawn) | undrawn + meets = (sample_violation == 0) & judged + counts += efficient(criteria.costs(sample), meets, tolerances) met += meets for name in criteria.objectives: sums[name] += sample[name] @@ -874,11 +905,11 @@ def pareto_probability( frame["pareto_probability"] = counts / n_resamples frame["requirements_probability"] = met / n_resamples frames.append(frame) - return _summaries( + summary = _summaries( frames, criteria.by, - statistics, + [*statistics, *errors], criteria, - extra=errors, after=["pareto_probability", "requirements_probability"], ) + return _without_constant(summary, errors) diff --git a/src/tatc/tradespace/tables.py b/src/tatc/tradespace/tables.py new file mode 100644 index 00000000..ce05dd38 --- /dev/null +++ b/src/tatc/tradespace/tables.py @@ -0,0 +1,340 @@ +""" +Tables of trade studies: the results of a study (a row per evaluation, a +design in a replicate) and the summaries of its designs (a row per design): +their columns, their groups, the values of the metrics of designs in each +replicate, the values of designs, and checks that a table has the rows that +a function needs. + +@author: Paul T. Grogan +""" + +from __future__ import annotations + +from collections.abc import Iterable, Iterator, Mapping, Sequence +from typing import Any + +import numpy as np +import pandas as pd + +from .space import STATUS_COLUMNS + +FEASIBLE = "feasible" +"""The column of the results of a study of whether each record is feasible, +and the statistic (and column of summaries) of the share of a design's +replicates that are feasible (see `aggregate`).""" + +JUDGMENT = ("violation", "meets_requirements", "pareto") +"""The columns of the judgment of designs by criteria in their summaries (see +`aggregate`).""" + +SEPARATE = ( + "give the columns that separate them as `by` (of the criteria), or combine " + + "their groups `across` (see Across)" +) +"""How to separate several records of an evaluation for criteria.""" + +SUMMARIZE = ( + "summarize the results of a study (a row per replicate) first, with a row " + + "per design (see aggregate), or select the rows of one group (such as those " + + "of a scenario)" +) +"""How to give each design one row, rather than the results of a study (a +row per replicate).""" + + +def names(value: str | Iterable[str]) -> list[str]: + """ + Gets names given as a name or a sequence of names. + + Args: + value (str | Iterable[str]): The name, or names. + + Returns: + list[str]: the names + """ + return [value] if isinstance(value, str) else list(value) + + +def groups(frame: pd.DataFrame, by: Sequence[str]) -> Iterator[tuple[tuple, Any]]: + """ + Iterates over the groups of a data frame by columns (or the frame, if + none): the values of the columns, and the positions of the group's rows. + + Args: + frame (pandas.DataFrame): The data frame. + by (Sequence[str]): The columns. + + Returns: + Iterator[tuple[tuple, numpy.ndarray]]: the values and positions of + each group + + Raises: + ValueError: if the frame lacks a column. + """ + if not by: + yield (), np.arange(len(frame)) + return + missing = [column for column in by if column not in frame.columns] + if missing: + raise ValueError(f"no columns {missing} to group by") + for key, positions in frame.groupby(list(by), sort=False).indices.items(): + yield (key if isinstance(key, tuple) else (key,)), positions + + +def check_summary( + summary: pd.DataFrame, by: Sequence[str] = (), hint: str = SUMMARIZE +) -> None: + """ + Checks that a data frame is a summary of designs (a row per design, in + each group of the columns `by`), not the results of a study (a row per + replicate), which the functions of summaries would judge as if each + replicate were a design. + + Args: + summary (pandas.DataFrame): The data frame. + by (Sequence[str]): The columns of groups, in each of which a design + may have a row. + hint (str): What to do if the data frame is not a summary. + + Raises: + ValueError: if the data frame has several rows of a design (in a + group), with the hint. + """ + if "design" in summary.columns: + keys = summary[["design", *(c for c in by if c in summary.columns)]] + elif summary.index.name == "design" and not by: + keys = summary.index.to_frame() + else: + return + if keys.duplicated().any(): + raise ValueError(f"the data frame has several rows of a design: {hint}") + + +def check_records( + results: pd.DataFrame, + keys: Sequence[str] = ("design", "replicate"), + hint: str = SEPARATE, + metrics: Sequence[str] = (), +) -> None: + """ + Checks that results have one record per evaluation (a design in a + replicate, or a combination of the values of other `keys`). + + Args: + results (pandas.DataFrame): The results. + keys (Sequence[str]): The columns of an evaluation. + hint (str): How to separate several records of an evaluation. + metrics (Sequence[str]): The metrics, whose values may differ + between the records of an evaluation without separating them. + + Raises: + ValueError: if the results have several records of an evaluation, + with the hint and the columns whose values differ between them + (which may separate them). + """ + keys = list(keys) + if not results.duplicated(keys).any(): + return + candidates = [ + column + for column in results.columns + if column not in (*STATUS_COLUMNS, *keys, *metrics) or column == "scenario" + ] + varying: list[str] = [] + if candidates: + counts = results.groupby(keys)[candidates].nunique(dropna=False).max() + varying = list(counts.index[counts > 1]) + raise ValueError( + "the results have several records of an evaluation (a design in a " + + f"replicate): {hint}" + + (f", such as {varying}" if varying else "") + ) + + +def matrices( + group: pd.DataFrame, + columns: Sequence[str], + designs: pd.Index | None = None, + replicates: pd.Index | None = None, + hint: str = SEPARATE, +) -> tuple[pd.Index, pd.Index, dict[str, np.ndarray]]: + """ + Gets the values of metrics of each design (rows) in each replicate + (columns) of the results of a group, which must have one record per + evaluation (see `check_records`): of the designs and replicates of the + group, or of those given (`NaN` without a record). + + Args: + group (pandas.DataFrame): The results. + columns (Sequence[str]): The metrics. + designs (pandas.Index | None): The designs (keys), or `None` for + those of the results, in order. + replicates (pandas.Index | None): The replicates, or `None` for those + of the results, sorted. + hint (str): How to separate several records of an evaluation. + + Returns: + tuple[pandas.Index, pandas.Index, dict[str, numpy.ndarray]]: the + designs, the replicates, and the values of each metric (shape + (designs, replicates)) + + Raises: + ValueError: if the results lack a metric, or have several records + of an evaluation. + """ + missing = [column for column in columns if column not in group.columns] + if missing: + raise ValueError(f"metrics that are not in the results: {missing}") + check_records(group, hint=hint, metrics=columns) + if designs is None: + designs = pd.Index(group["design"].drop_duplicates()) + if replicates is None: + replicates = pd.Index(sorted(group["replicate"].unique())) + values = {} + for column in columns: + table = group.pivot(index="design", columns="replicate", values=column) + values[column] = table.reindex(index=designs, columns=replicates).to_numpy( + dtype=float + ) + return designs, replicates, values + + +def feasible_records(results: pd.DataFrame) -> tuple[pd.DataFrame, pd.DataFrame]: + """ + Gets the feasible and the infeasible records of results (every record is + feasible without a column `feasible`). + + Args: + results (pandas.DataFrame): The results. + + Returns: + tuple[pandas.DataFrame, pandas.DataFrame]: the feasible records and + the infeasible ones + """ + if FEASIBLE not in results.columns: + return results, results.iloc[:0] + status = results[FEASIBLE].astype(bool).to_numpy() + return results[status], results[~status] + + +def _constant_columns(results: pd.DataFrame, excluded: set[str]) -> list[str]: + """ + Gets the columns (other than `excluded`) that are the same in every + record of each design. + """ + candidates = [column for column in results.columns if column not in excluded] + if not candidates or len(results) == 0: + return [] + constant = results.groupby("design")[candidates].nunique(dropna=False) + return [column for column in candidates if (constant[column] <= 1).all()] + + +def value_columns( + results: pd.DataFrame, + statistics: Mapping[str, Any], + by: Sequence[str], + design_columns: Sequence[str] | None, +) -> list[str]: + """ + Gets the columns of the values of designs that a summary of results + keeps: those given, or those that are the same in every feasible record + of each design (but the metrics of the statistics, the columns of groups, + and status columns), without the names of statistics and the columns of + groups. + + Args: + results (pandas.DataFrame): The results. + statistics (Mapping[str, Statistic]): The statistics of the summary, + by name. + by (Sequence[str]): The columns of groups (such as those of the + criteria's `by`, and the column they combine `across`). + design_columns (Sequence[str] | None): The columns of the values of + designs, or `None` for those that are the same in every feasible + record of a design. + + Returns: + list[str]: the columns + """ + if design_columns is None: + metrics = { + column for statistic in statistics.values() for column in statistic.columns + } + design_columns = _constant_columns( + feasible_records(results)[0], {*STATUS_COLUMNS, *metrics, *by} + ) + return [c for c in design_columns if c not in statistics and c not in by] + + +def with_values( + frame: pd.DataFrame, results: pd.DataFrame, designs: Any, columns: Sequence[str] +) -> None: + """ + Adds the values of designs (columns of the first record of each design of + results) to the rows of the designs (in order) of a data frame. + + Args: + frame (pandas.DataFrame): The data frame, a row per design. + results (pandas.DataFrame): The results. + designs (Any): The keys of the designs of the rows. + columns (Sequence[str]): The columns of the values of designs. + """ + first = results.drop_duplicates("design").set_index("design") + for column in columns: + frame[column] = first.loc[designs, column].to_numpy() + + +def design_values( + results: pd.DataFrame, designs: Sequence[str], columns: Sequence[str] +) -> pd.DataFrame: + """ + Gets the values of designs from their records in results (see + `with_values`). + + Args: + results (pandas.DataFrame): The results. + designs (Sequence[str]): The keys of the designs. + columns (Sequence[str]): The columns of the values of designs. + + Returns: + pandas.DataFrame: a row per design: its key (`design`), and its values + """ + frame = pd.DataFrame({"design": list(designs)}) + with_values(frame, results, list(designs), columns) + return frame + + +def draw_resamples(count: int, n_resamples: int, seed: Any) -> np.ndarray: + """ + Gets the replicates of each resample of a bootstrap: a row per resample of + `count` replicates (their positions) drawn with replacement. + + Args: + count (int): The number of replicates. + n_resamples (int): The number of resamples (at least 2). + seed (Any): The seed, or a random number generator, which draws them. + + Returns: + numpy.ndarray: the positions of the replicates (shape (n_resamples, + count)) + + Raises: + ValueError: if `n_resamples` is less than 2. + """ + if n_resamples < 2: + raise ValueError("n_resamples must be at least 2") + return np.random.default_rng(seed).integers(count, size=(n_resamples, count)) + + +def efficient_keys(summary: pd.DataFrame) -> list: + """ + Gets the keys of the efficient designs of a summary of criteria (whose + `pareto` is true, in any group), each once, in order. + + Args: + summary (pandas.DataFrame): The summary (see `aggregate`). + + Returns: + list: the keys + """ + rows = summary["pareto"].to_numpy(dtype=bool) + return list(pd.unique(summary.loc[rows, "design"])) diff --git a/src/tatc/tradespace/values.py b/src/tatc/tradespace/values.py index a7057eae..49b0bc6b 100644 --- a/src/tatc/tradespace/values.py +++ b/src/tatc/tradespace/values.py @@ -1,17 +1,18 @@ """ -Views of the values of designs, and the scopes given to the callables of -design spaces. +Views of the values of designs, the scopes given to the callables of design +spaces, and the paths of values (see `Values`). @author: Paul T. Grogan """ from __future__ import annotations -import dataclasses import re from collections.abc import Iterator, Mapping from typing import Any +import numpy as np + class _ChoiceValue: """The value of a choice: the chosen branch and its value.""" @@ -70,6 +71,43 @@ def _join(path: str, segment: str | int) -> str: return f"{path}.{segment}" if path else segment +_ITEM_INDEX = re.compile(r"\[\d+\]") +"""The index of an item of a repetition in a path (`[k]`).""" + + +def generic_path(path: str) -> str: + """ + Gets the path of the node of a value: its path (see `Design.flat`) with + `[*]` for the index of any item of a repetition, as the paths of + uncertain parameters (see `DesignSpace.uncertain_paths`), shifts, and + the overrides of scenarios name them (such as `planes[*].phase` of + `planes[2].phase`). + + Args: + path (str): The path of a value. + + Returns: + str: the path, with `[*]` for the indices of items + """ + return _ITEM_INDEX.sub("[*]", path) + + +def is_number(value: Any) -> bool: + """ + Whether a value is a number: an integer or a float (also of numpy), but + not a boolean. + + Args: + value (Any): The value. + + Returns: + bool: `True` if the value is a number + """ + return isinstance(value, (int, float, np.number)) and not isinstance( + value, (bool, np.bool_) + ) + + def _step(value: Any, segment: str | int, path: str) -> Any: """ Gets the value of a segment of a path within a value (see `Values`): a @@ -165,9 +203,10 @@ class ChoiceValues: d.layout == "walker" # d.layout.choice == "walker" d.layout.planes # d.layout.walker.planes, if it chose walker - An attribute is a value of the branch if the branch has one of that - name, and otherwise the branch, if it is the branch's name; a path (see - `Values`) names the branch first, as the columns of results do. + An attribute is a value of the branch (of a branch that is a group, a + choice, or a repetition) if the branch has one of that name, and + otherwise the branch, if it is the branch's name; a path (see `Values`) + names the branch first, as the columns of results do. """ def __init__(self, value: _ChoiceValue): @@ -188,14 +227,18 @@ def __getattr__(self, name: str) -> Any: # then the branch by its name (which paths give first, see `Values`) if name.startswith("_"): raise AttributeError(name) - try: - return getattr(self.value, name) - except AttributeError: - if name == self._value.choice: - return self.value - raise AttributeError( - f"the choice chose {self.choice!r}, which has no value {name!r}" - ) from None + value = self.value + if isinstance(value, (Values, ChoiceValues, RepeatValues)): + # not the attributes of a branch that is a plain value (a variable) + try: + return getattr(value, name) + except AttributeError: + pass + if name == self._value.choice: + return value + raise AttributeError( + f"the choice chose {self.choice!r}, which has no value {name!r}" + ) def __getitem__(self, name: str) -> Any: return _resolve_path(self, name) @@ -338,44 +381,3 @@ def __getitem__(self, name: str) -> Any: value = _step(value, segment, walked) walked = _join(walked, segment) return value - - -def configure(base: Any, values: Any = None, **overrides: Any) -> Any: - """ - Configures a dataclass (such as a `RestorationPolicy` or a - `DeploymentSchedule`) from the values of a design: the fields of `base` - that the values name (such as those of `policy_space`, or design - variables named after fields) are replaced by them, as are those given - as keyword arguments. Values that name no field are ignored. - - Args: - base (Any): The dataclass instance, whose other fields are kept. - values (Any): The values of a design (a `Design`, a `Values` or - `ChoiceValues` view, or a mapping), or `None`. - **overrides (Any): Other values of fields. - - Returns: - Any: a copy of `base` with the values of its fields - - Raises: - TypeError: if `base` is not a dataclass instance, or `values` are - not values of a design. - """ - if not dataclasses.is_dataclass(base) or isinstance(base, type): - raise TypeError("configure requires a dataclass instance") - if isinstance(values, ChoiceValues): - values = values.value - elif values is not None and not isinstance(values, Mapping): - # a design (see `Design.values`), whose module imports this one - view = getattr(values, "values", None) - if not isinstance(view, Values): - raise TypeError( - f"configure requires the values of a design, not {values!r}" - ) - values = view - names = {field.name for field in dataclasses.fields(base)} - changes = {name: values[name] for name in (values or {}) if name in names} - unknown = set(overrides) - names - if unknown: - raise ValueError(f"no fields named {sorted(unknown)}") - return dataclasses.replace(base, **changes, **overrides) diff --git a/src/tatc/tradespace/walks.py b/src/tatc/tradespace/walks.py index 8cbe931c..255e1586 100644 --- a/src/tatc/tradespace/walks.py +++ b/src/tatc/tradespace/walks.py @@ -18,7 +18,6 @@ import copy import math -import re from collections.abc import Callable, Mapping from functools import partial from typing import Any @@ -38,7 +37,7 @@ Variable, _Domain, ) -from .values import Scope, _ChoiceValue, _join, _RepeatValue +from .values import Scope, _ChoiceValue, _join, _RepeatValue, is_number _ABSENT = object() """Marker of a node that records no decision (fixed, derived, or uncertain), @@ -151,17 +150,6 @@ class _Unsorted(Infeasible): """ -_ITEM_INDEX = re.compile(r"\[\d+\]") - - -def _generic(path: str) -> str: - """ - Gets the path of a node with `[*]` for the index of any item of a - repetition (as of `DesignSpace.uncertain_paths`). - """ - return _ITEM_INDEX.sub("[*]", path) - - def _walk( node: Node, path: str, @@ -225,6 +213,8 @@ def _walk_group( Decides the children of a group in order, then checks its constraints (see `_walk`). """ + if prescribed is not _ABSENT and ctx.normalize is not None: + _check_children(node, path, prescribed) values: dict = {} if publish is not None: publish(values) @@ -255,6 +245,26 @@ def _walk_group( return values, decisions +def _check_children(node: Group, path: str, prescribed: Any) -> None: + """ + Checks that the prescribed decisions of a group (such as those given to + `DesignSpace.design`) are a mapping of the decisions of its children, + raising a `ValueError` if not, or if they name others. + """ + where = path or "the design space" + if not isinstance(prescribed, Mapping): + raise ValueError( + f"the decisions of {where} are a mapping of its children, " + + f"not {prescribed!r}" + ) + unknown = [name for name in prescribed if name not in node.children] + if unknown: + raise ValueError( + f"decisions of no children of {where}: {sorted(unknown, key=str)} " + + f"(it has {list(node.children)})" + ) + + def _get_violation(result: Any) -> float: """ Gets the violation of a constraint from its result: a boolean (`True` if @@ -492,13 +502,6 @@ def advance(self) -> bool: return False -def _is_number(value: Any) -> bool: - """Whether a value is a number (not a boolean).""" - return isinstance(value, (int, float, np.number)) and not isinstance( - value, (bool, np.bool_) - ) - - def _level_of(path: str, domain: _Domain, value: Any) -> Any: """ Gets the value of a domain that a decision is (see `DesignSpace.design` @@ -523,9 +526,9 @@ def _level_of(path: str, domain: _Domain, value: Any) -> Any: return _scalar(level) except (TypeError, ValueError): continue - if _is_number(value): + if is_number(value): for level in domain.levels: - if _is_number(level) and math.isclose( + if is_number(level) and math.isclose( float(level), float(value), rel_tol=1e-9, abs_tol=1e-12 ): return _scalar(level) diff --git a/tests/tradespace/test_attribution.py b/tests/tradespace/test_attribution.py index b3f168a3..30366969 100644 --- a/tests/tradespace/test_attribution.py +++ b/tests/tradespace/test_attribution.py @@ -287,7 +287,9 @@ def evaluate(d): return _evaluate(d) with tempfile.TemporaryDirectory() as directory: - store = ResultStore(Path(directory) / "results.sqlite", "attribution") + store = ResultStore( + Path(directory) / "results.sqlite", namespace="attribution" + ) study = Study(SPACE, lambda d: d, evaluate, replicates=3, store=store) first = attribute_variance(study, ["y"], self.designs, sample_size=3) self.assertEqual(len(self.calls), 2 * (2 * 3 + 3 * 3)) diff --git a/tests/tradespace/test_cache.py b/tests/tradespace/test_cache.py index 5b4e8e08..7a1bc282 100644 --- a/tests/tradespace/test_cache.py +++ b/tests/tradespace/test_cache.py @@ -23,6 +23,7 @@ Study, ) from tatc.tradespace.cache import get_satellite_key +from tatc.tradespace.fingerprint import get_fingerprint HAS_JOBLIB = importlib.util.find_spec("joblib") is not None @@ -104,11 +105,13 @@ def test_hits_and_relabeling(self): def test_disk_cache(self): """Results on disk are shared by caches of the same namespace.""" with tempfile.TemporaryDirectory() as directory: - SatelliteCache(self.analysis, directory, namespace="x")(_satellite("a")) - again = SatelliteCache(self.analysis, directory, namespace="x") + SatelliteCache(self.analysis, directory=directory, namespace="x")( + _satellite("a") + ) + again = SatelliteCache(self.analysis, directory=directory, namespace="x") self.assertEqual(list(again(_satellite("b")).satellite), ["b", "b"]) self.assertEqual((again.hits, again.misses), (1, 0)) - other = SatelliteCache(self.analysis, directory, namespace="y") + other = SatelliteCache(self.analysis, directory=directory, namespace="y") other(_satellite("c")) self.assertEqual(other.misses, 1) self.assertEqual(self.calls, ["a", "c"]) @@ -125,7 +128,9 @@ def make(rows): + f" return pd.DataFrame({{'satellite': [{names}]}})", namespace, ) - return SatelliteCache(namespace["analysis"], directory, namespace="x") + return SatelliteCache( + namespace["analysis"], directory=directory, namespace="x" + ) with tempfile.TemporaryDirectory() as directory: for rows in (1, 1): @@ -158,12 +163,30 @@ def make(rows): self.assertEqual(len([p for p in namespaces[0].iterdir() if p.is_dir()]), 1) self.assertEqual(SatelliteCache(_name).prune(), 0) # in memory + def test_fingerprint(self): + """A cache is described by its function and namespace, not by its + counts of hits and misses, nor the results it holds.""" + + def make(offset, namespace=""): + return SatelliteCache(lambda satellite: offset, namespace=namespace) + + cache = make(0.0) + before = get_fingerprint(cache) + cache(_satellite("a")) + cache(_satellite("b")) + self.assertEqual((cache.hits, cache.misses), (1, 1)) + self.assertEqual(get_fingerprint(cache), before) + self.assertEqual(get_fingerprint(make(0.0)), before) + self.assertNotEqual(get_fingerprint(make(1.0)), before) + self.assertNotEqual(get_fingerprint(make(0.0, "other")), before) + def test_disk_cache_of_other_data(self): """Results on disk are keyed by the data the function closes over.""" def make(frame): return SatelliteCache( - lambda satellite: frame.assign(satellite=satellite.name), directory + lambda satellite: frame.assign(satellite=satellite.name), + directory=directory, ) with tempfile.TemporaryDirectory() as directory: @@ -179,18 +202,45 @@ def make(frame): self.assertEqual(list(other(_satellite("c")).value), [2.0]) self.assertEqual(other.misses, 1) + def test_contexts(self): + """A cache on disk keeps the context of its namespace beside its + results, by which the namespaces of a directory are found.""" + with tempfile.TemporaryDirectory() as directory: + for namespace, context in ( + ("x", (3, EPOCH)), + ("y", None), + ("z", {"seed": 1}), + ): + SatelliteCache( + self.analysis, + directory=directory, + namespace=namespace, + context=context, + ) + contexts = SatelliteCache.contexts(directory) + self.assertEqual(contexts, {"x": (3, EPOCH), "y": None, "z": {"seed": 1}}) + # a context that cannot be read is none + for path in Path(directory).rglob("context.json"): + path.write_text("{") + self.assertEqual(set(SatelliteCache.contexts(directory).values()), {None}) + self.assertEqual(SatelliteCache.contexts(directory), {}) # removed + with self.assertRaises(TypeError): + SatelliteCache( # pylint: disable=too-many-function-args + self.analysis, directory + ) + def test_unreadable_file(self): """A result that cannot be read from disk is computed again and replaced.""" with tempfile.TemporaryDirectory() as directory: - cache = SatelliteCache(self.analysis, directory, namespace="x") + cache = SatelliteCache(self.analysis, directory=directory, namespace="x") cache(_satellite("a")) for path in Path(directory).rglob("*.pkl"): path.write_bytes(b"not a pickle") - again = SatelliteCache(self.analysis, directory, namespace="x") + again = SatelliteCache(self.analysis, directory=directory, namespace="x") self.assertEqual(list(again(_satellite("b")).satellite), ["b", "b"]) self.assertEqual(again.misses, 1) # the file is replaced - third = SatelliteCache(self.analysis, directory, namespace="x") + third = SatelliteCache(self.analysis, directory=directory, namespace="x") third(_satellite("c")) self.assertEqual((third.hits, third.misses), (1, 0)) @@ -199,7 +249,7 @@ def test_disk_cache_in_parallel(self): """Workers of a study share a cache on disk, storing each result once.""" satellites = [_satellite(f"s{i}", anomaly=30 * (i % 4)) for i in range(40)] with tempfile.TemporaryDirectory() as directory: - cache = SatelliteCache(_frame, directory, namespace="parallel") + cache = SatelliteCache(_frame, directory=directory, namespace="parallel") study = Study( DesignSpace(i=Integer(0, 39)), lambda d: satellites[d.i], diff --git a/tests/tradespace/test_comparison.py b/tests/tradespace/test_comparison.py index 2213bb6d..fec830f6 100644 --- a/tests/tradespace/test_comparison.py +++ b/tests/tradespace/test_comparison.py @@ -49,7 +49,7 @@ def test_pairs(self): self.assertEqual(compared.loc[("c", "a"), "exceedance"], 1.0) self.assertAlmostEqual(compared.loc[("a", "b"), "cost difference"], 0.0) self.assertAlmostEqual(compared.loc[("c", "a"), "cost difference"], 6.5) - self.assertTrue((compared["replicates"] == 4).all()) + self.assertTrue((compared["shared_replicates"] == 4).all()) self.assertEqual(len(compared), 9) def test_order_and_infeasible(self): @@ -62,12 +62,12 @@ def test_order_and_infeasible(self): compared = exceedance(results, "cost", ["b", "a"]) self.assertEqual(list(compared["design"]), ["b", "b", "a", "a"]) pair = compared[(compared.design == "b") & (compared.other == "a")].iloc[0] - self.assertEqual(pair["replicates"], 2) + self.assertEqual(pair["shared_replicates"], 2) self.assertEqual(pair["exceedance"], 1.0) missing = _results({"a": [np.nan, np.nan], "b": [1.0, 2.0]}) pair = exceedance(missing, "cost").set_index(["design", "other"]) self.assertTrue(np.isnan(pair.loc[("a", "b"), "exceedance"])) - self.assertEqual(pair.loc[("a", "b"), "replicates"], 0) + self.assertEqual(pair.loc[("a", "b"), "shared_replicates"], 0) def test_groups(self): """Designs are compared in each group of `by`, which several records of @@ -104,7 +104,7 @@ def test_infinite_and_infeasible(self): results["feasible"] = False compared = exceedance(results, "cost") self.assertEqual(len(compared), 4) - self.assertTrue((compared["replicates"] == 0).all()) + self.assertTrue((compared["shared_replicates"] == 0).all()) empty = exceedance(results.iloc[:0], "cost") self.assertTrue(empty.empty) self.assertIn("exceedance", empty.columns) diff --git a/tests/tradespace/test_confirmation.py b/tests/tradespace/test_confirmation.py index 583398e5..3ee19e21 100644 --- a/tests/tradespace/test_confirmation.py +++ b/tests/tradespace/test_confirmation.py @@ -5,11 +5,13 @@ """ import unittest +import warnings import numpy as np import pandas as pd from tatc.tradespace import ( + Confirmation, Criteria, DesignSpace, Integer, @@ -126,3 +128,16 @@ def test_requirements(self): self.assertFalse((summary.pareto & ~summary.meets_requirements).any()) with self.assertRaises(ValueError): confirm(self.study, OBJECTIVES, self.results, self.selected, replicates=0) + + def test_optimism_without_designs(self): + """The optimism of a confirmation without designs is unknown.""" + empty = Confirmation( + results=pd.DataFrame(), + summary=pd.DataFrame({"cost optimism": [], "value optimism": []}), + criteria=Criteria(OBJECTIVES), + ) + with warnings.catch_warnings(): + warnings.simplefilter("error") + optimism = empty.optimism + self.assertTrue(optimism.isna().all()) + self.assertEqual(list(optimism.index), list(OBJECTIVES)) diff --git a/tests/tradespace/test_cost.py b/tests/tradespace/test_cost.py index af0b5e82..a9dcab84 100644 --- a/tests/tradespace/test_cost.py +++ b/tests/tradespace/test_cost.py @@ -20,6 +20,7 @@ LaunchCost, OperationsCost, Quantile, + RestorationPolicy, SatelliteCost, Study, Triangular, @@ -160,21 +161,29 @@ def test_rideshare(self): ) def test_spares(self): - """Spares in orbit are built, launched, and operated with each plane.""" + """Spares in orbit are built, launched, and operated with each plane, + and spares on the ground are built, of the policy of the deployment.""" model = CostModel( self.satellite, launch=LaunchCost(per_launch=30), operations=OperationsCost(per_satellite_year=1), ) schedule = DeploymentSchedule(launch_capacity=4) - estimate = model.estimate(schedule.plan(_walker(2, 4), orbit_spares=1)) + spared = RestorationPolicy(orbit_spares=1) + estimate = model.estimate(schedule.plan(_walker(2, 4), policy=spared)) self.assertEqual(estimate.units[None], 10) self.assertEqual(estimate.launches, 4) self.assertEqual(estimate.operations, 10) # spares (which do not age) are not replaced at each design life replaced = dataclasses.replace(schedule, years=6, design_life=2) - units = model.estimate(replaced.plan(_walker(2, 4), orbit_spares=1)).units + units = model.estimate(replaced.plan(_walker(2, 4), policy=spared)).units self.assertEqual(units[None], 10 + 2 * 8) + # those on the ground, as the history of the deployment produces them + grounded = dataclasses.replace(spared, ground_spares=2) + deployment = schedule.plan(_walker(2, 4), policy=grounded) + estimate = model.estimate(deployment) + self.assertEqual(estimate.units[None], 10 + 2) + self.assertEqual(estimate.total, model.estimate(deployment.planned()).total) def test_masses_of_the_deployment(self): """Launches are priced by the masses that size them: those of the diff --git a/tests/tradespace/test_criteria.py b/tests/tradespace/test_criteria.py index 4c19e469..41ce0790 100644 --- a/tests/tradespace/test_criteria.py +++ b/tests/tradespace/test_criteria.py @@ -1,11 +1,12 @@ """ -Unit tests for statistics over replicates and requirements on them. +Unit tests for criteria: requirements on statistics, and the objectives, +tolerances, and rules across groups by which designs are judged. @author Paul T. Grogan """ +import dataclasses import unittest -import warnings import numpy as np import pandas as pd @@ -13,85 +14,12 @@ from tatc.tradespace import ( Across, Criteria, - DesignSpace, - Integer, - Maximum, Mean, - Minimum, - Probability, Quantile, Requirement, - StandardDeviation, - StandardError, - Study, - Uncertain, - aggregate, pareto_front, - pareto_probability, - screen, - summarize, ) -VALUES = np.array( - [[1.0, 2.0, 3.0, np.nan], [4.0, np.nan, np.nan, np.nan], [np.nan] * 4] -) - - -class TestStatistics(unittest.TestCase): - """ - Unit tests for statistics. - """ - - def test_reductions(self): - """Statistics ignore missing replicates.""" - np.testing.assert_allclose(Mean("x").reduce(VALUES), [2, 4, np.nan]) - np.testing.assert_allclose(Minimum("x").reduce(VALUES), [1, 4, np.nan]) - np.testing.assert_allclose(Maximum("x").reduce(VALUES), [3, 4, np.nan]) - np.testing.assert_allclose(Quantile("x", 0.25).reduce(VALUES), [1.5, 4, np.nan]) - np.testing.assert_allclose( - StandardDeviation("x").reduce(VALUES), [1, np.nan, np.nan] - ) - np.testing.assert_allclose( - StandardError("x").reduce(VALUES), [1 / np.sqrt(3), np.nan, np.nan] - ) - np.testing.assert_allclose( - Probability("x", ">=", 2).reduce(VALUES), [2 / 3, 1, np.nan] - ) - np.testing.assert_allclose( - Probability("x", "<", 2).reduce(VALUES), [1 / 3, 0, np.nan] - ) - - def test_quantiles_with_missing_values(self): - """Quantiles are numpy's, of the values of each design.""" - rng = np.random.default_rng(5) - values = rng.normal(size=(200, 12)) - values[rng.random(values.shape) < 0.4] = np.nan - values[0] = np.nan - values[1, 1:] = np.nan - for q in (0, 0.1, 0.5, 0.7, 1): - with warnings.catch_warnings(): - warnings.simplefilter("ignore", RuntimeWarning) - expected = np.nanquantile(values, q, axis=1) - np.testing.assert_allclose(Quantile("x", q).reduce(values), expected) - - def test_invalid(self): - """Quantiles and operators are checked.""" - with self.assertRaises(ValueError): - Quantile("x", 1.5) - with self.assertRaises(ValueError): - Probability("x", "==", 1) - with self.assertRaises(ValueError): - Requirement("x", "!=", 1) - with self.assertRaises(ValueError): - Requirement("x", ">=", 1, scale=0) - - def test_equality(self): - """Statistics of the same kind and parameters are equal.""" - self.assertEqual(Quantile("x", 0.2), Quantile("x", 0.2)) - self.assertNotEqual(Quantile("x", 0.2), Quantile("x", 0.3)) - self.assertNotEqual(Mean("x"), Maximum("x")) - self.assertEqual(len({Mean("x"), Mean("x"), Mean("y")}), 2) - class TestRequirement(unittest.TestCase): """ @@ -124,118 +52,20 @@ def test_scale(self): Requirement("x", "<=", -10).violation(statistic), [1.5, 2.2] ) - -def _results(): - """Results of three designs in four replicates.""" - values = {"a": [10, 12, 14, 16], "b": [5, 30, 5, 30], "c": [1, 1, 1, 1]} - return pd.DataFrame( - [ - { - "design": key, - "replicate": r, - "feasible": True, - "cost": {"a": 2, "b": 2, "c": 1}[key], - "value": v, - "size": {"a": "small", "b": "small", "c": "large"}[key], - } - for key, row in values.items() - for r, v in enumerate(row) - ] - ) - - -class TestAggregate(unittest.TestCase): - """ - Unit tests for aggregating results. - """ - - def test_statistics(self): - """Statistics and design values are aggregated, without violations.""" - frame = aggregate( - _results(), - statistics={ - "value": "value", - "value p25": Quantile("value", 0.25), - "cost": "cost", - }, - ).set_index("design") - self.assertEqual(frame.loc["a", "value"], 13) - self.assertAlmostEqual(frame.loc["b", "value p25"], 5) - self.assertEqual(frame.loc["c", "size"], "large") - self.assertTrue((frame.replicates == 4).all()) - self.assertNotIn("violation", frame.columns) - self.assertEqual(list(aggregate(_results(), ["value"]).value), [13, 17.5, 1]) - # a mapping of statistics by name is not one of objectives - with self.assertRaisesRegex(ValueError, "statistics"): - aggregate(_results(), {"value": "value"}) - with self.assertRaises(ValueError): - aggregate(_results()) - - def test_objectives(self): - """A mapping of objectives are criteria of their means, with others.""" - frame = aggregate( - _results(), - {"value": "max"}, - statistics={"value p25": Quantile("value", 0.25)}, - ).set_index("design") - self.assertEqual(frame.loc["a", "value"], 13) - self.assertAlmostEqual(frame.loc["b", "value p25"], 5) - self.assertTrue(frame.meets_requirements.all()) - # statistics that the criteria name otherwise - with self.assertRaisesRegex(ValueError, "otherwise"): - aggregate( - _results(), {"value": "max"}, statistics={"value": Quantile("value", 1)} - ) - # a statistic the criteria name the same way is not a clash - same = aggregate(_results(), {"value": "max"}, statistics={"value": "value"}) - self.assertEqual(list(same.value), [13, 17.5, 1]) - # objectives grouped by a column - self.assertEqual(len(aggregate(_results(), {"value": "max"}, by="size")), 3) - - def test_criteria(self): - """Criteria add the violations of their requirements, relative to them.""" - criteria = Criteria( - {"cost": "min", "value": "max"}, - statistics={"value p25": Quantile("value", 0.25)}, - requirements=[ - Requirement("value p25", ">=", 5), - Requirement("cost", "<=", 1.5), - ], - ) - frame = aggregate(_results(), criteria).set_index("design") - self.assertEqual( - list(frame.columns[-8:]), - [ - "cost", - "value", - "value p25", - "replicates", - "feasible", - "violation", - "meets_requirements", - "pareto", - ], + def test_statements(self): + """Requirements tell which values meet them, and state themselves.""" + requirement = Requirement("cost", "<=", 1.5) + np.testing.assert_array_equal( + requirement.met([1.0, 2.0, np.nan]), [True, False, False] ) - self.assertAlmostEqual(frame.loc["a", "violation"], 0.5 / 1.5) - self.assertAlmostEqual(frame.loc["c", "violation"], 4 / 5) - self.assertEqual(list(frame.meets_requirements), [False, False, False]) - # none meets the requirements, so that none is efficient - self.assertEqual(list(frame.pareto), [False, False, False]) - with self.assertRaises(ValueError): - aggregate(_results(), criteria, by=["size"]) + self.assertEqual(str(requirement), "cost <= 1.5") - def test_requirement_on_metric(self): - """A requirement on a metric is on its mean.""" - criteria = Criteria( - {"value": "max"}, requirements=[Requirement("cost", "<=", 1)] - ) - frame = aggregate(_results(), criteria) - self.assertIn("cost", frame.columns) - self.assertEqual(list(frame.meets_requirements), [False, False, True]) - # a requirement on a metric that the results do not have - missing = Criteria({"value": "max"}, requirements=[Requirement("w", ">=", 1)]) + def test_invalid(self): + """Operators and scales are checked.""" + with self.assertRaises(ValueError): + Requirement("x", "!=", 1) with self.assertRaises(ValueError): - aggregate(_results(), missing) + Requirement("x", ">=", 1, scale=0) class TestCriteria(unittest.TestCase): @@ -255,8 +85,18 @@ def test_names(self): self.assertEqual(criteria.metrics, ["a", "x", "y"]) self.assertEqual(criteria.statistic("a"), Mean("a")) self.assertEqual(criteria.statistic("b"), Mean("y")) + self.assertEqual( + criteria.resolved, {"a": Mean("a"), "b": Mean("y"), "c": Mean("x")} + ) self.assertEqual(criteria.by, ("sensor",)) + def test_conventional_names(self): + """Statistics given without names are named by convention.""" + criteria = Criteria( + {"value p25": "max"}, statistics=[Quantile("value", 0.25), "cost"] + ) + self.assertEqual(criteria.names, ["value p25", "cost"]) + def test_invalid(self): """Objectives, statistics, requirements, and tolerances are checked.""" with self.assertRaises(ValueError): @@ -283,316 +123,66 @@ def test_shorthand(self): pd.testing.assert_series_equal( pareto_front(frame, objectives), pareto_front(frame, Criteria(objectives)) ) + criteria = Criteria(objectives) + self.assertIs(Criteria.of(criteria), criteria) + self.assertEqual(Criteria.of(objectives), criteria) + with self.assertRaises(TypeError): + Criteria.of(["cost"]) - def test_records_of_groups(self): - """Several records of an evaluation need the columns that separate them.""" - results = pd.concat([_results().assign(sensor=s) for s in ("x", "y")]) - with self.assertRaisesRegex(ValueError, r"by.*\['sensor'\]"): - aggregate(results, ["value"]) - with self.assertRaisesRegex(ValueError, "sensor"): - pareto_probability(results, {"value": "max"}) - frame = aggregate(results, Criteria({"value": "max"}, by="sensor")) - self.assertEqual(len(frame), 6) - self.assertEqual(len(summarize(results, ["value"], by="sensor")), 6) - - -class TestParetoProbabilityRequirements(unittest.TestCase): - """ - Unit tests for the probability of efficiency with statistics and requirements. - """ - - def test_quantile_objective(self): - """A pessimistic objective prefers the design with less spread.""" - objectives = {"cost": "min", "value": "max"} - by_mean = pareto_probability(_results(), objectives).set_index("design") - self.assertTrue(by_mean.loc["b", "pareto"]) # b has the larger mean - pessimistic = pareto_probability( - _results(), - Criteria( - {"cost": "min", "value q": "max"}, - statistics={"value q": Quantile("value", 0.25)}, - ), - ).set_index("design") - self.assertTrue(pessimistic.loc["a", "pareto"]) - self.assertFalse(pessimistic.loc["b", "pareto"]) - - def test_requirements(self): - """Designs that miss a requirement are not efficient.""" - probability = pareto_probability( - _results(), - Criteria( - {"cost": "min", "value": "max"}, - requirements=[Requirement("reliable", ">=", 0.75)], - statistics={"reliable": Probability("value", ">=", 10)}, - ), - ).set_index("design") - self.assertEqual(list(probability.meets_requirements), [True, False, False]) - # a is efficient unless b meets the requirement (and dominates it) - self.assertEqual(probability.loc["a", "requirements_probability"], 1) - self.assertGreater(probability.loc["a", "pareto_probability"], 0.5) - self.assertLess(probability.loc["a", "pareto_probability"], 1) - self.assertEqual(probability.loc["c", "pareto_probability"], 0) - # b meets the threshold in half of its replicates: it meets the - # requirement in some resamples, and is then efficient - self.assertGreater(probability.loc["b", "requirements_probability"], 0.1) - self.assertLess(probability.loc["b", "requirements_probability"], 0.9) - self.assertEqual(probability.loc["c", "requirements_probability"], 0) - - def test_unequal_replicates(self): - """Designs may have different replicates.""" - results = _results() - results = results[~((results.design == "c") & (results.replicate > 0))] - probability = pareto_probability(results, {"cost": "min", "value": "max"}) - self.assertEqual(list(probability.replicates), [4, 4, 1]) - self.assertEqual( - probability.set_index("design").loc["c", "pareto_probability"], 1 - ) - - -class TestScreenRequirements(unittest.TestCase): - """ - Unit tests for screening with requirements. - """ - - def test_misses_ranked_last(self): - """Designs that miss requirements are ranked after those that meet them.""" - space = DesignSpace(a=Integer(1, 6), noise=Uncertain.uniform(0, 1)) - study = Study( - space, - lambda d: d, - lambda d: {"cost": d.a, "value": d.a**0.5 + d.noise}, - replicates=2, - ) - screening = screen( - [study, study], - Criteria( - {"cost": "min", "value": "max"}, - requirements=[Requirement("cost", "<=", 3)], - ), - space.enumerate(), - keep=4, - ) - first = screening.summaries[0].set_index("design") - meets = first[first.meets_requirements] - misses = first[~first.meets_requirements] - self.assertGreater(misses.pareto_rank.min(), meets.pareto_rank.max()) - # the nearest miss (cost 4) is kept to fill four designs - self.assertEqual(sorted(first[first.kept].cost), [1, 2, 3, 4]) - - -class TestSummaries(unittest.TestCase): - """ - Unit tests for summaries of criteria. - """ - - def test_pareto(self): - """Summaries of criteria give the efficient designs, in each group.""" - criteria = Criteria({"cost": "min", "value": "max"}, by="size") - summary = aggregate(_results(), criteria) - self.assertEqual( - list(summary.pareto), - list(pareto_front(summary.drop(columns="pareto"), criteria)), - ) - # designs a (a mean of 13) and b (17.5) of the same cost, and c alone - self.assertEqual( - dict(zip(summary.design, summary.pareto)), - {"a": False, "b": True, "c": True}, - ) - - def test_summarize_criteria(self): - """Summaries of criteria add the spread of their means of metrics.""" + def test_costs_and_violation(self): + """Objectives are costs (maximized ones negated), and the violations + of requirements add.""" criteria = Criteria( {"cost": "min", "value": "max"}, - statistics={"value p25": Quantile("value", 0.25)}, - ) - summary = summarize(_results(), criteria) - for column in ("cost std", "cost se", "value std", "value se", "pareto"): - self.assertIn(column, summary.columns) - self.assertNotIn("value p25 se", summary.columns) - grouped = summarize(_results(), {"value": "max"}, by="size") - self.assertEqual(len(grouped), 3) - with self.assertRaises(ValueError): - summarize(_results(), Criteria({"value": "max"}), by="size") - - def test_statistics_of_names(self): - """Statistics given by names are the means of the metrics.""" - summary = aggregate(_results(), {"value": "max"}, statistics=["cost"]) - self.assertEqual(list(summary.cost), [2.0, 2.0, 1.0]) - - -class TestNames(unittest.TestCase): - """ - Unit tests for the conventional names of statistics and requirements. - """ - - def test_names(self): - """Statistics are named by convention, and given without names.""" - self.assertEqual(Mean("cost").name, "cost") - self.assertEqual(StandardDeviation("cost").name, "cost std") - self.assertEqual(StandardError("cost").name, "cost se") - self.assertEqual(Minimum("cost").name, "cost min") - self.assertEqual(Maximum("cost").name, "cost max") - self.assertEqual(Quantile("cost", 0.7).name, "cost p70") - self.assertEqual(Probability("cost", "<=", 150).name, "P(cost <= 150)") - criteria = Criteria( - {"value p25": "max"}, statistics=[Quantile("value", 0.25), "cost"] + requirements=[Requirement("cost", "<=", 2), Requirement("value", ">=", 4)], ) - self.assertEqual(criteria.names, ["value p25", "cost"]) - self.assertEqual( - list(aggregate(_results(), statistics=[Quantile("value", 0.25)]).columns)[ - -3: - ], - ["value p25", "replicates", "feasible"], - ) - - def test_requirements(self): - """Requirements tell which values meet them, and state themselves.""" - requirement = Requirement("cost", "<=", 1.5) + np.testing.assert_array_equal(criteria.signs, [1.0, -1.0]) + values = {"cost": np.array([1.0, 3.0]), "value": np.array([5.0, np.nan])} np.testing.assert_array_equal( - requirement.met([1.0, 2.0, np.nan]), [True, False, False] + criteria.costs(values), [[1.0, -5.0], [3.0, np.nan]] ) - self.assertEqual(str(requirement), "cost <= 1.5") - - def test_summarize_statistics(self): - """Summaries take other statistics, with the spread of their means.""" - summary = summarize(_results(), {"value": "max"}, statistics=["cost"]) - for column in ("value", "value se", "cost", "cost std", "cost se", "pareto"): - self.assertIn(column, summary.columns) - - -def _partly_infeasible(scenario=None, shares=None): - """Results of three designs in four replicates: a is feasible in every - replicate, b in two, and c in none (whose records lack metrics).""" - values = {"a": [1, 2, 3, 4], "b": [10, None, 30, None], "c": [None] * 4} - values.update(shares or {}) - return pd.DataFrame( - [ - { - "design": key, - "replicate": r, - **({} if scenario is None else {"scenario": scenario}), - "feasible": v is not None, - "cost": ( - {"a": 2.0, "b": 1.0, "c": 1.0}[key] if v is not None else np.nan - ), - "value": np.nan if v is None else float(v), - } - for key, row in values.items() - for r, v in enumerate(row) - ] - ) - - -class TestFeasibility(unittest.TestCase): - """ - Unit tests for the judgment of designs by their feasible replicates. - """ - - def test_feasible_share(self): - """Designs are judged by their feasible replicates, of which - `replicates` is the number and `feasible` the share; designs without a - feasible replicate are left out.""" - summary = aggregate(_partly_infeasible(), {"cost": "min", "value": "max"}) - summary = summary.set_index("design") - self.assertEqual(list(summary.index), ["a", "b"]) - self.assertEqual(summary.loc["b", "value"], 20) - self.assertEqual(list(summary.replicates), [4, 2]) - self.assertEqual(list(summary.feasible), [1.0, 0.5]) - # b, cheaper and better in its feasible replicates, dominates a - self.assertEqual(list(summary.pareto), [False, True]) - self.assertEqual( - list(summary.columns[-5:]), - ["replicates", "feasible", "violation", "meets_requirements", "pareto"], + np.testing.assert_allclose(criteria.violation(values, 2), [0.0, np.nan]) + np.testing.assert_allclose( + criteria.violation({"cost": [3.0], "value": [2.0]}, 1), [0.5 + 0.5] ) + self.assertEqual(criteria.costs({"cost": [], "value": []}).shape, (0, 2)) + np.testing.assert_array_equal(Criteria({"a": "min"}).violation({}, 3), 0.0) - def test_requirement(self): - """Requirements on `feasible` judge the share of feasible replicates - over every replicate of a design.""" - every = Criteria( - {"cost": "min", "value": "max"}, - requirements=[Requirement("feasible", ">=", 1)], + def test_tolerance_array(self): + """Tolerances are values in the units of objectives, or shares of + them, in the order of the objectives (zero if not given).""" + criteria = Criteria( + {"a": "min", "b": "max", "c": "min"}, tolerances={"c": "5%", "a": 2} ) - summary = aggregate(_partly_infeasible(), every).set_index("design") - self.assertEqual(list(summary.feasible), [1.0, 0.5]) - self.assertEqual(list(summary.meets_requirements), [True, False]) - self.assertAlmostEqual(summary.loc["b", "violation"], 0.5) - self.assertEqual(list(summary.pareto), [True, False]) - half = Criteria( - {"cost": "min", "value": "max"}, - requirements=[Requirement("feasible", ">=", 0.5)], + np.testing.assert_array_equal( + criteria.tolerance_array, [[2.0, 0.0, 0.0], [0.0, 0.0, 0.05]] ) - summary = aggregate(_partly_infeasible(), half) - self.assertTrue(summary.meets_requirements.all()) - # its spread is not summarized - summary = summarize(_partly_infeasible(), every) - self.assertNotIn("feasible se", summary.columns) - self.assertEqual(list(summary.feasible), [1.0, 0.5]) - - def test_groups(self): - """Infeasible records without a value of a group (such as a sensor) - count in every group of the design.""" - results = _partly_infeasible() - feasible = results[results.feasible] - records = pd.concat( - [ - feasible.assign(sensor="x"), - feasible.assign(sensor="y", value=feasible.value + 1), - results[~results.feasible], - ], - ignore_index=True, + # derived from the tolerances, which compare criteria + changed = dataclasses.replace(criteria, tolerances={"b": 1}) + np.testing.assert_array_equal( + changed.tolerance_array, [[0.0, 1.0, 0.0], [0.0, 0.0, 0.0]] ) - summary = aggregate(records, ["value"], by="sensor") - summary = summary.set_index(["sensor", "design"]) - self.assertEqual(summary.loc[("y", "b"), "value"], 21) - self.assertEqual(summary.loc[("x", "b"), "feasible"], 0.5) - self.assertEqual(summary.loc[("y", "b"), "feasible"], 0.5) - self.assertEqual(summary.loc[("y", "a"), "feasible"], 1.0) + self.assertEqual(criteria, dataclasses.replace(criteria)) + self.assertNotEqual(criteria, changed) - def test_across(self): - """Across groups, `feasible` is over the replicates of every group - together, and designs need feasible replicates in every group.""" - results = pd.concat( - [ - _partly_infeasible("s1", {"b": [10, 20, 30, 40]}), - _partly_infeasible("s2"), - ], - ignore_index=True, + def test_combiners(self): + """Statistics across groups are combined by their worst, or their + mean.""" + self.assertEqual(Criteria({"a": "min"}).combiners, {}) + criteria = Criteria( + {"a": "min", "b": "max"}, + statistics={"c": "x", "d": "y"}, + requirements=[Requirement("c", ">=", 1)], + across=Across(rules={"b": "mean"}), ) - for rule in ("worst", "mean"): - with self.subTest(rule=rule): - criteria = Criteria( - {"cost": "min", "value": "max"}, - requirements=[Requirement("feasible", ">=", 0.7)], - across=Across(rule=rule), - ) - summary = aggregate(results, criteria).set_index("design") - self.assertEqual(list(summary.index), ["a", "b"]) - self.assertEqual(summary.loc["b", "feasible"], 0.75) - self.assertEqual(summary.loc["b", "replicates"], 2) - self.assertTrue(summary.meets_requirements.all()) - - def test_no_feasible_design(self): - """Results without a feasible record have empty summaries.""" - results = _partly_infeasible() - infeasible = results[results.design == "c"].drop(columns=["cost", "value"]) - criteria = Criteria({"cost": "min", "value": "max"}, by="size") - for summary in ( - aggregate(infeasible, {"cost": "min", "value": "max"}), - aggregate(infeasible.assign(size=1), criteria), - aggregate(infeasible.iloc[:0], {"cost": "min", "value": "max"}), - ): - self.assertTrue(summary.empty) - self.assertEqual( - list(summary.columns[-5:]), - ["replicates", "feasible", "violation", "meets_requirements", "pareto"], - ) - # of the types of their columns, which select rows - self.assertEqual(summary.pareto.dtype, bool) - self.assertTrue(summary[summary.pareto].empty) - self.assertTrue(aggregate(infeasible, ["value"]).empty) - across = Criteria({"cost": "min", "value": "max"}, across=Across(rule="mean")) - scenarios = pd.concat( - [_partly_infeasible("s1"), _partly_infeasible("s2")], ignore_index=True + self.assertEqual( + criteria.combiners, {"a": "max", "b": "mean", "c": "min", "d": "mean"} ) - self.assertEqual(len(aggregate(scenarios, across)), 2) - self.assertTrue(aggregate(scenarios.iloc[:0], across).empty) + with self.assertRaisesRegex(ValueError, "no worst"): + Criteria( + {"a": "min"}, statistics={"d": "y"}, across=Across(rules={"d": "worst"}) + ) + with self.assertRaisesRegex(ValueError, "disagree"): + Criteria( + {"a": "min"}, requirements=[Requirement("a", ">=", 1)], across=Across() + ) diff --git a/tests/tradespace/test_deployment.py b/tests/tradespace/test_deployment.py index e8bfbd18..9fd94812 100644 --- a/tests/tradespace/test_deployment.py +++ b/tests/tradespace/test_deployment.py @@ -13,6 +13,7 @@ import pandas as pd from tatc.tradespace import ( + CostModel, DeploymentSchedule, DesignSpace, Exponential, @@ -20,6 +21,8 @@ Real, Requirement, RestorationPolicy, + SatelliteCost, + Stage, sso_planes_space, walker_space, ) @@ -65,11 +68,10 @@ def capacity(index, values): schedule.launches_of(4, 50.0) self.assertEqual(schedule.launches_of(4, 50.0, (1, None)), 1) # restorations that wait to share a launch fill it to the plane's capacity - history = deployment.simulate( - FailureModel(life=Exponential(2.0)), - RestorationPolicy(batch_years=1.0), - seed=0, + batching = schedule.plan( + _walker(2, 4), masses=50.0, policy=RestorationPolicy(batch_years=1.0) ) + history = batching.simulate(FailureModel(life=Exponential(2.0)), seed=0) restorations = [l for l in history.launches if l.purpose == "restoration"] self.assertTrue(any(l.plane == 1 and l.satellites > 2 for l in restorations)) self.assertTrue( @@ -78,16 +80,13 @@ def capacity(index, values): def test_production_rate(self): """A production line deploys planes as their satellites are built.""" - deployment = DeploymentSchedule(development_years=2, production_rate=8).plan( - _walker(3, 4) - ) + schedule = DeploymentSchedule(years=2, development_years=2, production_rate=8) + deployment = schedule.plan(_walker(3, 4)) # 4 satellites a plane at 8 a year: ready every half year self.assertEqual([l.time for l in deployment.launches], [2.5, 3.0, 3.5]) self.assertEqual(deployment.begin, 2.5) self.assertEqual(deployment.deployed, 3.5) - larger = DeploymentSchedule(development_years=2, production_rate=8).plan( - _walker(3, 6) - ) + larger = schedule.plan(_walker(3, 6)) self.assertGreater(larger.deployed, deployment.deployed) def test_launch_cadence(self): @@ -116,6 +115,19 @@ def test_launch_cadence(self): self.assertEqual(deployment.end, 10) self.assertEqual(deployment.units, {None: 12 + 4}) + def test_deployment_outlasting_the_mission(self): + """A deployment whose launches outlast the mission is not deployed in + it: the time it is deployed is infinite (as the time until a mission + meets a requirement that it never meets).""" + schedule = DeploymentSchedule(years=1.5, launch_interval=1) + deployment = schedule.plan(_walker(3, 1)) + self.assertEqual([l.time for l in deployment.launches], [0, 1, 2]) + self.assertEqual([l.time for l in deployment.planned().launches], [0, 1]) + self.assertEqual(deployment.planned().deployed, math.inf) + self.assertEqual(deployment.deployed, math.inf) + longer = dataclasses.replace(schedule, years=2.5).plan(_walker(3, 1)) + self.assertEqual(longer.deployed, 2) + def test_replacements_keep_the_interval(self): """Planned replacements of several types keep the launch interval, from the launches of the deployment and from each other, and are replaced a @@ -150,7 +162,8 @@ def test_spares_are_not_replaced(self): """Planned replacements replace the satellites of the layout, not the spares in orbit, which do not age: a spare is launched once.""" schedule = DeploymentSchedule(years=6, design_life=2) - deployment = schedule.plan(_walker(1, 2), orbit_spares=1) + spared = RestorationPolicy(orbit_spares=1) + deployment = schedule.plan(_walker(1, 2), policy=spared) self.assertEqual( [(l.time, l.satellites, l.purpose) for l in deployment.launches], [(0, 3, "deployment"), (2, 2, "replacement"), (4, 2, "replacement")], @@ -161,20 +174,50 @@ def test_spares_are_not_replaced(self): self.assertEqual(deployment.simulate().parked, [(0, 6, 1)]) # a launch of the spare alone is not replaced single = dataclasses.replace(schedule, launch_capacity=1) - launches = single.plan(_walker(1, 2), orbit_spares=1).launches + launches = single.plan(_walker(1, 2), policy=spared).launches self.assertEqual( sorted((l.purpose, l.first) for l in launches), [("deployment", 0), ("deployment", 1), ("deployment", 2)] + [("replacement", 0)] * 2 + [("replacement", 1)] * 2, ) - with self.assertRaises(ValueError): - schedule.plan(_walker(1, 2), orbit_spares=-1) - # spares of each type - mixed = schedule.plan( - {"a": _walker(1, 2), "b": _walker(1, 2)}, orbit_spares={"a": 1, "b": 0} - ) + # spares of each type (of every type of the deployment) + by_type = RestorationPolicy(orbit_spares={"a": 1, "b": 0}) + mixed = schedule.plan({"a": _walker(1, 2), "b": _walker(1, 2)}, policy=by_type) self.assertEqual([p.orbit_spares for p in mixed.planes], [1, 0]) + for lacking in (by_type, RestorationPolicy(ground_spares={"a": 1})): + with self.assertRaises(ValueError): + schedule.plan(_walker(1, 2), policy=lacking) + + def test_policy(self): + """A deployment has the policy it is planned with, whose spares in + orbit its planes include, whose spares on the ground the history + without failures produces (after the planes that are not staged, and + before a stage, which the time it is deployed and its costs take), + and with which it restores failures.""" + self.assertEqual( + DeploymentSchedule().plan(_walker()).policy, RestorationPolicy() + ) + policy = RestorationPolicy(ground_spares=2) + schedule = DeploymentSchedule(years=5, production_rate=1.0) + # the second plane is staged, and deployed at the first launch + deployment = schedule.plan(_walker(2, 2), policy=policy, stages=[Stage(1, 0)]) + self.assertIs(deployment.policy, policy) + planned = deployment.planned() + spares = [b for b in planned.production if b.purpose == "spare"] + self.assertEqual([(b.begin, b.end) for b in spares], [(2, 4)]) + self.assertEqual(planned.deployed, 6) + self.assertEqual(deployment.deployed, 6) + self.assertEqual(deployment.units, {None: 2}) # of the plan alone + model = CostModel(SatelliteCost(first_unit=10)) + self.assertEqual(model.estimate(deployment).production, 60) + self.assertEqual(model.estimate(deployment).units, {None: 6}) + # its simulations restore failures with its spares in orbit + spared = DeploymentSchedule(years=5).plan( + _walker(1, 2), policy=RestorationPolicy(orbit_spares=1) + ) + history = spared.simulate(FailureModel(life=Exponential(0.5)), seed=1) + self.assertEqual(history.restorations[0].source, "orbit") def test_types_and_order(self): """Types are developed over their own durations, planes in an order.""" diff --git a/tests/tradespace/test_failures.py b/tests/tradespace/test_failures.py index 7e4274d2..b18a3cc3 100644 --- a/tests/tradespace/test_failures.py +++ b/tests/tradespace/test_failures.py @@ -27,6 +27,7 @@ Requirement, RestorationPolicy, SatelliteCost, + Stage, Study, Uncertain, Weibull, @@ -36,14 +37,17 @@ policy_space, walker_space, ) -from tatc.tradespace import histories as histories_module -from tatc.tradespace.failures import Lifetime -from tatc.tradespace.histories import ( +from tatc.tradespace import expectations as expectations_module +from tatc.tradespace.expectations import ( MAX_SETS, + ExactExpectationsError, _exact_sets, + exact_expectations, +) +from tatc.tradespace.failures import Lifetime +from tatc.tradespace.histories import ( allocate_histories, evaluate_histories, - exact_expectations, summarize_histories, ) from tatc.tradespace.mission import ( @@ -52,7 +56,8 @@ evaluate_phases, summarize_phases, ) -from tatc.tradespace.values import configure +from tatc.tradespace.simulation import _Simulation +from tatc.tradespace import configure def _walker(planes=1, per_plane=2): @@ -68,6 +73,9 @@ def _names(count): return [f"satellite {k + 1}" for k in range(count)] +DEGRADE = RestorationPolicy(restore=False) + + @dataclass(frozen=True) class _Fixed(Lifetime): """A life of a fixed duration (the first satellite only, if `first`).""" @@ -192,9 +200,9 @@ def setUp(self): # every satellite fails 1.5 years after it begins to operate self.failures = FailureModel(life=_Fixed(1.5)) - def _simulate(self, policy, orbit_spares=0, failures=None, seed=0): - deployment = self.schedule.plan(self.layout, orbit_spares=orbit_spares) - return deployment.simulate(failures or self.failures, policy, seed) + def _simulate(self, policy, failures=None, seed=0): + deployment = self.schedule.plan(self.layout, policy=policy) + return deployment.simulate(failures or self.failures, seed) def test_without_failures(self): """Without failures, the history is the deployment's.""" @@ -253,8 +261,8 @@ def test_restore_by_production(self): def test_restore_from_orbit(self): """A spare in orbit takes a failed satellite's place after drifting.""" - policy = RestorationPolicy(detection_years=0.1, drift_years=0.2) - history = self._simulate(policy, orbit_spares=1) + policy = RestorationPolicy(detection_years=0.1, drift_years=0.2, orbit_spares=1) + history = self._simulate(policy) first = sorted(history.restorations, key=lambda r: r[3])[0] self.assertEqual(first[4], "orbit") self.assertAlmostEqual(first[3] - first[2], 0.3) @@ -277,6 +285,29 @@ def test_restore_from_ground(self): spares = [b for b in history.production if b.purpose == "spare"] self.assertEqual(sum(b.satellites for b in spares), 2) + def test_ground_spare_at_the_next_slot(self): + """A spare on the ground is launched at the next slot, not on a launch + booked for the plane later (such as of a spare in orbit replenished).""" + policy = RestorationPolicy( + orbit_spares=1, ground_spares=1, replenish=True, procurement_years=3 + ) + deployment = DeploymentSchedule(years=10).plan(self.layout, policy=policy) + lives = {(0, 0, 0): 1.0, (0, 1, 0): 1.5} # position 0 fails at 1, 1 at 1.5 + + def life(simulation, plane, position, generation, start=0.0): + del simulation, start + return lives.get((plane, position, generation), math.inf) + + with mock.patch.object(_Simulation, "_life", life): + history = deployment.simulate(self.failures, seed=0) + restored = {r.position: (r.source, r.restored) for r in history.restorations} + self.assertEqual(restored[0], ("orbit", 1.0 + 0.1 + 0.25)) + # known at 1.6, while the replenished spare is launched at 4.1 + self.assertEqual(restored[1][0], "ground") + self.assertAlmostEqual(restored[1][1], 1.6) + launches = [(l.purpose, round(l.time, 6)) for l in history.launches[1:]] + self.assertEqual(launches, [("restoration", 1.6), ("spare", 4.1)]) + def test_batching(self): """Restorations of a plane waiting within a window share a launch.""" alone = self._simulate(RestorationPolicy(ground_spares=2)) @@ -299,8 +330,9 @@ def test_launch_failures(self): def test_planned_replacement(self): """A planned replacement restores a degraded satellite.""" schedule = DeploymentSchedule(years=4, design_life=2, development_years=1) - history = schedule.plan(self.layout).simulate( - self.failures, RestorationPolicy(restore=False), seed=0 + degrade = RestorationPolicy(restore=False) + history = schedule.plan(self.layout, policy=degrade).simulate( + self.failures, seed=0 ) # launched at 1, failed at 2.5, replaced at 3, failed at 4.5 self.assertEqual(history.operating[0, 0], [(1, 2.5), (3, 4.5)]) @@ -309,12 +341,10 @@ def test_design_life_does_not_retire(self): """A satellite whose planned replacement fails to launch operates past its design life, and the replacement is not flown again.""" schedule = DeploymentSchedule(years=6, design_life=2, development_years=1) - deployment = schedule.plan(self.layout) + deployment = schedule.plan(self.layout, policy=RestorationPolicy(restore=False)) launches_fail = FailureModel(launch=0.5) for seed in range(50): - history = deployment.simulate( - launches_fail, RestorationPolicy(restore=False), seed - ) + history = deployment.simulate(launches_fail, seed) deployed = [l for l in history.launches if l.purpose == "deployment"] replaced = [l for l in history.launches if l.purpose == "replacement"] if not deployed[0].failed and replaced[0].failed: @@ -349,16 +379,14 @@ def test_costs_of_policies(self): ) failures = FailureModel(life=Exponential(0.3)) totals = {} - for name, policy, spares in ( - ("degrade", RestorationPolicy(restore=False), 0), - ("produce", RestorationPolicy(), 0), - ("orbit", RestorationPolicy(replenish=True), 1), + for name, policy in ( + ("degrade", RestorationPolicy(restore=False)), + ("produce", RestorationPolicy()), + ("orbit", RestorationPolicy(replenish=True, orbit_spares=1)), ): costs, availability = [], [] for seed in range(100): - history = self._simulate( - policy, orbit_spares=spares, failures=failures, seed=seed - ) + history = self._simulate(policy, failures=failures, seed=seed) costs.append(model.estimate(history).total) availability.append(history.metrics()["availability"]) totals[name] = (np.mean(costs), np.mean(availability)) @@ -452,8 +480,8 @@ def test_trade_of_policies(self): def evaluate(d): policy = configure(RestorationPolicy(), d.policy) - deployment = schedule.plan(d.layout, orbit_spares=policy.orbit_spares) - history = deployment.simulate(failures, policy, d.failure_seed) + deployment = schedule.plan(d.layout, policy=policy) + history = deployment.simulate(failures, d.failure_seed) return { "cost": model.estimate(history).total, "availability": history.metrics()["availability"], @@ -517,26 +545,23 @@ def test_simulate_many(self): """Histories of a replicate differ, and are the same in every design.""" deployment = self.schedule.plan(self.layout) histories = deployment.simulate_many( - self.failures, RestorationPolicy(), 7, histories=10, sampling="random" + self.failures, 7, histories=10, sampling="random" ) self.assertEqual(len(histories), 10) self.assertGreater(len({tuple(h.failures) for h in histories}), 1) - again = deployment.simulate(self.failures, RestorationPolicy(), (7, 3)) + again = deployment.simulate(self.failures, (7, 3)) self.assertEqual(again.failures, histories[3].failures) - degraded = deployment.simulate_many( - self.failures, - RestorationPolicy(restore=False), - 7, - histories=10, - sampling="random", + degrading = self.schedule.plan(self.layout, policy=DEGRADE) + degraded = degrading.simulate_many( + self.failures, 7, histories=10, sampling="random" ) self.assertEqual(degraded[3].failures[0], histories[3].failures[0]) self.assertEqual( - len(deployment.simulate_many(self.failures, None, None, histories=10)), 1 + len(deployment.simulate_many(self.failures, None, histories=10)), 1 ) self.assertIs(deployment.planned(), deployment.planned()) with self.assertRaises(ValueError): - deployment.simulate_many(self.failures, None, 7, histories=0) + deployment.simulate_many(self.failures, 7, histories=0) # without a model of failures, as simulate, nothing fails unfailing = deployment.simulate_many(seed=7, histories=3) self.assertEqual([h.failures for h in unfailing], [[], [], []]) @@ -545,9 +570,7 @@ def test_simulate_many(self): def test_phase_cache(self): """A cache evaluates each set of satellites once, as without it.""" deployment = self.schedule.plan(self.layout) - histories = deployment.simulate_many( - self.failures, RestorationPolicy(), 7, histories=20 - ) + histories = deployment.simulate_many(self.failures, 7, histories=20) cache = PhaseCache(self._metric) for history in histories: phases = history.phases(self.satellites) @@ -584,9 +607,7 @@ def test_phase_cache(self): def test_evaluate_and_summarize(self): """Histories are evaluated, priced, and summarized as one record.""" deployment = self.schedule.plan(self.layout) - histories = deployment.simulate_many( - self.failures, RestorationPolicy(), 7, histories=30 - ) + histories = deployment.simulate_many(self.failures, 7, histories=30) model = CostModel( SatelliteCost(development=10, first_unit=5), launch=LaunchCost(per_launch=3) ) @@ -618,7 +639,8 @@ def test_evaluate_and_summarize(self): self.assertIn("share mission histories p50", summary) self.assertIn("cost histories p70", summary) self.assertAlmostEqual( - summary["P(share mission >= 60)"], (missions["share mission"] >= 60).mean() + summary["P(share mission >= 60) histories"], + (missions["share mission"] >= 60).mean(), ) # without a cache, the same evaluations direct = evaluate_histories( @@ -659,7 +681,7 @@ def test_lifetimes_from_uniform(self): def test_strata(self): """Each draw of the histories of a replicate takes each stratum once.""" - from tatc.tradespace.histories import ( + from tatc.tradespace.simulation import ( _Sampler, ) # pylint: disable=import-outside-toplevel @@ -673,6 +695,7 @@ def test_strata(self): def test_stratified_histories(self): """Stratified histories estimate means more precisely, without bias.""" deployment = self.schedule.plan(self.layout) + degrading = self.schedule.plan(self.layout, policy=DEGRADE) estimates = {} for sampling in ("random", "stratified"): estimates[sampling] = np.array( @@ -680,12 +703,8 @@ def test_stratified_histories(self): np.mean( [ h.metrics()["availability"] - for h in deployment.simulate_many( - self.failures, - RestorationPolicy(restore=False), - seed, - histories=20, - sampling=sampling, + for h in degrading.simulate_many( + self.failures, seed, histories=20, sampling=sampling ) ] ) @@ -697,16 +716,12 @@ def test_stratified_histories(self): estimates["stratified"].mean(), estimates["random"].mean(), delta=0.02 ) # common random numbers: the same failures of a slot under other policies - first = deployment.simulate_many( - self.failures, RestorationPolicy(restore=False), 1, histories=8 - ) - other = deployment.simulate_many( - self.failures, RestorationPolicy(), 1, histories=8 - ) + first = degrading.simulate_many(self.failures, 1, histories=8) + other = deployment.simulate_many(self.failures, 1, histories=8) self.assertEqual(first[3].failures[0], other[3].failures[0]) with self.assertRaises(ValueError): deployment.simulate_many( - self.failures, None, 1, histories=8, sampling="antithetic" + self.failures, 1, histories=8, sampling="antithetic" ) def test_expected_metrics(self): @@ -856,14 +871,12 @@ def _metric(observations): return {"score": float(score**2)} def _compare(self, schedule, failures): - deployment = schedule.plan(self.layout) + deployment = schedule.plan(self.layout, policy=DEGRADE) capability = Capability( self.satellites, self.observations, PhaseCache(self._metric) ) exact = exact_expectations(deployment, failures, capability) - histories = deployment.simulate_many( - failures, RestorationPolicy(restore=False), 3, histories=4000 - ) + histories = deployment.simulate_many(failures, 3, histories=4000) missions = evaluate_histories(histories, capability) error = missions["score mission"].std() / np.sqrt(len(missions)) self.assertAlmostEqual( @@ -896,7 +909,7 @@ def test_without_failures(self): """Without failures, the expectation is the mission's.""" deployment = DeploymentSchedule( years=4, development_years=1, production_rate=2 - ).plan(self.layout) + ).plan(self.layout, policy=DEGRADE) capability = Capability(self.satellites, self.observations, self._metric) exact = exact_expectations(deployment, FailureModel(), capability) phases = deployment.phases(self.satellites) @@ -916,11 +929,12 @@ def test_sets_known_before_enumerating(self): """The sets that exact expectations enumerate are counted before they are, so that a constellation of too many fails at once (and the failures of a study fall back to histories, see Failures).""" - deployment = DeploymentSchedule(years=4, launch_interval=0.5).plan(self.layout) + schedule = DeploymentSchedule(years=4, launch_interval=0.5) + deployment = schedule.plan(self.layout, policy=DEGRADE) failures = FailureModel(life=Exponential(0.3), launch=0.05) capability = Capability(self.satellites, self.observations, self._metric) - weigh = mock.Mock(wraps=histories_module._set_weight) - with mock.patch.object(histories_module, "_set_weight", weigh): + weigh = mock.Mock(wraps=expectations_module._set_weight) + with mock.patch.object(expectations_module, "_set_weight", weigh): exact = exact_expectations(deployment, failures, capability) self.assertEqual(weigh.call_count, _exact_sets(deployment, failures)) self.assertGreaterEqual(exact["coverage"], 0.999) @@ -928,13 +942,13 @@ def test_sets_known_before_enumerating(self): reliable = FailureModel(life=Exponential(0.001)) self.assertLess(_exact_sets(deployment, reliable), 2**4) # 20 satellites (of 4 planes of 5) of a few years: too many, at once - large = DeploymentSchedule(years=5).plan(_walker(4, 5)) + large = DeploymentSchedule(years=5).plan(_walker(4, 5), policy=DEGRADE) failures = FailureModel(life=Exponential(0.3)) self.assertGreater(_exact_sets(large, failures), MAX_SETS) names = _names(20) - weigh = mock.Mock(wraps=histories_module._set_weight) - with mock.patch.object(histories_module, "_set_weight", weigh): - with self.assertRaisesRegex(ValueError, "too many sets"): + weigh = mock.Mock(wraps=expectations_module._set_weight) + with mock.patch.object(expectations_module, "_set_weight", weigh): + with self.assertRaisesRegex(ExactExpectationsError, "too many sets"): exact_expectations( large, failures, @@ -943,22 +957,27 @@ def test_sets_known_before_enumerating(self): weigh.assert_not_called() def test_limits(self): - """Sets are enumerated within limits.""" - deployment = DeploymentSchedule(years=4).plan(self.layout) + """Sets are enumerated within limits, of missions without restoration + that are not staged.""" + schedule = DeploymentSchedule(years=4) + deployment = schedule.plan(self.layout, policy=DEGRADE) failures = FailureModel(life=Exponential(0.5)) - with self.assertRaises(ValueError): - exact_expectations( - deployment, - failures, - Capability(self.satellites, self.observations, self._metric), - max_sets=3, - ) - with self.assertRaises(ValueError): + capability = Capability(self.satellites, self.observations, self._metric) + with self.assertRaises(ExactExpectationsError): + exact_expectations(deployment, failures, capability, max_sets=3) + with self.assertRaises(ValueError) as caught: exact_expectations( deployment, failures, Capability(self.satellites[:3], self.observations, self._metric), ) + self.assertNotIsInstance(caught.exception, ExactExpectationsError) + # the policy of the deployment restores failures, or it is staged + with self.assertRaisesRegex(ExactExpectationsError, "restore"): + exact_expectations(schedule.plan(self.layout), failures, capability) + staged = schedule.plan(self.layout, policy=DEGRADE, stages=[Stage(1, 1.0)]) + with self.assertRaisesRegex(ExactExpectationsError, "staged"): + exact_expectations(staged, failures, capability) class TestImportanceSampling(unittest.TestCase): @@ -993,7 +1012,7 @@ def test_stressed_lives(self): def test_rare_losses(self): """Stress estimates the probability of a rare loss with less variance.""" - deployment = DeploymentSchedule(years=5).plan(_walker(1, 3)) + deployment = DeploymentSchedule(years=5).plan(_walker(1, 3), policy=DEGRADE) failures = FailureModel(life=Exponential(0.01)) p = 1 - math.exp(-0.05) exact = 3 * p**2 * (1 - p) + p**3 @@ -1002,11 +1021,7 @@ def test_rare_losses(self): values = [] for seed in range(25): histories = deployment.simulate_many( - failures, - RestorationPolicy(restore=False), - seed, - histories=200, - stress=stress, + failures, seed, histories=200, stress=stress ) rows = pd.DataFrame( [{**h.metrics(), "weight": h.weight} for h in histories] @@ -1014,25 +1029,23 @@ def test_rare_losses(self): summary = summarize_histories( rows, requirements=[Requirement("failures", ">=", 2)] ) - values.append(summary["P(failures >= 2)"]) + values.append(summary["P(failures >= 2) histories"]) if stress > 1: self.assertGreater(summary["effective histories"], 30) estimates[stress] = np.array(values) self.assertAlmostEqual(estimates[8.0].mean(), exact, delta=0.001) self.assertLess(estimates[8.0].var(), estimates[1.0].var() / 5) # without stress, histories are not weighted - plain = deployment.simulate_many(failures, None, 1, histories=5) + plain = deployment.simulate_many(failures, 1, histories=5) self.assertTrue(all(h.weight == 1.0 for h in plain)) with self.assertRaises(ValueError): - deployment.simulate_many(failures, None, 1, histories=5, stress=0) + deployment.simulate_many(failures, 1, histories=5, stress=0) def test_stressed_launches(self): """Stressed launches are weighted to their probability of failure.""" - deployment = DeploymentSchedule(years=2).plan(_walker(1, 2)) + deployment = DeploymentSchedule(years=2).plan(_walker(1, 2), policy=DEGRADE) failures = FailureModel(launch=0.02) - histories = deployment.simulate_many( - failures, RestorationPolicy(restore=False), 4, histories=3000, stress=10.0 - ) + histories = deployment.simulate_many(failures, 4, histories=3000, stress=10.0) weights = np.array([h.weight for h in histories]) lost = np.array([h.launches[0].failed for h in histories]) self.assertGreater(lost.mean(), 0.1) # stressed: failures are common @@ -1052,7 +1065,7 @@ def test_times_and_columns(self): self.assertEqual(summary["accurate time"], math.inf) self.assertEqual(summary["accurate time histories p30"], 2.0) self.assertEqual(summary["accurate time histories p90"], math.inf) - self.assertEqual(summary["P(accurate time <= 3)"], 0.5) + self.assertEqual(summary["P(accurate time <= 3) histories"], 0.5) with self.assertRaisesRegex(ValueError, "other"): summarize_histories(histories, quantiles={"other": 0.5}) with self.assertRaisesRegex(ValueError, "other"): @@ -1071,7 +1084,7 @@ def test_weighted_summaries(self): ) self.assertAlmostEqual(summary["value"], (4 + 2 + 3 + 8) / 8) self.assertEqual(summary["value histories p50"], 1.0) # half the weight is at 1 - self.assertAlmostEqual(summary["P(value >= 3)"], 3 / 8) + self.assertAlmostEqual(summary["P(value >= 3) histories"], 3 / 8) self.assertAlmostEqual(summary["effective histories"], 64 / 22) self.assertNotIn("weight", summary) self.assertGreater(summary["value histories std"], 0) diff --git a/tests/tradespace/test_fingerprint.py b/tests/tradespace/test_fingerprint.py index d769fd20..b5dd7b67 100644 --- a/tests/tradespace/test_fingerprint.py +++ b/tests/tradespace/test_fingerprint.py @@ -12,6 +12,7 @@ import subprocess import sys import unittest +import warnings from types import SimpleNamespace from unittest import mock from datetime import datetime, timedelta, timezone @@ -32,14 +33,18 @@ DesignSpace, Integer, Real, + SatelliteCache, SatelliteCost, Study, Uncertain, ) from tatc.tradespace.fingerprint import ( compare_definitions, + describe, get_definition, get_fingerprint, + find_stale, + warn_stale, ) THRESHOLD = 4 @@ -127,6 +132,23 @@ def _uses_model(d): return {"cost": MODEL.estimate(d.layout).total} +def _offset_cache(offset): + """A cache of an analysis of satellites that gives an offset.""" + return SatelliteCache(lambda satellite: offset) + + +SATELLITES = _offset_cache(0.0) +BASE = DesignSpace(n=Integer(1, 2)).design({"n": 1}) + + +def _uses_satellites(satellites): + return {"m": SATELLITES(satellites)} + + +def _uses_base(d): + return {"m": BASE.n * d} + + START = datetime(2026, 1, 1, tzinfo=timezone.utc) @@ -427,7 +449,7 @@ def test_imports_resolve(self): self.assertTrue(resources) # a constant of a package depends on its source only self.assertEqual( - fingerprint._resolve("tatc", "__version__"), {("file", "tatc")} + fingerprint._resolve_import("tatc", "__version__"), {("file", "tatc")} ) def test_static_imports(self): @@ -624,3 +646,134 @@ def classes(body): # the code of the methods of the class edited = classes("{'v': d.a + self.k}") self.assertNotEqual(get_fingerprint(f=score(1)), get_fingerprint(f=edited(1))) + + +class _Described: + """An object that describes itself by what changes results.""" + + def __init__(self, value, calls=0): + self.value, self.calls = value, calls + + def __fingerprint__(self): + return {"value": self.value} + + +class TestSelfDescribed(unittest.TestCase): + """ + Unit tests for objects that describe themselves (by `__fingerprint__`), + such as designs and caches of satellites. + """ + + def test_hook(self): + """An object is described by what its `__fingerprint__` gives, not by + its other attributes.""" + self.assertEqual( + get_fingerprint(_Described(1)), get_fingerprint(_Described(1, calls=5)) + ) + self.assertNotEqual( + get_fingerprint(_Described(1)), get_fingerprint(_Described(2)) + ) + # the class is not described by the hook (it is not an object of it) + self.assertNotIn("fingerprint", get_definition(_Described)["values"]["0"]) + + def test_satellite_cache(self): + """A study whose function refers to a cache of satellites changes its + fingerprint with the cache's function, not with its use.""" + global SATELLITES # pylint: disable=global-statement + space = DesignSpace(n=Integer(1, 2)) + + def fingerprint_of(): + return Study(space, lambda d: [], _uses_satellites).fingerprint + + before = fingerprint_of() + SATELLITES([]) + SATELLITES.hits += 3 + self.assertEqual(fingerprint_of(), before) + try: + SATELLITES = _offset_cache(1.0) + self.assertNotEqual(fingerprint_of(), before) + finally: + SATELLITES = _offset_cache(0.0) + self.assertEqual(fingerprint_of(), before) + + def test_design(self): + """A design is described by its design space, decisions, replicate, + and scenario.""" + global BASE # pylint: disable=global-statement + space = DesignSpace(n=Integer(1, 2), u=Uncertain.uniform(0, 1)) + before = get_fingerprint(_uses_base) + try: + BASE = BASE.space.design({"n": 2}) + self.assertNotEqual(get_fingerprint(_uses_base), before) + finally: + BASE = BASE.space.design({"n": 1}) + self.assertEqual(get_fingerprint(_uses_base), before) + design = space.design({"n": 1}) + prints = { + get_fingerprint(design), + get_fingerprint(space.design({"n": 2})), + get_fingerprint(design.realize(0)), + get_fingerprint(design.realize(1)), + get_fingerprint(design.realize(0, overrides={"u": 0.5}, scenario="half")), + get_fingerprint(DesignSpace(n=Integer(1, 3)).design({"n": 1})), + } + self.assertEqual(len(prints), 6) + self.assertEqual( + get_fingerprint(design), get_fingerprint(space.design({"n": 1})) + ) + + def test_describe(self): + """A value is described as a definition describes it.""" + values = {"limit": 2.0, "names": ("a", "b")} + self.assertEqual(describe(values), get_definition(v=values)["values"]["v"]) + self.assertEqual(describe(values), {"limit": "2.0", "names": ["a", "b"]}) + + +class TestStale(unittest.TestCase): + """ + Unit tests for the results of the same study with other code. + """ + + def setUp(self): + self.older = {"values": {"f": {"code": "aa", "constants": [1], "names": []}}} + self.newer = {"values": {"f": {"code": "bb", "constants": [1], "names": []}}} + self.other = {"values": {"f": {"code": "bb", "constants": [2], "names": []}}} + + def test_stale(self): + """Definitions of the same values but other code are stale, in order, + with their numbers of results.""" + others = {"b": self.older, "c": self.other, "d": None, "a": self.older} + counts = {"a": 0, "b": 3, "c": 5, "d": 1} + found = find_stale(self.newer, others, counts.__getitem__) + self.assertEqual(list(found.items()), [("b", 3), ("a", 0)]) + + def test_warn_stale(self): + """A warning names the stale results and the differences of the latest + of them, once if asked.""" + definitions = {"b": self.older} + with self.assertWarnsRegex( + UserWarning, r"^7 things with other code.*\(remove them\).*f\.code" + ): + warned = warn_stale( + {"a": 0, "b": 7}, + self.newer, + definitions.get, + lambda count: f"{count} things", + "remove them", + ) + self.assertTrue(warned) + with warnings.catch_warnings(): + warnings.simplefilter("error") + self.assertFalse( + warn_stale({"a": 0}, self.newer, definitions.get, str, "remove them") + ) + self.assertFalse( + warn_stale( + {"b": 7}, + self.newer, + definitions.get, + str, + "remove them", + once=lambda: False, + ) + ) diff --git a/tests/tradespace/test_layering.py b/tests/tradespace/test_layering.py index f76c5a2b..8e5dbcbd 100644 --- a/tests/tradespace/test_layering.py +++ b/tests/tradespace/test_layering.py @@ -23,10 +23,12 @@ "dominance", "fingerprint", "hashing", + "memory", "nodes", "optimization", "pareto", "plotting", + "references", "refinement", "scenarios", "screening", @@ -36,12 +38,30 @@ "store", "study", "summary", + "tables", "utility", "values", "walks", } """The modules of trade studies of any designs.""" +MISSIONS = { + "cache", + "constellations", + "cost", + "deployment", + "events", + "expectations", + "failures", + "histories", + "mission", + "observations", + "plans", + "simulation", +} +"""The modules of constellations and their missions (and the caches of their +satellites), which may import the general modules.""" + def _imports(path: Path) -> set[str]: """ @@ -79,6 +99,11 @@ def setUp(self): if path.stem != "__init__" } + def test_classified(self): + """Every module is either general or of constellations and missions.""" + self.assertEqual(GENERAL & MISSIONS, set()) + self.assertEqual(GENERAL | MISSIONS, set(self.modules)) + def test_general_modules(self): """General modules do not import those of constellations and missions.""" self.assertLessEqual(GENERAL, set(self.modules)) diff --git a/tests/tradespace/test_observations.py b/tests/tradespace/test_observations.py index 7180e0b1..90e2991b 100644 --- a/tests/tradespace/test_observations.py +++ b/tests/tradespace/test_observations.py @@ -39,6 +39,7 @@ Real, Requirement, RestorationPolicy, + SatelliteCache, SatelliteCost, Stage, Study, @@ -52,10 +53,11 @@ risk_space, walker_space, ) -from tatc.tradespace.histories import exact_expectations, summarize_histories +from tatc.tradespace.expectations import exact_expectations +from tatc.tradespace.fingerprint import get_fingerprint +from tatc.tradespace.histories import summarize_histories from tatc.tradespace.mission import summarize_phases -from tatc.tradespace.observations import value_of -from tatc.tradespace.values import configure +from tatc.tradespace import configure HAS_JOBLIB = importlib.util.find_spec("joblib") is not None @@ -95,22 +97,10 @@ def _observations(directory=None): return Observations(TARGETS, START, HOURS, directory=directory) -class TestReferences(unittest.TestCase): - """ - Unit tests for references to the values of designs. - """ - - def test_value_of(self): - """References name values, paths of values, or compute them.""" - d = SPACE.enumerate()[0].realize(0) - self.assertEqual(value_of(d, "altitude"), d.altitude) - self.assertEqual(value_of(d, "layout.planes"), d.layout.planes) - self.assertEqual(value_of(d, lambda d: 2 * d.altitude), 2 * d.altitude) - self.assertIsNone(value_of(d, None)) - with self.assertRaises(KeyError): - value_of(d, "layout.other") - with self.assertRaises(TypeError): - value_of(d, 3) +def _grid(count, seed=None): + """Targets at the equator, of a seed (which a replicate draws).""" + del seed + return pd.DataFrame({"latitude": [0.0] * count, "longitude": range(count)}) class TestTargets(unittest.TestCase): @@ -183,6 +173,47 @@ def test_disk_cache(self): again(_build(designs[0]), designs[0]) self.assertEqual(again.cache_of(designs[0]).misses, 0) + def test_targets_generated_when_needed(self): + """Caches on disk of generated targets are keyed by their recipe and + seed, so that opening (and pruning) them generates no targets, nor do + results on disk.""" + designs = [d.realize(r) for d in SPACE.enumerate()[:1] for r in (0, 1)] + original = Targets._of_seed # pylint: disable=protected-access + with ( + tempfile.TemporaryDirectory() as directory, + mock.patch.object( + Targets, "_of_seed", autospec=True, side_effect=original + ) as generated, + ): + first = _observations(directory) + for d in designs: + first(_build(d)[:1], d) + self.assertEqual(generated.call_count, len(designs)) + generated.reset_mock() + again = _observations(directory) + self.assertEqual(again.prune(), 0) + again(_build(designs[0])[:1], designs[0]) # from the results on disk + generated.assert_not_called() + self.assertEqual( + sorted(SatelliteCache.contexts(directory).values()), + sorted((d.points_seed, START) for d in designs), + ) + # the fingerprint of a cache follows the recipe of the targets (their + # function and its arguments), not the targets kept in memory + d = designs[0] + + def fingerprint(targets): + return get_fingerprint( + Observations(targets, START, HOURS).cache_of(d).function + ) + + fresh = Targets(_grid, 5, seed="points_seed") + recipes = [fresh, Targets(_grid, 6, seed="points_seed"), TARGETS] + prints = [fingerprint(targets) for targets in recipes] + self.assertEqual(len(set(prints)), 3) + fresh.of(d) + self.assertEqual(fingerprint(fresh), prints[0]) + def test_directory_not_in_fingerprint(self): """The directory of a cache does not change the fingerprint of a study.""" prints = { @@ -594,6 +625,27 @@ def test_staging_recorded(self): # decision a year later, and launched at 1.5 self.assertEqual(list(means["deployed"]), [0.25, 1.5]) + def test_metrics_of_every_satellite_once(self): + """With a plan, the metrics of every satellite are those of the last + phase of the mission, evaluated once.""" + calls = [] + + def metrics(observations): + if len(observations) > 0: + calls.append(frozenset(observations.satellite)) + return _metrics(observations) + + design = SPACE.enumerate()[3] + study = ObservationStudy( + SPACE, _build, _observations(), metrics, plan=PLAN, phases=True + ) + result = study.run([design]).iloc[0] + self.assertEqual(len(calls), len(set(calls))) + satellites = study.satellites_of(design) + observed = study.observations_of(design) + self.assertEqual(result["observed"], _metrics(observed)["observed"]) + self.assertIn(frozenset(s.name for s in satellites), calls) + def test_spares_of_the_policy(self): """The policy of each design gives its spares, which are produced whether or not the study has failures.""" @@ -663,11 +715,12 @@ def test_failure_times(self): for column in ( "observed time", "observed time histories p50", - "P(observed time <= 1)", + "P(observed time <= 1) histories", ): self.assertEqual(result[column], summary[column]) self.assertAlmostEqual( - result["P(observed time <= 1)"], (histories["observed time"] <= 1).mean() + result["P(observed time <= 1) histories"], + (histories["observed time"] <= 1).mean(), ) def test_failure_validation(self): @@ -796,8 +849,9 @@ def test_mission(self): summarize_phases(phases)["observed mission"], result["observed mission"] ) self.assertAlmostEqual(mission.estimate().total, result["cost"]) - self.assertEqual(mission.planned().deployed, result["deployed"]) - self.assertIs(mission.planned(), mission.planned()) + self.assertEqual(deployment.planned().deployed, result["deployed"]) + self.assertIs(deployment.planned(), deployment.planned()) + self.assertIs(deployment.policy, PLAN.policy) with self.assertRaisesRegex(ValueError, "failures"): mission.histories() unplanned = self.study.replace(plan=None, phases=None) @@ -942,7 +996,8 @@ def test_exact_or_sampled(self): result = study.run([design]).iloc[0] for column in ("observed mission", "availability"): self.assertAlmostEqual(result[column], exact[column]) - with mock.patch("tatc.tradespace.plans.MAX_SETS", 1): + bounded = partial(exact_expectations, max_sets=1) + with mock.patch("tatc.tradespace.plans.exact_expectations", bounded): fallback = study.run([design]).iloc[0] for column in ("observed mission", "availability"): self.assertAlmostEqual(fallback[column], sampled[column].mean()) diff --git a/tests/tradespace/test_optimization.py b/tests/tradespace/test_optimization.py index 1d9c0147..d6b69fef 100644 --- a/tests/tradespace/test_optimization.py +++ b/tests/tradespace/test_optimization.py @@ -30,7 +30,11 @@ pareto_front, summarize, ) -from tatc.tradespace.optimization import Evaluations, make_pymoo_problem +from tatc.tradespace.optimization import ( + Evaluations, + _constraint_names, + make_pymoo_problem, +) HAS_OPTUNA = importlib.util.find_spec("optuna") is not None HAS_PYMOO = importlib.util.find_spec("pymoo") is not None @@ -202,6 +206,20 @@ def test_one_record_per_evaluation(self): with self.assertRaises(ValueError): Evaluations(study, OBJECTIVES).evaluate(_space().enumerate()[:1]) + def test_constraint_names(self): + """Requirements are constraints of distinct names: their statements, + their values in full where these are alike, or their order.""" + requirements = [ + Requirement("a", ">=", 2.0000001), + Requirement("a", ">=", 2.0000002), + Requirement("b", "<=", 1), + Requirement("b", "<=", 1, scale=2), + ] + self.assertEqual( + _constraint_names(requirements), + ["a >= 2.0000001", "a >= 2.0000002", "b <= 1", "b <= 1 (2)"], + ) + def _exact_hypervolume(): summary = summarize(_study().run(), list(OBJECTIVES)) @@ -337,6 +355,22 @@ def test_distinct(self): with self.assertRaises(ValueError): optimize_pymoo(_study(), OBJECTIVES, algorithm=object(), seed=1) + def test_algorithm_unchanged(self): + """A distinct search does not change the algorithm it is given, which + another search may take.""" + # pylint: disable-next=import-outside-toplevel + from pymoo.algorithms.moo.nsga2 import NSGA2 + + algorithm = NSGA2(pop_size=8) + own = algorithm.mating.eliminate_duplicates + optimize_pymoo(_study(), OBJECTIVES, algorithm, ("n_gen", 2), seed=1) + self.assertIs(algorithm.mating.eliminate_duplicates, own) + self.assertIs(algorithm.initialization.eliminate_duplicates, own) + plain = optimize_pymoo( + _study(), OBJECTIVES, algorithm, ("n_gen", 2), seed=1, distinct=False + ) + self.assertGreater(len(plain.evaluated), 0) + def test_max_designs(self): """A search stops after the generation in which it has evaluated the most designs, or by its termination.""" @@ -495,6 +529,27 @@ def test_optuna(self): with self.assertRaises(ValueError): optimize_optuna(_study(), self.CRITERIA, n_trials=1, constraints=False) + def test_optuna_names(self): + """Requirements that state themselves alike are distinct constraints.""" + import optuna # pylint: disable=import-outside-toplevel + + optuna.logging.set_verbosity(optuna.logging.WARNING) + criteria = Criteria( + OBJECTIVES, + statistics={"value p0": Minimum("value")}, + requirements=[ + Requirement("value p0", ">=", 2.0000001), + Requirement("value p0", ">=", 2.5000001), + Requirement("value p0", ">=", 2.5000002), + ], + ) + optuna_study = optimize_optuna( + _study(), criteria, n_trials=10, sampler=optuna.samplers.RandomSampler(1) + ).state + names = ("value p0 >= 2", "value p0 >= 2.5000001", "value p0 >= 2.5000002") + keys = {tuple(sorted(trial.constraints)) for trial in optuna_study.trials} + self.assertEqual(keys, {("feasibility", *names)}) + def test_pymoo(self): """Problems have a constraint for each requirement.""" problem = make_pymoo_problem(_study(), self.CRITERIA) diff --git a/tests/tradespace/test_pareto.py b/tests/tradespace/test_pareto.py index 7b71e1c4..89737f62 100644 --- a/tests/tradespace/test_pareto.py +++ b/tests/tradespace/test_pareto.py @@ -1,5 +1,7 @@ """ -Unit tests for Pareto efficiency. +Unit tests for the Pareto efficiency of the rows of summaries of designs: +fronts, ranks, and hypervolumes, and the dominance of points with +tolerances. @author Paul T. Grogan """ @@ -13,12 +15,30 @@ from tatc.tradespace import ( Criteria, Requirement, + aggregate, hypervolume, hypervolume_progress, pareto_front, - pareto_probability, pareto_ranks, ) +from tatc.tradespace.dominance import dominated + + +def _results(values): + """Results of designs (rows) in replicates (columns), with a cost of 1.""" + return pd.DataFrame( + [ + { + "design": f"d{i}", + "replicate": r, + "cost": 1.0, + "value": v, + "feasible": True, + } + for i, row in enumerate(values) + for r, v in enumerate(row) + ] + ) def _brute_hypervolume(costs: np.ndarray, reference: np.ndarray) -> float: @@ -151,92 +171,38 @@ def test_relative(self): self.assertEqual(list(absolute), [True, False, False, False]) -class TestParetoProbability(unittest.TestCase): +class TestSummaries(unittest.TestCase): """ - Unit tests for the probability of Pareto efficiency. + Unit tests for the efficient designs of summaries (a row per design), and + the functions of summaries given the results of a study. """ - @staticmethod - def _results(values): - """Results of designs (rows) in replicates (columns), with a cost of 1.""" - return pd.DataFrame( - [ - { - "design": f"d{i}", - "replicate": r, - "cost": 1.0, - "value": v, - "feasible": True, - } - for i, row in enumerate(values) - for r, v in enumerate(row) - ] - ) - - def test_settled(self): - """Designs separated in every replicate are efficient or not for sure.""" - results = self._results([[1, 2, 3], [5, 6, 7]]) - probability = pareto_probability(results, {"cost": "min", "value": "max"}) - self.assertEqual(list(probability.pareto_probability), [0, 1]) - self.assertEqual(list(probability.pareto), [False, True]) - self.assertEqual(list(probability.value), [2, 6]) - - def test_common_random_numbers(self): - """Designs that differ by a constant in every replicate are settled.""" - rng = np.random.default_rng(0) - common = rng.normal(0, 5, 8) - results = self._results([common, common + 0.1]) - probability = pareto_probability(results, {"cost": "min", "value": "max"}) - self.assertEqual(list(probability.pareto_probability), [0, 1]) - - def test_unsettled(self): - """Designs whose order changes between replicates are uncertain.""" - # equal means: d0 varies between replicates, d1 does not - results = self._results([[0, 2] * 4, [1] * 8]) - probability = pareto_probability( - results, {"cost": "min", "value": "max"}, n_resamples=300 - ) - p = probability.pareto_probability - self.assertTrue(((p > 0.05) & (p < 0.95)).all()) + def setUp(self): + self.results = _results([[1, 2, 3], [5, 6, 7]]) + self.objectives = {"cost": "min", "value": "max"} - def test_groups(self): - """Fronts of groups are found separately.""" + def test_pareto(self): + """Summaries of criteria give the efficient designs, in each group.""" results = pd.concat( [ - self._results([[1, 2], [3, 4]]).assign(sensor="a"), - self._results([[3, 4], [1, 2]]).assign(sensor="b"), - ] - ) - probability = pareto_probability( - results, Criteria({"cost": "min", "value": "max"}, by=["sensor"]) + _results([[10, 12, 14, 16], [5, 30, 5, 30]]).assign( + cost=2.0, size="small" + ), + _results([[1] * 4]).assign(design="d2", size="large"), + ], + ignore_index=True, ) - winners = probability[probability.pareto_probability == 1] + criteria = Criteria(self.objectives, by="size") + summary = aggregate(results, criteria) self.assertEqual( - sorted(zip(winners.sensor, winners.design)), [("a", "d1"), ("b", "d0")] + list(summary.pareto), + list(pareto_front(summary.drop(columns="pareto"), criteria)), ) - - def test_design_values(self): - """Probabilities keep the values of the designs, as summaries do.""" - results = self._results([[1, 2], [3, 4]]) - results["size"] = results["design"].map({"d0": "small", "d1": "large"}) - results["seed"] = results["replicate"] # an uncertain parameter - probability = pareto_probability(results, {"cost": "min", "value": "max"}) - self.assertEqual(list(probability["size"]), ["small", "large"]) - self.assertNotIn("seed", probability.columns) - bare = pareto_probability( - results, {"cost": "min", "value": "max"}, design_columns=[] + # designs d0 (a mean of 13) and d1 (17.5) of the same cost, and d2 alone + self.assertEqual( + dict(zip(summary.design, summary.pareto)), + {"d0": False, "d1": True, "d2": True}, ) - self.assertNotIn("size", bare.columns) - - -class TestSummaries(unittest.TestCase): - """ - Unit tests for the functions of summaries given the results of a study. - """ - - def setUp(self): - self.results = TestParetoProbability._results([[1, 2, 3], [5, 6, 7]]) - self.objectives = {"cost": "min", "value": "max"} def test_results_raise(self): """Results with a row per replicate are not summaries of designs.""" @@ -279,19 +245,16 @@ def _every_pair(costs, tolerances=None): absolute, relative = ( np.zeros((2, costs.shape[1])) if tolerances is None else tolerances ) - dominated = np.zeros(len(costs), dtype=bool) + beaten = np.zeros(len(costs), dtype=bool) for i, point in enumerate(costs): penalized = costs + absolute + relative * np.abs(point) no_worse = np.all(penalized <= point, axis=1) better = np.any(penalized < point, axis=1) - dominated[i] = np.any(no_worse & better) - return dominated + beaten[i] = np.any(no_worse & better) + return beaten def test_matches_every_pair(self): """Dominance, with or without tolerances, is that of every pair.""" - # pylint: disable=import-outside-toplevel,protected-access - from tatc.tradespace import pareto - rng = np.random.default_rng(3) sets = ( rng.random((700, 3)), @@ -309,7 +272,7 @@ def test_matches_every_pair(self): if tolerance is not None: tolerance = tolerance[:, : costs.shape[1]] np.testing.assert_array_equal( - pareto._dominated(costs, tolerance), + dominated(costs, tolerance), self._every_pair(costs, tolerance), ) @@ -355,37 +318,6 @@ def test_progress(self): hypervolume_progress(results, objectives, (10, 0), step=0) -class TestStandardErrors(unittest.TestCase): - """ - Unit tests for the standard errors of the objectives of designs. - """ - - def test_standard_errors(self): - """The bootstrap gives the standard error of each objective.""" - rng = np.random.default_rng(0) - results = pd.DataFrame( - [ - { - "design": design, - "replicate": r, - "feasible": True, - "x": float(i), - "y": i + rng.normal(0, 2), - } - for i, design in enumerate("ab") - for r in range(40) - ] - ) - probability = pareto_probability( - results, {"x": "min", "y": "max"}, n_resamples=2000 - ) - np.testing.assert_allclose(probability["x se"], 0.0) - expected = results.groupby("design").y.std(ddof=0) / np.sqrt(40) - np.testing.assert_allclose( - probability.set_index("design")["y se"], expected, rtol=0.15 - ) - - class TestMissingObjectives(unittest.TestCase): """ Unit tests for designs with missing objectives. @@ -400,69 +332,3 @@ def test_not_efficient(self): self.assertEqual(list(pareto_front(summary, objectives)), [True, False, True]) self.assertEqual(list(pareto_ranks(summary, objectives)), [0, 1, 0]) self.assertAlmostEqual(hypervolume(summary, objectives, {"x": 3, "y": 2}), 3.0) - - -class TestFeasibleProbability(unittest.TestCase): - """ - Unit tests for the probability of efficiency of designs infeasible in - some replicates. - """ - - @staticmethod - def _results(feasible): - """Two designs in eight replicates: d1, better, is feasible only where - given.""" - return pd.DataFrame( - [ - { - "design": design, - "replicate": r, - "feasible": True if design == "d0" else feasible[r], - "cost": 1.0, - "value": 1.0 if design == "d0" else 2.0, - } - for design in ("d0", "d1") - for r in range(len(feasible)) - ] - ) - - def test_feasible_requirement(self): - """A requirement on the share of feasible replicates is uncertain in - the bootstrap.""" - results = self._results([True, False] * 4) - criteria = Criteria( - {"cost": "min", "value": "max"}, - requirements=[Requirement("feasible", ">=", 0.5)], - ) - probability = pareto_probability(results, criteria, n_resamples=200) - probability = probability.set_index("design") - self.assertEqual(probability.loc["d1", "feasible"], 0.5) - self.assertEqual(probability.loc["d1", "replicates"], 4) - met = probability.loc["d1", "requirements_probability"] - self.assertGreater(met, 0.2) - self.assertLess(met, 0.9) - self.assertEqual(probability.loc["d0", "requirements_probability"], 1.0) - # without the requirement, d1 is judged by its feasible replicates - plain = pareto_probability(results, {"cost": "min", "value": "max"}) - plain = plain.set_index("design") - self.assertEqual(plain.loc["d1", "pareto_probability"], 1.0) - self.assertEqual(plain.loc["d0", "pareto_probability"], 0.0) - - def test_no_feasible_design(self): - """Results without a feasible record have an empty summary.""" - results = self._results([False] * 4) - results = results[results.design == "d1"].drop(columns=["cost", "value"]) - probability = pareto_probability(results, {"cost": "min", "value": "max"}) - self.assertTrue(probability.empty) - self.assertEqual( - list(probability.columns[-6:]), - [ - "feasible", - "violation", - "meets_requirements", - "pareto", - "pareto_probability", - "requirements_probability", - ], - ) - self.assertIn("value se", probability.columns) diff --git a/tests/tradespace/test_references.py b/tests/tradespace/test_references.py new file mode 100644 index 00000000..75ec23ff --- /dev/null +++ b/tests/tradespace/test_references.py @@ -0,0 +1,129 @@ +""" +Unit tests for reading designs: references to their values, dataclasses +configured from them, and functions given them. + +@author Paul T. Grogan +""" + +import dataclasses +import unittest + +from tatc.tradespace import ( + Choice, + DesignSpace, + Integer, + Real, + Uncertain, + configure, + value_of, +) +from tatc.tradespace.references import given_design, takes_design + +SPACE = DesignSpace( + altitude=Real(600e3, 700e3, step=100e3), + layout=DesignSpace(planes=Integer(1, 2), per_plane=Integer(1, 2)), + growth=Uncertain.uniform(1.0, 1.5), +) + + +@dataclasses.dataclass(frozen=True) +class _Policy: + """A policy of two fields.""" + + spares: int = 0 + years: float = 1.0 + + +class TestReferences(unittest.TestCase): + """ + Unit tests for references to the values of designs. + """ + + def test_value_of(self): + """References name values, paths of values, or compute them.""" + d = SPACE.enumerate()[0].realize(0) + self.assertEqual(value_of(d, "altitude"), d.altitude) + self.assertEqual(value_of(d, "layout.planes"), d.layout.planes) + self.assertEqual(value_of(d, lambda d: 2 * d.altitude), 2 * d.altitude) + self.assertIsNone(value_of(d, None)) + with self.assertRaises(KeyError): + value_of(d, "layout.other") + with self.assertRaises(TypeError): + value_of(d, 3) + + +class TestConfigure(unittest.TestCase): + """ + Unit tests for dataclasses configured from the values of designs. + """ + + def test_design(self): + """A dataclass is configured from a design, or a view of its values.""" + design = DesignSpace(spares=Integer(1, 2), other=Integer(0, 1)).enumerate()[-1] + self.assertEqual(configure(_Policy(), design), _Policy(spares=2)) + self.assertEqual(configure(_Policy(), design.values), _Policy(spares=2)) + self.assertEqual(configure(_Policy(), design, years=2.0).years, 2.0) + self.assertEqual(configure(_Policy(), {"spares": 3}), _Policy(spares=3)) + with self.assertRaisesRegex(TypeError, "values of a design"): + configure(_Policy(), 3) + with self.assertRaisesRegex(TypeError, "dataclass instance"): + configure(_Policy, design) + with self.assertRaisesRegex(ValueError, "no fields"): + configure(_Policy(), design, other=1) + + def test_choice(self): + """A choice configures by the values of its branch, which must be a + group (or a fixed `None`).""" + space = DesignSpace( + policy=Choice( + spared=DesignSpace(spares=Integer(1, 2)), + plain=Integer(1, 2), + none=None, + ) + ) + spared = space.design({"policy": ["spared", {"spares": 2}]}) + self.assertEqual(configure(_Policy(), spared.policy), _Policy(spares=2)) + none = space.design({"policy": "none"}) + self.assertEqual(configure(_Policy(), none.policy), _Policy()) + plain = space.design({"policy": ["plain", 2]}) + with self.assertRaisesRegex(TypeError, "chose 'plain', whose value is 2"): + configure(_Policy(), plain.policy) + + +class TestGivenDesign(unittest.TestCase): + """ + Unit tests for functions given the design by a keyword. + """ + + def test_takes_design(self): + """A function takes the design if it has a parameter named `design` + that may be given by keyword.""" + + def positional(x, design): + return x, design + + def keyword(x, *, design=None): + return x, design + + def only_position(x, design, /): + return x, design + + self.assertTrue(takes_design(positional)) + self.assertTrue(takes_design(keyword)) + self.assertFalse(takes_design(only_position)) + self.assertFalse(takes_design(lambda x: x)) + self.assertFalse(takes_design(lambda x, **kwargs: x)) + self.assertFalse(takes_design(len)) + + def test_given_design(self): + """A function that takes the design is given it; others are not.""" + design = SPACE.enumerate()[0] + self.assertEqual( + given_design(lambda x, design: (x, design.key), design)(1), + (1, design.key), + ) + + def alone(x): + return x + + self.assertIs(given_design(alone, design), alone) diff --git a/tests/tradespace/test_refinement.py b/tests/tradespace/test_refinement.py index b4c9d027..dad0f1c6 100644 --- a/tests/tradespace/test_refinement.py +++ b/tests/tradespace/test_refinement.py @@ -11,8 +11,10 @@ import pandas as pd from tatc.tradespace import ( + Across, Criteria, DesignSpace, + Fixed, Infeasible, Integer, Quantile, @@ -94,8 +96,8 @@ def test_refines_uncertain_designs(self): max_rounds=6, n_resamples=200, ) - history = refinement.history - self.assertGreater(history.refined.iloc[0], 0) + rounds = refinement.rounds + self.assertGreater(rounds.refined.iloc[0], 0) replicates = refinement.results.groupby("design").replicate.nunique() # the clearly worse variant is never refined worse = [d.key for d in self.designs if d.variant == 2] @@ -133,7 +135,7 @@ def test_limits(self): self.assertLessEqual( refinement.results.groupby("design").replicate.nunique().max(), 8 ) - self.assertEqual(refinement.history.refined.iloc[-1], 0) + self.assertEqual(refinement.rounds.refined.iloc[-1], 0) with self.assertRaises(ValueError): refine( self.study, OBJECTIVES, self.results, self.designs, bounds=(0.9, 0.1) @@ -217,9 +219,11 @@ def test_partial_step(self): self.assertTrue(set(replicates) <= {5, 7}) def test_warns_without_tolerance(self): - """Designs that remain uncertain without a tolerance give a warning.""" - with self.assertWarns(UserWarning): + """Designs that remain uncertain without a tolerance give a warning, + at the call of the refinement.""" + with self.assertWarns(UserWarning) as context: refine(self.study, OBJECTIVES, self.results, self.designs, max_rounds=1) + self.assertEqual(context.filename, __file__) def test_precision(self): """A design about a tolerance from the front stops once precise enough.""" @@ -258,7 +262,7 @@ def refined(precision): self.assertLessEqual(precise, 30) self.assertEqual(refinement.indifferent.design.tolist(), [designs[1].key]) self.assertEqual(len(refinement.uncertain), 0) - self.assertEqual(refinement.history.indifferent.iloc[-1], 1) + self.assertEqual(refinement.rounds.indifferent.iloc[-1], 1) with self.assertRaises(ValueError): refine(study, criteria, results, designs, precision=0) @@ -272,7 +276,7 @@ def test_budget(self): nothing = refine( self.study, OBJECTIVES, self.results, self.designs, budget=0 ) - self.assertEqual(refinement.history.evaluations.sum(), 12) + self.assertEqual(refinement.rounds.evaluations.sum(), 12) replicates = refinement.results.groupby("design").replicate.nunique() self.assertEqual(sorted(replicates[replicates > 5]), [7, 10, 10]) # the designs whose probability was nearest 0.5 @@ -283,6 +287,40 @@ def test_budget(self): self.assertEqual(set(replicates[replicates > 5].index), set(nearest)) self.assertEqual(len(nothing.results), len(self.results)) + def test_budget_of_scenarios(self): + """A replicate of a study with scenarios spends an evaluation of the + budget in each scenario, as the refinement counts them.""" + space = DesignSpace( + cost=Integer(1, 6), + variant=Integer(0, 2), + shift=Fixed(0.0), + noise=Uncertain.normal(0, 1), + ) + + def evaluate(d): + value = np.sqrt(d.cost) * 3 + {0: 0.0, 1: 1.0, 2: -3.0}[d.variant] + return {"cost": d.cost, "value": value + d.shift + d.noise} + + study = Study( + space, + lambda d: d, + evaluate, + replicates=3, + common_random_numbers=False, + scenarios={"a": {}, "b": {"shift": 0.5}, "c": {"shift": -0.5}}, + ) + results = study.run(space.enumerate()) + criteria = Criteria(OBJECTIVES, across=Across(rule="mean")) + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + refinement = refine( + study, criteria, results, budget=13, step=2, max_rounds=3 + ) + added = len(refinement.results) - len(results) + self.assertEqual(refinement.evaluations, added) + # four replicates of the budget's 13 evaluations, in each of 3 scenarios + self.assertEqual(added, 12) + def test_precise(self): """Designs are precise if each varying objective is within its tolerance.""" probability = pd.DataFrame( @@ -304,6 +342,11 @@ def test_precise(self): np.testing.assert_array_equal( _precise(probability, Criteria(OBJECTIVES), 0.5), [False, False, False] ) + # an objective without a standard error does not vary + np.testing.assert_array_equal( + _precise(probability.drop(columns="cost se"), criteria, 0.5), + [True, False, True], + ) class TestRefineInfeasible(unittest.TestCase): diff --git a/tests/tradespace/test_scenarios.py b/tests/tradespace/test_scenarios.py index cabd3d2c..2244c74d 100644 --- a/tests/tradespace/test_scenarios.py +++ b/tests/tradespace/test_scenarios.py @@ -106,7 +106,7 @@ def test_parallel(self): def test_store(self): """The evaluations of each scenario are stored by its values.""" - store = ResultStore(self.path, "scenarios") + store = ResultStore(self.path, namespace="scenarios") plain = self._study(store=store).run() self.assertEqual(len(self.calls), 6) # a scenario without values shares the evaluations without scenarios @@ -133,7 +133,7 @@ def test_store(self): def test_attribution(self): """The variance of designs in each scenario is attributed to their uncertain parameters.""" - store = ResultStore(self.path, "scenarios") + store = ResultStore(self.path, namespace="scenarios") study = self._study(SCENARIOS, store=store) a = attribute_variance( study, ["y"], SPACE.enumerate(), sample_size=20, by=["scenario"] @@ -424,28 +424,6 @@ def test_agrees_with_scenarios(self): np.testing.assert_array_equal(probability.replicates, 3) self.assertTrue(probability.pareto.all()) - def test_resamples_share_replicates(self): - """A bootstrap draws each replicate in every scenario at once.""" - rows = [ - { - "design": "A", - "replicate": r, - "scenario": s, - "feasible": True, - "perf": v, - } - for r in range(6) - for s, v in (("s1", float(r)), ("s2", 10.0 - r)) - ] - results = pd.DataFrame(rows) - mean = Criteria({"perf": "max"}, across=Across(rule="mean")) - probability = pareto_probability(results, mean, n_resamples=50) - self.assertAlmostEqual(probability["perf"].iloc[0], 5.0) - self.assertAlmostEqual(probability["perf se"].iloc[0], 0.0) - worst = Criteria({"perf": "max"}, across=Across()) - probability = pareto_probability(results, worst, n_resamples=50) - self.assertGreater(probability["perf se"].iloc[0], 0.0) - def test_invalid(self): """Rules, weights, and the statistics combined by their worst are checked.""" diff --git a/tests/tradespace/test_screening.py b/tests/tradespace/test_screening.py index 8a771871..5c4a5cb8 100644 --- a/tests/tradespace/test_screening.py +++ b/tests/tradespace/test_screening.py @@ -13,6 +13,7 @@ Criteria, DesignSpace, Integer, + Requirement, Study, Uncertain, confirm, @@ -166,3 +167,34 @@ def test_criteria_tolerance(self): self.assertTrue( (final.pareto_rank == 0).sum() >= pareto_front(final, OBJECTIVES).sum() ) + + +class TestScreenRequirements(unittest.TestCase): + """ + Unit tests for screening with requirements. + """ + + def test_misses_ranked_last(self): + """Designs that miss requirements are ranked after those that meet them.""" + space = DesignSpace(a=Integer(1, 6), noise=Uncertain.uniform(0, 1)) + study = Study( + space, + lambda d: d, + lambda d: {"cost": d.a, "value": d.a**0.5 + d.noise}, + replicates=2, + ) + screening = screen( + [study, study], + Criteria( + {"cost": "min", "value": "max"}, + requirements=[Requirement("cost", "<=", 3)], + ), + space.enumerate(), + keep=4, + ) + first = screening.summaries[0].set_index("design") + meets = first[first.meets_requirements] + misses = first[~first.meets_requirements] + self.assertGreater(misses.pareto_rank.min(), meets.pareto_rank.max()) + # the nearest miss (cost 4) is kept to fill four designs + self.assertEqual(sorted(first[first.kept].cost), [1, 2, 3, 4]) diff --git a/tests/tradespace/test_sensitivity.py b/tests/tradespace/test_sensitivity.py index 6232b7f8..9119f132 100644 --- a/tests/tradespace/test_sensitivity.py +++ b/tests/tradespace/test_sensitivity.py @@ -66,6 +66,16 @@ def test_main_effects(self): binned = main_effects(self.frame, "c", "metric", max_levels=4) self.assertEqual(len(binned), 4) + def test_order_of_bins(self): + """The bins of a numeric variable are in the order of their values.""" + summary = pd.DataFrame({"altitude": range(21), "cost": range(21)}) + effects = main_effects(summary, "altitude", "cost", max_levels=4) + self.assertTrue(effects.index.is_monotonic_increasing) + self.assertEqual(list(effects["mean"]), sorted(effects["mean"])) + self.assertEqual( + [interval.right for interval in effects.index], [5, 10, 15, 20] + ) + def test_results_raise(self): """The results of a study (a row per replicate) are not summaries.""" results = pd.DataFrame( diff --git a/tests/tradespace/test_space.py b/tests/tradespace/test_space.py index e035d8f8..15660d3d 100644 --- a/tests/tradespace/test_space.py +++ b/tests/tradespace/test_space.py @@ -21,6 +21,8 @@ Repeat, Uncertain, ) +from tatc.tradespace.space import RESERVED_NAMES, STATUS_COLUMNS +from tatc.tradespace.values import generic_path, is_number def _planes_space(): @@ -104,6 +106,13 @@ def test_reserved_names(self): with self.assertRaises(ValueError): DesignSpace(index=Integer(0, 1)) + def test_representation(self): + """A logarithmic variable says so in its representation.""" + self.assertEqual( + repr(Real(1, 10, log=True)), "Real(1, 10, step=None, log=True)" + ) + self.assertEqual(repr(Real(1, 10)), "Real(1, 10, step=None)") + class TestDesignSpace(unittest.TestCase): """ @@ -170,6 +179,39 @@ def test_design_from_decisions(self): with self.assertRaises(Infeasible): space.design({"per_plane": 4, "planes": [{}, {}]}) + def test_unknown_decisions(self): + """Decisions of no children (such as a misspelt name) raise, also + within groups, as do decisions of a group that are not a mapping.""" + space = DesignSpace( + a=Integer(1, 3), + b=Integer(1, 2), + g=DesignSpace(c=Integer(0, 1)), + parts=Repeat(DesignSpace(d=Integer(0, 1)), count=1), + ) + good = {"a": 1, "b": 2, "g": {"c": 0}, "parts": [{"d": 1}]} + self.assertEqual(space.design(good).decisions, good) + with self.assertRaisesRegex( + ValueError, r"no children of the design space.*typo" + ): + space.design({**good, "typo": 7}) + with self.assertRaisesRegex(ValueError, r"no children of g: \['e'\]"): + space.design({**good, "g": {"c": 0, "e": 1}}) + with self.assertRaisesRegex(ValueError, r"no children of parts\[0\]"): + space.design({**good, "parts": [{"d": 1, "e": 1}]}) + with self.assertRaisesRegex(ValueError, "a mapping"): + space.design({**good, "g": [0]}) + + def test_single_constraint(self): + """A design space (or an extension) takes a single constraint.""" + space = DesignSpace(lambda d: d.a < 3, a=Integer(1, 3)) + self.assertEqual([d.a for d in space.enumerate()], [1, 2]) + keyword = DesignSpace(a=Integer(1, 3), constraints=lambda d: d.a < 3) + self.assertEqual(len(keyword.enumerate()), 2) + extended = space.extend(lambda d: d.a > 1) + self.assertEqual([d.a for d in extended.enumerate()], [2]) + with self.assertRaisesRegex(TypeError, "a constraint is a callable"): + DesignSpace([lambda d: True, 3], a=Integer(1, 3)) + def test_sample(self): """Sampled designs are feasible, and Latin hypercube samples are stratified.""" space = _planes_space() @@ -276,6 +318,52 @@ def test_uncertain_paths(self): ) self.assertEqual(DesignSpace(a=Integer(1, 2)).uncertain_paths(), []) + def test_uncertain_values(self): + """A design gives the values of the uncertain parameters it draws, by + path: of the branches it chooses and of its items.""" + space = DesignSpace( + planes=Repeat( + DesignSpace(phase=Uncertain.uniform(0, 1), k=Integer(0, 1)), + count=Integer(1, 2), + ), + layout=Choice( + drawn=DesignSpace(u=Uncertain.normal(0, 1)), plain=Integer(1, 2) + ), + seed=Uncertain.seed(), + fixed=1.0, + ) + design = space.design( + {"planes": [{"k": 0}, {"k": 1}], "layout": ["drawn", None]} + ) + realized = design.realize(3) + values = realized.uncertain_values() + self.assertEqual( + list(values), + ["planes[0].phase", "planes[1].phase", "layout.drawn.u", "seed"], + ) + self.assertEqual(values["planes[1].phase"], realized.planes[1].phase) + self.assertEqual(values["seed"], realized.seed) + # nominal values of a design that is not realized + self.assertTrue(math.isnan(design.uncertain_values()["layout.drawn.u"])) + # not those of branches it does not choose + plain = space.design({"planes": [{"k": 0}], "layout": ["plain", 1]}) + self.assertEqual(list(plain.uncertain_values()), ["planes[0].phase", "seed"]) + # with the values of a scenario + overridden = design.realize(3, overrides={"seed": 7}, scenario="s") + self.assertEqual(overridden.uncertain_values()["seed"], 7) + + def test_negative_indices(self): + """Replicates and the offsets of shifts are non-negative integers.""" + design = _planes_space().enumerate()[0] + with self.assertRaisesRegex(ValueError, "a replicate must be a non-negative"): + design.realize(-1) + with self.assertRaisesRegex(ValueError, "a replicate must be a non-negative"): + design.realize(1.5) + with self.assertRaisesRegex(ValueError, "offset of 'planes"): + design.realize(3, shift={"planes[*].phase": -1}) + shifted = design.realize(0, shift={"planes[*].phase": 3}) + self.assertEqual(shifted.planes[0].phase, design.realize(3).planes[0].phase) + def test_shift(self): """A shift draws named parameters as in other replicates.""" space = DesignSpace( @@ -389,7 +477,7 @@ def test_round_trip(self): self.assertEqual([d.flat() for d in rebuilt][5], self.designs[5].flat()) # from a summary indexed by design, of some keys, in their order keys = [self.designs[3].key, self.designs[1].key] - some = self.space.designs_of(self.frame.set_index("design"), keys) + some = self.space.designs_of(self.frame.set_index("design"), keys=keys) self.assertEqual([d.key for d in some], keys) # a design for each row, aligned with the rows (as of results of # several rows of a design), each design rebuilt once @@ -406,7 +494,7 @@ def test_round_trip(self): def test_errors(self): """Rows without the values of decisions, or of other designs, raise.""" with self.assertRaises(KeyError): - self.space.designs_of(self.frame, ["unknown"]) + self.space.designs_of(self.frame, keys=["unknown"]) with self.assertRaisesRegex(ValueError, "no value of altitude"): self.space.designs_of(self.frame.drop(columns="altitude")) other = self.frame.assign(design=self.frame.design.iloc[::-1].to_numpy()) @@ -513,6 +601,23 @@ class TestReservedNames(unittest.TestCase): Unit tests for names that the views of values give otherwise. """ + def test_message(self): + """The error of a reserved name says why, and lists the names.""" + with self.assertRaises(ValueError) as context: + DesignSpace(items=Integer(1, 3)) + message = str(context.exception) + self.assertIn("['items']", message) + self.assertIn("views of their values", message) + self.assertIn(str(sorted(RESERVED_NAMES)), message) + + def test_status_columns(self): + """The status columns of results, and the attributes of designs, are + reserved names.""" + self.assertLessEqual(set(STATUS_COLUMNS), RESERVED_NAMES) + self.assertIn("uncertain_values", RESERVED_NAMES) + with self.assertRaisesRegex(ValueError, "reserved"): + DesignSpace(uncertain_values=Integer(1, 2)) + def test_reserved(self): """Children and branches may not be named as attributes of views, or as the status columns of the results of studies.""" @@ -645,6 +750,24 @@ def test_items(self): with self.assertRaises(IndexError): parts[index] # pylint: disable=pointless-statement + def test_plain_branch(self): + """A choice whose branch is a plain value (a variable) gives the + branch by its name, not the attributes of the value.""" + space = DesignSpace(x=Choice(a=Integer(1, 3), b=Real(0, 1, step=0.5))) + design = space.design({"x": ["a", 2]}) + self.assertEqual(design.x.a, 2) + self.assertEqual(design.x, "a") + for name in ("real", "bit_length", "b"): + with self.subTest(name=name): + with self.assertRaisesRegex(AttributeError, "chose 'a'"): + getattr(design.x, name) + self.assertNotIn(name, design.x) + # a branch that is a repetition gives its count + repeated = DesignSpace( + x=Choice(parts=Repeat(Integer(0, 1), count=2), none=None) + ).design({"x": ["parts", [0, 1]]}) + self.assertEqual(repeated.x.count, 2) + def test_counts_given(self): """Items given for a count that is not decided must match it.""" space = DesignSpace( @@ -745,6 +868,18 @@ def test_nan(self): space.design({"n": 1}) self.assertEqual(context.exception.violation, 1) + def test_equality(self): + """Realized designs are equal if of the same replicate and scenario.""" + design = self.space.design({"n": 1}) + low = design.realize(0, overrides={"limit": 1}, scenario="low") + high = design.realize(0, overrides={"limit": 4}, scenario="high") + self.assertNotEqual(low, high) + self.assertEqual(len({low, high}), 2) + again = design.realize(0, overrides={"limit": 1}, scenario="low") + self.assertEqual(low, again) + self.assertEqual(hash(low), hash(again)) + self.assertNotEqual(design.realize(0), low) + def test_scenario_name(self): """A realized design gives the name of its scenario.""" design = self.space.design({"n": 1}) @@ -788,6 +923,12 @@ def test_keywords(self): space.sample(5, "random") # pylint: disable=too-many-function-args with self.assertRaises(TypeError): space.enumerate()[0].realize(0, 1) # pylint: disable=too-many-function-args + with self.assertRaises(TypeError): + Repeat(Integer(0, 1), 2, False) # pylint: disable=too-many-function-args + frame = pd.DataFrame([{"design": d.key, **d.flat()} for d in space.enumerate()]) + with self.assertRaises(TypeError): + # pylint: disable-next=too-many-function-args + space.designs_of(frame, list(frame.design)) class TestDesignsOfSpaces(unittest.TestCase): @@ -807,6 +948,10 @@ def test_other_spaces(self): self.assertEqual([d.altitude for d in designs], [700, 700]) same = higher.enumerate() self.assertTrue(all(a is b for a, b in zip(_designs(higher, same), same))) + # but not designs with decisions that the design space does not have + spared = space.extend(spares=Integer(0, 1)).design({"n": 1, "spares": 1}) + with self.assertRaisesRegex(ValueError, "another design space.*spares"): + _designs(space, [spared]) def test_frames(self): """Designs rebuilt from frames read the frame's keys once, and a frame @@ -846,28 +991,22 @@ def __getitem__(self, key): self.assertIn("no value of b", str(context.exception.__cause__)) -class TestConfigure(unittest.TestCase): +class TestPathHelpers(unittest.TestCase): """ - Unit tests for dataclasses configured from the values of designs. + Unit tests for the helpers of the paths and values of designs. """ - def test_design(self): - """A dataclass is configured from a design, or a view of its values.""" - # pylint: disable=import-outside-toplevel - import dataclasses + def test_generic_path(self): + """The paths of nodes name any item of a repetition by `[*]`.""" + self.assertEqual(generic_path("planes[12].phase"), "planes[*].phase") + self.assertEqual(generic_path("a[0].b[1]"), "a[*].b[*]") + self.assertEqual(generic_path("layout.walker.planes"), "layout.walker.planes") - from tatc.tradespace.values import configure - - @dataclasses.dataclass(frozen=True) - class Policy: - """A policy of two fields.""" - - spares: int = 0 - years: float = 1.0 + def test_is_number(self): + """Numbers are integers and floats (also numpy's), not booleans.""" + import numpy as np # pylint: disable=import-outside-toplevel - design = DesignSpace(spares=Integer(1, 2), other=Integer(0, 1)).enumerate()[-1] - self.assertEqual(configure(Policy(), design), Policy(spares=2)) - self.assertEqual(configure(Policy(), design.values), Policy(spares=2)) - self.assertEqual(configure(Policy(), design, years=2.0).years, 2.0) - with self.assertRaisesRegex(TypeError, "values of a design"): - configure(Policy(), 3) + for value in (1, 2.5, np.int64(3), np.float32(1.5), math.nan): + self.assertTrue(is_number(value), value) + for value in (True, np.bool_(False), "1", None): + self.assertFalse(is_number(value), value) diff --git a/tests/tradespace/test_stages.py b/tests/tradespace/test_stages.py index 456ccf4c..8b365d6f 100644 --- a/tests/tradespace/test_stages.py +++ b/tests/tradespace/test_stages.py @@ -21,7 +21,7 @@ Stage, walker_space, ) -from tatc.tradespace.histories import exact_expectations +from tatc.tradespace.expectations import exact_expectations from tatc.tradespace.mission import Capability, PhaseCache # three planes of two satellites @@ -65,7 +65,7 @@ def test_planned_delay(self): self.assertEqual({launch.plane for launch in deployment.launches}, {0, 1}) history = deployment.simulate() decided = deployment.begin + 1.0 - self.assertEqual(history.stages, [decided]) + self.assertEqual(history.decided, [decided]) # produced from the decision (after the line's earlier work) and launched produced = [b for b in history.production if b.begin == decided] self.assertEqual( @@ -101,7 +101,7 @@ def test_not_deployed(self): _layout(), stages=[Stage([1, 2], [0.5, 1.0], lambda d: False)] ) history = never.simulate() - self.assertEqual(history.stages, [None]) + self.assertEqual(history.decided, [None]) self.assertEqual(_launches(history, 1) + _launches(history, 2), []) self.assertNotIn((1, 0), history.operating) self.assertEqual(history.metrics()["stages deployed"], 0.0) @@ -110,6 +110,21 @@ def test_not_deployed(self): self.assertNotIn("stages deployed", plain.simulate().metrics()) self.assertEqual(never.deployed, history.deployed) + def test_deployed_after_the_end(self): + """A stage deployed too late to launch within the mission leaves the + deployment unfinished: the time it is deployed is infinite.""" + late = SCHEDULE.plan(_layout(), stages=[Stage(2, 4.75)]) + history = late.simulate() + self.assertEqual(history.decided, [late.begin + 4.75]) + self.assertEqual(_launches(history, 2), []) + self.assertEqual(history.deployed, float("inf")) + self.assertEqual(late.deployed, float("inf")) + # or deployed within it, or not at all + early = SCHEDULE.plan(_layout(), stages=[Stage(2, 4.0)]) + self.assertEqual(early.deployed, early.begin + 4.0 + 2 / 4) + never = SCHEDULE.plan(_layout(), stages=[Stage(2, 4.75, lambda d: False)]) + self.assertLess(never.deployed, never.end) + def test_cost_of_the_option(self): """A type of satellite whose planes are all staged costs its development, whether or not they are deployed: the cost of the option.""" @@ -128,7 +143,7 @@ def test_cost_of_the_option(self): {"a": plane, "b": plane}, stages=[Stage(1, 0.0, lambda decision: False)] ) estimate = model.estimate(never) - self.assertEqual(never.simulate().stages, [None]) + self.assertEqual(never.simulate().decided, [None]) self.assertEqual(estimate.units, {"a": 2}) self.assertEqual(estimate.development, 10 + 50) @@ -151,28 +166,28 @@ def rule(decision): begin = min(launch.time for launch in history.launches) # times are from the start of development, as every time of a mission self.assertEqual([d.time for d in seen], [begin + 0.5, begin + 1.0]) - self.assertEqual(history.stages, [begin + 0.25, begin + 1.0]) + self.assertEqual(history.decided, [begin + 0.25, begin + 1.0]) def test_contingency(self): """A rule on failures deploys a stage in the histories that need it.""" failures = FailureModel(life=Exponential(0.1)) policy = RestorationPolicy(restore=False) stage = Stage(2, [0.5, 1.0, 1.5, 2.0], lambda d: d.satellites_operating < 4) - deployment = SCHEDULE.plan(_layout(), stages=[stage]) - self.assertEqual(deployment.simulate().stages, [None]) - histories = deployment.simulate_many(failures, policy, seed=1, histories=20) - deployed = [h.stages[0] is not None for h in histories] + deployment = SCHEDULE.plan(_layout(), policy=policy, stages=[stage]) + self.assertEqual(deployment.simulate().decided, [None]) + histories = deployment.simulate_many(failures, seed=1, histories=20) + deployed = [h.decided[0] is not None for h in histories] self.assertTrue(any(deployed) and not all(deployed)) for history in histories: failed = [t for t, *_ in history.failures] - if history.stages[0] is not None: - self.assertLess(min(failed), history.stages[0]) + if history.decided[0] is not None: + self.assertLess(min(failed), history.decided[0]) # the satellites of a stage count in the availability of the # histories that deploy it (and only of those) self.assertLessEqual(history.metrics()["availability"], 1.0) # the same history draws the same failures again - again = deployment.simulate_many(failures, policy, seed=1, histories=20) - self.assertEqual([h.stages for h in again], [h.stages for h in histories]) + again = deployment.simulate_many(failures, seed=1, histories=20) + self.assertEqual([h.decided for h in again], [h.decided for h in histories]) def test_capability(self): """Rules read the capability of the satellites operating at a decision.""" @@ -193,13 +208,13 @@ def rule(decision): history = deployment.simulate() # the first plane alone at the first launch (the second is launched later) self.assertEqual(seen, [(0.0, 2, {"observing": 2.0})]) - self.assertEqual(history.stages, [deployment.begin]) + self.assertEqual(history.decided, [deployment.begin]) # the planned history reads it too self.assertEqual(history.metrics()["stages deployed"], 1.0) - self.assertEqual(deployment.planned().stages, [deployment.begin]) + self.assertEqual(deployment.planned().decided, [deployment.begin]) later = SCHEDULE.plan(_layout(), stages=[Stage(2, 0.5, rule)]) later.capability = deployment.capability - self.assertEqual(later.simulate().stages, [None]) + self.assertEqual(later.simulate().decided, [None]) # without a capability, a rule cannot read it unmeasured = SCHEDULE.plan(_layout(), stages=[Stage(2, 0.0, rule)]) with self.assertRaisesRegex(ValueError, "capability"): @@ -211,12 +226,14 @@ def test_capability_of_failures(self): policy = RestorationPolicy(restore=False) by_count = SCHEDULE.plan( _layout(), + policy=policy, stages=[ Stage(2, [0.5, 1.0, 1.5, 2.0], lambda d: d.satellites_operating < 4) ], ) measured = SCHEDULE.plan( _layout(), + policy=policy, stages=[ Stage( 2, @@ -229,10 +246,10 @@ def test_capability_of_failures(self): measured.capability = Capability( NAMES, OBSERVATIONS, cache, context="replicate" ) - expected = by_count.simulate_many(failures, policy, seed=1, histories=20) - histories = measured.simulate_many(failures, policy, seed=1, histories=20) - self.assertEqual([h.stages for h in histories], [h.stages for h in expected]) - self.assertTrue(any(h.stages[0] is not None for h in histories)) + expected = by_count.simulate_many(failures, seed=1, histories=20) + histories = measured.simulate_many(failures, seed=1, histories=20) + self.assertEqual([h.decided for h in histories], [h.decided for h in expected]) + self.assertTrue(any(h.decided[0] is not None for h in histories)) # each set of satellites read at a decision is evaluated once self.assertGreater(cache.hits, 0) @@ -279,11 +296,13 @@ def test_lead_and_launches(self): years=5, development_years=1, production_rate=4, launch_capacity=1 ) deployment = schedule.plan( - _layout(), orbit_spares=1, stages=[Stage(2, 1.0, lead_years=0.5)] + _layout(), + policy=RestorationPolicy(orbit_spares=1), + stages=[Stage(2, 1.0, lead_years=0.5)], ) history = deployment.simulate() # the line is free by the end of the lead time - decided = history.stages[0] + decided = history.decided[0] launched = [l for l in history.launches if l.plane == 2] self.assertEqual([l.satellites for l in launched], [1, 1, 1]) self.assertEqual(launched[0].time, decided + 0.5 + 3 / 4) @@ -294,8 +313,12 @@ def test_lead_and_launches(self): def test_exact_expectations(self): """Exact expectations need a deployment that is not staged.""" - deployment = SCHEDULE.plan(_layout(), stages=[Stage(2, 1.0)]) - with self.assertRaises(ValueError): + deployment = SCHEDULE.plan( + _layout(), + policy=RestorationPolicy(restore=False), + stages=[Stage(2, 1.0)], + ) + with self.assertRaisesRegex(ValueError, "staged"): exact_expectations( deployment, FailureModel(life=Exponential(0.2)), @@ -327,7 +350,7 @@ def test_numpy_values(self): self.assertEqual((stage.planes, stage.times), ((2, 1), (0.0, 1.0))) self.assertEqual(Stage([1], range(3)).times, (0.0, 1.0, 2.0)) deployment = SCHEDULE.plan(_layout(), stages=[Stage(np.int64(2), 1.0)]) - self.assertEqual(deployment.simulate().stages, [deployment.begin + 1.0]) + self.assertEqual(deployment.simulate().decided, [deployment.begin + 1.0]) if __name__ == "__main__": diff --git a/tests/tradespace/test_statistics.py b/tests/tradespace/test_statistics.py new file mode 100644 index 00000000..75472ed3 --- /dev/null +++ b/tests/tradespace/test_statistics.py @@ -0,0 +1,103 @@ +""" +Unit tests for statistics of the metrics of designs over their replicates. + +@author Paul T. Grogan +""" + +import unittest +import warnings + +import numpy as np + +from tatc.tradespace import ( + Maximum, + Mean, + Minimum, + Probability, + Quantile, + StandardDeviation, + StandardError, + Statistic, +) + +VALUES = np.array( + [[1.0, 2.0, 3.0, np.nan], [4.0, np.nan, np.nan, np.nan], [np.nan] * 4] +) + + +class TestStatistics(unittest.TestCase): + """ + Unit tests for statistics. + """ + + def test_reductions(self): + """Statistics ignore missing replicates.""" + np.testing.assert_allclose(Mean("x").reduce(VALUES), [2, 4, np.nan]) + np.testing.assert_allclose(Minimum("x").reduce(VALUES), [1, 4, np.nan]) + np.testing.assert_allclose(Maximum("x").reduce(VALUES), [3, 4, np.nan]) + np.testing.assert_allclose(Quantile("x", 0.25).reduce(VALUES), [1.5, 4, np.nan]) + np.testing.assert_allclose( + StandardDeviation("x").reduce(VALUES), [1, np.nan, np.nan] + ) + np.testing.assert_allclose( + StandardError("x").reduce(VALUES), [1 / np.sqrt(3), np.nan, np.nan] + ) + np.testing.assert_allclose( + Probability("x", ">=", 2).reduce(VALUES), [2 / 3, 1, np.nan] + ) + np.testing.assert_allclose( + Probability("x", "<", 2).reduce(VALUES), [1 / 3, 0, np.nan] + ) + + def test_quantiles_with_missing_values(self): + """Quantiles are numpy's, of the values of each design.""" + rng = np.random.default_rng(5) + values = rng.normal(size=(200, 12)) + values[rng.random(values.shape) < 0.4] = np.nan + values[0] = np.nan + values[1, 1:] = np.nan + for q in (0, 0.1, 0.5, 0.7, 1): + with warnings.catch_warnings(): + warnings.simplefilter("ignore", RuntimeWarning) + expected = np.nanquantile(values, q, axis=1) + np.testing.assert_allclose(Quantile("x", q).reduce(values), expected) + + def test_invalid(self): + """Quantiles and operators are checked.""" + with self.assertRaises(ValueError): + Quantile("x", 1.5) + with self.assertRaises(ValueError): + Probability("x", "==", 1) + + def test_equality(self): + """Statistics of the same kind and parameters are equal.""" + self.assertEqual(Quantile("x", 0.2), Quantile("x", 0.2)) + self.assertNotEqual(Quantile("x", 0.2), Quantile("x", 0.3)) + self.assertNotEqual(Mean("x"), Maximum("x")) + self.assertEqual(len({Mean("x"), Mean("x"), Mean("y")}), 2) + self.assertIsInstance(Mean("x"), Statistic) + + +class TestNames(unittest.TestCase): + """ + Unit tests for the conventional names of statistics. + """ + + def test_names(self): + """Statistics are named by convention.""" + self.assertEqual(Mean("cost").name, "cost") + self.assertEqual(StandardDeviation("cost").name, "cost std") + self.assertEqual(StandardError("cost").name, "cost se") + self.assertEqual(Minimum("cost").name, "cost min") + self.assertEqual(Maximum("cost").name, "cost max") + self.assertEqual(Quantile("cost", 0.7).name, "cost p70") + self.assertEqual(Probability("cost", "<=", 150).name, "P(cost <= 150)") + + def test_columns(self): + """A statistic needs the column of its metric.""" + self.assertEqual(Quantile("cost", 0.7).columns, ("cost",)) + self.assertEqual(Quantile("cost", 0.7).metric, "cost") + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/tradespace/test_store.py b/tests/tradespace/test_store.py index 4e42cce8..4eefec7e 100644 --- a/tests/tradespace/test_store.py +++ b/tests/tradespace/test_store.py @@ -72,7 +72,7 @@ def evaluate(d): def test_store_and_get(self): """Records are stored and retrieved by design and replicate.""" - store = ResultStore(self.path, "x") + store = ResultStore(self.path, namespace="x") store.put([("d1", 0, [{"value": 1}]), ("d1", 1, [{"value": 2}])]) self.assertEqual(len(store), 2) self.assertEqual(store.get([("d1", 1), ("d2", 0)]), {("d1", 1): [{"value": 2}]}) @@ -81,16 +81,20 @@ def test_store_and_get(self): self.assertEqual(store.get([("d1", 1)], "c"), {("d1", 1): [{"value": 3}]}) self.assertEqual(store.get([("d1", 1)])[("d1", 1)], [{"value": 2}]) self.assertEqual(store.contexts(), {"": 2, "c": 1}) - other = ResultStore(self.path, "y") + other = ResultStore(self.path, namespace="y") self.assertEqual(len(other), 0) store.clear() self.assertEqual(len(store), 0) # a store without a namespace has its own records self.assertEqual(len(ResultStore(self.path)), 0) + # the namespace is a keyword + with self.assertRaises(TypeError): + ResultStore(self.path, "x") # pylint: disable=too-many-function-args + self.assertIn("namespace='y'", repr(other)) def test_resume(self): """An interrupted study resumes, evaluating only what is not stored.""" - store = ResultStore(self.path, "study") + store = ResultStore(self.path, namespace="study") self.state.fail_at = 5 with self.assertRaises(_Interrupt): self._study(store).run() @@ -108,7 +112,7 @@ def test_resume(self): def test_more_replicates(self): """Extending a study evaluates only the new replicates.""" - store = ResultStore(self.path, "study") + store = ResultStore(self.path, namespace="study") self._study(store).run() self.calls.clear() results = self._study(store).run(replicate_indices=range(5)) @@ -118,7 +122,7 @@ def test_more_replicates(self): @unittest.skipUnless(HAS_JOBLIB, "requires joblib") def test_parallel(self): """Parallel studies store their evaluations as chunks complete.""" - store = ResultStore(self.path, "study") + store = ResultStore(self.path, namespace="study") study = Study( self.space, lambda d: d, @@ -135,7 +139,7 @@ def test_parallel(self): def test_other_definitions(self): """Records of studies of other definitions are not reused, and studies of other values share a store's namespace without a warning.""" - store = ResultStore(self.path, "study") + store = ResultStore(self.path, namespace="study") self._study(store).run() self.calls.clear() self._study(store).run() @@ -163,7 +167,7 @@ def study(offset): self.space, lambda d: d, lambda d, offset=offset: self.calls.append(1) or {"value": offset}, - store=ResultStore(self.path, "closure"), + store=ResultStore(self.path, namespace="closure"), ) study(0.0).run() @@ -174,7 +178,7 @@ def study(offset): def test_other_code(self): """A study warns of records of the same study with other code.""" - store = ResultStore(self.path, "code") + store = ResultStore(self.path, namespace="code") def study(evaluate): return Study(self.space, lambda d: d, evaluate, replicates=2, store=store) @@ -203,7 +207,7 @@ def study(evaluate): def test_warning_location(self): """The warning of evaluations with other code points at the run.""" - store = ResultStore(self.path, "where") + store = ResultStore(self.path, namespace="where") def study(evaluate): return Study(self.space, lambda d: d, evaluate, store=store) @@ -218,7 +222,7 @@ def study(evaluate): def test_prune_definitions(self): """Definitions kept without evaluations (of a study whose evaluations all failed) are of the study's contexts, which pruning removes.""" - store = ResultStore(self.path, "failed") + store = ResultStore(self.path, namespace="failed") def study(evaluate, **kwargs): return Study(self.space, lambda d: d, evaluate, store=store, **kwargs) @@ -259,7 +263,7 @@ def test_records_as_json(self): "tagged": {"$float": "x"}, "array": np.arange(3), } - store = ResultStore(self.path, "x") + store = ResultStore(self.path, namespace="x") store.put([("d1", 0, [record])]) read = store.get([("d1", 0)])[("d1", 0)][0] self.assertEqual(set(read), set(record)) @@ -281,7 +285,7 @@ def test_records_as_json(self): def test_definitions(self): """A store keeps the definitions of studies, which explain changes.""" - store = ResultStore(self.path, "study") + store = ResultStore(self.path, namespace="study") study = self._study(store) study.run() self.assertEqual(store.definition(study.fingerprint), study.definition) @@ -305,7 +309,7 @@ def test_definitions(self): def test_parallel_interruption(self): """Workers store each evaluation as it completes, before an error.""" - store = ResultStore(self.path, "interrupted") + store = ResultStore(self.path, namespace="interrupted") # an executor that waits for the chunks in progress as it shuts down with ThreadPoolExecutor(2) as executor: study = Study( @@ -327,7 +331,7 @@ def test_parallel_interruption(self): def test_variants(self): """Variants of replicates are kept apart from plain replicates.""" - store = ResultStore(self.path, "x") + store = ResultStore(self.path, namespace="x") store.put([("d1", 0, [{"value": 1}])]) store.put([("d1", 0, [{"value": 2}])], variant='{"u": 5}') self.assertEqual(store.get([("d1", 0)]), {("d1", 0): [{"value": 1}]}) @@ -339,7 +343,7 @@ def test_variants(self): def test_shifted_runs(self): """Shifted replicates are stored and reused apart from plain ones.""" - store = ResultStore(self.path, "study") + store = ResultStore(self.path, namespace="study") plain = self._study(store).run() shifted = self._study(store).run(shift={"noise": 3}) self.assertEqual(len(self.calls), 2 * 4 * 3) @@ -372,11 +376,11 @@ def test_table_without_variants(self): connection.execute( "INSERT INTO results VALUES ('x', '', 'd1', 0, '[{\"value\": 1}]')" ) - store = ResultStore(self.path, "x") + store = ResultStore(self.path, namespace="x") self.assertEqual(store.get([("d1", 0)]), {("d1", 0): [{"value": 1}]}) store.put([("d1", 0, [{"value": 2}])], variant="v") self.assertEqual(len(store), 2) - self.assertEqual(len(ResultStore(self.path, "x")), 2) + self.assertEqual(len(ResultStore(self.path, namespace="x")), 2) def test_earlier_format(self): """Files with evaluations of an earlier format are read as empty.""" @@ -389,7 +393,7 @@ def test_earlier_format(self): connection.execute( "INSERT INTO evaluations VALUES ('x', '', 'd1', 0, x'00')" ) - store = ResultStore(self.path, "x") + store = ResultStore(self.path, namespace="x") self.assertEqual(len(store), 0) store.put([("d1", 0, [{"value": 1}])]) self.assertEqual(store.get([("d1", 0)]), {("d1", 0): [{"value": 1}]}) diff --git a/tests/tradespace/test_study.py b/tests/tradespace/test_study.py index a01989d1..b86d2f2d 100644 --- a/tests/tradespace/test_study.py +++ b/tests/tradespace/test_study.py @@ -5,6 +5,7 @@ """ import importlib.util +import math import tempfile import unittest from types import SimpleNamespace @@ -23,6 +24,7 @@ WalkerConstellation, ) from tatc.tradespace import ( + Derived, DesignSpace, Fixed, Infeasible, @@ -269,7 +271,7 @@ def test_raise(self): def test_record(self): """Errors are recorded as infeasible evaluations, which are not stored.""" with tempfile.TemporaryDirectory() as directory: - store = ResultStore(Path(directory) / "results.sqlite", "errors") + store = ResultStore(Path(directory) / "results.sqlite", namespace="errors") study = Study( self.space, lambda d: d, self._evaluate, errors="record", store=store ) @@ -285,6 +287,34 @@ def test_record(self): self.assertTrue(again.feasible.all()) self.assertEqual(len(store), 4) + def test_realization(self): + """Errors of the realization of a design (such as of a value derived + from a drawn uncertain parameter) are recorded too, with the values of + the design.""" + space = DesignSpace( + n=Integer(1, 2), + u=Uncertain.uniform(-1, 1), + root=Derived(lambda d: math.sqrt(d.u)), + ) + with tempfile.TemporaryDirectory() as directory: + store = ResultStore(Path(directory) / "results.sqlite", namespace="draws") + study = Study( + space, + lambda d: d.n, + lambda n: {"m": n}, + replicates=8, + errors="record", + store=store, + ) + results = study.run() + failed = results[~results.feasible] + self.assertTrue(len(failed) > 0) + self.assertTrue(failed.error.str.startswith("ValueError: ").all()) + self.assertEqual(sorted(failed.n.unique()), [1, 2]) + self.assertEqual(len(store), int(results.feasible.sum())) + with self.assertRaises(ValueError): + study.replace(errors="raise", store=None).run() + class TestFeasibility(unittest.TestCase): """ @@ -298,7 +328,7 @@ def setUp(self): @staticmethod def _store(directory: str) -> ResultStore: - return ResultStore(Path(directory) / "results.sqlite", "feasibility") + return ResultStore(Path(directory) / "results.sqlite", namespace="feasibility") def test_rejected(self): """Designs that either function rejects with Infeasible are stored as infeasible.""" @@ -404,7 +434,15 @@ class TestMetricNames(unittest.TestCase): def test_reserved_names(self): """Metrics named as status columns, or replacing values of designs, raise errors.""" space = DesignSpace(a=Integer(1, 2), noise=Uncertain.uniform(0, 1)) - for metrics in ({"replicate": 0}, {"error": 0.1}, {"a": 9}, {"noise": 0.5}): + # also `scenario` (and the marker of unstored records) without scenarios + for metrics in ( + {"replicate": 0}, + {"error": 0.1}, + {"a": 9}, + {"noise": 0.5}, + {"scenario": "mine"}, + {"_unstored": False}, + ): for errors in ("raise", "record"): with self.subTest(metrics=metrics, errors=errors): study = Study( @@ -464,6 +502,18 @@ def test_evaluated_in_study_space(self): ) self.assertTrue(results.growth.between(1, 2).all()) + def test_other_decisions(self): + """Designs with decisions that the study's design space does not have + (such as of a design space that extends it) raise, rather than being + evaluated without them.""" + base = DesignSpace(a=Integer(1, 2)) + spared = base.extend(spares=Integer(0, 1)).design({"a": 1, "spares": 1}) + study = Study(base, lambda d: d.a, lambda a: {"m": a}) + with self.assertRaisesRegex(ValueError, "another design space.*spares"): + study.run([spared]) + with self.assertRaisesRegex(ValueError, "another design space.*spares"): + study.realize(spared) + class TestStudyScenarios(unittest.TestCase): """ @@ -526,10 +576,33 @@ def test_seed(self): Study(space, lambda d: d.u, lambda x: {"s": x}, seed=-1) def test_keywords(self): - """The settings of a study are keywords.""" + """The settings of a study, and the options of a run, are keywords.""" space = DesignSpace(n=Integer(1, 2)) with self.assertRaises(TypeError): Study(space, lambda d: d, dict, 3) # pylint: disable=too-many-function-args + study = Study(space, lambda d: d.n, lambda n: {"m": n}) + with self.assertRaises(TypeError): + study.run(None, print) # pylint: disable=too-many-function-args + + def test_indices(self): + """Replicate indices and the offsets of shifts are checked before any + evaluation.""" + calls = [] + space = DesignSpace(n=Integer(1, 2), u=Uncertain.uniform(0, 1)) + study = Study(space, lambda d: d.n, lambda n: calls.append(n) or {"m": n}) + for options in ( + {"replicate_indices": [0, -1]}, + {"replicate_indices": [0.5]}, + {"shift": {"u": -1}}, + {"shift": {"u": 1.5}}, + ): + with self.subTest(options=options): + with self.assertRaisesRegex(ValueError, "non-negative integer"): + study.run(**options) + self.assertEqual(calls, []) + shifted = study.run(replicate_indices=[2], shift={"u": 1}) + plain = study.run(replicate_indices=[3]) + self.assertEqual(list(shifted.u), list(plain.u)) class TestEmptyResults(unittest.TestCase): diff --git a/tests/tradespace/test_summary.py b/tests/tradespace/test_summary.py new file mode 100644 index 00000000..4c70d48c --- /dev/null +++ b/tests/tradespace/test_summary.py @@ -0,0 +1,725 @@ +""" +Unit tests for summaries of the results of studies: the statistics of each +design over its replicates (`aggregate` and `summarize`), its judgment by +criteria, and the probability that it is efficient (`pareto_probability`). + +@author Paul T. Grogan +""" + +import unittest +import warnings + +import numpy as np +import pandas as pd + +from tatc.tradespace import ( + Across, + Criteria, + Probability, + Quantile, + Requirement, + aggregate, + pareto_probability, + summarize, +) + + +def _results(): + """Results of three designs in four replicates.""" + values = {"a": [10, 12, 14, 16], "b": [5, 30, 5, 30], "c": [1, 1, 1, 1]} + return pd.DataFrame( + [ + { + "design": key, + "replicate": r, + "feasible": True, + "cost": {"a": 2, "b": 2, "c": 1}[key], + "value": v, + "size": {"a": "small", "b": "small", "c": "large"}[key], + } + for key, row in values.items() + for r, v in enumerate(row) + ] + ) + + +def _partly_infeasible(scenario=None, shares=None): + """Results of three designs in four replicates: a is feasible in every + replicate, b in two, and c in none (whose records lack metrics).""" + values = {"a": [1, 2, 3, 4], "b": [10, None, 30, None], "c": [None] * 4} + values.update(shares or {}) + return pd.DataFrame( + [ + { + "design": key, + "replicate": r, + **({} if scenario is None else {"scenario": scenario}), + "feasible": v is not None, + "cost": ( + {"a": 2.0, "b": 1.0, "c": 1.0}[key] if v is not None else np.nan + ), + "value": np.nan if v is None else float(v), + } + for key, row in values.items() + for r, v in enumerate(row) + ] + ) + + +def _replicates(values, cost=1.0): + """Results of designs (rows) in replicates (columns), with a cost.""" + return pd.DataFrame( + [ + { + "design": f"d{i}", + "replicate": r, + "cost": cost, + "value": v, + "feasible": True, + } + for i, row in enumerate(values) + for r, v in enumerate(row) + ] + ) + + +def _scenarios(values): + """Results of a design in scenarios (by name), from its values in each + replicate (in order).""" + return pd.DataFrame( + [ + { + "design": "d", + "replicate": r, + "scenario": scenario, + "feasible": True, + "v": float(v), + } + for scenario, row in values.items() + for r, v in enumerate(row) + ] + ) + + +class TestAggregate(unittest.TestCase): + """ + Unit tests for aggregating results. + """ + + def test_statistics(self): + """Statistics and design values are aggregated, without violations.""" + frame = aggregate( + _results(), + statistics={ + "value": "value", + "value p25": Quantile("value", 0.25), + "cost": "cost", + }, + ).set_index("design") + self.assertEqual(frame.loc["a", "value"], 13) + self.assertAlmostEqual(frame.loc["b", "value p25"], 5) + self.assertEqual(frame.loc["c", "size"], "large") + self.assertTrue((frame.replicates == 4).all()) + self.assertNotIn("violation", frame.columns) + self.assertEqual(list(aggregate(_results(), ["value"]).value), [13, 17.5, 1]) + # a mapping of statistics by name is not one of objectives + with self.assertRaisesRegex(ValueError, "statistics"): + aggregate(_results(), {"value": "value"}) + with self.assertRaises(ValueError): + aggregate(_results()) + + def test_objectives(self): + """A mapping of objectives are criteria of their means, with others.""" + frame = aggregate( + _results(), + {"value": "max"}, + statistics={"value p25": Quantile("value", 0.25)}, + ).set_index("design") + self.assertEqual(frame.loc["a", "value"], 13) + self.assertAlmostEqual(frame.loc["b", "value p25"], 5) + self.assertTrue(frame.meets_requirements.all()) + # statistics that the criteria name otherwise + with self.assertRaisesRegex(ValueError, "otherwise"): + aggregate( + _results(), {"value": "max"}, statistics={"value": Quantile("value", 1)} + ) + # a statistic the criteria name the same way is not a clash + same = aggregate(_results(), {"value": "max"}, statistics={"value": "value"}) + self.assertEqual(list(same.value), [13, 17.5, 1]) + # objectives grouped by a column + self.assertEqual(len(aggregate(_results(), {"value": "max"}, by="size")), 3) + + def test_criteria(self): + """Criteria add the violations of their requirements, relative to them.""" + criteria = Criteria( + {"cost": "min", "value": "max"}, + statistics={"value p25": Quantile("value", 0.25)}, + requirements=[ + Requirement("value p25", ">=", 5), + Requirement("cost", "<=", 1.5), + ], + ) + frame = aggregate(_results(), criteria).set_index("design") + self.assertEqual( + list(frame.columns[-8:]), + [ + "cost", + "value", + "value p25", + "replicates", + "feasible", + "violation", + "meets_requirements", + "pareto", + ], + ) + self.assertAlmostEqual(frame.loc["a", "violation"], 0.5 / 1.5) + self.assertAlmostEqual(frame.loc["c", "violation"], 4 / 5) + self.assertEqual(list(frame.meets_requirements), [False, False, False]) + # none meets the requirements, so that none is efficient + self.assertEqual(list(frame.pareto), [False, False, False]) + with self.assertRaises(ValueError): + aggregate(_results(), criteria, by=["size"]) + + def test_requirement_on_metric(self): + """A requirement on a metric is on its mean.""" + criteria = Criteria( + {"value": "max"}, requirements=[Requirement("cost", "<=", 1)] + ) + frame = aggregate(_results(), criteria) + self.assertIn("cost", frame.columns) + self.assertEqual(list(frame.meets_requirements), [False, False, True]) + # a requirement on a metric that the results do not have + missing = Criteria({"value": "max"}, requirements=[Requirement("w", ">=", 1)]) + with self.assertRaises(ValueError): + aggregate(_results(), missing) + + def test_statistics_of_names(self): + """Statistics given by names are the means of the metrics, and other + statistics are named by convention.""" + summary = aggregate(_results(), {"value": "max"}, statistics=["cost"]) + self.assertEqual(list(summary.cost), [2.0, 2.0, 1.0]) + self.assertEqual( + list(aggregate(_results(), statistics=[Quantile("value", 0.25)]).columns)[ + -3: + ], + ["value p25", "replicates", "feasible"], + ) + + def test_names_of_columns(self): + """A statistic of the name of a column of the results is its mean.""" + results = _results().assign(**{"P(value >= 10)": 0.5}) + statistic = Probability("value", ">=", 10) + criteria = Criteria({"P(value >= 10)": "max"}, statistics=[statistic]) + for function in (aggregate, summarize, pareto_probability): + with self.subTest(function=function.__name__): + with self.assertRaisesRegex(ValueError, "P\\(value >= 10\\)"): + function(results, criteria) + # the mean of the column, of its name + summary = aggregate(results, {"P(value >= 10)": "max"}) + np.testing.assert_allclose(summary["P(value >= 10)"], 0.5) + renamed = Criteria({"reliable": "max"}, statistics={"reliable": statistic}) + np.testing.assert_allclose( + aggregate(results, renamed).reliable, [1.0, 0.5, 0.0] + ) + # nor do the columns that summaries add + with self.assertRaisesRegex(ValueError, "value se"): + summarize(_results().assign(**{"value se": 1.0}), ["value"]) + with self.assertRaisesRegex(ValueError, "value se"): + pareto_probability(_results().assign(**{"value se": 1.0}), {"value": "max"}) + + def test_records_of_groups(self): + """Several records of an evaluation need the columns that separate them.""" + results = pd.concat([_results().assign(sensor=s) for s in ("x", "y")]) + with self.assertRaisesRegex(ValueError, r"by.*\['sensor'\]"): + aggregate(results, ["value"]) + with self.assertRaisesRegex(ValueError, "sensor"): + pareto_probability(results, {"value": "max"}) + frame = aggregate(results, Criteria({"value": "max"}, by="sensor")) + self.assertEqual(len(frame), 6) + self.assertEqual(len(summarize(results, ["value"], by="sensor")), 6) + + +class TestSummarize(unittest.TestCase): + """ + Unit tests for summaries with the spread of the means of metrics. + """ + + def test_summarize_criteria(self): + """Summaries of criteria add the spread of their means of metrics.""" + criteria = Criteria( + {"cost": "min", "value": "max"}, + statistics={"value p25": Quantile("value", 0.25)}, + ) + summary = summarize(_results(), criteria) + for column in ("value std", "value se", "pareto"): + self.assertIn(column, summary.columns) + self.assertNotIn("value p25 se", summary.columns) + grouped = summarize(_results(), {"value": "max"}, by="size") + self.assertEqual(len(grouped), 3) + with self.assertRaises(ValueError): + summarize(_results(), Criteria({"value": "max"}), by="size") + + def test_summarize_statistics(self): + """Summaries take other statistics, with the spread of their means.""" + results = _results().assign(cost=lambda f: f.cost + 0.1 * f.replicate) + summary = summarize(results, {"value": "max"}, statistics=["cost"]) + for column in ("value", "value se", "cost", "cost std", "cost se", "pareto"): + self.assertIn(column, summary.columns) + # each mean followed by its spread, without criteria + self.assertEqual( + list(summarize(results, ["value", "cost"]).columns[-8:]), + [ + "value", + "value std", + "value se", + "cost", + "cost std", + "cost se", + "replicates", + "feasible", + ], + ) + + def test_constant_spreads(self): + """The spreads of metrics that are the same in every replicate of each + design are left out.""" + summary = summarize(_results(), ["value", "cost"]) + self.assertNotIn("cost std", summary.columns) + self.assertNotIn("cost se", summary.columns) + spread = summary.set_index("design")[["value std", "value se"]] + np.testing.assert_allclose(spread.loc["c"].to_numpy(dtype=float), 0.0) + # of designs of one replicate, as of summaries without designs + single = summarize(_results()[_results().replicate == 0], ["value"]) + self.assertNotIn("value se", single.columns) + empty = summarize(_results().iloc[:0], ["value"]) + self.assertIn("value se", empty.columns) + # as are the standard errors of the bootstrap + probability = pareto_probability(_results(), {"cost": "min", "value": "max"}) + self.assertNotIn("cost se", probability.columns) + self.assertIn("value se", probability.columns) + + def test_spread_of_worst(self): + """Across groups, the spread of the worst is that of its group, as + is the standard error of the bootstrap.""" + results = _scenarios({"a": [10] * 8, "b": [5, 9] * 4}) + worst = Criteria({"v": "max"}, across=Across()) + summary = summarize(results, worst).iloc[0] + b = results[results.scenario == "b"].v + self.assertEqual(summary.v, 7.0) + self.assertAlmostEqual(summary["v std"], b.std()) + self.assertAlmostEqual(summary["v se"], b.std() / np.sqrt(8)) + bootstrap = pareto_probability(results, worst, n_resamples=2000) + # the bootstrap's standard deviation, of n rather than n - 1 replicates + self.assertAlmostEqual( + bootstrap["v se"].iloc[0], b.std(ddof=0) / np.sqrt(8), delta=0.05 + ) + + def test_spread_of_mean(self): + """Across groups, the spread of a weighted mean is that of the + weighted sum of each replicate's values, of groups that share + replicates, and that of independent groups otherwise.""" + rng = np.random.default_rng(2) + x = rng.normal(0, 1, 30) + weights = {"s1": 3, "s2": 1} + mean = Criteria({"v": "max"}, across=Across(rule="mean", weights=weights)) + # the same replicates, of correlated values + paired = _scenarios({"s1": x, "s2": 2 * x + rng.normal(0, 0.1, 30)}) + summary = summarize(paired, mean).iloc[0] + wide = paired.pivot(index="replicate", columns="scenario", values="v") + combined = 0.75 * wide.s1 + 0.25 * wide.s2 + self.assertAlmostEqual(summary.v, combined.mean()) + self.assertAlmostEqual(summary["v std"], combined.std()) + self.assertAlmostEqual(summary["v se"], combined.std() / np.sqrt(30)) + bootstrap = pareto_probability(paired, mean, n_resamples=2000) + self.assertAlmostEqual( + bootstrap["v se"].iloc[0] / summary["v se"], 1.0, delta=0.1 + ) + # replicates that no other group shares: independent groups + independent = paired.assign( + replicate=paired.replicate + 100 * (paired.scenario == "s2") + ) + summary = summarize(independent, mean).iloc[0] + errors = wide.std() / np.sqrt(30) + self.assertAlmostEqual( + summary["v se"], + np.sqrt(0.75**2 * errors.s1**2 + 0.25**2 * errors.s2**2), + ) + self.assertAlmostEqual( + summary["v std"], + np.sqrt(0.75**2 * wide.s1.var() + 0.25**2 * wide.s2.var()), + ) + # what the groups share cancels + cancel = Criteria({"v": "max"}, across=Across(rule="mean")) + steady = _scenarios({"s1": range(6), "s2": [10 - r for r in range(6)]}) + summary = summarize(steady, cancel) + self.assertEqual(summary.v.iloc[0], 5.0) + self.assertNotIn("v se", summary.columns) + self.assertNotIn("v se", pareto_probability(steady, cancel, n_resamples=50)) + + +class TestFeasibility(unittest.TestCase): + """ + Unit tests for the judgment of designs by their feasible replicates. + """ + + def test_feasible_share(self): + """Designs are judged by their feasible replicates, of which + `replicates` is the number and `feasible` the share; designs without a + feasible replicate are left out.""" + summary = aggregate(_partly_infeasible(), {"cost": "min", "value": "max"}) + summary = summary.set_index("design") + self.assertEqual(list(summary.index), ["a", "b"]) + self.assertEqual(summary.loc["b", "value"], 20) + self.assertEqual(list(summary.replicates), [4, 2]) + self.assertEqual(list(summary.feasible), [1.0, 0.5]) + # b, cheaper and better in its feasible replicates, dominates a + self.assertEqual(list(summary.pareto), [False, True]) + self.assertEqual( + list(summary.columns[-5:]), + ["replicates", "feasible", "violation", "meets_requirements", "pareto"], + ) + + def test_requirement(self): + """Requirements on `feasible` judge the share of feasible replicates + over every replicate of a design.""" + every = Criteria( + {"cost": "min", "value": "max"}, + requirements=[Requirement("feasible", ">=", 1)], + ) + summary = aggregate(_partly_infeasible(), every).set_index("design") + self.assertEqual(list(summary.feasible), [1.0, 0.5]) + self.assertEqual(list(summary.meets_requirements), [True, False]) + self.assertAlmostEqual(summary.loc["b", "violation"], 0.5) + self.assertEqual(list(summary.pareto), [True, False]) + half = Criteria( + {"cost": "min", "value": "max"}, + requirements=[Requirement("feasible", ">=", 0.5)], + ) + summary = aggregate(_partly_infeasible(), half) + self.assertTrue(summary.meets_requirements.all()) + # its spread is not summarized + summary = summarize(_partly_infeasible(), every) + self.assertNotIn("feasible se", summary.columns) + self.assertEqual(list(summary.feasible), [1.0, 0.5]) + + def test_groups(self): + """Infeasible records without a value of a group (such as a sensor) + count in every group of the design.""" + results = _partly_infeasible() + feasible = results[results.feasible] + records = pd.concat( + [ + feasible.assign(sensor="x"), + feasible.assign(sensor="y", value=feasible.value + 1), + results[~results.feasible], + ], + ignore_index=True, + ) + summary = aggregate(records, ["value"], by="sensor") + summary = summary.set_index(["sensor", "design"]) + self.assertEqual(summary.loc[("y", "b"), "value"], 21) + self.assertEqual(summary.loc[("x", "b"), "feasible"], 0.5) + self.assertEqual(summary.loc[("y", "b"), "feasible"], 0.5) + self.assertEqual(summary.loc[("y", "a"), "feasible"], 1.0) + + def test_across(self): + """Across groups, `feasible` is over the replicates of every group + together, and designs need feasible replicates in every group.""" + results = pd.concat( + [ + _partly_infeasible("s1", {"b": [10, 20, 30, 40]}), + _partly_infeasible("s2"), + ], + ignore_index=True, + ) + for rule in ("worst", "mean"): + with self.subTest(rule=rule): + criteria = Criteria( + {"cost": "min", "value": "max"}, + requirements=[Requirement("feasible", ">=", 0.7)], + across=Across(rule=rule), + ) + summary = aggregate(results, criteria).set_index("design") + self.assertEqual(list(summary.index), ["a", "b"]) + self.assertEqual(summary.loc["b", "feasible"], 0.75) + self.assertEqual(summary.loc["b", "replicates"], 2) + self.assertTrue(summary.meets_requirements.all()) + + def test_no_feasible_design(self): + """Results without a feasible record have empty summaries.""" + results = _partly_infeasible() + infeasible = results[results.design == "c"].drop(columns=["cost", "value"]) + criteria = Criteria({"cost": "min", "value": "max"}, by="size") + for summary in ( + aggregate(infeasible, {"cost": "min", "value": "max"}), + aggregate(infeasible.assign(size=1), criteria), + aggregate(infeasible.iloc[:0], {"cost": "min", "value": "max"}), + ): + self.assertTrue(summary.empty) + self.assertEqual( + list(summary.columns[-5:]), + ["replicates", "feasible", "violation", "meets_requirements", "pareto"], + ) + # of the types of their columns, which select rows + self.assertEqual(summary.pareto.dtype, bool) + self.assertTrue(summary[summary.pareto].empty) + self.assertTrue(aggregate(infeasible, ["value"]).empty) + across = Criteria({"cost": "min", "value": "max"}, across=Across(rule="mean")) + scenarios = pd.concat( + [_partly_infeasible("s1"), _partly_infeasible("s2")], ignore_index=True + ) + self.assertEqual(len(aggregate(scenarios, across)), 2) + self.assertTrue(aggregate(scenarios.iloc[:0], across).empty) + + +class TestParetoProbability(unittest.TestCase): + """ + Unit tests for the probability of Pareto efficiency. + """ + + def test_settled(self): + """Designs separated in every replicate are efficient or not for sure.""" + results = _replicates([[1, 2, 3], [5, 6, 7]]) + probability = pareto_probability(results, {"cost": "min", "value": "max"}) + self.assertEqual(list(probability.pareto_probability), [0, 1]) + self.assertEqual(list(probability.pareto), [False, True]) + self.assertEqual(list(probability.value), [2, 6]) + + def test_common_random_numbers(self): + """Designs that differ by a constant in every replicate are settled.""" + rng = np.random.default_rng(0) + common = rng.normal(0, 5, 8) + results = _replicates([common, common + 0.1]) + probability = pareto_probability(results, {"cost": "min", "value": "max"}) + self.assertEqual(list(probability.pareto_probability), [0, 1]) + + def test_unsettled(self): + """Designs whose order changes between replicates are uncertain.""" + # equal means: d0 varies between replicates, d1 does not + results = _replicates([[0, 2] * 4, [1] * 8]) + probability = pareto_probability( + results, {"cost": "min", "value": "max"}, n_resamples=300 + ) + p = probability.pareto_probability + self.assertTrue(((p > 0.05) & (p < 0.95)).all()) + + def test_groups(self): + """Fronts of groups are found separately.""" + results = pd.concat( + [ + _replicates([[1, 2], [3, 4]]).assign(sensor="a"), + _replicates([[3, 4], [1, 2]]).assign(sensor="b"), + ] + ) + probability = pareto_probability( + results, Criteria({"cost": "min", "value": "max"}, by=["sensor"]) + ) + winners = probability[probability.pareto_probability == 1] + self.assertEqual( + sorted(zip(winners.sensor, winners.design)), [("a", "d1"), ("b", "d0")] + ) + + def test_design_values(self): + """Probabilities keep the values of the designs, as summaries do.""" + results = _replicates([[1, 2], [3, 4]]) + results["size"] = results["design"].map({"d0": "small", "d1": "large"}) + results["seed"] = results["replicate"] # an uncertain parameter + probability = pareto_probability(results, {"cost": "min", "value": "max"}) + self.assertEqual(list(probability["size"]), ["small", "large"]) + self.assertNotIn("seed", probability.columns) + bare = pareto_probability( + results, {"cost": "min", "value": "max"}, design_columns=[] + ) + self.assertNotIn("size", bare.columns) + + def test_quantile_objective(self): + """A pessimistic objective prefers the design with less spread.""" + objectives = {"cost": "min", "value": "max"} + by_mean = pareto_probability(_results(), objectives).set_index("design") + self.assertTrue(by_mean.loc["b", "pareto"]) # b has the larger mean + pessimistic = pareto_probability( + _results(), + Criteria( + {"cost": "min", "value q": "max"}, + statistics={"value q": Quantile("value", 0.25)}, + ), + ).set_index("design") + self.assertTrue(pessimistic.loc["a", "pareto"]) + self.assertFalse(pessimistic.loc["b", "pareto"]) + + def test_requirements(self): + """Designs that miss a requirement are not efficient.""" + probability = pareto_probability( + _results(), + Criteria( + {"cost": "min", "value": "max"}, + requirements=[Requirement("reliable", ">=", 0.75)], + statistics={"reliable": Probability("value", ">=", 10)}, + ), + ).set_index("design") + self.assertEqual(list(probability.meets_requirements), [True, False, False]) + # a is efficient unless b meets the requirement (and dominates it) + self.assertEqual(probability.loc["a", "requirements_probability"], 1) + self.assertGreater(probability.loc["a", "pareto_probability"], 0.5) + self.assertLess(probability.loc["a", "pareto_probability"], 1) + self.assertEqual(probability.loc["c", "pareto_probability"], 0) + # b meets the threshold in half of its replicates: it meets the + # requirement in some resamples, and is then efficient + self.assertGreater(probability.loc["b", "requirements_probability"], 0.1) + self.assertLess(probability.loc["b", "requirements_probability"], 0.9) + self.assertEqual(probability.loc["c", "requirements_probability"], 0) + + def test_unequal_replicates(self): + """Designs may have different replicates.""" + results = _results() + results = results[~((results.design == "c") & (results.replicate > 0))] + probability = pareto_probability(results, {"cost": "min", "value": "max"}) + self.assertEqual(list(probability.replicates), [4, 4, 1]) + self.assertEqual( + probability.set_index("design").loc["c", "pareto_probability"], 1 + ) + + def test_standard_errors(self): + """The bootstrap gives the standard error of each objective.""" + rng = np.random.default_rng(0) + results = pd.DataFrame( + [ + { + "design": design, + "replicate": r, + "feasible": True, + "x": float(i), + "y": i + rng.normal(0, 2), + } + for i, design in enumerate("ab") + for r in range(40) + ] + ) + probability = pareto_probability( + results, {"x": "min", "y": "max"}, n_resamples=2000 + ) + # x is the same in every replicate of each design + self.assertNotIn("x se", probability.columns) + expected = results.groupby("design").y.std(ddof=0) / np.sqrt(40) + np.testing.assert_allclose( + probability.set_index("design")["y se"], expected, rtol=0.15 + ) + + def test_resamples_share_replicates(self): + """A bootstrap draws each replicate in every scenario at once.""" + results = _scenarios({"s1": range(6), "s2": [10 - r for r in range(6)]}) + mean = Criteria({"v": "max"}, across=Across(rule="mean")) + probability = pareto_probability(results, mean, n_resamples=50) + self.assertAlmostEqual(probability["v"].iloc[0], 5.0) + # the mean of every resample is 5 + self.assertNotIn("v se", probability.columns) + worst = Criteria({"v": "max"}, across=Across()) + probability = pareto_probability(results, worst, n_resamples=50) + self.assertGreater(probability["v se"].iloc[0], 0.0) + + +class TestFeasibleProbability(unittest.TestCase): + """ + Unit tests for the probability of efficiency of designs infeasible in + some replicates. + """ + + @staticmethod + def _results(feasible): + """Two designs in eight replicates: d1, better, is feasible only where + given.""" + return pd.DataFrame( + [ + { + "design": design, + "replicate": r, + "feasible": True if design == "d0" else feasible[r], + "cost": 1.0, + "value": 1.0 if design == "d0" else 2.0, + } + for design in ("d0", "d1") + for r in range(len(feasible)) + ] + ) + + def test_feasible_requirement(self): + """A requirement on the share of feasible replicates is uncertain in + the bootstrap.""" + results = self._results([True, False] * 4) + criteria = Criteria( + {"cost": "min", "value": "max"}, + requirements=[Requirement("feasible", ">=", 0.5)], + ) + probability = pareto_probability(results, criteria, n_resamples=200) + probability = probability.set_index("design") + self.assertEqual(probability.loc["d1", "feasible"], 0.5) + self.assertEqual(probability.loc["d1", "replicates"], 4) + met = probability.loc["d1", "requirements_probability"] + self.assertGreater(met, 0.2) + self.assertLess(met, 0.9) + self.assertEqual(probability.loc["d0", "requirements_probability"], 1.0) + # without the requirement, d1 is judged by its feasible replicates, + # but for the few resamples that draw none of them (1 in 256) + plain = pareto_probability(results, {"cost": "min", "value": "max"}) + plain = plain.set_index("design") + self.assertGreater(plain.loc["d1", "pareto_probability"], 0.98) + self.assertAlmostEqual( + plain.loc["d0", "pareto_probability"], + 1 - plain.loc["d1", "pareto_probability"], + ) + + def test_infeasible_draws(self): + """A design whose drawn replicates are all infeasible is not judged + by its undrawn replicates.""" + rows = [] + for r in range(5): + rows.append( + { + "design": "rare", + "replicate": r, + "feasible": r == 0, + "value": 10.0 if r == 0 else np.nan, + } + ) + rows.append( + {"design": "steady", "replicate": r, "feasible": True, "value": 9.0} + ) + results = pd.DataFrame(rows) + probability = pareto_probability( + results, {"value": "max"}, n_resamples=4000, seed=1 + ).set_index("design") + # rare is efficient in the resamples that draw its replicate 0 + drawn = 1 - 0.8**5 + self.assertAlmostEqual( + probability.loc["rare", "pareto_probability"], drawn, delta=0.03 + ) + self.assertAlmostEqual( + probability.loc["steady", "pareto_probability"], 1 - drawn, delta=0.03 + ) + # nor does it meet the requirements without a feasible drawn replicate + self.assertAlmostEqual( + probability.loc["rare", "requirements_probability"], drawn, delta=0.03 + ) + self.assertEqual(probability.loc["steady", "requirements_probability"], 1.0) + + def test_no_feasible_design(self): + """Results without a feasible record have an empty summary.""" + results = self._results([False] * 4) + results = results[results.design == "d1"].drop(columns=["cost", "value"]) + with warnings.catch_warnings(): + warnings.simplefilter("error") + probability = pareto_probability(results, {"cost": "min", "value": "max"}) + self.assertTrue(probability.empty) + self.assertEqual( + list(probability.columns[-6:]), + [ + "feasible", + "violation", + "meets_requirements", + "pareto", + "pareto_probability", + "requirements_probability", + ], + ) + self.assertIn("value se", probability.columns) diff --git a/tests/tradespace/test_tables.py b/tests/tradespace/test_tables.py new file mode 100644 index 00000000..c8b6c2dd --- /dev/null +++ b/tests/tradespace/test_tables.py @@ -0,0 +1,114 @@ +""" +Unit tests for the tables of trade studies: the results of studies and the +summaries of their designs. + +@author Paul T. Grogan +""" + +import unittest + +import numpy as np +import pandas as pd + +from tatc.tradespace import Mean +from tatc.tradespace.tables import ( + check_records, + check_summary, + design_values, + draw_resamples, + efficient_keys, + feasible_records, + groups, + matrices, + names, + value_columns, +) + + +def _results(): + """Results of two designs in two replicates, one infeasible.""" + return pd.DataFrame( + { + "design": ["a", "a", "b", "b"], + "replicate": [0, 1, 0, 1], + "feasible": [True, True, True, False], + "size": [1, 1, 2, 2], + "seed": [7, 8, 7, 8], + "value": [1.0, 3.0, 2.0, np.nan], + } + ) + + +class TestTables(unittest.TestCase): + """ + Unit tests for tables of results and summaries. + """ + + def test_names(self): + """Names are given as a name or a sequence of names.""" + self.assertEqual(names("a"), ["a"]) + self.assertEqual(names(("a", "b")), ["a", "b"]) + + def test_groups(self): + """Groups are the positions of the rows of each value.""" + frame = _results() + self.assertEqual([key for key, _ in groups(frame, ())], [()]) + found = {key: list(rows) for key, rows in groups(frame, ["size"])} + self.assertEqual(found, {(1,): [0, 1], (2,): [2, 3]}) + with self.assertRaises(ValueError): + list(groups(frame, ["sensor"])) + + def test_records(self): + """Results need one record per evaluation, and a summary one row per + design.""" + results = _results() + check_records(results) + doubled = pd.concat([results, results.assign(sensor="y", value=0.0)]) + with self.assertRaisesRegex(ValueError, r"as `by`, such as \['sensor'\]$"): + check_records( + doubled.fillna({"sensor": "x"}), hint="as `by`", metrics=["value"] + ) + # columns of the evaluation, and metrics, do not separate them + check_records(doubled, ["design", "replicate", "sensor"]) + with self.assertRaisesRegex(ValueError, "aggregate"): + check_summary(results) + check_summary(results, by=["replicate"]) + + def test_matrices(self): + """The values of metrics of designs in replicates.""" + designs, replicates, values = matrices(_results(), ["value"]) + self.assertEqual(list(designs), ["a", "b"]) + self.assertEqual(list(replicates), [0, 1]) + np.testing.assert_array_equal(values["value"], [[1.0, 3.0], [2.0, np.nan]]) + with self.assertRaises(ValueError): + matrices(_results(), ["cost"]) + + def test_values_of_designs(self): + """The values of designs are the columns of their feasible records that + do not vary.""" + feasible, infeasible = feasible_records(_results()) + self.assertEqual((len(feasible), len(infeasible)), (3, 1)) + statistics = {"value": Mean("value")} + self.assertEqual(value_columns(_results(), statistics, (), None), ["size"]) + self.assertEqual(value_columns(_results(), statistics, ("size",), None), []) + self.assertEqual( + value_columns(_results(), {}, (), ["size", "value"]), ["size", "value"] + ) + frame = design_values(_results(), ["b", "a"], ["size"]) + self.assertEqual(frame.to_dict("list"), {"design": ["b", "a"], "size": [2, 1]}) + + def test_resamples(self): + """Resamples draw replicates with replacement.""" + drawn = draw_resamples(5, 3, 0) + self.assertEqual(drawn.shape, (3, 5)) + self.assertTrue(((drawn >= 0) & (drawn < 5)).all()) + np.testing.assert_array_equal(drawn, draw_resamples(5, 3, 0)) + with self.assertRaises(ValueError): + draw_resamples(5, 1, 0) + + def test_efficient_keys(self): + """The efficient designs of a summary, each once, in order.""" + summary = pd.DataFrame( + {"design": ["b", "a", "b", "c"], "pareto": [True, False, True, True]} + ) + self.assertEqual(efficient_keys(summary), ["b", "c"]) diff --git a/tests/tradespace/test_utility.py b/tests/tradespace/test_utility.py index 31537736..2d40fbe7 100644 --- a/tests/tradespace/test_utility.py +++ b/tests/tradespace/test_utility.py @@ -196,8 +196,11 @@ def test_summarize(self): {"utility": "max", "cost": "min"}, statistics=[Mean(self.utility)] ) summary = summarize(_results(), criteria).set_index("design") - for column in ("utility std", "utility se", "cost std", "cost se"): + for column in ("utility std", "utility se"): self.assertIn(column, summary.columns) + # the cost of each design is the same in every replicate + for column in ("cost std", "cost se"): + self.assertNotIn(column, summary.columns) spread = aggregate( _results(), criteria, From bfc470bf8da3c8198b9cc998c7386c7bc331085d Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Sat, 14 Nov 2026 21:40:08 -0700 Subject: [PATCH 50/52] review the trade space a sixth time, to simplify it: summarize replaces aggregate (spread=, criteria as Criteria or directions, metrics and statistics in statistics=, the standard errors of summarize in pareto_probability), studies describe their designs (describe=, a description column), enumerate gives the extensions of designs (DesignSpace.enumerate(designs)), Failures take statistics over histories (Quantile, Probability, StandardDeviation) and require a seed, requirements on phases are the study's with or without failures, every field of a MissionPlan is a value or a reference (also stages) with the design's policy by default, masses come from the plan (no SatelliteCost.mass), Triangular takes its mode by keyword, the optimizers' options are keyword-only, plot_designs rings the front by default and annotates with annotate, the outcomes of steps share their first fields (Screening.summaries one frame), StandardError and design_columns are gone, the internals of criteria, design spaces, stores, missions, and observations are private (DesignSpace no longer encodes designs), simulate_histories folds into simulate_many, phases are evaluated one way, fingerprint rules are a table, and spreads of infinite values are missing without warnings --- CHANGELOG.md | 21 +- docs/api_reference/tradespace/define.rst | 8 +- docs/api_reference/tradespace/evaluate.rst | 12 +- docs/api_reference/tradespace/index.rst | 20 +- docs/api_reference/tradespace/judge.rst | 9 +- docs/api_reference/tradespace/missions.rst | 26 +- docs/api_reference/tradespace/search.rst | 13 +- docs/examples/osse/RunOSSEMonsoon.ipynb | 2 +- .../tradespace/CompareScenarios.ipynb | 74 ++- .../tradespace/EvaluateTradeSpace.ipynb | 72 +-- .../tradespace/ExplainTradeSpace.ipynb | 68 ++- docs/examples/tradespace/PlanDeployment.ipynb | 45 +- .../examples/tradespace/PlanForFailures.ipynb | 143 +++-- .../tradespace/RankUncertainDesigns.ipynb | 136 +++-- .../tradespace/SearchTradeSpace.ipynb | 59 +- .../tradespace/TradeCostAndUtility.ipynb | 68 ++- .../tradespace/trade_space_example.py | 15 +- src/tatc/tradespace/__init__.py | 7 +- src/tatc/tradespace/attribution.py | 36 +- src/tatc/tradespace/cache.py | 50 +- src/tatc/tradespace/confirmation.py | 26 +- src/tatc/tradespace/cost.py | 54 +- src/tatc/tradespace/criteria.py | 296 +++++----- src/tatc/tradespace/deployment.py | 240 +++----- src/tatc/tradespace/dominance.py | 2 +- src/tatc/tradespace/events.py | 137 +++-- src/tatc/tradespace/expectations.py | 10 +- src/tatc/tradespace/failures.py | 20 +- src/tatc/tradespace/fingerprint.py | 191 +++---- src/tatc/tradespace/histories.py | 164 ++++-- src/tatc/tradespace/mission.py | 229 +++----- src/tatc/tradespace/nodes.py | 15 - src/tatc/tradespace/observations.py | 220 +++----- src/tatc/tradespace/optimization.py | 56 +- src/tatc/tradespace/pareto.py | 48 +- src/tatc/tradespace/plans.py | 529 ++++++++---------- src/tatc/tradespace/plotting.py | 77 ++- src/tatc/tradespace/references.py | 38 +- src/tatc/tradespace/refinement.py | 59 +- src/tatc/tradespace/scenarios.py | 34 +- src/tatc/tradespace/screening.py | 43 +- src/tatc/tradespace/sensitivity.py | 4 +- src/tatc/tradespace/simulation.py | 62 +- src/tatc/tradespace/space.py | 208 +++---- src/tatc/tradespace/statistics.py | 63 ++- src/tatc/tradespace/store.py | 26 +- src/tatc/tradespace/study.py | 114 ++-- src/tatc/tradespace/summary.py | 504 ++++++++--------- src/tatc/tradespace/tables.py | 8 +- src/tatc/tradespace/utility.py | 2 +- src/tatc/tradespace/walks.py | 29 +- tests/tradespace/test_attribution.py | 2 +- tests/tradespace/test_cache.py | 13 +- tests/tradespace/test_confirmation.py | 5 +- tests/tradespace/test_cost.py | 29 +- tests/tradespace/test_criteria.py | 42 +- tests/tradespace/test_deployment.py | 2 - tests/tradespace/test_failures.py | 83 +-- tests/tradespace/test_fingerprint.py | 9 +- tests/tradespace/test_observations.py | 175 +++--- tests/tradespace/test_optimization.py | 81 ++- tests/tradespace/test_pareto.py | 10 +- tests/tradespace/test_plotting.py | 17 +- tests/tradespace/test_references.py | 20 +- tests/tradespace/test_refinement.py | 9 +- tests/tradespace/test_scenarios.py | 35 +- tests/tradespace/test_screening.py | 9 +- tests/tradespace/test_sensitivity.py | 4 +- tests/tradespace/test_space.py | 51 +- tests/tradespace/test_stages.py | 32 +- tests/tradespace/test_statistics.py | 6 +- tests/tradespace/test_store.py | 62 +- tests/tradespace/test_study.py | 114 +++- tests/tradespace/test_summary.py | 191 ++++--- tests/tradespace/test_tables.py | 2 +- tests/tradespace/test_utility.py | 23 +- 76 files changed, 2627 insertions(+), 2791 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index b7c0d8d5..dac18f22 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,17 +16,17 @@ Added: - Module `tradespace` (prototype) for trade studies. A `DesignSpace` declares design variables (`Real`, `Integer`, `Categorical`), fixed and `Derived` values, and `Uncertain` parameters (drawn per replicate, not searched), grouped hierarchically with `Choice` (one of several branches) and `Repeat` (a variable number of items, such as orbit planes, optionally unordered). Bounds, derived values, and constraints are callables of the values decided before them. `DesignSpace.enumerate` gives every feasible design (a full factorial design, including variables that exist only in some designs), and `sample` a Latin hypercube or random sample. A `Design` has a `key` from its decisions and `flat` values by path, and `realize` draws a replicate's uncertain parameters, with common random numbers between designs by default. `Study` builds and evaluates designs in replicates into a data frame, in worker processes with `n_jobs` (or on an `executor`; idle workers wait two minutes for more evaluations before they exit), giving the realized design to an evaluation function with a parameter named `design`, recording as infeasible the designs that its functions reject with `Infeasible` or that fail the validation of TAT-C's schemas (other errors, including other `ValueError`s, are raised or recorded as failed), and raising an error for metrics that would replace its status columns or a design's values; `summarize` gives the mean, standard deviation, and standard error of metrics over replicates. - Class `tradespace.SatelliteCache`, which caches an analysis of single satellites by their content (orbit, instruments, and attitude, not their name, see `get_satellite_key`), in memory or on disk, so that designs that share satellites compute their results once. On disk, results are kept by namespace and by the definition of the function (see `get_definition`); a cache warns if its namespace has results only of its function with other code, naming what differs, `SatelliteCache.prune` removes the results of other definitions, and results that cannot be read are computed again. - Functions `tradespace.pareto_front`, `pareto_ranks` (both with optional tolerances of objectives, within which designs near the front are efficient), and `hypervolume` (exact) of designs with several objectives to minimize or maximize, and `pareto_probability`, the probability that each design is efficient given the uncertainty of its replicates (a bootstrap that resamples the same replicates for every design). - - Criteria by which designs are judged (`tradespace.Criteria`): objectives to minimize or maximize, requirements (`Requirement`, output constraints that designs meet or violate once evaluated, by an amount relative to the required value or a `scale`), the statistics over replicates that they name (`Mean`, `StandardDeviation`, `StandardError`, `Minimum`, `Maximum`, `Quantile`, and `Probability`, the share of replicates that meet a threshold; other names are means of metrics), tolerances of objectives, and the columns that group the records of an evaluation (`by`, such as a sensor), whose designs are judged separately. `aggregate` gives statistics of each design (and, with criteria, the violations of their requirements), and `summarize` means with their standard deviations and standard errors. `pareto_front`, `pareto_ranks` (which ranks designs that miss requirements after those that meet them), `hypervolume`, `pareto_probability` (which also gives the probability of meeting the requirements), `refine`, `confirm`, `screen`, `optimize_optuna` (a constraint of each trial for each requirement), and `optimize_pymoo` (a constraint for each requirement) take criteria, or a mapping of objectives to their directions. Results with several records of an evaluation that `by` does not separate raise an error. + - Criteria by which designs are judged (`tradespace.Criteria`): objectives to minimize or maximize, requirements (`Requirement`, output constraints that designs meet or violate once evaluated, by an amount relative to the required value or a `scale`), the statistics over replicates that they name (`Mean`, `StandardDeviation`, `Minimum`, `Maximum`, `Quantile`, and `Probability`, the share of replicates that meet a threshold; other names are means of metrics), tolerances of objectives, and the columns that group the records of an evaluation (`by`, such as a sensor), whose designs are judged separately. `summarize` gives statistics of each design (and, with criteria, the violations of their requirements), with the standard deviations and standard errors of means. `pareto_front`, `pareto_ranks` (which ranks designs that miss requirements after those that meet them), `hypervolume`, `pareto_probability` (which also gives the probability of meeting the requirements), `refine`, `confirm`, `screen`, `optimize_optuna` (a constraint of each trial for each requirement), and `optimize_pymoo` (a constraint for each requirement) take criteria, or a mapping of objectives to their directions. Results with several records of an evaluation that `by` does not separate raise an error. - Function `tradespace.refine` (and class `Refinement`), which adds replicates only to the designs whose Pareto efficiency is uncertain, until it is settled, optionally with a tolerance of differences that do not matter (also of `pareto_probability`), and within a `budget` of evaluations (refining the least settled designs first). Designs about a tolerance from the front, which more replicates settle only slowly, are `indifferent` and not refined once their objectives are known to within a share of their tolerances (`precision`, from the standard errors of the objectives that `pareto_probability` gives). `Study.run` evaluates given replicates (`replicate_indices`). - Class `tradespace.ResultStore`, a persistent store (SQLite) of the evaluations of a study (argument `store` of `Study`), from which a study that is interrupted or extended takes the evaluations stored before (except evaluations that failed and designs that failed validation, which are evaluated again). Workers add each evaluation as it completes, so that an interrupted run loses only the evaluations in progress, and records are kept as JSON (with values such as dates and infinite numbers tagged, so that they are read exactly). Function `tradespace.sensitivity` (and `main_effects`), the share of the variance of metrics explained by each design variable where it is active. Tolerances of objectives may be percentages of their values (such as `"5%"`). `Uncertain.seed` draws a seed of random numbers for each replicate, and `remove_failures` removes the satellites that fail, the same in every design. - Building blocks of constellations: fragments of design spaces of Walker constellations (`tradespace.walker_space`) and planes of sun-synchronous orbits (`sso_planes_space`, whose planes have different crossing times), `build_constellation`, which builds the satellites of either with instruments or entries of the instrument catalog (with their validated attitudes, and several entries on one satellite), and `count_satellites` and `count_planes`. The phase and node of the lead satellite of a Walker constellation (`phase_fraction` and `node_fraction`, design variables or uncertain parameters) are fractions of the intervals over which they give distinct constellations (`360 / per_plane` degrees of phase, and `360 / planes` degrees of node for a delta configuration or 360 for a star), so that a search does not evaluate the same constellation at several phases or nodes. Planes of inclined orbits (`planes_space`), each with its own inclination and node (uncertain by default, as of satellites launched as secondary payloads). Streets-of-coverage constellations (`soc_space`), whose planes and satellites in each plane the fragment derives from a swath width, inclination, and altitude, and mutual orbiting groups (`mog_space`), launched together as one plane. The fragments name the number of planes `planes` and the satellites in each plane `per_plane`. The satellites of the planes of `sso_planes_space` and `planes_space` are evenly spaced, or follow each other in a train at an `interval` (minutes), on the same ground track or in the same plane (`repeat_ground_track`). The phase of each plane (`phase_fraction`) is a fraction of the interval over which it gives distinct planes (`360 / per_plane` degrees for evenly spaced satellites, 360 for a train), from which each fragment derives the plane's `true_anomaly`, as for the lead satellite of a Walker constellation. `build_constellation`, `count_satellites`, and `count_planes` take several layouts (a list, or a `Repeat` of a `Choice` of layouts), such as the shells of a mixed constellation. The values of each fragment in a design are those of a `Layout` (`layout_of`, with `WalkerLayout`, `SSOPlanesLayout`, `PlanesLayout`, `SOCLayout`, `MOGLayout`, and `Layouts` of several), which gives its `Plane`s and the orbits of their satellites in order; other layouts subclass it and are built, counted (`plane_sizes`), deployed, and costed as the others. - Function `tradespace.screen` (and class `Screening`), which screens designs with studies of increasing fidelity, keeping whole fronts of the best designs of each stage for the next. - - Searches of design spaces with optional optimizers: `tradespace.optimize_optuna` suggests designs with Optuna trials (`DesignSpace.suggest`, define-by-run over the hierarchical space), and `optimize_pymoo` and `make_pymoo_problem` search the unit hypercube that encodes a design space (`DesignSpace.unit_paths`, `encode`, and `decode`) with pymoo, whose algorithms eliminate the proposals of designs proposed or evaluated before (`distinct`, by design, `make_pymoo_problem`'s `duplicates`). Each design is evaluated once, and the designs proposed together are evaluated together, in parallel if the study is. A search returns its results and designs (`Search`), which `refine` and `confirm` refine and confirm as for any study. Constraints of a design space may return the amount of their violation (`Infeasible.violation`), which Optuna's trials record (`set_constraint`) for its constraint-aware samplers, and which is the constraint value of pymoo problems. Optional dependencies `tradespace` (joblib, Optuna, and pymoo). + - Searches of design spaces with optional optimizers: `tradespace.optimize_optuna` suggests designs with Optuna trials (define-by-run over the hierarchical space), and `optimize_pymoo` and `make_pymoo_problem` search the unit hypercube that encodes a design space (a dimension per decision) with pymoo, whose algorithms eliminate the proposals of designs proposed or evaluated before (`distinct`, by design, `make_pymoo_problem`'s `duplicates`). Each design is evaluated once, and the designs proposed together are evaluated together, in parallel if the study is. A search returns its results and designs (`Search`), which `refine` and `confirm` refine and confirm as for any study. Constraints of a design space may return the amount of their violation (`Infeasible.violation`), which Optuna's trials record (`set_constraint`) for its constraint-aware samplers, and which is the constraint value of pymoo problems. Optional dependencies `tradespace` (joblib, Optuna, and pymoo). - Deployment of constellations (`tradespace.DeploymentSchedule`): from the rates and durations of a study (the mission, the design life, development, and production rate of each type of satellite, its production on a line, and launches at a cadence and capacity, in number or mass, optionally in an order of planes), each design's deployment (`DeploymentSchedule.plan`, a `Deployment` of its `Production`, `Launch`es, and replacements), so that a design of more satellites and planes takes longer to deploy. A sustained constellation (`DeploymentSchedule.sustained`, such as of an operational program over the period of a study) is replaced after the end of the mission as before it, and its costs are those incurred by the end, which count the units in production then by the share produced and later blocks by the share of their development done. A deployment's launches divide the mission into phases of constant sets of operating satellites (`Deployment.phases`), evaluated over the study's representative period from the observations of the full constellation (`evaluate_phases`) and combined over the mission (`summarize_phases`: the time-weighted mean of each metric and the time until it first meets a requirement). - - Simulated missions with failures (`Deployment.simulate`, a `MissionHistory` for each replicate, drawn from its seed with common random numbers between designs): lives of satellites whose failure rates vary over the lifecycle (`tradespace.Exponential`, `Weibull`, `Bathtub` of competing causes, and `Piecewise` rates by age, `Lifetime`), failures of launches (`FailureModel`), and a policy that degrades or restores failed satellites (`RestorationPolicy`) by spares in orbit (taking a failed satellite's place after drifting), spares on the ground (launched at the next launch slot), or satellites produced when needed (after procurement, on the production line), optionally replenishing spares and batching restorations in launches. A history gives the phases in which satellites operate (`MissionHistory.phases`), measures of the mission (`MissionHistory.metrics`: failures, restorations, spares used, time to restore, and availability), and, priced by a `CostModel`, the cost of what it produces and launches. Policies are decisions of designs with a fragment of a design space (`policy_space`: whether to restore, spares in orbit and on the ground, and other fields of the policy, without spares that would never be used), and `configure` makes a policy (or a deployment schedule, or another dataclass) from the values of a design. Many histories of a replicate's mission (`Deployment.simulate_many`) share its sample of targets: `evaluate_histories` evaluates them (with their measures and costs) with a cache that evaluates each set of operating satellites once (`PhaseCache`, keyed by the content of the satellites and shared by the histories, policies, and designs of a replicate), and `summarize_histories` gives their means, quantiles (the risk of the mission), and probabilities of meeting requirements, as one record of the replicate. The histories of a replicate are stratified by default (a Latin hypercube over the histories of each satellite's life and each launch, drawn from uniform numbers by `Lifetime.from_uniform`), which estimates the means of missions 3 to 15 times more precisely than independent histories, and means may be estimated with control variates (`summarize_histories(controls=...)`, such as the availability of the mission, whose expected value simulations alone estimate, `Deployment.expected_metrics`). `allocate_histories` recommends the histories of each replicate (and the replicates, for a standard error) from a pilot with independent histories, by the variances between replicates and between histories and their costs (`summarize_histories(spread=True)` gives the standard deviations of the histories). `exact_expectations` computes the expected capability and availability of a mission without restoration exactly (the sets of operating satellites by their probabilities, from the survival of each launch group, with planned replacements), without sampling error. Histories may be drawn from stressed failures for importance sampling (`simulate_many(stress=...)`: hazards and launch failures times a factor, each history weighted by its likelihood ratio censored at the end of the mission, `Lifetime.stressed` and `MissionHistory.weight`), which `summarize_histories` weighs in every statistic, with the effective number of histories: the probabilities of rare losses with 30 to 70 times less variance. + - Simulated missions with failures (`Deployment.simulate`, a `MissionHistory` for each replicate, drawn from its seed with common random numbers between designs): lives of satellites whose failure rates vary over the lifecycle (`tradespace.Exponential`, `Weibull`, `Bathtub` of competing causes, and `Piecewise` rates by age, `Lifetime`), failures of launches (`FailureModel`), and a policy that degrades or restores failed satellites (`RestorationPolicy`) by spares in orbit (taking a failed satellite's place after drifting), spares on the ground (launched at the next launch slot), or satellites produced when needed (after procurement, on the production line), optionally replenishing spares and batching restorations in launches. A history gives the phases in which satellites operate (`MissionHistory.phases`), measures of the mission (`MissionHistory.metrics`: failures, restorations, spares used, time to restore, and availability), and, priced by a `CostModel`, the cost of what it produces and launches. Policies are decisions of designs with a fragment of a design space (`policy_space`: whether to restore, spares in orbit and on the ground, and other fields of the policy, without spares that would never be used), and `configure` makes a policy (or a deployment schedule, or another dataclass) from the values of a design. Many histories of a replicate's mission (`Deployment.simulate_many`) share its sample of targets: `evaluate_histories` evaluates them (with their measures and costs) with a cache that evaluates each set of operating satellites once (`PhaseCache`, keyed by the content of the satellites and shared by the histories, policies, and designs of a replicate), and `summarize_histories` gives their means, quantiles (the risk of the mission), and probabilities of meeting requirements, as one record of the replicate. The histories of a replicate are stratified by default (a Latin hypercube over the histories of each satellite's life and each launch, drawn from uniform numbers by `Lifetime.from_uniform`), which estimates the means of missions 3 to 15 times more precisely than independent histories, and means may be estimated with control variates (`summarize_histories(controls=...)`, such as the availability of the mission, whose expected value simulations alone estimate). `allocate_histories` recommends the histories of each replicate (and the replicates, for a standard error) from a pilot with independent histories, by the variances between replicates and between histories and their costs (from the `StandardDeviation` of a metric over the histories). `exact_expectations` computes the expected capability and availability of a mission without restoration exactly (the sets of operating satellites by their probabilities, from the survival of each launch group, with planned replacements), without sampling error. Histories may be drawn from stressed failures for importance sampling (`simulate_many(stress=...)`: hazards and launch failures times a factor, each history weighted by its likelihood ratio censored at the end of the mission, `Lifetime.stressed` and `MissionHistory.weight`), which `summarize_histories` weighs in every statistic, with the effective number of histories: the probabilities of rare losses with 30 to 70 times less variance. - Life-cycle costs of deployments for trade studies (`tradespace.CostModel`): the development of each type of satellite, the production of its units on a learning curve (`SatelliteCost`), launches (per launch, or prices per satellite and kg, `LaunchCost`), operations (`OperationsCost`), replacements, and spares in orbit, dated by the deployment for their present value at a discount rate (`CostEstimate.present_value`, metric `cost present`) and annual costs (`CostEstimate.annual`, metric `cost peak annual`), with growth factors for cost risk (such as uncertain parameters, whose quantiles over replicates give the cost at a confidence level). TAT-C does not include cost-estimating relationships: the costs are given by the study. Fingerprints describe dataclasses (such as cost models) by their fields. - Function `tradespace.confirm` (and class `Confirmation`), which evaluates selected designs (such as a front) with new replicates that played no part in their selection, removing the optimism of the selection (the winner's curse, `Confirmation.optimism`). `ResultStore` keys evaluations by the fingerprint of a study (`Study.fingerprint`, a hash of `Study.definition`, see `get_definition`: its seed, use of common random numbers, design space, and build and evaluation functions, with the data frames they are given described by their content, the version of Python, and the source of the modules of TAT-C and resource files they depend on, found from their imports) and keeps each definition, so that variants of a study share a store without mixing their evaluations, and a study warns of evaluations of the same study with other code (of its functions, of TAT-C, or of Python), which are not reused, naming what differs (`fingerprint.compare_definitions`); `Study.prune` removes them (and not the evaluations of other studies that share the store). Changes to TAT-C that a study does not depend on (such as to modules it does not use) keep its results. Namespaces of stores and caches are optional, for what fingerprints cannot see (data that functions read from files, and the code of other modules). `refine` treats designs with fewer than `min_replicates` (5) as uncertain whatever their probability, adds the replicates left to `max_replicates` in a last partial step, and warns if designs remain uncertain without a tolerance. `sensitivity` gives adjusted shares (epsilon squared) by default, without the share that the levels of a variable explain by chance (`adjusted=False` for correlation ratios). - - The schedule and cost model of a `tradespace.MissionPlan` may be functions of the design (`schedule_of`, `cost_model_of`), which size them by its values with relationships of the study's own, such as the costs of a type of satellite from its payload or the capacity of launches to the design's altitude; launches limited in mass take the masses of the satellites from the cost model (`masses_of`, or the plan's `masses`). The `launch_mass_capacity` of a `DeploymentSchedule` may be a function of a plane (`mass_capacity_of`), for planes at different inclinations. + - The schedule and cost model of a `tradespace.MissionPlan` may be functions of the design, which size them by its values with relationships of the study's own, such as the costs of a type of satellite from its payload or the capacity of launches to the design's altitude; launches limited in mass take the masses of the satellites from the plan (`masses`). The `launch_mass_capacity` of a `DeploymentSchedule` may be a function of a plane, for planes at different inclinations. - The start of the period of `tradespace.Observations` may be a value of the design (`start_of` and `end_of` give a design's period), such as an uncertain epoch drawn for each replicate over the mission, whose observations are cached apart, so that replicates average over the geometry and seasons of the mission that the one window of quasi-static phases misses (see `evaluate_phases`). The schedule of deployments states that a design life does not retire a satellite that is not replaced, and simulations that a planned replacement whose launch fails is not flown again. - Utilities of the metrics of designs (`tradespace.Utility`), for trade spaces of utility against cost: a single-attribute utility of each metric (`LinearUtility`, `ExponentialUtility` of a risk attitude, `PiecewiseUtility`, or any function), combined by weights additively or in Keeney and Raiffa's multiplicative form. A utility is a metric of any statistic (its `Mean` is the expected utility over the replicates, and a utility given as a statistic of `Criteria` is its mean), computed in each replicate, and gives the utility of each row of a data frame (such as a summary of the means of designs). Statistics name the columns they need (`Statistic.columns`). - Staged deployments (`tradespace.Stage`, argument `stages` of `DeploymentSchedule.plan` and `MissionPlan`, which may give the stages of each design): planes that are produced and launched only if a rule decides to, at times during the mission, from what it knows then (`Decision`: the satellites operating, the history so far, and, through the design, its uncertain parameters and scenario), after a lead time and at the next launch slots, and replaced and restored as other planes. Rules may also read the capability of the satellites operating at a decision (`Decision.capability`, the study's metrics of their observations, as of a phase), which the evaluations of an `ObservationStudy` give each deployment (`Deployment.capability`, a `tradespace.Capability` of its satellites, observations, and cached phases, which also caches the phases of studies without failures), such as for a plane deployed only if those in orbit fall short. A stage that is not deployed is neither produced, launched, nor priced; `MissionHistory.decided` gives when each was deployed, and its metrics the `stages deployed`. Exact expectations of missions without restoration (`exact_expectations`) need deployments that are not staged, so that studies of staged deployments sample their histories. @@ -36,13 +36,14 @@ Added: - Structured cost risk (after Maier, Yeakel, and Wendoloski, "Cost Variance Analysis in Constellation Architecture Studies," 2023): growth factors of each type of satellite (by kind, for development, production, and launches, in `CostModel.estimate` and `MissionPlan.growth`), and the costs of types of satellites as sums of their components (`tradespace.Component`, `SatelliteCost.components`), whose growth has a distribution by maturity (such as `tradespace.Triangular`), correlated between components (`CostModel.correlation`). `CostModel.draw` draws the growth of the components from standard normal scores of the components and a common score, which `tradespace.risk_space` declares as uncertain parameters of a design space (named by `MissionPlan.scores`, also of a nested group), so that common random numbers give the designs that share a component the same growth of it; without drawn growth, components cost their expected growth. Types of satellites that share a component (by name) develop it once in a deployment. Production in blocks (`SatelliteCost.block_size`): each block after the first develops its type again (a share of its development, `redevelopment`) before its first unit is produced, and restarts the learning curve; `CostEstimate.blocks` counts the blocks of each type. Function `tradespace.exceedance` gives the probability that a metric of each design exceeds that of each other in the same replicate (such as that one design costs more than another), and `plot_exceedance` plots them as a matrix. The validation notebook `ValidateCostVarianceNSOSA` reproduces the paper's example of two NSOSA constellations that share a configuration. - Searches with Optuna accept categorical options that depend on earlier decisions (a parameter for each set of options), use TPE with a constant liar in batches by default (which spreads the trials of a batch), and stop after `max_designs` designs evaluated (trials that suggest designs evaluated before are told their objectives without evaluating them again). A design infeasible in some of its replicates violates its feasibility by their share (`Evaluations.infeasibility`), and the first design evaluated in a search is evaluated alone, to check that evaluations give one record each. `Study` records errors of evaluations as infeasible, without storing them, with `errors="record"`. Enumeration walks the items of unordered repetitions in one order only, and `DesignSpace.size` counts designs without keeping them. Pareto fronts are found by a vectorized sweep in lexicographic order that compares designs only with the efficient designs before them, and fronts with tolerances by comparing designs only with the efficient designs without tolerances (which dominate every design that any design dominates within the tolerances), in blocks of bounded memory. - Studies of the observations of constellations (`tradespace.ObservationStudy`): the targets of each replicate (`Targets`, fixed or generated from a seed of the design), the observations of each satellite, cached on disk (`Observations`), the metrics of the observations, and, with a `MissionPlan`, the costs of the deployment and the summaries of its phases or of the histories of its `Failures`. Plots of the results of studies (`plot_designs`, `plot_progress`, and `plot_means`, with matplotlib, in the `tradespace` extra), and the hypervolume of a search as it proceeds (`hypervolume_progress`). - - The steps of trade studies share their arguments and outcomes: `tradespace.refine(study, criteria, results)`, `confirm(study, criteria, results)` (by default, the front of the results), `screen(studies, criteria, designs)` (with criteria for each stage), and `attribute_variance(study, metrics, designs)` take designs as `Design` objects, their keys, or rows of a summary or of results, and `Refinement`, `Confirmation`, `Screening`, and `Search` give their `results`, the `summary` of their designs, and the `designs`. `DesignSpace.designs_of` rebuilds designs from rows of their values, which summaries keep (also those of `pareto_probability`, `confirm`, and `screen`), and `DesignSpace.extend`, `DesignSpace.design(design, **overrides)`, and `Study.replace` make variants of design spaces, designs, and studies. `aggregate` takes criteria, a mapping of objectives, or metrics (as the other functions do), and other `statistics` by name; `pareto_front`, `pareto_ranks`, `hypervolume`, `sensitivity`, and `main_effects` raise an error given the results of a study (a row per replicate) instead of a summary. Studies with a mission plan record the years by which it is `deployed`, and the parts of observation studies that refer to values of designs are typed as a `Reference`. Columns: ` se`, ` mission` for the mean over the phases of a mission, ` histories p`, ` histories std`, and `P() histories` for statistics over the histories of failures, and `pareto_trace` and `max_regret`. Package `tradespace` exports the functions and classes of trade studies; the parts from which they are made (such as `PhaseCache`, `Layout`, `configure`, and the fingerprints) are imported from its modules. - - Values of `tradespace` designs by the paths of the columns of results (`d["layout.walker.planes"]`, also in the callables of design spaces and in references), choices equal to the names of their branches, and reserved names of children that views and designs give otherwise (such as `values` and `key`). `Repeat` counts may be `Integer`, `Categorical`, `Fixed`, or `Derived`; `DesignSpace.design` checks decisions against their domains; and the constructors of uncertain parameters (with `Uncertain.triangular`) take nominal values and name their distributions. Summaries of criteria give whether each design is efficient (`pareto`, also of `summarize`, which takes criteria, and of `confirm`, `screen`, and searches), designs with a missing objective are not efficient, and `aggregate` takes `statistics` by name. `Study.realize` realizes a design as a study does (in a scenario), and an `ObservationStudy` gives the mission of a design as its evaluation plans it (`mission_of`). `Study.prune` removes a study's evaluations with other code (and not those of other studies that share its store, `ResultStore.remove`), `Observations.prune` removes the results of its caches with other code, and caches warn of results of other code once, in the main process. Fingerprints describe geometries by their content, ignore docstrings, and describe the functions of a study's own modules (such as one next to a notebook) by their code. Missions restore failures by default, and `Failures` sample histories with importance sampling (`stress`), control variates (`controls`), and spreads over the histories. Layouts describe themselves (`Layout.describe`) and are built at their own altitude (the given one is for layouts without one; `soc_space` keeps the altitude its planes are derived at). `plot_designs` colors some designs over the others (`highlight`, `label`, `others`, `front_label`), and `COLORS`, `INK`, and `GRAY` name the colors of plots. Each design confirmed gives its ` optimism`, `robustness` keeps the values of designs, and `Search.summary` keeps the designs the search found feasible. The simulation of missions is in module `simulation`. - - Decisions given to `tradespace.DesignSpace.design` by value are levels of their domains (`2.0` or `numpy.int64(2)` give the key of the enumerated design), designs and scopes tell whether they have a value (`"layout.walker.planes" in design`), and the items of a `Repeat` take slices. `DesignSpace.designs_of` gives a series of designs aligned to the rows of a data frame (`space.designs_of(summary).map(describe)`). Statistics given without names are named by convention (`Statistic.name`, such as `"cost p70"` for `Quantile("cost", 0.7)` and `"P(cost <= 150)"`), so that `statistics` may be a list, `summarize(results, criteria, statistics=...)` adds the means and spreads of other metrics to a summary of criteria, criteria `across` scenarios are summarized and aggregated as others, and `Requirement.met` tells which values meet a requirement. An `ObservationStudy` counts the satellites and planes of a design's `layout` by default, gives the histories of a design's failures (`mission_of(design).histories()`) and its satellites, targets, and observations (`satellites_of`, `targets_of`, `observations_of`) as its evaluation realizes them, and `MissionPlan.policy` refers to each design's restoration policy (such as of `policy_space`). Fingerprints describe the classes and callable objects of a study's own modules by their attributes and the code of their methods, and tell studies that differ in constants apart from the same study with other code; `Observations.prune` removes only the results of its own analyses with other code. `plot_designs` colors designs by a column or by values of their rows (`by`), `plot_shares` plots shares of variance (of `sensitivity` or `attribute_variance`) as grouped bars with their standard errors, and `use_style` applies the style of the plots of trade studies (with constrained layouts) to the figures of a session. `robustness` gives each objective of a design in each scenario (` `). `Deployment.planes` are `PlannedPlane`s (type, satellites, and spares in orbit), `DeploymentSchedule.next_slot` gives the next launch slot that keeps the launch interval, and `Capability.evaluate` evaluates phases with a deployment's cached observations. Searches with Optuna are seeded by default (`seed=0`), and lives of satellites are drawn from uniform numbers (`Lifetime.from_uniform`, which subclasses implement). + - The steps of trade studies share their arguments and outcomes: `tradespace.refine(study, criteria, results)`, `confirm(study, criteria, results)` (by default, the front of the results), `screen(studies, criteria, designs)` (with criteria for each stage), and `attribute_variance(study, metrics, designs)` take designs as `Design` objects, their keys, or rows of a summary or of results, and `Refinement`, `Confirmation`, `Screening`, and `Search` give their `results`, the `summary` of their designs, and the `designs`. `DesignSpace.designs_of` rebuilds designs from rows of their values, which summaries keep (also those of `pareto_probability`, `confirm`, and `screen`), and `DesignSpace.extend`, `DesignSpace.design(design, **overrides)`, and `Study.replace` make variants of design spaces, designs, and studies. `summarize` takes criteria or a mapping of objectives (as the other functions do), and other `statistics` by name; `pareto_front`, `pareto_ranks`, `hypervolume`, `sensitivity`, and `main_effects` raise an error given the results of a study (a row per replicate) instead of a summary. Studies with a mission plan record the years by which it is `deployed`, and the parts of observation studies that refer to values of designs are typed as a `Reference`. Columns: ` se`, ` mission` for the mean over the phases of a mission, ` histories p`, ` histories std`, and `P() histories` for statistics over the histories of failures, and `pareto_trace` and `max_regret`. Package `tradespace` exports the functions and classes of trade studies; the parts from which they are made (such as `PhaseCache`, `Layout`, `configure`, and the fingerprints) are imported from its modules. + - Values of `tradespace` designs by the paths of the columns of results (`d["layout.walker.planes"]`, also in the callables of design spaces and in references), choices equal to the names of their branches, and reserved names of children that views and designs give otherwise (such as `values` and `key`). `Repeat` counts may be `Integer`, `Categorical`, `Fixed`, or `Derived`; `DesignSpace.design` checks decisions against their domains; and the constructors of uncertain parameters (with `Uncertain.triangular`) take nominal values and name their distributions. Summaries of criteria give whether each design is efficient (`pareto`, also of `confirm`, `screen`, and searches), and designs with a missing objective are not efficient. `Study.realize` realizes a design as a study does (in a scenario), and an `ObservationStudy` gives the mission of a design as its evaluation plans it (`mission_of`). `Study.prune` removes a study's evaluations with other code (and not those of other studies that share its store), `Observations.prune` removes the results of its caches with other code, and caches warn of results of other code once, in the main process. Fingerprints describe geometries by their content, ignore docstrings, and describe the functions of a study's own modules (such as one next to a notebook) by their code. Missions restore failures by default, and `Failures` sample histories with importance sampling (`stress`), control variates (`controls`), and spreads over the histories. Layouts describe themselves (`Layout.describe`) and are built at their own altitude (the given one is for layouts without one; `soc_space` keeps the altitude its planes are derived at). `plot_designs` colors some designs over the others (`highlight`, `label`, `others`, `front_label`), and `COLORS`, `INK`, and `GRAY` name the colors of plots. Each design confirmed gives its ` optimism`, `robustness` keeps the values of designs, and `Search.summary` keeps the designs the search found feasible. The simulation of missions is in module `simulation`. + - Decisions given to `tradespace.DesignSpace.design` by value are levels of their domains (`2.0` or `numpy.int64(2)` give the key of the enumerated design), designs and scopes tell whether they have a value (`"layout.walker.planes" in design`), and the items of a `Repeat` take slices. `DesignSpace.designs_of` gives a series of designs aligned to the rows of a data frame (`space.designs_of(summary).map(describe)`). Statistics given without names are named by convention (`Statistic.name`, such as `"cost p70"` for `Quantile("cost", 0.7)` and `"P(cost <= 150)"`), so that `statistics` may be a list, `summarize(results, criteria, statistics=...)` adds the means and spreads of other metrics to a summary of criteria, criteria `across` scenarios are summarized as others, and `Requirement.met` tells which values meet a requirement. An `ObservationStudy` counts the satellites and planes of a design's `layout` by default, gives the histories of a design's failures (`mission_of(design).histories()`) and its satellites, targets, and observations (`satellites_of`, `targets_of`, `observations_of`) as its evaluation realizes them, and `MissionPlan.policy` refers to each design's restoration policy (such as of `policy_space`). Fingerprints describe the classes and callable objects of a study's own modules by their attributes and the code of their methods, and tell studies that differ in constants apart from the same study with other code; `Observations.prune` removes only the results of its own analyses with other code. `plot_designs` colors designs by a column or by values of their rows (`by`), `plot_shares` plots shares of variance (of `sensitivity` or `attribute_variance`) as grouped bars with their standard errors, and `use_style` applies the style of the plots of trade studies (with constrained layouts) to the figures of a session. `robustness` gives each objective of a design in each scenario (` `). `Deployment.planes` are `PlannedPlane`s (type, satellites, and spares in orbit), replacements launch at the next slot that keeps the launch interval, and `Capability.evaluate` evaluates phases with a deployment's cached observations. Searches with Optuna are seeded by default (`seed=0`), and lives of satellites are drawn from uniform numbers (`Lifetime.from_uniform`, which subclasses implement). - Designs of another design space (such as the space that a study's space extends) are evaluated in the study's space, and constraints are checked in each scenario: a design that violates them in a scenario is infeasible in it, and a constraint that gives `NaN` is violated. Children of design spaces may not take the names of the status columns of results (`design`, `feasible`, `error`, `seconds`, and `scenario`). `DesignSpace.design` takes the name of a branch for a choice (`space.design(base, layout="sso")`), unordered items are in the order of their levels, `Design.scenario` names the scenario of a realized design, `Design.realize` takes the `overrides` of a scenario, and `DesignSpace.check_uncertain` and `check_overrides` check the paths of uncertain parameters and of scenarios. The options of `Study` and `DesignSpace.sample` are keyword-only. Fingerprints describe the globals of a study's functions as they describe its given values (pydantic models, partials, objects of the study's own classes, containers by their content, and the functions of its own modules reached through them), and find the same study with other code alike in every version of Python. `Study.prune` also removes the definitions of a study without evaluations, warnings of studies and caches point at the code that runs them, and an evaluation that gives an empty data frame raises an error. - - Summaries give the share of the replicates of each design that are feasible (`feasible`, which requirements may name, such as `Requirement("feasible", ">=", 1)`), and judge designs by their feasible replicates, as searches do. Statistics are in module `statistics`, and summaries (`aggregate`, `summarize`, and `pareto_probability`) in module `summary`. The tolerances of criteria are `Criteria.tolerances`. Each step gives the designs it selects for the next step (`designs`: the efficient designs of a refinement or a search, the survivors of a screening, and the designs confirmed) and its `criteria`, with `Refinement.candidates` and `Refinement.evaluations` (those it added), `Search.evaluated`, and `Screening.history` (the results of every stage; its `results` are those of the last stage, which other steps take). `robustness` takes the column of the scenarios from the criteria, gives ` ` for every objective that is not a value of designs, and gives an infinite regret for a missing objective. `optimize_pymoo` stops after `max_designs`, `screen` checks the share or number of designs it keeps (`keep`), `plot_designs` and `plot_means` draw the designs without a group (`by`) in gray, and `summarize` gives the spread of the mean of a `Utility`. - - The mission of each design of an observation study (module `plans`): `MissionPlan.policy` gives the restoration policy of each design (by default, restoring failed satellites; a policy, a function, or a reference to values that configure it, such as those of `policy_space`), with its spares in orbit (`RestorationPolicy.orbit_spares`, launched with their planes) and on the ground, and `ObservationStudy.mission_of` gives the `Mission` of a design (its deployment, phases, cost estimate, and histories) as its evaluation plans it (`MissionPlan.plan_mission`). `Failures(phases=...)` gives the time until each history meets requirements, and `Failures` checks its options when it is made. Exact expectations fall back to the means of the histories for missions with too many sets of satellites (`expectations.MAX_SETS`). Planned replacements keep the launch interval, spares in orbit that are never used are not replaced at the end of their design life, launches are priced by the masses of the deployment, the phases of a mission are cached by the uncertain values of its replicate, and studies of staged deployments record the `stages deployed`. A deployment is planned with its restoration policy (`DeploymentSchedule.plan(policy=...)`, `Deployment.policy`), whose spares its planned history (`Deployment.planned`), its simulations (`Deployment.simulate(model)`), and its costs share, the options of `DeploymentSchedule.plan` and `ObservationStudy` are keyword-only, `layout_of` is exported, a layout names its pattern (`pattern`), `Stage` takes numpy values, and the development of a staged type that is never deployed is the cost of its option. References to values of designs are in module `references`. - - Fingerprints describe objects by what their `__fingerprint__()` returns (designs, and caches of satellites by their function and namespace), so that a study whose functions use them is evaluated again when they change. Decisions that name no child of a design space raise an error (also those of designs of another space, in a study's space), `errors="record"` records the errors of realizing a design, metrics may not be named `scenario`, replicates and shifts must not be negative, and a design space takes a single constraint. Module `references` reads designs: `configure` and `value_of` are exported, and functions given the design follow one convention (`takes_design`, `given_design`). `Design.uncertain_values()` gives the values of a design's uncertain parameters, and `Statistic` and the classes of the steps (`Refinement`, `Confirmation`, `Screening`, `Search`, `Attribution`) are exported. `summarize` gives the spread of the statistics it reports across scenarios (of the worst scenario, or of the weighted mean over the replicates that the scenarios share) and leaves out spreads that are zero for every design. Statistics may not take the names of columns of the results, and `summarize_histories` names the share of histories that meet a requirement `P() histories`. `refine` charges the evaluations of every scenario to its budget (`Refinement.rounds` gives its rounds), `pareto_probability` leaves out of a resample a design without a feasible replicate drawn, `main_effects` orders its bins, searches with pymoo leave the caller's algorithm unchanged, and Optuna's constraints of requirements have distinct names. `exceedance` gives the `shared_replicates` of two designs. A ground spare goes up at the next launch slot, the planes of a stage launch in the order they are ready, and `MissionHistory.deployed` is infinite for a deployment that outlasts the mission. `SatelliteCache` keeps a context with each namespace (`context`, `SatelliteCache.contexts`), `Observations` generates the targets of a replicate only to observe them, an `ObservationStudy` computes the metrics of all of a design's satellites once, exact expectations are faster (module `expectations`), and the options of `Study.run`, `designs_of`, `ResultStore`, `SatelliteCache`, and `Repeat` are keyword-only. + - Summaries give the share of the replicates of each design that are feasible (`feasible`, which requirements may name, such as `Requirement("feasible", ">=", 1)`), and judge designs by their feasible replicates, as searches do. Statistics are in module `statistics`, and summaries (`summarize` and `pareto_probability`) in module `summary`. The tolerances of criteria are `Criteria.tolerances`. Each step gives the designs it selects for the next step (`designs`: the efficient designs of a refinement or a search, the survivors of a screening, and the designs confirmed) and its `criteria`, with `Refinement.candidates` and `Refinement.evaluations` (those it added), `Search.evaluated`, and `Screening.history` (the results of every stage; its `results` are those of the last stage, which other steps take). `robustness` takes the column of the scenarios from the criteria, gives ` ` for every objective that is not a value of designs, and gives an infinite regret for a missing objective. `optimize_pymoo` stops after `max_designs`, `screen` checks the share or number of designs it keeps (`keep`), `plot_designs` and `plot_means` draw the designs without a group (`by`) in gray, and `summarize` gives the spread of the mean of a `Utility`. + - The mission of each design of an observation study (module `plans`): `MissionPlan.policy` gives the restoration policy of each design (by default, the design's value `policy` if it has one, and otherwise restoring failed satellites; a policy, a function, or a reference to values that configure it, such as those of `policy_space`), with its spares in orbit (`RestorationPolicy.orbit_spares`, launched with their planes) and on the ground, and `ObservationStudy.mission_of` gives the `Mission` of a design (its deployment, phases, cost estimate, and histories) as its evaluation plans it (`MissionPlan.plan_mission`). With failures, the requirements on the phases of a study (`phases`) give the time until each history meets them, and `Failures` checks its options when it is made. Exact expectations fall back to the means of the histories for missions with too many sets of satellites (`expectations.MAX_SETS`). Planned replacements keep the launch interval, spares in orbit that are never used are not replaced at the end of their design life, launches are priced by the masses of the deployment, the phases of a mission are cached by the uncertain values of its replicate, and studies of staged deployments record the `stages deployed`. A deployment is planned with its restoration policy (`DeploymentSchedule.plan(policy=...)`, `Deployment.policy`), whose spares its planned history (`Deployment.planned`), its simulations (`Deployment.simulate(model)`), and its costs share, the options of `DeploymentSchedule.plan` and `ObservationStudy` are keyword-only, `layout_of` is exported, a layout names its pattern (`pattern`), `Stage` takes numpy values, and the development of a staged type that is never deployed is the cost of its option. References to values of designs are in module `references`. + - Fingerprints describe objects by what their `__fingerprint__()` returns (designs, and caches of satellites by their function and namespace), so that a study whose functions use them is evaluated again when they change. Decisions that name no child of a design space raise an error (also those of designs of another space, in a study's space), `errors="record"` records the errors of realizing a design, metrics may not be named `scenario`, replicates and shifts must not be negative, and a design space takes a single constraint. Module `references` reads designs: `configure` and `value_of` are exported, and functions given the design follow one convention (a parameter named `design`). `Design.uncertain_values()` gives the values of a design's uncertain parameters, and `Statistic` and the classes of the steps (`Refinement`, `Confirmation`, `Screening`, `Search`, `Attribution`) are exported. `summarize` gives the spread of the statistics it reports across scenarios (of the worst scenario, or of the weighted mean over the replicates that the scenarios share) and leaves out spreads that are zero for every design. Statistics may not take the names of columns of the results, and `summarize_histories` names the share of histories that meet a requirement `P() histories`. `refine` charges the evaluations of every scenario to its budget (`Refinement.rounds` gives its rounds), `pareto_probability` leaves out of a resample a design without a feasible replicate drawn, `main_effects` orders its bins, searches with pymoo leave the caller's algorithm unchanged, and Optuna's constraints of requirements have distinct names. `exceedance` gives the `shared_replicates` of two designs. A ground spare goes up at the next launch slot, the planes of a stage launch in the order they are ready, and `MissionHistory.deployed` is infinite for a deployment that outlasts the mission. `SatelliteCache` keeps a context with each namespace, `Observations` generates the targets of a replicate only to observe them, an `ObservationStudy` computes the metrics of all of a design's satellites once, exact expectations are faster (module `expectations`), and the options of `Study.run`, `designs_of`, `ResultStore`, `SatelliteCache`, and `Repeat` are keyword-only. + - A `tradespace.Study` may describe its designs (`describe`, a `description` column of the results that summaries keep, outside the fingerprint), and `DesignSpace.enumerate(designs)` gives every design that extends designs of a space it extends (such as each design with each policy). `summarize` gives the statistics of designs with the spreads of their means (or without, `spread=False`) and takes criteria or a mapping of objectives, with metrics and other statistics in `statistics`; `pareto_probability` gives the standard errors of means as `summarize` does, and of other objectives by its bootstrap. `Failures` take statistics over the histories (`Quantile`, `Probability`, and `StandardDeviation`) and require a `seed`, a study's requirements on phases (`phases`) apply with or without failures, and each field of a `MissionPlan` is a value or a reference to the design (also `stages`), with the restoration policy of the design's value `policy` by default. The masses of satellites are given by the plan (`MissionPlan.masses`), `Triangular` takes its `mode` by keyword, the options of the optimizers are keyword-only (`optimize_optuna(n_trials=100)`), `plot_designs` rings the efficient designs (`pareto`) by default and labels designs with `annotate`, and the outcomes of steps give their `results`, `summary`, `designs`, and `criteria` first (`Screening.summaries` gives the summaries of every stage in one frame). The parts of criteria, design spaces, stores, missions, and observations that only the module uses are private, and `DesignSpace` neither encodes designs nor documents the internals of its optimizers. - Trade space tutorial (`docs/examples/tradespace`): eight notebooks that follow one trade of constellations, each adding one idea to those before it: `EvaluateTradeSpace` (design space, study, and Pareto front), `ExplainTradeSpace` (sampling error, revisits, and sensitivity), `SearchTradeSpace` (hypervolume, screening, and optimizers), `RankUncertainDesigns` (probability of efficiency, refinement, confirmation, and requirements on statistics), `CompareScenarios` (scenarios, regret, and searches across scenarios), `TradeCostAndUtility` (costs with uncertain growth, budgets, and utility), `PlanDeployment` (phases and staging), and `PlanForFailures` (failures, restoration policies, and the attribution of variance). Each notebook defines what it introduces, and imports what earlier notebooks defined from `trade_space_example.py`. - The `RunOSSEMonsoon` example declares its constellation trade as a design space, caches the looks of each satellite, evaluates its replicates in parallel, and finds its Pareto-efficient designs. diff --git a/docs/api_reference/tradespace/define.rst b/docs/api_reference/tradespace/define.rst index b0ebaa42..7a31b5f6 100644 --- a/docs/api_reference/tradespace/define.rst +++ b/docs/api_reference/tradespace/define.rst @@ -9,7 +9,7 @@ Design Spaces and Designs ========================= .. autoclass:: tatc.tradespace.DesignSpace - :members: enumerate, size, sample, design, designs_of, extend, suggest, unit_paths, uncertain_paths, check_uncertain, check_overrides, encode, decode + :members: enumerate, size, sample, design, designs_of, extend, uncertain_paths .. autoclass:: tatc.tradespace.Design :members: flat, uncertain_values, realize, values, decisions, scenario @@ -34,7 +34,7 @@ Variables and Values .. autoclass:: tatc.tradespace.Derived .. autoclass:: tatc.tradespace.Uncertain - :members: uniform, normal, choice, seed + :members: uniform, normal, triangular, choice, seed .. autoclass:: tatc.tradespace.Choice @@ -100,7 +100,3 @@ Reading Designs .. autofunction:: tatc.tradespace.value_of .. autofunction:: tatc.tradespace.configure - -.. autofunction:: tatc.tradespace.references.takes_design - -.. autofunction:: tatc.tradespace.references.given_design diff --git a/docs/api_reference/tradespace/evaluate.rst b/docs/api_reference/tradespace/evaluate.rst index 91618b46..cb72ebcf 100644 --- a/docs/api_reference/tradespace/evaluate.rst +++ b/docs/api_reference/tradespace/evaluate.rst @@ -18,10 +18,9 @@ Observation Studies :members: satellites_of, targets_of, observations_of, mission_of, prune .. autoclass:: tatc.tradespace.Observations - :members: end, start_of, end_of, cache_of, context_of, prune, __call__ + :members: start_of, end_of, prune, __call__ .. autoclass:: tatc.tradespace.Targets - :members: of, seed_of The parts of observation studies read the values of designs by references (see :doc:`define` for :py:data:`tatc.tradespace.references.Reference` and @@ -34,19 +33,18 @@ Missions of Designs :no-members: .. autoclass:: tatc.tradespace.MissionPlan - :members: schedule_of, cost_model_of, masses_of, growth_of, stages_of, policy_of, plan_mission + :members: plan_mission .. autoclass:: tatc.tradespace.Failures - :members: seed_of, simulate, evaluate, summarize .. autoclass:: tatc.tradespace.mission.Mission - :members: phases, estimate, histories, metrics, summarize + :members: phases, estimate, histories, capability, requirements Stores of Results ================= .. autoclass:: tatc.tradespace.ResultStore - :members: get, put, define, definition, contexts, remove, clear + :members: clear Caches of Satellites ==================== @@ -55,7 +53,7 @@ Caches of Satellites :no-members: .. autoclass:: tatc.tradespace.SatelliteCache - :members: get, prune, clear_memory, folder, context, contexts, __call__ + :members: __call__, prune, clear_memory, folder, fingerprint, hits, misses .. autofunction:: tatc.tradespace.cache.get_satellite_key diff --git a/docs/api_reference/tradespace/index.rst b/docs/api_reference/tradespace/index.rst index 57e624b2..f219c0f8 100644 --- a/docs/api_reference/tradespace/index.rst +++ b/docs/api_reference/tradespace/index.rst @@ -16,7 +16,7 @@ before:: from tatc.tradespace import ( Criteria, DesignSpace, Integer, ResultStore, Study, Uncertain, - aggregate, confirm, refine, + confirm, refine, summarize, ) space = DesignSpace(planes=Integer(1, 4), per_plane=Integer(1, 4), seed=Uncertain.seed()) @@ -24,7 +24,7 @@ before:: results = study.run() # a row per design and replicate criteria = Criteria({"satellites": "min", "coverage": "max"}) - summary = aggregate(results, criteria) # a row per design, with `pareto` + summary = summarize(results, criteria) # a row per design, with `pareto` front = summary[summary.pareto] refinement = refine(study, criteria, results) # replicates where efficiency is uncertain @@ -66,9 +66,8 @@ take one or the other: * - Take results (a row per replicate) - Take summaries (a row per design) - * - `aggregate`, `summarize`, `pareto_probability`, - `hypervolume_progress`, `robustness`, `exceedance`, `refine`, - `confirm`, `plot_means` + * - `summarize`, `pareto_probability`, `hypervolume_progress`, + `robustness`, `exceedance`, `refine`, `confirm`, `plot_means` - `pareto_front`, `pareto_ranks`, `hypervolume`, `sensitivity`, `main_effects`, `plot_designs` @@ -86,11 +85,12 @@ and columns that TAT-C defines are named in snake case: * statistics over the replicates of a design: named by the criteria, or by convention if given without names (see `Statistic.name`, such as `"cost p70"` for `Quantile("cost", 0.7)`), the means of metrics by - their names, and ` std` and ` se` (by `summarize`, and the - standard error of each objective by `pareto_probability`, left out where - they are zero for every design), and of confirmed designs, ` - selected` (by the replicates that selected them) and ` - optimism`. A statistic other than the mean of a metric must not have the + their names, each mean followed by its spread, ` std` and + ` se` (by `summarize`, and by `pareto_probability`, which gives + the standard error of an objective that is not a mean by its bootstrap, + left out where they are zero for every design), and of confirmed designs, + ` selected` (by the replicates that selected them) and + ` optimism`. A statistic other than the mean of a metric must not have the name of a column of the results. * statistics within a replicate, over the mission of a design (see `ObservationStudy`): ` mission` (the mean over the phases of the diff --git a/docs/api_reference/tradespace/judge.rst b/docs/api_reference/tradespace/judge.rst index 75acefe8..bf3f68d6 100644 --- a/docs/api_reference/tradespace/judge.rst +++ b/docs/api_reference/tradespace/judge.rst @@ -9,13 +9,12 @@ Criteria, Statistics, and Requirements :no-members: .. autoclass:: tatc.tradespace.Criteria - :members: names, metrics, statistic, resolved, of, signs, costs, violation, combiners, tolerance_array + :members: names, metrics .. autoclass:: tatc.tradespace.Requirement :members: met, violation .. autoclass:: tatc.tradespace.Across - :members: weights_of .. automodule:: tatc.tradespace.statistics :no-members: @@ -24,8 +23,6 @@ Criteria, Statistics, and Requirements .. autoclass:: tatc.tradespace.StandardDeviation -.. autoclass:: tatc.tradespace.StandardError - .. autoclass:: tatc.tradespace.Minimum .. autoclass:: tatc.tradespace.Maximum @@ -35,7 +32,7 @@ Criteria, Statistics, and Requirements .. autoclass:: tatc.tradespace.Probability .. autoclass:: tatc.tradespace.Statistic - :members: name, metric, reduce, columns, values_of + :members: name, metric, reduce Summaries ========= @@ -43,8 +40,6 @@ Summaries .. automodule:: tatc.tradespace.summary :no-members: -.. autofunction:: tatc.tradespace.aggregate - .. autofunction:: tatc.tradespace.summarize .. autofunction:: tatc.tradespace.pareto_probability diff --git a/docs/api_reference/tradespace/missions.rst b/docs/api_reference/tradespace/missions.rst index 1d819963..0ffb270f 100644 --- a/docs/api_reference/tradespace/missions.rst +++ b/docs/api_reference/tradespace/missions.rst @@ -46,12 +46,12 @@ Deployment :no-members: .. autoclass:: tatc.tradespace.DeploymentSchedule - :members: plan, production_years, next_slot, per_launch, split, launches_of, mass_capacity_of, design_life_of + :members: plan, launches_of .. autoclass:: tatc.tradespace.Stage .. autoclass:: tatc.tradespace.deployment.Deployment - :members: simulate, simulate_many, expected_metrics, planned, phases, begin, end, deployed, units, stages, policy, capability + :members: simulate, simulate_many, planned, phases, begin, end, deployed, units, stages, policy, capability .. automodule:: tatc.tradespace.events :no-members: @@ -62,13 +62,6 @@ Deployment .. autoclass:: tatc.tradespace.events.Production -.. autodata:: tatc.tradespace.events.PerType - :annotation: - -.. autofunction:: tatc.tradespace.events.per_type - -.. autofunction:: tatc.tradespace.events.per_type_values - .. autoclass:: tatc.tradespace.mission.Decision :members: time, since_launch, stage, satellites_operating, history, stages_deployed, capability @@ -111,28 +104,17 @@ Missions .. autoclass:: tatc.tradespace.mission.Restoration -.. autodata:: tatc.tradespace.mission.PHASE_COLUMNS - :annotation: - .. autofunction:: tatc.tradespace.mission.evaluate_phases .. autofunction:: tatc.tradespace.mission.summarize_phases .. autoclass:: tatc.tradespace.mission.PhaseCache - :members: evaluate, metrics_of, clear + :members: clear .. autoclass:: tatc.tradespace.mission.Capability - :members: evaluate, at, position_names, names + :members: evaluate, names :special-members: __call__ -.. automodule:: tatc.tradespace.simulation - :no-members: - -.. autofunction:: tatc.tradespace.simulation.simulate_histories - -.. autodata:: tatc.tradespace.simulation.SAMPLINGS - :annotation: - .. automodule:: tatc.tradespace.histories :no-members: diff --git a/docs/api_reference/tradespace/search.rst b/docs/api_reference/tradespace/search.rst index 40d61650..f75f7ccd 100644 --- a/docs/api_reference/tradespace/search.rst +++ b/docs/api_reference/tradespace/search.rst @@ -5,7 +5,8 @@ Refinement and Searches Each of these steps takes a study and criteria (or metrics), and returns an outcome (exported for type hints, such as `Refinement`) of its `results`, the `summary` of its designs, the `designs` themselves, which the next step -takes, and its `criteria`. +takes, and its `criteria`, in that order (an `Attribution` gives the +`shares` of the variance of each design, and their `summary`). Adaptive Replication ==================== @@ -13,7 +14,7 @@ Adaptive Replication .. autofunction:: tatc.tradespace.refine .. autoclass:: tatc.tradespace.Refinement - :members: results, summary, rounds, designs, candidates, criteria, evaluations, uncertain, indifferent + :members: results, summary, designs, criteria, rounds, candidates, evaluations Confirmation ============ @@ -21,7 +22,7 @@ Confirmation .. autofunction:: tatc.tradespace.confirm .. autoclass:: tatc.tradespace.Confirmation - :members: results, summary, criteria, designs, optimism + :members: results, summary, designs, criteria, optimism Screening ========= @@ -29,7 +30,7 @@ Screening .. autofunction:: tatc.tradespace.screen .. autoclass:: tatc.tradespace.Screening - :members: results, summary, summaries, history, designs, criteria + :members: results, summary, designs, criteria, history, summaries Attribution of Variance ======================= @@ -40,7 +41,7 @@ Attribution of Variance .. autofunction:: tatc.tradespace.attribute_variance .. autoclass:: tatc.tradespace.Attribution - :members: results, shares, summary, summary_of, differences, designs + :members: results, shares, designs, by, summary, summary_of, differences Optimizers ========== @@ -53,7 +54,7 @@ Optimizers .. autofunction:: tatc.tradespace.optimize_pymoo .. autoclass:: tatc.tradespace.Search - :members: results, summary, designs, evaluated, criteria, state + :members: results, summary, designs, criteria, evaluated, state .. autofunction:: tatc.tradespace.optimization.make_pymoo_problem diff --git a/docs/examples/osse/RunOSSEMonsoon.ipynb b/docs/examples/osse/RunOSSEMonsoon.ipynb index e6e80e40..eebc547f 100644 --- a/docs/examples/osse/RunOSSEMonsoon.ipynb +++ b/docs/examples/osse/RunOSSEMonsoon.ipynb @@ -3151,7 +3151,7 @@ "\n", "OBJECTIVES = {\"satellites\": \"min\", \"planes\": \"min\", \"resolved\": \"max\"}\n", "# the mean shares over the replicates, by design and sensor, and the efficient designs of each sensor\n", - "trade_means = summarize(trade, [\"observed\", \"resolved\"], by=[\"sensor\"])\n", + "trade_means = summarize(trade, statistics=[\"observed\", \"resolved\"], by=[\"sensor\"])\n", "efficient = pd.concat(\n", " [group[pareto_front(group, OBJECTIVES)] for _, group in trade_means.groupby(\"sensor\")]\n", ")\n", diff --git a/docs/examples/tradespace/CompareScenarios.ipynb b/docs/examples/tradespace/CompareScenarios.ipynb index a31e5870..ea75737a 100644 --- a/docs/examples/tradespace/CompareScenarios.ipynb +++ b/docs/examples/tradespace/CompareScenarios.ipynb @@ -41,10 +41,10 @@ "id": "4c97b966", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:44.017812Z", - "iopub.status.busy": "2026-11-14T15:43:44.017812Z", - "iopub.status.idle": "2026-11-14T15:43:46.976490Z", - "shell.execute_reply": "2026-11-14T15:43:46.976490Z" + "iopub.execute_input": "2026-11-15T04:33:44.728113Z", + "iopub.status.busy": "2026-11-15T04:33:44.727957Z", + "iopub.status.idle": "2026-11-15T04:33:47.238570Z", + "shell.execute_reply": "2026-11-15T04:33:47.238053Z" } }, "outputs": [ @@ -62,7 +62,7 @@ "\n", "import pandas as pd\n", "\n", - "from trade_space_example import ACCURACY, DECORRELATION_TIME, MAX_SATELLITES, accuracy_study, describe, sample, space\n", + "from trade_space_example import ACCURACY, DECORRELATION_TIME, MAX_SATELLITES, accuracy_study, sample, space\n", "from tatc.tradespace import Fixed\n", "\n", "field_space = space.extend(decorrelation_time=Fixed(DECORRELATION_TIME))\n", @@ -91,7 +91,7 @@ "source": [ "## Compare the Fronts of the Scenarios\n", "\n", - "Criteria `by` the scenario judge designs in each field: `aggregate` summarizes each design in each field, with whether it is on the front of the field (`pareto`). `robustness` gives the share of the fields in which each design is efficient (its **Pareto trace**). The table gives the designs efficient in more than half of the fields:" + "Criteria `by` the scenario judge designs in each field: `summarize` gives a row per design and field, with whether it is on the front of the field (`pareto`). `robustness` gives the share of the fields in which each design is efficient (its **Pareto trace**). The table gives the designs efficient in more than half of the fields:" ] }, { @@ -100,10 +100,10 @@ "id": "8e021fe5", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:46.976490Z", - "iopub.status.busy": "2026-11-14T15:43:46.976490Z", - "iopub.status.idle": "2026-11-14T15:43:47.214691Z", - "shell.execute_reply": "2026-11-14T15:43:47.214691Z" + "iopub.execute_input": "2026-11-15T04:33:47.240358Z", + "iopub.status.busy": "2026-11-15T04:33:47.240030Z", + "iopub.status.idle": "2026-11-15T04:33:47.357928Z", + "shell.execute_reply": "2026-11-15T04:33:47.357304Z" } }, "outputs": [ @@ -280,15 +280,14 @@ } ], "source": [ - "from tatc.tradespace import Criteria, aggregate, robustness\n", + "from tatc.tradespace import Criteria, robustness, summarize\n", "\n", "BY_FIELD = Criteria(ACCURACY, by=\"scenario\")\n", - "by_field = aggregate(fields, BY_FIELD) # a row per design and field, and whether it is efficient in the field\n", + "by_field = summarize(fields, BY_FIELD) # a row per design and field, and whether it is efficient in the field\n", "print(\"efficient designs:\", by_field[by_field.pareto].scenario.value_counts()[list(FIELDS)].to_dict())\n", "\n", "# a row per design: its share accurately sampled in each field, and the share of the fields in which it is efficient\n", "traced = robustness(fields, ACCURACY).set_index(\"design\")\n", - "traced[\"description\"] = space.designs_of(traced).map(describe)\n", "ACCURATE = [f\"{field} accurate\" for field in FIELDS]\n", "traced[traced.pareto_trace > 0.5].sort_values([\"satellites\", \"planes\"])[\n", " [\"description\", \"satellites\", \"planes\", *ACCURATE, \"pareto_trace\"]\n", @@ -309,16 +308,16 @@ "id": "8b9e713f", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:47.216693Z", - "iopub.status.busy": "2026-11-14T15:43:47.216693Z", - "iopub.status.idle": "2026-11-14T15:43:47.846284Z", - "shell.execute_reply": "2026-11-14T15:43:47.845151Z" + "iopub.execute_input": "2026-11-15T04:33:47.359293Z", + "iopub.status.busy": "2026-11-15T04:33:47.359131Z", + "iopub.status.idle": "2026-11-15T04:33:47.870108Z", + "shell.execute_reply": "2026-11-15T04:33:47.869597Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -342,7 +341,6 @@ " \"satellites\",\n", " \"accurate\",\n", " by=\"layout\",\n", - " front=\"pareto\",\n", " names=LAYOUTS,\n", " jitter=0.18, # spreads the designs of each number of satellites, for legibility\n", " legend=\"lower right\" if ax is axes[0] else None,\n", @@ -380,10 +378,10 @@ "id": "acf5055d", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:47.847847Z", - "iopub.status.busy": "2026-11-14T15:43:47.847331Z", - "iopub.status.idle": "2026-11-14T15:43:48.082891Z", - "shell.execute_reply": "2026-11-14T15:43:48.082891Z" + "iopub.execute_input": "2026-11-15T04:33:47.871376Z", + "iopub.status.busy": "2026-11-15T04:33:47.871141Z", + "iopub.status.idle": "2026-11-15T04:33:48.063602Z", + "shell.execute_reply": "2026-11-15T04:33:48.062897Z" } }, "outputs": [ @@ -525,16 +523,16 @@ "id": "ae6ac96b", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:48.082891Z", - "iopub.status.busy": "2026-11-14T15:43:48.082891Z", - "iopub.status.idle": "2026-11-14T15:43:48.272688Z", - "shell.execute_reply": "2026-11-14T15:43:48.272688Z" + "iopub.execute_input": "2026-11-15T04:33:48.065013Z", + "iopub.status.busy": "2026-11-15T04:33:48.064674Z", + "iopub.status.idle": "2026-11-15T04:33:48.239143Z", + "shell.execute_reply": "2026-11-15T04:33:48.238612Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -596,10 +594,10 @@ "id": "2050e0b0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:48.272688Z", - "iopub.status.busy": "2026-11-14T15:43:48.272688Z", - "iopub.status.idle": "2026-11-14T15:43:49.335684Z", - "shell.execute_reply": "2026-11-14T15:43:49.335684Z" + "iopub.execute_input": "2026-11-15T04:33:48.240517Z", + "iopub.status.busy": "2026-11-15T04:33:48.240373Z", + "iopub.status.idle": "2026-11-15T04:33:49.427820Z", + "shell.execute_reply": "2026-11-15T04:33:49.427022Z" } }, "outputs": [ @@ -607,23 +605,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "147 designs evaluated (in 3 fields each): 99.3% of the hypervolume of the true front, and 8 of its 12 designs\n", + "156 designs evaluated (in 3 fields each): 94.8% of the hypervolume of the true front, and 7 of its 12 designs\n", "the field in which each design is least accurate: {'1 hour': 1028, '3 hours': 68}\n" ] } ], "source": [ - "from pymoo.algorithms.moo.nsga2 import NSGA2\n", - "\n", "from tatc.tradespace import Across, hypervolume, hypervolume_progress, optimize_pymoo\n", "\n", "FIELD_MEAN = Criteria(ACCURACY, across=Across(rule=\"mean\"))\n", "REFERENCE = {\"satellites\": MAX_SATELLITES + 1, \"planes\": 5, \"accurate\": 0} # worse than every design\n", - "mean_summary = aggregate(fields, FIELD_MEAN)\n", + "mean_summary = summarize(fields, FIELD_MEAN)\n", "true_front = set(mean_summary.design[mean_summary.pareto])\n", "true_hypervolume = hypervolume(mean_summary, FIELD_MEAN, REFERENCE)\n", "\n", - "search = optimize_pymoo(field_study, FIELD_MEAN, NSGA2(pop_size=20), (\"n_gen\", 10), seed=1) # 200 proposals\n", + "search = optimize_pymoo(field_study, FIELD_MEAN, seed=1) # NSGA-II: 10 generations of 20, 200 proposals\n", "found = 100 * hypervolume_progress(search.results, FIELD_MEAN, REFERENCE).iloc[-1] / true_hypervolume\n", "evaluated = set(search.results.design)\n", "print(\n", @@ -639,7 +635,7 @@ "id": "13af5d5e", "metadata": {}, "source": [ - "The search finds 99.3% of the hypervolume of the true front of the mean with 147 designs, and 8 of its 12 designs. Each design costs three times as much as in a search of one field, as it is evaluated in each field.\n", + "The search finds 94.8% of the hypervolume of the true front of the mean with 156 designs, and 7 of its 12 designs. Each design costs three times as much as in a search of one field, as it is evaluated in each field.\n", "\n", "A worst case (`rule=\"worst\"`) suits scenarios that are hardest for different designs. Here, the field that varies within an hour is the hardest for 1,028 of the 1,096 designs, so a search by the worst would mostly search that field alone." ] @@ -675,7 +671,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.16" + "version": "3.14.10" } }, "nbformat": 4, diff --git a/docs/examples/tradespace/EvaluateTradeSpace.ipynb b/docs/examples/tradespace/EvaluateTradeSpace.ipynb index 2362dc26..203ab214 100644 --- a/docs/examples/tradespace/EvaluateTradeSpace.ipynb +++ b/docs/examples/tradespace/EvaluateTradeSpace.ipynb @@ -35,10 +35,10 @@ "id": "bc7b296c", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T16:16:57.069687Z", - "iopub.status.busy": "2026-11-14T16:16:57.069687Z", - "iopub.status.idle": "2026-11-14T16:16:59.395918Z", - "shell.execute_reply": "2026-11-14T16:16:59.395918Z" + "iopub.execute_input": "2026-11-15T04:33:07.226541Z", + "iopub.status.busy": "2026-11-15T04:33:07.226413Z", + "iopub.status.idle": "2026-11-15T04:33:09.053417Z", + "shell.execute_reply": "2026-11-15T04:33:09.052892Z" } }, "outputs": [], @@ -84,10 +84,10 @@ "id": "c05d366a", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T16:16:59.397926Z", - "iopub.status.busy": "2026-11-14T16:16:59.397926Z", - "iopub.status.idle": "2026-11-14T16:16:59.523326Z", - "shell.execute_reply": "2026-11-14T16:16:59.523326Z" + "iopub.execute_input": "2026-11-15T04:33:09.054803Z", + "iopub.status.busy": "2026-11-15T04:33:09.054558Z", + "iopub.status.idle": "2026-11-15T04:33:09.114516Z", + "shell.execute_reply": "2026-11-15T04:33:09.114062Z" } }, "outputs": [ @@ -153,6 +153,7 @@ "\n", "* `n_jobs=-1` evaluates designs in parallel, on every processor;\n", "* the `directory` of the `Observations` caches the observations of each satellite on disk, as many designs share satellites;\n", + "* `describe` describes each design in a few words, in a column `description` of the results (a function from the module `trade_space_example.py` beside the notebooks);\n", "* `store` keeps the results in a file: running the notebook again reads them rather than evaluating the designs again (unless the study changes)." ] }, @@ -162,10 +163,10 @@ "id": "374124d4", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T16:16:59.525318Z", - "iopub.status.busy": "2026-11-14T16:16:59.525318Z", - "iopub.status.idle": "2026-11-14T16:16:59.539373Z", - "shell.execute_reply": "2026-11-14T16:16:59.539373Z" + "iopub.execute_input": "2026-11-15T04:33:09.115786Z", + "iopub.status.busy": "2026-11-15T04:33:09.115598Z", + "iopub.status.idle": "2026-11-15T04:33:09.178395Z", + "shell.execute_reply": "2026-11-15T04:33:09.177898Z" } }, "outputs": [], @@ -173,6 +174,7 @@ "import tempfile\n", "from pathlib import Path\n", "\n", + "from trade_space_example import describe\n", "from tatc.generation import generate_points_fibonacci_lattice\n", "from tatc.schemas import Instrument\n", "from tatc.tradespace import ObservationStudy, Observations, ResultStore, Targets, build_constellation\n", @@ -206,6 +208,7 @@ " replicates=N_REPLICATES,\n", " n_jobs=-1,\n", " store=ResultStore(CACHE_DIRECTORY / \"results.sqlite\"),\n", + " describe=describe, # a description of each design, in the results\n", ")" ] }, @@ -225,10 +228,10 @@ "id": "8967e528", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T16:16:59.541361Z", - "iopub.status.busy": "2026-11-14T16:16:59.541361Z", - "iopub.status.idle": "2026-11-14T16:17:00.215515Z", - "shell.execute_reply": "2026-11-14T16:17:00.214520Z" + "iopub.execute_input": "2026-11-15T04:33:09.179594Z", + "iopub.status.busy": "2026-11-15T04:33:09.179434Z", + "iopub.status.idle": "2026-11-15T04:33:09.661432Z", + "shell.execute_reply": "2026-11-15T04:33:09.660991Z" } }, "outputs": [ @@ -366,7 +369,7 @@ "\n", "The objectives are fewer satellites, fewer planes, and more points sufficiently sampled. A design is **Pareto-efficient** if no other design is as good in every objective and better in one.\n", "\n", - "`summarize` averages the replicates of each design by the objectives, given whether each is minimized or maximized: a row per design, with the mean of each metric, its standard error (`se`, the uncertainty of the mean), and whether the design is efficient (`pareto`). The rows keep the values of the designs, from which `space.designs_of` rebuilds them (and `describe`, from the module `trade_space_example.py` beside the notebooks, describes each in a few words)." + "`summarize` averages the replicates of each design by the objectives, given whether each is minimized or maximized: a row per design, with the mean of each metric, its standard error (`se`, the uncertainty of the mean), and whether the design is efficient (`pareto`). The rows keep the values of the designs, from which `space.designs_of` rebuilds them, and their `description`." ] }, { @@ -375,10 +378,10 @@ "id": "9e23a64a", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T16:17:00.216514Z", - "iopub.status.busy": "2026-11-14T16:17:00.216514Z", - "iopub.status.idle": "2026-11-14T16:17:00.482788Z", - "shell.execute_reply": "2026-11-14T16:17:00.482788Z" + "iopub.execute_input": "2026-11-15T04:33:09.662621Z", + "iopub.status.busy": "2026-11-15T04:33:09.662461Z", + "iopub.status.idle": "2026-11-15T04:33:09.687214Z", + "shell.execute_reply": "2026-11-15T04:33:09.686685Z" } }, "outputs": [ @@ -497,12 +500,10 @@ } ], "source": [ - "from trade_space_example import describe\n", "from tatc.tradespace import summarize\n", "\n", "OBJECTIVES = {\"satellites\": \"min\", \"planes\": \"min\", \"sufficient\": \"max\"}\n", "summary = summarize(results, OBJECTIVES) # a row per design, and whether it is efficient\n", - "summary[\"description\"] = space.designs_of(summary).map(describe)\n", "front = summary[summary.pareto].sort_values([\"satellites\", \"planes\"])\n", "front[[\"description\", \"satellites\", \"planes\", \"sufficient\", \"sufficient se\"]].round(1)" ] @@ -521,16 +522,16 @@ "id": "6f877e2d", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T16:17:00.484781Z", - "iopub.status.busy": "2026-11-14T16:17:00.484781Z", - "iopub.status.idle": "2026-11-14T16:17:00.617407Z", - "shell.execute_reply": "2026-11-14T16:17:00.617407Z" + "iopub.execute_input": "2026-11-15T04:33:09.688290Z", + "iopub.status.busy": "2026-11-15T04:33:09.688127Z", + "iopub.status.idle": "2026-11-15T04:33:09.801760Z", + "shell.execute_reply": "2026-11-15T04:33:09.801195Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -581,16 +582,16 @@ "id": "523cddaa", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T16:17:00.617407Z", - "iopub.status.busy": "2026-11-14T16:17:00.617407Z", - "iopub.status.idle": "2026-11-14T16:17:00.776663Z", - "shell.execute_reply": "2026-11-14T16:17:00.776663Z" + "iopub.execute_input": "2026-11-15T04:33:09.802897Z", + "iopub.status.busy": "2026-11-15T04:33:09.802729Z", + "iopub.status.idle": "2026-11-15T04:33:09.926054Z", + "shell.execute_reply": "2026-11-15T04:33:09.925387Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -608,8 +609,7 @@ " \"satellites\",\n", " \"sufficient\",\n", " by=summary.planes.clip(upper=3), # 3 or 4 planes share a color\n", - " front=\"pareto\",\n", - " labels=lambda row: f\"{row.satellites:.0f} sat., {row.planes:.0f} pl.\",\n", + " annotate=lambda row: f\"{row.satellites:.0f} sat., {row.planes:.0f} pl.\",\n", " names=PLANE_GROUPS,\n", " jitter=0.18, # spreads the designs of each number of satellites, for legibility\n", " legend=\"upper left\",\n", @@ -678,7 +678,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.16" + "version": "3.14.10" } }, "nbformat": 4, diff --git a/docs/examples/tradespace/ExplainTradeSpace.ipynb b/docs/examples/tradespace/ExplainTradeSpace.ipynb index 955af84b..e697733e 100644 --- a/docs/examples/tradespace/ExplainTradeSpace.ipynb +++ b/docs/examples/tradespace/ExplainTradeSpace.ipynb @@ -36,10 +36,10 @@ "id": "99a62858", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:08.922061Z", - "iopub.status.busy": "2026-11-14T15:43:08.922061Z", - "iopub.status.idle": "2026-11-14T15:43:12.082392Z", - "shell.execute_reply": "2026-11-14T15:43:12.082392Z" + "iopub.execute_input": "2026-11-15T04:33:11.599761Z", + "iopub.status.busy": "2026-11-15T04:33:11.599589Z", + "iopub.status.idle": "2026-11-15T04:33:14.062109Z", + "shell.execute_reply": "2026-11-15T04:33:14.061547Z" } }, "outputs": [], @@ -55,7 +55,6 @@ " PLANE_GROUPS,\n", " SAMPLES_PER_DAY,\n", " START,\n", - " describe,\n", " designs,\n", " space,\n", " study,\n", @@ -84,8 +83,7 @@ "\n", "accuracy_study = study.replace(metrics=sample)\n", "results = accuracy_study.run(designs)\n", - "summary = summarize(results, [\"satellites\", \"planes\", \"sufficient\", \"accurate\"])\n", - "summary[\"description\"] = space.designs_of(summary).map(describe)" + "summary = summarize(results, statistics=[\"satellites\", \"planes\", \"sufficient\", \"accurate\"])" ] }, { @@ -102,16 +100,16 @@ "id": "7326121b", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:12.082392Z", - "iopub.status.busy": "2026-11-14T15:43:12.082392Z", - "iopub.status.idle": "2026-11-14T15:43:12.224209Z", - "shell.execute_reply": "2026-11-14T15:43:12.224209Z" + "iopub.execute_input": "2026-11-15T04:33:14.064848Z", + "iopub.status.busy": "2026-11-15T04:33:14.064078Z", + "iopub.status.idle": "2026-11-15T04:33:14.184895Z", + "shell.execute_reply": "2026-11-15T04:33:14.184235Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -157,10 +155,10 @@ "id": "715976e0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:12.224209Z", - "iopub.status.busy": "2026-11-14T15:43:12.224209Z", - "iopub.status.idle": "2026-11-14T15:43:12.240256Z", - "shell.execute_reply": "2026-11-14T15:43:12.240256Z" + "iopub.execute_input": "2026-11-15T04:33:14.186107Z", + "iopub.status.busy": "2026-11-15T04:33:14.185932Z", + "iopub.status.idle": "2026-11-15T04:33:14.196128Z", + "shell.execute_reply": "2026-11-15T04:33:14.195640Z" } }, "outputs": [ @@ -394,10 +392,10 @@ "id": "92827f66", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:12.242261Z", - "iopub.status.busy": "2026-11-14T15:43:12.242261Z", - "iopub.status.idle": "2026-11-14T15:43:12.319088Z", - "shell.execute_reply": "2026-11-14T15:43:12.319088Z" + "iopub.execute_input": "2026-11-15T04:33:14.197231Z", + "iopub.status.busy": "2026-11-15T04:33:14.197070Z", + "iopub.status.idle": "2026-11-15T04:33:14.286669Z", + "shell.execute_reply": "2026-11-15T04:33:14.286118Z" } }, "outputs": [ @@ -531,16 +529,16 @@ "id": "5555b886", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:12.319088Z", - "iopub.status.busy": "2026-11-14T15:43:12.319088Z", - "iopub.status.idle": "2026-11-14T15:43:12.476747Z", - "shell.execute_reply": "2026-11-14T15:43:12.476404Z" + "iopub.execute_input": "2026-11-15T04:33:14.287955Z", + "iopub.status.busy": "2026-11-15T04:33:14.287791Z", + "iopub.status.idle": "2026-11-15T04:33:14.442913Z", + "shell.execute_reply": "2026-11-15T04:33:14.442323Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -598,10 +596,10 @@ "id": "40126ee8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:12.477750Z", - "iopub.status.busy": "2026-11-14T15:43:12.477750Z", - "iopub.status.idle": "2026-11-14T15:43:12.508123Z", - "shell.execute_reply": "2026-11-14T15:43:12.508123Z" + "iopub.execute_input": "2026-11-15T04:33:14.444051Z", + "iopub.status.busy": "2026-11-15T04:33:14.443895Z", + "iopub.status.idle": "2026-11-15T04:33:14.461577Z", + "shell.execute_reply": "2026-11-15T04:33:14.461057Z" } }, "outputs": [ @@ -731,16 +729,16 @@ "id": "b1adf213", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:12.508123Z", - "iopub.status.busy": "2026-11-14T15:43:12.508123Z", - "iopub.status.idle": "2026-11-14T15:43:12.602035Z", - "shell.execute_reply": "2026-11-14T15:43:12.602035Z" + "iopub.execute_input": "2026-11-15T04:33:14.462929Z", + "iopub.status.busy": "2026-11-15T04:33:14.462770Z", + "iopub.status.idle": "2026-11-15T04:33:14.553390Z", + "shell.execute_reply": "2026-11-15T04:33:14.552788Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAvkAAAGbCAYAAABeaI+0AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjIsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvgI3uAAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAeexJREFUeJzt3Qd4FNXXBvCTQu819N6RojRp0gVBpEhTQBEQRUAQFOmggAoWFP9KFQWUKh1sFAsIAqKAIEWkE4ih95Jkvuc9frPOLrvJbgrZnby/5wlkd2dn7tydJOfee+6dIMMwDCEiIiIiItsITu4CEBERERFR4mKQT0RERERkMwzyiYiIiIhshkE+EREREZHNMMgnIiIiIrIZBvlERERERDbDIJ+IiIiIyGYY5BP5MdzG4vLly/o/ERERkbcY5BP5sStXrkiWLFnk0qVLyV0UW4iJiZHTp0/q/8S69Ce8Nlmf/ozXZ2DWJ4N8IiIiIiKbYZBPRERERGQzDPKJiIiIiGyGQT4RERERkc0wyCciIiIishkG+URERERENsMgn4iIiIjIZhjkExERERHZDIN8IiIiIiKbYZBPRERERGQzDPKJiIiIiGyGQT4RERERkc0wyCciIiIishkG+URERERENsMgn4hSlNDQVMldBNtgXbI+/RmvT0rpQpO7AEQUt+BgtscTqx5z5QrjJce69Du8Nlmf/io6xpCg5C4ExQuDfKIAMHJJuJy6ei65i0FERClIsdypZWLH/BITYyR3USgeGOQTBYCjkbfl0AX+kiUiIiLvMAeAiIiIiMhmGOQTEREREdkMg3wiIiIiIpthkE9EREREZDMM8omIiIiIbIZBPhERERGRzTDIJyIiIiKyGQb5NhYTEyNnzpyR8+fPy82bN+XUqVM+vf/27dty8uRJMQzP67NHRUXpNjhWYsIxzbLbydmzZ+Xy5cvJXQwiIiKyOQb5NrVkyRLJkSOH3H///TJ06FBZt26dFC9e3Kd9/Pbbb1KwYEG5du2ax23279+v2yRmML548WLJnj27o+x20qlTJ5k4cWJyF4OIiIhsjkG+Tb3yyisybtw4OX36tEybNk3SpUsnBQoUkEAwePBgp7ITERERkW8Y5NvMnTt3NH3m2LFj2huO7/FVunRp+fHHH92+59KlS3Ljxg2vj4EUnQsXLiQoFQdpK67HdFf2uMp169Yt3c4sF1J8kGZkQhoRjhVbOhFGKq5fv67fX7lyRSIjIx2vXb161VGHqCd3Ll68KOfOndPvsR+UwQp1hbIRERER3SsM8m1m37598uCDD2pQ++KLL+r3+KpcufJd6TobN26UihUrSr58+SRXrlxSu3ZtfX9sPvvsM922UKFCkjdvXlmwYIHPqTh4b9GiRSVLlizSrl07DZKtZUcjwCz7999/H+v+cA5IF3rzzTc1PalKlSqyd+9efe3dd9+V3LlzS6lSpSRz5szSq1cvp9QjNBCeeuopLQfqoHr16vLCCy9ImzZtHNssXLjQUYcYCSlSpIisXLnSqQwjRoyQtm3b6leePHmkefPm+nx4eLjUqVNH6wtfHTt2ZD4+ERER3ROh9+YwdK8gaEevc1BQkMyfP18aN26sz69evVoDatOhQ4ekRYsWMmXKFHnyySe1UTBs2DBp1aqV/PHHH5ImTZq79o0gvGfPnjJr1izp2rWrHDlyRBo1auR12Q4ePKjHmjx5sjz//POajtO0aVPp37+/zJ4922PZvbF582Z9b6ZMmfQxzuujjz6Sn376ScqVK6e984899pie4wcffKDbvPPOO7J+/Xo937Jly8ry5cvl8ccfl5o1azr226NHD/0yzZ07Vzp37iwHDhzQhoEJx8F+v/zySwkO/rftjPelSpVKe/kzZMggr776qixatEgefvhhj+eBhge+TOYk3VolM0ipW2m9rg8iIqL4unIjWs5ejZZiuVOzEgOZQbaEj3bt2rWOx6tWrTLSpEnjePzSSy8ZDRs2NE6fPm2Eh4cbp06dMo4cOWKEhoYav/zyi26zZcsW3c+VK1f0cf/+/Y3atWs7HWfq1Km6TWRkZJxlGjBggFG1alWn51asWGEEBQUZ58+f91j22GA7bL9v3z6n54sWLWpMnDjR6fxmzJhh5MmTx7FNwYIFjbffftvpfc2bN7/rHOHOnTu6nxMnThjFihUz5s2b53itT58+RunSpZ22R12iXNu3b3c8d+PGDSNbtmzG8OHDPZ7P6NGj9X2uX5cuXfKqPoiIiBIqJjrK8X1UdIwRHR1thIef0P8p4e5VfbInP4VC7/W2bdukatWqTs+HhYU55aS79sRXqFDB6blKlSp5fUz0fiNtyOqBBx7Q9ByMLFSrVk3iq0SJEo7vkZKDUYa3337b0WtvCg0N1dx/jFyg59/1fDCagBQg6zlj1GHTpk2a8pM2bVr5559/HPMA3B3ffB9Y94/3InUoNlhNaODAgU49+UhHujJ3nERfCveyNoiIiOInNE9RydR9rONxSHCQxMR4Xkqb/BeD/BQqJCRE03V8yalHCo91Uiu4Pvb1/WZqirv0IF8geDeZ6TJIC8KSle5gIizqwFN5TN26ddMAHpN3EeQDUnuio6M9Ht96Pti/9dziqi9s664uoiKOSXTk4VjfS0RERGTixNsUChNJN2zYcNdEUPSqe7r5FXq5kftufd3a6x0X9PqjR9y60g1W/EmfPv1dPeEJgeVCcSzk2Lsyj42gvEyZMno+Vq6Pd+/eLR06dHAE+Lih2N9//x1nGdAQwDFwviY0FOKa2ExERESUGBjkp1D9+vXT4Lply5byww8/aPCJlWSwwoynZSv79OmjQS7eu2fPHp0ci5QYX46JlXSwyg3ShVasWCFDhgzRNf1RlsQ0YcIEvSHYyy+/LDt37pQdO3boRFuspmPCRNgPP/xQ5syZI3/++adOyt2+fbtO/DUhnQkjAjhfBOxYQceb5TCxqg8m3vbt21cn9+LGYpiw68vIBxEREVF8MV3HpvLnz6854CbXm2FhucmtW7fK+PHjNfhG+gnuMDt9+nRHwI20EezHTH9B4Io75yJvHKvQoLd65syZMmDAAE19iQuOiVVoRo0aJa1bt5asWbPqja+sOejuyh4bbIftXWHVHhwLjZD27dtLtmzZpEGDBk45+l26dNG177HUJgL7unXrSu/evXXugAmr/qChgPJiH3gPzsPs2Qc8f/PmzbvK8P7772vDAfvMmTOnrm6EbbFkJxEREVFSCsLs2yQ9ApGfwqVv7bUHLAmKxsv//vc/8QdIp0Kj4OjIDpKBOflERJTEQgqWlmzDPr8r1TUiIlzCwvI5Ov4o/u5VfbInnxLN+fPnHXeOdYV14tGL7Q/7NGEFnrFjx2r6EPY1b9487f1Hzz4RERFRIGOQT4kGaTxr1qxx+xpugjVx4kS/2KepWLFi0rBhQ50XgGUxS5curRNvXZf5JCIiIgo0TNch8mNM1yEionuJ6Tr2SddhYhURERERkc0wyCciIiIishkG+URERERENsMgn4iIiIjIZhjkExERERHZDIN8IiIiIiKb4Tr5RAEgNKywhKRNldzFICIimwvNUzS5i0CJhEE+UQDI1HWEZM6cObmLQUREKYAREy1BwSHJXQxKIKbrEAXIjTMoceoxMjKC9cm69Du8Nlmf/oQBvj0wyCeiFCUq6k5yF8E2WJesT3/G65NSOgb5REREREQ2wyCfiIiIiMhmGOQTEREREdkMg3wiIiIiIpthkE9EKUpoKO83wLr0T7w2WZ9EiYnr5BMFgOBgtscTqx5z5QpLlH2ldKxL1qc/C5TrMzrGkJDgoOQuBtkUg3yiADBySbicunouuYtBRESJpFju1DKxY37WJyUZBvlEAeBo5G05dMFI7mIQERFRgGAOABERERGRzTDIJyIiIiKyGQb5REREREQ2wyCfiIiIiMhmGOQTEREREdkMg3wiIiIiIpthkE9EREREZDO2D/KHDBkihw4dSu5i+GV93L59Wx+fOHFCUrKPP/5Yvv/+++QuBhEREVGisX2QP2HCBDl69Kj4m5iYGA2wDx8+nGz1gSAfj0+dOiUp2Zw5c+Tnn39O7mIQERERJRrbB/n+CkE+Auzjx48nd1GIiIiIyGZCJYUZP368XLlyRYKDg6VgwYLyyCOPSJEiRRyvf/TRR1KsWDF93uqtt96SWrVqyUMPPaSP0fOLFA/s5+GHH5aqVas6tr1w4YIG8K+88orkyJHD8fzIkSOlc+fOUqZMGRk7dqw+N336dPnmm28kd+7cMnDgQKdjLliwQNKkSSNt2rTRx9u3b5clS5bICy+8IIUKFdLnpk6dKqVLl5YGDRrEeW7e2Lt3r8ydO1eeeeYZ3S96+5cuXSr79++XvHnzSsuWLSVfvnyO7b/66iuJiIiQevXqybJly+TatWsyatQop32+//77Uq1aNTEMQzZv3iypUqWSJ598UsLCwpy2w35wrH/++UdKlSolbdu21fN33Q8aSD/88IOUKFFCnnjiiVjPx9tjW+H8UQ9BQUH6udStW9fp87XuNzQ0VDZu3Kj7bdeuneTPn9+ncyIiIiJKCimuJz9LliySNWtWyZAhgwZnFStW1IDRdP78eQ3Orfbs2SNDhw6VnDlzOoL1pk2bagCHfPY6derIu+++69j+0qVLGuQj2Ld6++23HfnwKAdkzJhRy5MpU6a7ynrs2DF58803HY9nzZql+129erU+jo6OlsGDB8vNmze9Ore4/PLLL9qIyZYtmwb4Z8+elSpVqmjOOo6Ffd53330aLJs2bNggI0aM0Po4ffq0ZM6c+a79zpw5UxsNffr0kYsXL2pjAGXD+Zmw73Llyun/ONaUKVP02JcvX3baT/fu3bUxFBUVpecZF2+O7Qr7RT2iPvF5NW7cWIN61/326NFDXnrpJf280dipUKGCnDlzxqdzIiIiIkoKQQa6OG0MvbFr167VQM0d9Kh/++23smnTJn2M/PTChQtrIFu9enV9DoHcli1bNAg+cOCAlC9fXgPtZs2a6euff/65PPvss/LXX39JgQIFNOe9aNGi+hi9zaa0adPKl19+KY8++qgGqej9xWhA/fr13ZZt69atUrt2bW14IHguW7asFC9eXNKnTy+LFi1yvI7GhLtGguu5udbH1atX9X04NwSqHTp00MZKz549dVsE1AhIUWbTuHHjZPny5fLrr7/q45dfflkmT54s+/bt07K5g4YBRhiwDcqOnng0JlA3n332mdYF3ovGk3lsXJbYBiMEOKa5n5CQENmxY4f2oHsjrmPDgw8+qJ8JGivuoL4wmnLu3DlHLzz2i88EdYuRE+wXDaNevXppI9Hbc3J169Yt/TKh/jEq89bSQ3L2VlqvzpmIKDlcuREtZ69Gs/K9VCx3apnY0Xn011/hb1xERLiEheXTv3kUGPWZ4tJ1kH6ycuVKOXjwoAZQR44c0Z56E9ItELyj1xxB/p07dzSIRyoMrF+/XlM4zAAfkP7x3HPPaY9tXOkjvkCKCAJT7BffY5IuytWqVSsNGNFLj55hM8CP69w8WbhwofZMz549W9NJTOj1RqoKgl8cD1/oAd+1a5fWCxopUKlSJY8BvgmpLDgXwAX91FNPyZgxY/QxGgyYm4AUGeuxECgjRcnqscce8zrA9+bYnuBz/v333zWwx0gJ0pBQn0i1MrVo0cLxw4n/0fgzRwh8OScrjNy89tprdz3fu1Eut6MkRET+woiJlqDgkOQuRkCJjjEkJDgouYtBNpWignwEvui1RW9skyZNNCUD6TLoxbZCz2u3bt1k0qRJmoZx/fp16dSpk76GlBTXfG4EeLly5dLXEhN6rdFTj95+9LojBxzlRwsQwSOCfHMUwNtzcwe5/8gXtzZc0JuM9BZzPyakpOALZTBZ5x14goaRFeoQ6U4IfPG/uR9rAI/GjGuOuzfH8uXYGNlw1yjYtm2btG7dWt+LERhAfVi5pguh7AjiwZdzskJamHVuhtmTf2XuOIm+FO7jmRMR3RuheYpKpu7/zjXzB/gbde5cpOTIkcuve54Z4FNSSlFB/ooVKxw93GYvNFI20DtuhdQN9Pxikuv8+fM16DN7UZGO4xrMI7BDUIfXwNy3GfABeoPR+21yF1y6gyB+8eLF2pOMybV4H3rX161bp5N/X3zxRZ/OzR1sh8my6Jles2aNnjsaC8hJR1oK8v4TyrXOwsPDdSIvzsdsNKGXHvnyiS22Y7tCihU+97///lsnYAMmHcfV8+8qvueEenc3MTcq4phER97b5VaJiAJZVNR/f3OJUiL/bd4mAfROI7Azgzukt2B1G1foeX366aflnXfe0Zx25Kab0EuOHHikspg+/fRT7XVHrjUggETvL3LHTQgcrb3f2B495K6TMJHfjqDeGuQjbQQjCgjyzeewHUYYMOnXl3NzB8H8d999pw0JNHCwX0CO/v/+9z+dgGvCOfz000+x7g85+++9957Tczgnc1QBjR00Ppo3b66PkYqEOQyYQ4AJqib0nOPcEyq2Y7sy8+GtPT8ffvihz8dM6nMiIiIiik2KCvKRfoEgFT3h/fr1kwceeEAntbqDlJ3du3frEpTmspmA3l1MmkQePnK78X/fvn01qDV7bxEgYvJl79695fnnn9dUH6T+uOaSo8GA9AxMXjWDYgSg6E23BotIC8GqLTVr1nQE+eixt+bj+3JusQX6mKRqBvpYDQiTkJFrjpVk0NjB99guNlgS1LWBgbQVpBth+c8aNWro+YwePVpfQ70gEMfIxP3336/12b59ez33xEiBiu3YrrAaDuq3UaNGOkqChhXy832V1OdERERElKLTdTCRsWTJkvo9lsDERFSktqBHFZNM0duKnHRXmEiaJ08eXX7RNa0DATzWoEdOPAJ6pHIgp93q9ddfl4YNG8off/yhDQWspY8eYayQY8JxURZM0DSD9f79+zvlkKPHH2v3owc6Xbp0+hzSP7CUpjUNxNtzs9YH0kLw2FxzH/n3WEkGATpGIdBgQK89vnbu3KmvDx8+3GmSLVJ8zFWITFiJBg0QKzQQUB9YoQiBLsqH/ZmwPZar/Prrr7U+EFzPmDHDaRuscoRJvr6K69hYXtM8J3yeqAOMRqAcCPjx2WFEw6wnT2Xp0qWL4zPy9pyIiIiIkoLtl9CML/TeIqUDy2Ei/YbiD3n9GBkZMGBAijp2YkA6F0ZZjo7sIBmYk09EfiqkYGnJNuxz8Rdc8pH16c+4hGYywTr5SK3BspLo4WWA77+wXCVuMOUJRlOIiIiIUiLbp+v4CukxWA4TN4V6/PHHk7s4thDfNBtvPqvYUl+QZpVUxyYiIiLyZ0zXIfJjTNchokDAdB17Y/pTYNZnilpdh4iIiIgoJWCQT0RERERkMwzyiYiIiIhshkE+EREREZHNMMgnIiIiIrIZLqFJFABCwwpLSNpUyV0MIiK3QvMUZc0Q+RkG+UQBIFPXEZI5c+bkLgYRkUdGTLQEBYewhoj8BNN1iAJkTV1KnHqMjIxgfbIu/Y4drk0G+ET+hUE+EaUoUVF3krsItsG6ZH0Skf9ikE9EREREZDMM8omIiIiIbIZBPhERERGRzTDIJyIiIiKyGQb5RJSihIbyfgOsS//Ea5OIEhPXyScKAMHBbI8nVj3myhWWKPtK6ViXrM97LTrGkJDgoHt+XKJAxSCfKACMXBIup66eS+5iEBEli2K5U8vEjvlZ+0Q+YJBPFACORt6WQxeM5C4GERERBQjmABARERER2QyDfCIiIiIim2GQT0RERERkMwzyiYiIiIhshkE+EREREZHNMMgnIiIiIrIZBvlERERERDbDIJ+IiIiIyGYY5JOtNGzYUCZOnJjcxSAiIiJKVgzyyVauX78ut2/fFn/00EMPyXvvvZfcxSAiIqIUgEE+0T3izw0QIiIishcG+WRrTzzxhGTMmFEyZcokxYsXl+7du8s///zjeB2pPVWrVr3rfc2bN5f+/fvr9zdv3pRBgwZJkSJFJGfOnPranj17nLbHvhcuXOj03COPPCJjx47V79u0aSO///67jB49WsuDr0uXLiXRWRMREVFKxyCfbO3TTz+VM2fOyOnTp2X16tUa4Hfp0sWpEYDge9u2bY7njh49Kt9884106tRJH7/44ouycuVKmT9/vvz666+SJ08ezf23BunXrl2TO3fuOB37xo0bcuvWLf0e761UqZIMHz5cy4OvLFmy3IMaICIiopQoNLkLQJSU0qZN6/i+bNmy8vHHH0vhwoXl7Nmz2itfsGBBadq0qcyaNUuqV6/uaBiUKVNGatasqcE4XkOQj8cwdepU7dWfMWOGvPzyy16XIzg4WFKnTq29+J6gUWA2DODy5cv6f62SGaTUrf/OhYi8d+VGtJy9Gs0qC2DFcqdO7iIQBRwG+WRru3btkjFjxmhv/blz58QwDH3+2LFjGuRDz549NY1n0qRJGozPnj1b+vbtq6/t27dPoqOjpVatWo59IlCvVq3aXSk7ieHNN9+U11577a7nezfKJZkzZ0704xGlBEZMtAQFhyR3MSiBomMMCQkOYj0SeYlBPtl6ouvDDz+sKTkTJkyQ3Llza4oNeuGtqTUtW7bU4H7JkiUSFhYmp06dkq5du+prMTEx+n9IiHOAgMcI/mNjNih8MXToUBk4cKBTTz5GG67MHSfRl8J93h9RSheap6hk6v7v3Bh/ht81585FSo4cuXTUj+7GAJ/INwzyybbQC48c/HHjxjlSZKy596ZUqVLJ008/rWk6CPJbtGih/0Pp0qX1/x07dkj9+vUdf4wxMoARAFPWrFmdcvQR4B85ckTq1q3reC40NNTRaPAkTZo0+uUqKuKYREcejkctEFGgiIpyntdDRJQQ7C4g20IPOAL4efPmaXD9559/yoABA9xui4D9hx9+kKVLl2rqjqlAgQLSoUMHXV0HE3IxmRaTZ5H68+yzzzq2Q77+Z599prn+2GbUqFFy4sSJu8qze/fuOAN9IiIiooRikE+2hfScmTNnasCNPPrGjRtrj707JUuW1F73bNmy6RKZVtOmTdOJuJi4i6U4sfLOmjVrdP+mN954Q1fLyZ8/v6YDIc2mRo0aTvsZPHiwjgCkS5eOS2gSERFRkgoy4pM4TOSn0IuOtBj04FshB9987urVq5I+ffq78l6rVKmiDQHk77uDH5WoqKi79m2FPH0zfx9lwfdoYLiWBSvoxLbKjgmNBTQejo7sIBmYrkPks5CCpSXbsM/9vuYwwhcRES5hYfmYk8/69Du8PgOzPpmTT7aCXnJ3rIG5u+Aaa+gjlWbZsmUe9x0UFBRrgO86QTe2ssS1HyIiIqKEYJBPKR56ytG7jiU0CxUqlOLrg4iIiAIfg3xK8cLDw7XXncvWERERkV0wyKcUL0OGDCm+DoiIiMheuLoOEREREZHNMMgnIiIiIrIZBvlERERERDbDIJ+IiIiIyGYY5BMRERER2QxX1yEKAKFhhSUkLW+gReTzz06eoqw0IkqRGOQTBYBMXUdI5syZk7sYRAHJiImWoOD/7kZNRJQSMF2HKADExMQkdxFsU4+RkRGszxRWlwzwiSglYpBPRClKVNSd5C6CbbAuiYj8F4N8IiIiIiKbYZBPRERERGQzDPKJiIiIiGyGQT4RERERkc0wyCeiFCU0lPcbYF0SEdkf18knCgDBwWyPJ1Y95soVlij7Sun8tS6jYwwJCQ5K7mIQESU7BvlEAWDkknA5dfVccheDyK8Vy51aJnbMn9zFICLyCwzyiQLA0cjbcuiCkdzFICIiogDBHAAiIiIiIpthkE9EREREZDMM8omIiIiIbIZBPhERERGRzTDIJyIiIiKyGQb5REREREQ2wyCfiIiIiMhmGOQn0GeffSanT59OnE/DZvURFRWljyMjI5O7WLJmzRrZvXt3cheDiIiI6J5gkJ9AzzzzjOzdu1f8jWEYGmCfOXMm2erj5s2b+vjvv/+W5DZ27FhZuXJlcheDiIiI6J5gkG9T0dHRGmDv378/uYtCRERERPdY6L0+oN0tXLhQbty4IcHBwVKwYEGpXr26ZMiQwfE6epMLFSoklStXdnrfsmXLpFixYlKpUiV9jJSXn3/+WfdTt25dyZUrl2Pbq1evypdffimPP/64ZMqUyfH83LlzpUGDBlKgQAFZsGCBPvfNN9/I0aNHJUuWLNKmTRunY/7www+SLl06qVGjhj4+dOiQbNq0SVq2bCk5cuRwvD9v3rxarrjOzRv//POPfPXVV3pOxYsX1+d27typjREcB2VJmzatY/tff/1VLly4IDVr1pQff/xRLl++LE888YTTPlesWCElS5bUc9yxY4ekSpVKGjVqJKlTp/ZYjg0bNsjx48clKChIcufOLVWqVNH/3e03e/bsWg7s96GHHtI6s7pz547WG86tVKlScv/99991PLz/8OHDUqRIEalatarWIREREVFSYZCfyDZv3iyXLl3SnvQ///xTA7+vv/5a7rvvPn39p59+ki1btmgAbzp27JgG7OZzs2bNkj59+kidOnU0r71r166aetO+fXt9/ezZs9pLj9etQf6zzz6rwT+CfHNfCKCRsoMA2jXI//777zVwRrAPU6ZMkffee08+/fRT6datm6b84NhTp07VID+uc4sLGhsPP/ywBvjYLxoMnTp1kt9++00efPBBfR37X716tQbLgMYKGkYIikuUKKENJNcgf/jw4ZI1a1atx2rVqun+MmfOrOeFAN2dPXv26HZw4sQJ2b59u543PgfrfvF+NLjQKNu1a5eWA9ua9X7w4EFp0aKFHg+Nlq1bt0rFihVl6dKl2ihAXbVu3Vo/h1q1aumx8DwaOr42kIiIiIi8xSA/kX3wwQdOj/v27SuDBw/WoA569uwp7777rhw4cEBKly6tzyG4xPforQ4PD5d+/frJ5MmTNWiHt956S55//nlp3LixZMuWzatyfPjhhxqcDxkyROrXr+92Gzw/YcIEzZ1H7zmCYgTb+B9BPgLhc+fOSb169bw6t9ggTx8BfufOnWXixIn63JgxY7SXHiMIadKk0efQuMHX2rVrHe/F6xs3bpTatWt73P++ffu0vGjMYKQDIwLjx4/XunbnxRdfdHqMUZAXXnhBWrVqJaGh//1YoCHz+++/S8aMGbVRgobGnDlztIxoBHXo0EGefPJJee2113R7bIOGBj6/QYMG6XvREMJ+zAYHGnno/Xfn1q1b+mXCyAXUKplBSt36b4SDiO5WIHuqgK6W0NDALr+/YX2yPlM6BvlJ4I8//pC//vpLAzT02qLn11SmTBkNVtFbjwAbgeLs2bM1wAQEzEgH6dGjh+M9AwYMkNGjR2uKibWnOaHQqDCDzgceeEDLvXz5cundu7c+j2C/fPnykjNnTq/OzRPsf9y4cfLKK69oo8OE80Yv+OLFi7Ue8IVgGqkv6AEPCQnR7SpUqBBrgA8YEUCAD9hHr169ZNKkSR6DfEC6DlbcQUPmypUrGohjNMBMIzL3i/0BPhfUE3rvAT37+Orevbt8/vnnjnPAaAPqDkE+3hsTE6M9/I888ohTvbvz5ptvOhoMVr0b5dLRAiKyJ4wS5soVltzFsA3WJ+szORkx0RIU/G8Mk5wY5Cci9M4iNQMBHVIzkEISERGh6TVW6KFHsIueZgSDJ0+elKeeesoReCLf3ZqzjV52BLAIQBMT9oseb6TtoPcbaTfobT9//rzmj6Ns5iiAt+fmzogRIzTdB73+ptu3b+v7cU7r1q1z2r5jx47am50+fXp9nCdPnjiPgcDaqnDhwlqvCLqRd+8KqTjobUfAbc3Fx/lYg3ycpxVGHMyednxWgHkA1mNgf+Y+0KjDCAhGcFAWzJlAA65hw4Zuz2Po0KEycOBAx2M0pnA9XJk7TqIvhcdZD0RERJR8QvMUlUzdx/rFR8AgPxFhoiaCYKSXmMHh/Pnz5bvvvnPaDrn1/fv31zQOvN68eXMJC/u3BwcTbNGz7AqBtxmMmj3c6CE2IXcfX75CEI8g/9q1axqAIlUFQTyew/wBpPz4cm7ufPLJJ9qoQY83RjDQgMGkWPSMo+GAtJ/YuAvS3dWP62NMHnb3XgT/b7zxhmzbtk1Ta+DIkSPyxRdfaCDuLUz0hZEjR2oajydIv8I5IqVoyZIl2pD69ttvdXKwKzQizNQlq6iIYxIdedjrshEREVHKxiU+EhFu+oSceWvvL1akcYUeakweff/993VVHWtqDialIgj95ZdfnG7khFxvBN9mzzYCfeT1mxCUI8XFhGAdPfV4nxUmsSIdxhrkI3jHKjoI8s3n/ve//znl43t7bu5gRRmUD184V7NxgvSV6dOn35Wfjgm4caX/oN6s0AixNnIWLVqkK+G4Y96cq2jRoo7nzNWIfIHVhdCQQF1Z4fwwwRYwWoE5D2hslCtXThsEmFRsTvolIiIiSgrsyU9EzZo107xzrByDCazorcWKNO4gZQfLNqIHHz35Jqzi8txzz8ljjz2mufgIXJFXjv1iiU1ALnyXLl20hxg3mrp48aIG3K7LMiIIfeedd+TUqVMajGJ1nVGjRukxsDIPIF0FASgaDGhgmEH+sGHDNH3HzMf35dzcQUBtpv8gdWXmzJmaM49GBMqJyavoRcfoAcqKfH1P8Br2ZV0tCHXQpEkTfQ77wOpCaLy4g3kGSKNp27at5txjwi562H2FkQiMTCC9CEE9GkkI6letWqX5+KgrzF9AwwYTevH5IbUHjbhHH33U5+MREREReYs9+Qn09NNPS758+RyBLCai5s+fXyeooqcaPeTYxhUmcOJ9yMW3ruYCH3/8sS5niZV2kCOONBKkl1ghSEYKDIJILMWIpTCRDoP8bRMCf7OnHqkpgMaDGeADevuRB44A3kw/QQoLluhEI8Pk7blZ6wONETw21/jHPtCbD8jDRx499oWVgzAHACvtIK3FGuCjLAjerdAwcV0OFHWBFW8wCoBgGuvSo+fchAm+5j0IkCqE1XqQNoOlLbHkKOrHWlZAKpF1H4BA3jpxFvWJ5UTNicuoz3nz5mmAD6jr9evX634xSRd1gO3Kli3rckUQERERJZ4gw5ckZEo0WFoRPfm4CZS5JjzFD0YcMDpgbZTYBSbeovF1dGQHycCcfCIiIr8WUrC0ZBv2eazbIK03IiJcwsLyJenNMZmuc48hzx355OitR5oHA3wiIiIiSmxM17nHsB478sWRCjJt2rR7fXhbcpdWQ0RERJSSsSf/HsNKM7jDLSUe3GiLiIiIiP7DnnwiIiIiIpthkE9EREREZDMM8omIiIiIbIZBPhERERGRzTDIJyIiIiKyGa6uQxQAQsMKS0jaVMldDCIiIopFaJ6i4i8Y5BMFgExdR0jmzJmTuxhEREQUByMmWoKCQyS5MV2HKADgFtiUOPUYGRnB+mRd+h1em6xPf8br0zf+EOADg3wiSlGiou4kdxFsg3XJ+vRnvD5Znykdg3wiIiIiIpthkE9EREREZDMM8omIiIiIbIZBPhERERGRzTDIJ6IUJTSU9xtgXRIR2R/XyScKAMHBbI8nVj3myhWWKPtK6eKqy+gYQ0KCg+5pmYiI6D8M8okCwMgl4XLq6rnkLgaRV4rlTi0TO+ZnbRERJSMG+UQB4GjkbTl0wUjuYhAREVGAYA4AEREREZHNMMgnIiIiIrIZBvlERERERDbDIJ+IiIiIyGYY5BMRERER2QyDfCIiIiIim2GQT0RERERkMwzyiYiIiIhsJsUE+f/73/+kT58+yV0M23jmmWdk1qxZyV0MIiIiIkrJQf7JkyflwIED4o8++OADefHFFyWQ7Nu3T8LDw5O7GAHlqaeektmzZyd3MYiIiCgFSDFBvj87ceKEHDx4MLmLQUnszz//lNOnT7OeiYiIKMml2CB//vz5UrVqVf1q2LChDBgwQCIiIhyvb9u2TWrUqCGXL192eh96Yh977DHH4++//17atWsntWrVki5dusjOnTudth8+fLiMGzfO6bnp06dLz549Hfv7/PPPZcuWLY7y/Pjjj3eV959//pGXX35ZGjRoIG3bttXye/OaN2V01alTJ/n0009lzJgx8vDDD0uLFi3k22+/jfU9OD7KXq1aNd1+4sSJcvv27bv2+9lnn8kbb7whzZo1k5YtW8qKFSvu2teqVavk8ccfl7p160qPHj1k//79Tq/v2rVLunXrJg899JD2jm/fvj3Wsq1evVrat2+v2w8aNEguXLjgeM0wDJkxY4aWp06dOjJw4ECtTyu89vXXXzs999xzz8mUKVO8PjeM1GD0A2lj5ud89erVWMtNREREFF8pNshv1KiRTJ06Vb+GDRumPay1a9d2BKYPPPCA9rAvWLDA6X3vv/++lCtXTr9fv369NG3aVO677z4N5LNkyaKBNII5099//y1Hjx512gfSXMzAFe9v0qSJlC9f3lGeSpUq3VVeBL3YLxoNCHy/+uorWbJkSZyveVNGV3v27JHevXvLmTNnZMiQIRqQImjduHGjx/dge5QdgS8aMKg3lMV1vy+88IIGt0OHDtWguk2bNrJjxw7HNpMnT9Zt0FAYP368FCpUSI9vjnScO3dO6tWrJ7lz59bXEVAjMLc20Kzee+896dixo+7jtddek/z58zulRuE5nCO2GTFihDaA0LiwNlDwHI5rhdSvU6dOeX1u/fr1k8KFC+tz5uecLl06j/VJRERElBChkkIhSMSXCb3gBQsW1B5rBLShoaHaW4zJpb169XIEe/hauHChPkZQ/fTTT2uPN2BEAMHz66+/fldvuid58uSRsLAwiYyM1EDUHfQ2//LLL7JhwwYNQAFB8K1bt2J9LSFlRCMHgaj5niNHjmhAvG7dOrfbFy9e3PE9zqNMmTLacEHPNRoWJoyCoLcbEKwvW7ZMe+6rVKmioyZocOExPg9A7zsaRO+++65MmzZNy37t2jV56623JDj43zYqAnTUg6uLFy9q4D5p0iTteQfs16wb9OhjxAE9+Z07d9bn0ABCwwIjGeZ7vBXbuZUsWVLSp0+vjQxPnzOgbGb5wBxJqlUyg5S6ldan8hAllwLZU7Hy4yE0lPVGRIknxQb5N2/e1LQZ9HSjxzo6OlouXbokhw8fdmyDHmkEk8ilRu/9J598or39pUqVkpiYGA34kaZihZ7lmTNnJmpZg4KCdOQBPcX9+/fXQBVBdZo0afR1T68lpIzYpxVGG2KbHIw6xATi33//XXu9UZ8IvDGKYR2ZcA1wEfSavfBIu0EAP3jwYAkJCdH34ws95iVKlNBtKlSoIDly5JBWrVppIwzBdM6cOd2WCfu7ceOGtG7d2ul5s97wueJ1jHSYMmfOrIG+dXTBW7Gdm7fefPNNbUy56t0ol5aNiOwJnRa5coVJSmTEREtQcEhyF4PIdlJskI+gGHn3SNUoUqSIpE2bVp544gkN+kzFihXToBm9+UgNmTdvnrzzzjv6GtI50OOaIUMGp/1mzJhRrly5kujlRX73nDlzNBUHQTDKjPKgx9zTa/g/vmVEr7MV9oEAHEE3Gh1WqIv69etr4wf1ihGS69eva0PBWp+AERIr7Mvshcf+AXXsrsyAUQE0XPCZfPTRR9K1a1dttMydO/eu95jHNt/ryqyDxPoMYzs3byHVB+lH1p58jDBdmTtOoi9xNSMispfQPEUlU/exyV0MIltKsUE+UikwURI9wmag6q7XFb35mJR7//336zaYwAloFKCnFr3BjzzyiGP7vXv3OqWuIIBEwGvlusIKenDiCgbR+/zss8/qFwJ3pBQhFeXLL7+M9TVvyuiO62RXpMkULVr0rgDffA056lu3bnWk5mAisa+Q0gJ37tyJNaUFKU5I68EXRhAqVqyo6TV9+/Z12g6NDnOiLnrnXZmjA6gfpNSY8Nja++/NZ+gNbz9nc6TBKirimERH/jfKRERERBSbFDvxNnv27PLrr7/q9wi80KPvrvcWq9Ug9QSBfocOHZx6hdEAwERRTNA1g0n0KJs5/IBUFaxuY07cxARN18m8CFqxjr/Vd999p4Eu3oc0IowkmD3d6DFGwIiGRmyveVtGpIhg9R2rxYsXO1JWjh07Jh9//LF0797dbV1my5ZN/zdXuUHvM+rTV2XLlpXGjRtrT7ZZXkD9LV26VL//+eeftf6QigSpU6d2Ol/ruWCUAyMxSFc6e/asPof6Qg6+GeRjBGLkyJGOPHiMEGCSL1KBrJ8hGoW4DgD1F58lT/E5W8+LiIiIKKmk2CAfq+Qg+EWPNia+Ipfc7Nm1Qq8qlp1EkOga5CKQNXP0S5curUtuYhukkJgQZCPYRC84/sdIgDmp1ITnEBgjvcZcQvP8+fMaZKNXGz3JSD0pUKCABsJ58+bV4B+TPGN7zdsyIohH48MKk3fRm4334at69eqa8+8OJqqOGjVK34O5C0gvcVeX3sCkZvTo4/2oLzTGcC44N8DnhfQkNCywYhDqDBODsZSmu3NBgwC57Kgf7A91kDVrVsfrCOoxgoNrAJ8RltjE3Atr+bEqEUYrsA9sgyVPMTfAV5jIiwYCys0lNImIiCgpBRm+Jg0HKEzeRG+3mcIBSMHARFsEjEhrQSCH79HjaoWVaJDj7prCYsLKOEjfQLBrDSCtjh8/rv9jGyyhiVEDBJwmBPNYwQbBPgJMfCxYfrNy5cqOXO+oqCg5dOiQBq358uVz2n9sr8VVRpQN5cFqOIAgFI0TBPUoE46P91mhLpCag0aFCQ0TjEggyMdrv/32mwbnZs470oRy5crltKoR6t/d/rHyDfaF562r85iwVCUCenxu1vNxPRcTAnmUDw0I19x5wARh7BOvu02XiYrSsmLSL76QnpQpUyZHXXt7bma50TBDChgmGMcG1wPO/+jIDpKB6TpEZDMhBUtLtmGfJ/p+MdobEREuYWH5HCuxEevTX9yr6zPFBPnxhYYBgnH0iLvmfNuVGeQjRYmSF4N8IrIzBvmBgY2mwKxPNm9j0adPH00PQZqGeYdaIiIiIiJ/l2JX1/EG0lUQ6KMnP660CjtBXjxST4iIiIgoMDHIj4U1fz8lcc1nJyIiIqLAwnQdIiIiIiKbYZBPRERERGQzDPKJiIiIiGyGQT4RERERkc0wyCciIiIishmurkMUAELDCktI2lTJXQwiokQVmqcoa5QoiTDIJwoAmbqOkMyZMyd3MYiIEp0REy1BwSnnXjRE9wrTdYgC5BbYlDj1GBkZwfpkXfqdlHxtMsAnShoM8okoRYmKupPcRbAN1iXrk4j8F4N8IiIiIiKbYZBPRERERGQzDPKJiIiIiGyGQT4RERERkc0wyCciIiIishkG+UQBIDg4MH9Uo2OM5C4CERFRisSbYREFgJFLwuXU1XMSSIrlTi0TO+ZP7mIQERGlSAzyiQLA0cjbcugCe8WJiIjIO4GZA0BERERERB4xyCciIiIishkG+URERERENsMgn4iIiIjIZhjkExERERHZDIN8IiIiIiKbYZBPRERERGQzDPLJNvbu3SunTp1K8DbxtW/fPjl58mSS7JuIiIjIFwzyyTZ69Oghn376qePxnj17JDw83Odt4qtfv34yderURNkXERERUUIwyCfb6tatm8yZM8fpufvuu08KFCgQ6zZEREREgS40uQtA5I2DBw/K+fPnJSgoSHLnzi2FCxeW4GDPbdT9+/fLtWvX5MSJE/LLL7/oc9WqVZOXXnpJsmbNGus2u3btkkKFCknOnDkd+/vzzz8lc+bMTg2E6OhofR7b5c2b12NZMFIQGRkpxYsXl4wZM/IDJyIioiTHIJ8CwieffCI//vijfo+891SpUsm8efOkZs2abrefNm2aBu+rVq2SHTt26HPr1q3TdJ1HH31URowY4XGb5s2byzvvvCNdunRx7O+FF16QOnXqyLhx4xwNhBYtWsjly5clU6ZMGuRfvXrVqQxnz56Vzp07y/bt27VxcPjwYendu7dMnDhRGytERERESYVBPgWECRMmOL43DEOD7aeeekoOHDjgtkd/0qRJsnHjRmnXrp0MGTLE7T692caTnj17SuXKlWXhwoUSGhoqb7/9tgwePFhatmzp2ObJJ5+UfPnyyenTpyVNmjTaOEGjpHz58pom5M6tW7f0y4RGBNQqmUFK3UorgaRA9lTJXQQiIqIUi0E+BYzbt2/L8ePH5dy5c1K1alUZNWqUrpRTsGDBe5469PPPP8sff/yhAT4gDQiBvnWbtWvXyvLly3U7NEzwhdGA1atXewzy33zzTXnttdfuer53o1yaLmQnRky0BAWHJHcxiIiIbIlBPgUErIjz8ssvS4YMGTQn3+y9Ry/5vQ7y//77b/2/dOnSjucQ7JcoUcLxGCMMZtDuqkKFCh73PXToUBk4cKBTTz7O78rccRJ9KXFWAfIHoXmKSqbuY5O7GERERLbFIJ/8HiatPvvss7Jo0SJp27atPocefOS5x8TEJPrxkC+PXnerO3fuOL5HDj5g0q45idd8bEqb9t/UmsWLF/vUCEFaD75cRUUck+jIwz6eCREREaVUXEKT/N6xY8d0JZsmTZo4nvvmm2/ifF+6dOmcgnNvtwkLC3O6qRUm1OJGVybk1ON9mKRrwvbWbbBKT/r06XVysCtrY4CIiIgoKbAnn/xe2bJlNfDu06eP5rLjBlZjx8ad6oE18ZH/XrduXe1ZR+DtzTatW7eWDz74QIoVK6ZLXmKC7o0bNxzvyZYtm/Tv319X3EHAjsfIo7dOAEYPPyYLDxo0SFNuGjRoIBEREbJ06VI91oABAxKxhoiIiIicMcgnv4c8/PXr12t++5gxY6RIkSI6oRUBtJk64+5GV9j29ddf1wAcQTp63r3ZZvjw4RrwY9nO7Nmza0BfqlQpp7Sb8ePHS65cuWT27Nm6Tj5W58FKPdZt+vbtK+XKldP5BGiUYO19rAjUqlWre1JvRERElHIFGa7Jx0TkNzAKkCVLFjk6soNksFFOfkjB0pJt2Of3/LiYwxERES5hYflivZkasS7vNV6brE9/xuszMOuTf+WIiIiIiGyGQT4RERERkc0wyCciIiIishkG+URERERENsMgn4iIiIjIZhjkExERERHZDIN8IiIiIiKbYZBPRERERGQzDPKJiIiIiGwmNLkLQERxCw0rLCFpU9mmqkLzFE3uIhAREdkag3yiAJCp6wjJnDmz2IkREy1BwSHJXQwiIiJbYroOUQCIiYkRu2GAT0RElHQY5BMRERER2QyDfCIiIiIim2GQT0RERERkMwzyiYiIiIhshkE+EREREZHNMMgnIiIiIrIZBvlEASA4OHB+VKNjjOQuAhERUYrHm2ERBYCRS8Ll1NVz4u+K5U4tEzvmT+5iEBERpXgM8okCwNHI23LoAnvIiYiIyDuBkwNAREREREReYZBPRERERGQzDPKJiIiIiGyGQT4RERERkc0wyCciIiIishkG+URERERENsMgn4iIiIgoJQf577//vsyZMyfpShNgXOvjrbfekoULF4q/GjNmjKxYscJv9hNIUuI5ExERUQoJ8n/44QfZtm2b+KN3331XPv/883t6TNf6WLdunfz+++/ir7755hv5448/fHrPqFGjZPXq1QneT6BLiedMREREgcs26Trff/+9/Prrr8ldDNv56quvZM+ePU7Pvfbaa9K6dWtJSVLiORMREVHgCk3Imz/99FNZv369fp8jRw558MEHpVOnThIUFOQIENG7/d577931vvDwcBk+fLg+3rFjhyxYsEDOnz8vFStWlB49ekjGjBkd22O72rVrS/PmzR3PffTRR5I2bVrddvr06bJz5075+++/pUuXLvr622+/LXnz5nVsv337dpk1a5ZMmTJFH1+8eFH69u2r+3zyySf1uVWrVslvv/0mo0ePjvPcvHH27FkZNmyYNGjQQJ544gmJiYmRL7/8UhskadKkkXr16kmbNm0c2x88eFBef/11mThxop7T0aNH5dVXX5WyZcs6tsH7Dxw4II888oiOXFy6dEk++eQTfe3PP/+UL774Qv755x8pVaqU9OzZU7JlyxZruhEaRjin3Llza3kee+wxx+uowyNHjmgKkhnoo1xbtmyR+++/X+677z49HuodPf5WH3zwgQQHB0u/fv3iVTYrvAef3eHDh6VIkSLSrVs3yZcvn742dOhQLTc+z82bN0uqVKnk2WeflTJlynh9nqZ9+/bJvHnzJCIiQqpVqybPPPOMhIb++yNiPWfzuPXr15dr167JTz/9pMd96qmnpEKFCk77XL58uXz99deSM2dOadWqlWzYsEFKlCgh7dq18+rciYiIiO55T3758uWlWbNm+lWoUCEN9BB0m0qXLq0B1q5duxzPRUdHy8iRIx1B/MqVK6VmzZpy48YNqVy5ssyePVtq1aolt27dcrxnzZo1GiRabdy4UQMvQGCVK1cuKVy4sKM8GTJkcNoewd3UqVM1aAUEZvPnz5dp06Y5tkFgf+7cOa/OLS4nTpyQunXrys2bN6V9+/Ya4Ldt21bz9hGAIlh95ZVXpE+fPk7BLALhOnXqSFRUlDRq1EiyZ8/utF80ZpCa1LVrVylYsKA0btzYEUzifXfu3NEAFY0VnAMCVk8QtOL8mjZtqkFo7969tVFiqlKlimTJkkU/R7MuEMxaU1fCwsJk7Nix2qAx4bNDQylz5szxLpvp6tWrUr16ddm6dau+F/WJ8qJBaDbMEFzPnDlT6/XUqVO6nfV6ies8YcmSJXr9nTx5UrdHoxANEU/pOjju008/rQ0tNMJw/jguGiKmSZMmaeMO1x4aimhMogGHz5CIiIjIb3vyEXzhy4Qgtnjx4pragAAU36MXG72w6NmFb7/9ViIjI7XH3TAMGTBggAwaNEjefPNNfR2BU9GiRbXHHa95A42E/Pnzaw+p2ZPvCg0AfKEXHftHPn3Hjh1l6dKl2sDAqAAaDmbQH9e5xWb//v3y8MMP63sQ6KEHGcE7glu8lj59et0O6R/YZ//+/bV324RjIIj3BL3HqMcCBQroYwS+6L1G2dGggF69emlvP4JKNArcQY+2FXqm8dyIESO0jA0bNtRGBoJfT/WKbRDELlq0SF544QV9Djn8t2/f1vOPb9lMaCAicMdoQUhIiD6H6yV16tSObRBAoz7wOsqA0Rk0JBG4e3Oe+PxRJgT+aJyY4mqEVKpUSa8feO6553S0ACNS2A8aJxiVwXWPfQPKVa5cuVj3iQaStYF7+fJl/b9WyQxS6lZa8XcFsqcSfxca6v9lJCIiStYgH73yCKR++eUX7clEbzVSNJB2YgbC6A1FygZSPxCYIeBHqgQCs+PHj2vPeocOHRz7RO8vgiEE3N4G+d5CcIfgvnv37vo/gmkE3hgRQA8vevEfeughr8/NHfTSogcf52xNYUHqEt6PIBSNG/ML6SC7d+92CvLRQIgNAkUzwAf0OqOMCDgx6mHuG73S6D33BMEkglJMFsa5IzDH9vhM0NPuDZwT0pjQiDGDfHyP1JRMmTLp5xifspnQCMJ1M3jwYP3ccO4YXbDCscwGACAVZsiQIV6fJyZPY2QA+7fCKEVs0IC1KlmypDZIYO/evZpChIaOCSMN1tQrd9DYxXXpqnejXI6REYo/XK+5csX+ufrKiImWoOD/rj8iIqKAD/LRE44AFb3vSJlBKgd6dK9cueLYBkEOct+x/CCCIqQ5IH0DzBQP15QUNACOHTsmiQ1BPnp4EXwhxxwBPZ5D7z7SfZBvjWDf23NzB+ka2AaBvhWCSATmZnqNCSkkDzzwgNNzrkGsK9fXzdSVJk2aOPVwo7GA83IHjRZsj55ipJGgtx6Brzfn6Aq9/Jh3gaAZefZo0Ji96PEpm1WePHk0tQo94tgHyo1gHClCZmDvmtuP6wnHNRsUcZ0nrgfwpjxWGP1xDSDROLRe21mzZnXaJq55CMj1HzhwoOMxyo1G5ZW54yT6UrhP5aOkF5qnqGTqPpZVTURE9gnyEUQhkEPvKAInM6fctXcWE0yReoIefPRyIrXD7KlGrjsgOEQqjcn1MfaB3lfX41sn53ozIRaNDPQgI/ceE3wRLCPIxyReBHj43pdzcweNGkwKbdmypaatmPtEoIZ0Dk9pLwlhjiygkWJNMYoN0obQy3769GkNpAGNGlfe1Cty2NHDjkmr6P1GjzMaL/EtmyvMDTDvR4BRF+wb8wTQAAPXBiEmLKNBhbJjMm1c52mW8a+//rpr4mx8mdc2RquKFSvmeB6PY4NrHV+uoiKOSXTkf/n+REREREky8Ra9lmCdcIneVXeQsrN27VqZPHmyBmZmDyx6zZHTjV5gswcUARhWI7Gm8CCVBb25JjNwc+39NyfNmpAiglxp17z8CRMmOFItEIQjXQPpO2ZA7su5ufPiiy/K+PHj5dFHH5Uff/xRn8PkUKTyfPbZZ07bLlu2TPO3PUF9oGGAIDW2IBuNFvQCI1/fGuxa683K/AzMc0T9v/HGG3dt565e3encubOm6eALoyDmqjTxKZvr+VvvPVC1alXtqTdz1QGr/6DxBuidt+b/e3OeKCPSdpCPbzYmsR0m28YXGj3mxHMTGo6YkE1ERETktz35SEPAhFEsAYkUFPS+Ix3DXS8kenERnCGYxrKEVh9//LH2zGIb5F8jKMYqNugJNyEfG0E5Vi9Bbyx6XJH/7NqDjtxwBHno4cccAASICACtK+ggkMcKPmZAj/1hIi5y7c18fF/OzRO8H6kiLVq00Fx0TPTEiAFW08GkYizviZQhjBRYlwZ1haVGEThjkqh1SVAr9FgjgER5US/oMcekUaShzJgxw+17EICivlAufKHhZKYqWSG//aWXXtI6QHoKltB0B6kwKCP2gxWEElI2q3Tp0um+EXSjRxwr3KDhYR0RQYCOJU6R9oSGFFJi0Kjw9jxRRixNimsO22NCLXLqsQoPVuWJDzQu8Dlj/gnmdaBMaNjgHKzzB4iIiIiSQpCBSNRLCMCxGgmCbRN6WQ8dOqQBKJa+XLx4sa5pb50YClhhBcE5esxdYWIkeuYvXLig6RLWNc5N6E1GsISlMXF8HBe9xQjuTFiBBYE9eowRXCGoQlqKdVQAQR7W5UfQaS6ziWMjHefxxx93OmZc5+ZaH1hXHwGomeIDGMFAecwbKeEckXKC1B8Ek1hK04RVh7BKDIJaczQBPfjYL84HaTBYbQZlRZ65K+SrYxIuUkKQLoKgF3MJTNg3ViEy13oH1Cm2RznQo41GEQJbayCMOsOSlFiFBr30WOvddT+AuRZYTQdBta9liw0uUQTvmO+A1BrUt5lGhDJgpAjHxCRqXBNoELru25vzxLKlWGsf1xrKZ00Zc607pGJhNSfrtYrrCA1Ba1oSPlM8j+Mg7Qj7xaRszFPxBkYskFZ2dGQHycB0Hb8TUrC0ZBt2b++07S/wMx0RES5hYfkcv6+I9ekveH2yPv3Zvbo+fQry4wu9tgiY0HNrDbiJEsoM8hN7JabEgAYZGjTmZFtMOsdKQBjBiWspTRODfP/GIJ9BfmJhUJq4WJ+sT392r67PBK2u421+Ou56i6UDXXvKicy7/HqCu/n6kiblTzAygFEHpABh3gXS1ZBG5m2AT0REROS3QT5SJ5Bagi/mIpMr9HLHlvce1zWD/H+kzfgjpOcg5QupQphTgPQsT/MqiIiIiAIqyEfuO5EnWLo0IcuKYgUjf4YbgrmbP0FERESUlDhbioiIiIjIZhjkExERERHZDIN8IiIiIiKbYZBPRERERGQzDPKJiIiIiGwmyVfXIaKECw0rLCFpvbtDMN07oXmKsrqJiMgvMcgnCgCZuo6QzJkzJ3cxyA0jJlqCgmO/nwMREdG9xnQdogC5BTYlTj1GRkYkan0ywCciIn/EIJ+IUpSoqDvJXQQiIqIkxyCfiIiIiMhmGOQTEREREdkMg3wiIiIiIpthkE9EREREZDMM8omIiIiIbIZBPhERERGRzTDIJyIiIiKyGQb5REREREQ2wyCfiIiIiMhmGOQTEREREdkMg3wiIiIiIpthkE9EREREZDMM8omIiIiIbIZBPhERERGRzTDIJyIiIkrBrly5IosXL5Y1a9bo4wMHDshnn30mf/zxR7KV6cSJE/Ldd99JIDkRzzIfPXpUvv/++0Qvjy2D/IsXL0pUVFRyF8Nv6wOPo6Ojk/SYV69elVu3biXpPpPiGN4em4iI/FtoaKok3T+C4pkzZ2owjAAtJiYm0YLAY8eOybp16+Readq0qcydO1f+/PNPOXnypNSpU0fP6fTp0/Ltt9/qc0kdkLue865du2Ty5MkSSHbFs8y//vqrTJs2LdHLY8sgP1u2bPLDDz+IP0qOBoi1PhCs4vH27duT9JiNGzeWt99+O0n3mRTH8BTQJ9WxiIgofqJjDI+vBQcHS65cYfp/Yu7XaujQobJixQr58ccf5fnnn9e/E3EF+hcuXNBe8rj8/vvv8r///U/uBZTpyJEjsnLlSnnllVc0uG/durXMnj1bHn74Ydm3b59cunQpUc7LX845pQhN7gKkJAjuEWDjB6h+/fpiZ5kyZZK0adMG5DHw2bRr106GDBmS5MciIqL4CQkOksELT8nhf24nWhUWy51aJnbM7/X2r776qvZ6o3OoQIEC2iNbvXp1fYzONYya16tXT7JmzarbIwYoXbq0I0Xj77//ljJlysjmzZv1+YoVK+p70KONnm2MFBQsWFB72nfu3Cm7d++W27dv63Y4jjvutkMAfvbsWaldu7Zuc/jwYTl+/LjUrFlTpk+frsfEsQAxyj///ON4nDFjRsmSJYtj/3fu3JGNGzdq+dGoeeaZZ5zOy9zmp59+0mPWqFFDihQp4vM5W33xxRfSqlUrLQuEh4fLjh07pGXLll7XQUREhKxatUqCgoIkLCxMGjZsKOnTp3cqV6lSpWTLli1y3333Sbly5WTPnj2asoR6K1SokNO2JUuWlK1bt+q2ZcuWdVsOT/VgNox+/vmXu841MaWIIP/y5ct6IaJFnzlzZrevp0mTRr+s8EMaGhrqFNzhgsEFkiqV8zAg9o/9YP/WngO0fjNkyKD7wevmftGjHxISosGj1bVr1/R585i4QPCcdb/WbeI6N28YhqHlxP6s53rz5k23gS2exw8kzgvHxvm4HnvZsmVOdYR8v9SpU2sd470oL+rRE/Sku34eruJzDNQd6hTPo+5de3nwOt6Lc8RnBPjl5nosE7bF/tzVk6/nTEREvkGAvy/8ZrJXG4LFdOnSyY0bN+TMmTMaPBcrVkz/BvTu3VuD4uLFi2s6x9SpU7WHHA2C4cOHawMAryEtZs6cORrQIyhHEPjLL7/o31gEv2+88YY2GPC3CH+X3AX5CNjdbYfj43hmkL9t2zZZvXq1VK1aVXvQ8TcXxwL06iO2MB+jXPny5ZP776+ofxfREYbzQvCMv2vdunVzOi/EExjVQCCN4w8aNEhTWNq2bevTOZcoUcJxXkgFwt/nXr166eP33ntPsmfP7jbI91QHV65ccZwTGgkDBw7UhgJiAZQLDTY0VlCunj17ynPPPaf1hnPv27evBvx58+Z1nANiIAT6GMWZMmWKdOjQwakcsdUDjt+4cVNtICCOwnljX4nNluk6rqpVq6atp/z582tFd+/e3RFwAx7jIrXCxYQPc/ny5foYeWoPPfSQfqj4YW7SpIm2hE1oEePisD4H+HC/+eYb/f7+++/X/zt16qTladSo0V1lHTx4sHTp0sXx+J133tH9fvXVV47nHnjgAR1G8+bcvBldQCscLUy03OHTTz/VfWJ/+CHq16+fXL9+3fGeESNGSLNmzaRHjx4a3FeoUOGu/bqmt+AXHn6g0HLG+aA1/uKLL2oDw4TA+qWXXtJj4oeuUqVK8vPPP3sse3yOgV8QOLfChQvr6/iFhBa56emnn9ZW+4QJE3Q7fKE+XY+FH8iOHTvq9YCy4peda4qYN+UhIqLAhUAZudT4u47OPATNH3zwgf7NWL9+vXz99dfSuXNneeutt9y+Hx1AmzZtknnz5unfnYULF+p++vTpI5UrV9Ze7QEDBmiwiSAUf/vxXPv27d3uz9vtTPi7hLLlypVLt8fXk08+qeU3H5cvX96x/aRJkzQwRaA7a9YsfR3ltXr//fc1MEbKT4MGDeSJJ56Qd9991+dztkKQbeaso0GC95gBv7d1UKJECRkzZozGL48//rg2NNauXet4HxosaARg3wjc8T2+li5dqo0QfJYmNBhwDtgWryPodxVbPXz44YfSrFlTjQ8xgoG4LimkiCAfrUO0PvGhIIDbv3+/BqqmZ599VoN5s+cWFi1apC3ANm3aaO89WosYUjl//rwGw+idRWvMm4k2JjOYxC8FHAstaVdoISO/zwwEETjmyZPHEUCih+DgwYOOdJ+4zi02CKpxoaN1iosVQ1Hz58+XYcOG6Q8fXsdwF/L3rakrgO1RHxiCQg+DN9BaR9nQusXwFVrbZiMK0EDBzH780OHYmARk/QFMjGNgyA/1hS/UJYZX8QvN9OWXX+ovmdGjRzu2sw5TWq+ZQ4cOyV9//aV1j+sDXxgO9KU8rvDLC40K6xcREfmnvXv3ym+//aZ/N/A3HR0/+LuMXmQTOno85aujM8scJcbfI3QguYMOIvQCYxt0zFk7p+KzXULOF0FybBCLmCMB+MI5WevD23O2QocmMhjQ846/0+hozZkzp0918N133+nnhDgAqUIYLYiMjHS8D511ZoMFwbk18MZjaznxmpnqg3QtjH64LmgSWz0gjqtZ80HHtuhETgopIsg3Ia0CPc8YOsMEExMuFvS4I7A1oYWK4A/BPCbWYGjlo48+0l5b9MpiWAoB8IYNGxK1jAjez507p4E3etlxIaJFai6thP8R9Ftz32I7N08QdKJligsQ+0QrHt58801tQeNiN9Nw0BuNHworBPgIhH3JU0cQj192SFmpUqWKXtTm0BkaCmhg4AcTr6FFjTKg1e2L2I5hhUYUvjDJCL+YEfB7C6sILFmyRIcLUQ+og7Fjx+ovnBkzZsSrPCbUPxoV5ldS5uoREVHC4O8zepjROYbRf8D/COJM6HwzX3PlmsJpdvAhoLV2IiLIxQRY9FLj74Jr9kFc26HxYe00Ql55fCBwRqAfG2QWIJA3RwLwhfQZX8/ZFXr6Udf4QiDviac6WLBggZYD6beffPKJxlLWkXXXcnkqJ6DhYD5Gh1+OHDm0/N7WA45tzfywXi+JKUXk5KP3dOLEiXpRo+WFiwg9xSYElGjtIbB/4YUXtHcWPdXmMkhogSNHy5w4Y17o+KHFaxjWSiwItjGBAz335ko4KBvSeNCrjOetk3bjOjdPunbtKkWLFtXeZTP3Ha1QNC4QsCLYdIXymJNekDvma365dcIJoAFhztjHcaFWrVo+7dOXYwAaZfiljPxB5BSarXYsD4YfOm+YPTII2q3XEFr2rr01cZXH3WoNaFSZ8EuZgT4RUeBALjd6bPE3FX9fkbYR2wiuO8jnRwcUOheRZoK/7adOndJ9In0YPcvuIKXE3XZIH0UKyrhx47RTEB13Dz74X0+yt5A2g30hhRepumb8ZNW/f39NAcb8BPxdRPCLCa1x9Va7nrMrpESNHDlSYxf0yHviqQ7KlCmjufMYMcdxMBfBNY/eWxgBQMouYhY0GNAAcRVbPSAboFGjhpIqVRptLGDUH/Wa2Gwf5KMnHC0+DO9giAlBHXq6MUvbtcf19ddf19559CjjAjJz6PEed8te4jkzSPQU8PqSzmNCEI/edQTVyONCjy5+mBCQI8g3g0Bvz82dp556Sn+QMErhepHjhwCNgNi4m4Qal9gaBeYEWPzySYjYjoGAGXWD9BnUI3o2kHqFURxfljU1P3PX91ivB2/K4467CeBEROR5NZzk2h/+drrrHMIotJlzjgAPaadmpxDSYjGKDghWrZ2E5io6gDx45L9jXhr+LiKWQMCKzik0IFwDaxN6sN1thw4nrCyDxgY6LRFUYltAhoI1DsCxzdF9QHxhdjYh+EZ6Et6PvHyUCz3l1vNCsI5UFeTEI5DG30YEuAhufTlnjIKbrwH+NmICLYL92Hiqg5deekn/7qPnvUWLFnpe6LB191lg3oF19AXBujV1F3Ea4ijEasgIwPeun29s9YAYc/78L2Tduu+1DLhW4hohiRfDhnBaa9eu1e8//PBD47777nN6ffDgwbqNq0ceecTo27evkS9fPmPy5MmO51evXm2kSpXKOH36tOO5AwcO6D42bdqkjy9fvqyPt2zZ4tjmr7/+0udWrVqlj2NiYoyQkBBj3bp1TsfFe69du+Z4vGjRIiN79uxGkyZNjFmzZulzAwcONDp16qT7279/v0/nZq2PK1euOMqJ46RNm1b/N1WpUsVo3759rPU7aNAgo2nTpk7PXb9+Xc/DVKNGDWPs2LGOx+XLlzcmTZrk9J7HH3/ceO655/T7M2fOaN0sXrzY43Fd9+nrMbZv367nfvXqVcfrS5cuvetzq1mzpjFu3DiPxzbLumbNGsfrt27dMvLmzWu88847XpfHG5cuXdLyXbhwwev3kGfR0dFGePgJ/Z8ShnWZuFifvouKjgmo/Qay5L4+d+/ebbz++utG6dKljaioKCM5LV68WP+WB0J92j4nHy1q5MOhtxvDN0jJwaxmd7BkEnqxkROP2fCmRx55RFt1aKmhdYjefqzCghaiuRwVWsKYVT9+/HhNncEarRgdcO3VRWsaM+4xYRUTNqFu3bqaJmRtIWKCBrZDT775HCYDW/PxfTk3dzDjHC1MnBf2ARjKM2eKI20JeWLII7Ou+OMOWsjIg4sv9KajDrCSD/LlkD6DXgdrvSQUei/QiseKRZhjgUk4GE5zhdY3ehKQp48UKdfVcFBWXCsYRUFvDXLzMDyLoUEMwRER0b1ZJ98T9DBHRkbEazQ9tv1S8sCddzHyjljFNff9Xivq0uvvz2wZ5GNIxUwnwbAIlixCigaGy7DcESY+uFsxBaujIAceKR1YxtGaSoJVXxDcYcnFRx99VIeVMPnSCjluGGJC4I/8LKTV4D3W1BakyGBdWOTdm0toooFgztIGDJMhYMY2Zk43zgNlRoPD5O25WesDDQ08NtNKMESHW3KjvFjKCcNXaFxgOA77R11gSM6ao4+1gM3cfBPKb10r3/XmUXjNNQ3FXI7UhLxFrCOLCb0YGkOjxZqf7rpPX4+BzxafGRoPGCpDvZn1ZU2zQc4fcvaQrmUuoel6LCyRhpWJMEyJzxuNNgzbWevAm3MmIqKkERWVsPRP8h+IvdCJiQ7X5FalShWd3xAIgtCdn9yF8BdoJSI3Cktc4oIiSm5oYKARgpEd68Rvih/06kVEhEtYWL543e6eWJdJhdcm69Of8foMzPq0/cRbbyDNAkEUenCRCoMlNYmIiIiIAhW7sv7/hgVYEhI3fcINmHxdEYWIiIiIyJ+wJ19E87O9ueMaEREREVEgYE8+EREREfkFrDx4/PhxSQllvnz5sq4mmFQY5BMREZHthIb6ftNGX2CZadytHUtZ4+aViRkMBmKgm1jn8+OPPybq8tn3QnzLjKW8X375ZUkqDPKJiIgo4Bgx0R5fw4oluXKFxWvlktj2a4UlrR977DFp06aNLpf96quvxvke3Pl0woQJcW6HpaxxLxa7sNv5BArm5BMREVHACQoOkSuzRkrUmSOJts/QPEUlU/exXm8/Z84cqVOnjhw6dEgqVKigN8osV66cvob7p2D1PjQATOb9V8xUjUuXLknBggXlxIkTkjt3br23ClY2R683er8xUoD7tBQuXFhu3rypz9++fVty5sypN8d0df36dTl8+LAuIILjYjtX165dk2PHjukyjrjnj7nYiOvzuBnkjRs3JF++fI7y3rkTI4UKFXIqO96DY+F97o7t6XwAIyC4ASn2465BhhuQYtVD8wZYKA9u/lmiRAm3n4e7OroeS51YzwPvw+v4DHCvHNw0E+dqHtv188qbN6/TPXZcxXZu2HdU1C1JagzyiYiIKCAhwI8+cSC5i6FBJwJKBG+4IyruKL9582YNEHEDJ9zJHfc6QVrH1KlT9X48SNV47733NKDE4h8IgtHjXaZMGb3RJZ7r1KmTNiJw88UnnnhCcuTIoTe3fOaZZ/Tmka4OHDggXbt21e9x13bc1BJ3iUWQGRUVpXdlX7x4sQaveA43vsT/7p7HzSNxM0yUFzZs+F42bdqsN/5E2VFGBN0o//LlyzWYdndsHNf1fHBjUBwT9YCgHw0E1BEWQrHCDTFx46nWrVvrY9wQCznskydPvuvc165d67aODsRSJziPiRMnatlR/ygr9j148GA9L9xEc+vWrXoTS/OcEbwj4MfrKH/VqlWdyoGGnadzQ0MKN17dvXu3pEoVKvXq1ZekxCCfiIiIKB6OHDmigRwCzMjISKlYsaIGsAgAT58+rUE+An6k6FjvHG/N60cKD27EOW7cOPn44481qMZd1XE3egTPgCAVDYKnnnoq1vJgpAABJBob58+fl+eee07WrVunN/icMmWKHDx4UHvCcZNFEwJnd8/HBXMRdu3apQ0Dk6dju54PymI2atDD/tVXX8mQIUPkm2++cTpGnz59dFsE+RgRmDlzpqxZs8bjqIq7Oro/ljqBo0eP6nmgZx53sR8+fLg2cnDXemyzcuVKbZwARiJ27twpxYsXlxkzZkjfvn3ll19+cTre9OnTPZ4bPl80GFDXZ86ckh49erkdbUksDPKJiIiI4mH06NGO9BMEn0i52bZtm3Tu3FnTPqB79+4yadIkt++vXbu2BvhQpUoVfa87jz76qOa0I+DEDTsRyKZLl+6u7fbt26c9xegxzp49u/ZcI4iFTZs2SY8ePe4K5D09HxeU3Rrgx3ZsVxjRQA85et5NZgqPVYsWLeSll17SlCA0iDBigvsa+VJH++IoV61atTTAh0qVKknGjBkddYFGGxoHJoxCIMAHpGYhyEfPvbfnhs+3S5cuOtKQOnVqefLJJ3WEIKlw4i0RERFRPKD3GL3ACCzr1aunz2XIkEHz2U1IU0Hg6I41pxu9vkjtML+36tixo+zdu1fTdtAzjEaEO+gxR5oKRhGwfcOGDR37RGMEPdmuPD2PIBS57SakqFilTZvW62O7ng/qqHfv3tozbn6566FHSk2vXr20B3/atGmxTt71VEcfxFIud5+Bp88ErJ8r8vPRkDNz9r05N9drw/p9UmBPPhEREVEiQXoOAlP0+CIIfP3112XUqFE+7QMTQNEDvWPHDk3nQKoKcsExqRc9/kgFcQeNCaSabN++XXuNV61aJY0aNXKk/KBs6LXGJGEE0Jhg6+l5fI8Vg5DagvSj6dNnyoMPPuixzLEd2/V8kBaDFBzMY3jggQc0UEb+e/78+e/aL0YZsA0aI02bNvV4fPTOu6ujjLGUy1eYo/DOO+9oj/7bb78tbdu2vWub2M6tXbt22vuPybjnz5/V/P/Y6jShGOQTERFRQMJqOMm1v1KlSmnPrKvmzZvLW2+9Je+//772AmMddDNPHHneZuoGUkKs6S7WVWdq1KghzZo10/xxTOxESsiWLVu0d71s2bLyySefuC3T0KFDZcCAAdrjjX1g4ilSVAAjDciLx5wBrA6DsiH49fQ8ctkxARUNlGLFiknfvi9IRESk27LHdWzX88G8A0z0xXwA9LRjwisCY8xLsNYRYCIt3lO/fv27RgSsxo8f77aOhsZSLtfzQAMEDRoTGj44vglpP+jBxz6Q2mMuh2otc926dT2eG1KKkP6D6yN79mwyYsQInRicVIIMNA+JyC9heBS/hDDci5UZKGHwxysiIlzCwvLFa/1sYl0mFV6bEq/17LGMZqDsN5Al1/WJJSjR4EDjAJNnPaU93QtffvmlLFiwQP8PlPrkXzkiIiIKOLEF4giiIiMjnPKpE2O/dG8htWbYsGG6dGVyBvieRi/8HdN1iIiIyHaiou4kdxEogZDfji9/0KRJE/0KJOzJJyIiIiKyGQb5REREREQ2wyCfiIiIiMhmGOQTEREREdkMg3wiIiIiIpthkE9EREREZDMM8omIiIiIbIZBPhERERGRzfBmWER+zDAM/f/y5cv39FbidoW7X165ckXSpWN9si79C69N1qc/4/Xpn/WZKVMmCQoK8vg6g3wiP3bu3Dn9v3DhwsldFCIiIvIjly5dksyZM3t8nUE+kR/Lnj27/n/8+HHJkiVLchcn4GFEpGDBgnLixIlYfzES6/Je47XJ+vRnvD79sz7Rkx8bBvlEfswcxkOAz6A08aAuWZ+sS3/Ea5P16c94fQZWfTLJl4iIiIjIZhjkExERERHZDIN8Ij+WJk0aGT16tP5PrE9/wmuT9enPeH2yPv3Zvbo+gwxzjT4iIiIiIrIF9uQTEREREdkMg3wiIiIiIpthkE9EREREZDNcJ5/oHjp//rz8/fffUqBAAcmbN2+ivSc++7WDf/75R44dOyZFihSRXLlyJfg9p06dkiNHjtx1r4JatWpJSoDzP336tBQvXlyyZcvmdX0ePHhQypcv7/E98dmvHRw9elTOnj0rZcqUkYwZM3r1npMnT+r7KleufNd7UM+obyussV2xYkVJCQ4dOqR3+CxXrpykS5cuzu1v374tBw4c0BsGFSpUyHHfkYTu1y727dsnN2/elPvuu09SpUoV5/Y3btzQaxA3acSNnFz9/vvvcu3aNafn8PcIP/d2FxMTI3/++adER0drfYaEhHh9feKaK1q0qNv3xGe/TjDxloiS3muvvWakSZPGKFeunP7frVs3IyoqKsHvic9+A11MTIzRr18/p/MeNGhQgt/z9ttvGxkyZDBq167t+GrYsKFhd7dv3zaefPJJI23atEbZsmX1/7feeivW9+zatcvo1KmTERYWhsUbjFWrViXKfu3g6tWrxiOPPKLXUunSpY306dMbM2fOjPU9mzdvNh577DEjZ86cWp/bt2+/a5vOnTsbuXPndro+e/XqZdhdZGSkUatWLSNLlixGiRIl9P+lS5d63P7atWvGwIEDjezZsxsVKlQw8uTJo9ff1q1bE7Rfuzh69KhRsWJFvdaKFCmiP8Pff/+9x+3PnTun11nWrFmNSpUq6fuqVKli7Nu3z2m78uXLG0WLFnW6PvE71e727t2r1w+us/z58xuFChVy+/Nrio6ONkaMGGHkypXLqFy5spEvXz59zzfffJOg/brDIJ/oHli9erURGhpq/PTTT/r44MGD+gvz3XffTdB74rNfO0DAlDFjRmP37t36GL/4ELR/8cUXCXoP/iDhj1hKM27cOA0e8ccfvvvuOyMoKMhYv369x/fMmzdPvyIiIjwG+fHZrx307dvXKFasmAaRMHfuXCM4ONj4448/PL5n2rRpxrJly4w9e/bEGuQ//fTTRkrTrl0744EHHtDGk/lzmi5dOuPkyZNutz9+/Lj+DkSwD3fu3NF6y5s3r1MHiK/7tYs6deoYjRo10kY4oLMjR44cxqVLl9xuj9+ZuD5v3bqlj2/cuGG0aNFCG1CuQf6kSZOMlCQ6OlrPG9cSOpIA11rhwoUd9eXq+vXren3if8D7+vfvb2TOnNlxfcZnv+4wyCe6B9q2bWs0btzY6bnnn39ef4gT8p747NcO0PvWpUsXp+dat26tf7gS8h78kb/vvvu0lxq9VOYfQbtDQPryyy87Pffggw9qUBmXCxcueAzyE7LfQIWAEn+s33nnHafn0cMZ12gT4LqLLcjv0KGD8euvvxqHDx/WQMDuzp8/b4SEhBiff/654zkEOeh196WXeNOmTVqvBw4cSNT9Bhp0BKEe1q1b53ju7Nmz2lmExqi3vvzyS92PtWGAvzujRo0ytm3bZoSHhxspwebNm7Uedu7c6Xju0KFD+tzXX3/t9X4wgoT34PdpYu6XE2+J7gHkKlapUsXpuerVq2tO5K1bt+L9nvjs1w48nTeeT+h79u7dK506dZImTZpI7ty5ZdasWWJnly9flsOHD/tcn8m1X3+Hc8a5u553tWrVEuW8ly1bJt27d9f9lShRQjZs2CB29scff2g+srU+U6dOLZUqVfKpPrdv367vM3PJE2u/gcY8N+t558iRQ4oVK+ZzfWJOE+aEWL377rvy7LPPSqlSpaRGjRqyf/9+sbPff/9dQkNDnebFYA4C5i3EVZ+YR7dx40aZN2+eDBs2TAYPHixZs2ZN8H6tGOQT3QOYGItfpFZ4jEk1Fy9ejPd74rPfQIeJYpgA5u68L1y4gNHJeL8Hkx3/+usvneh04sQJeeONN6Rnz57y008/iV3hGgJ3dWO+5k/79XdJed6tW7eWM2fOyK5du3Qic/PmzaVNmzY6WdeuEqM+MblxzJgx8vLLLzsm1qbk6xOTN7NkyRLv8966dau8//77MnLkSKfnX3nlFTl37pzs3LlTr0kco23btjrB1K7Onz+vgXdQUJDP9YkG+6uvviqDBg3S67Jjx46Jsl8rBvlE9wBWLkCgaYWg0+w9iu974rPfQGeuAuHuvNHz4fpL0Zf3NG7c2GkliN69e2tPysKFC8WuYqubhFxDSbVff5eU592uXTv9w28eB72mOM7XX38tdpXQ+jx+/Lg0bdpUf7Zff/31RNtvoMJ5YwTjzp078TpvjHQ++uij0q1bN+nXr5/Ta08//bSkSZNGv0eAP3HiRB1VRqPUrlK5+RvsbX2i0bl582ZdfaxZs2bSoEEDiYyMTPB+rRjkE90DhQsX1h9kKzzG0m6elhT05j3x2W+gQy9U/vz53Z436iOx3mMKCwu76312kidPHv3D7K5usOygv+3X35nX0704b9QvhvftfH0mpD4R4NevX1/uv/9+mT9/vtPyg/fyc/In5nmHh4c7PY/HcZ03RjgbNmyoo0dTpkyJ81j43Ql2vz4vX74sV65ccTyHkQsE695eR1jaFb352M/PP/+caPvVfft0NkQUL8jvRm9bVFSU47kVK1Zo75IJ619v2rRJe1m8fY8329gRznvVqlWONBukJ+ExnjdhuBi9JL68x3WNZ6Ty/Prrr7o+sV0h8EEP0sqVKx3PYT7HN99841Q3uH8A6iKx92s3OXPm1LQv63njOkLKl/W8kUKye/dur/eLn3HXeTboIcXvDTtfn1i7Pl++fE71iXkPyKm31iceo9fY+vOP6w859osWLbprHXhv92s3NWvWlAwZMjid95YtW/Q6sp73b7/9pjnjJtQtAvzHHntMpk2bdteI6fXr1+9Klfzuu+/0f9xDw64aNGigo8H4W2L69ttvNSC3/h1GihMane7+zpj3arCmj3m73zh5PUWXiOLtzJkzutYtVsNZuXKl0bt3b12qzTpz/tNPP3WaXe/Ne7zZxq4rRGAFE9wTAOeNtdizZcvmWKoR3nzzTV0i05f3YF3n119/3VizZo2uuoE1jLGONJaJtDOshoG6GjBggNYNlscrUKCAro9twhJvWL7NuiLHxo0bdaUHXLcTJkzQx0eOHPFpv3b01Vdf6coto0ePNpYvX27UrVtX782ApQdNHTt2NGrUqOF4jNVIUH9Y0hX1iSVf8dhczvHixYu68tP777+v62lPmTJF187GvrGij53Nnj3bSJUqla5YtGTJEv25xDKQ1tWF6tWrZ7Rq1cpxbWJ98TJlyhgbNmzQejS/UI++7NeO8LOKezjgGlqwYIFRvHhxo02bNk7b4P4Ozz33nH6P35H4O1O9enVdrtlan+YykFgNBr8/Z8yYYXz77bfG+PHjdcli/E2yu1deeUWXIJ01a5auUISlWl3vX4HXhw8frt/jd0KzZs30b/7atWuNjz76SNfAb9KkiWO5TG/3G5cg/BO/9gsR+QJ3WZ0wYYL24OHOtAMGDNBhZBN65MePH689neadLuN6j7fb2BGGjpGTjB5m5NFj0hdWdDB98cUXujLO+vXrvX4P7nr50Ucf6QgAJkJVrVpV+vbtqz1fdofVMiZPnqzD9mXLlpUhQ4bo9WTCa1gJYvHixfr4hx9+kBEjRty1nyeeeEL69Onj9X7t6vvvv5epU6fqRET8PGKCHXr5TZgIismz6BWFpUuXynvvvXfXfnD9YbUnwGTwDz/8UEcA0OOHnlXkRvt8F8wAhJ7n2bNnawoDeqPxs4u0RBPyw/EYk+Xxc96rVy+3+0H9WX8/xrVfu8LvR8w1wugQriP83TDz6aFz585aT8gbx8/90KFD3e4HK8OY6SNY9WXGjBnaK42fcUy6Rf6+3cXExMjMmTN1FB3fY0I85nOhJ96EemjVqpWuPARIy8F1h79FuCsw5o3g59z6s+zNfuPCIJ+IiIiIyGaYk09EREREZDMM8omIiIiIbIZBPhERERGRzTDIJyIiIiKyGQb5REREREQ2wyCfiIiIiMhmGOQTEREREdkMg3wispWIiAhZu/bf26kHGtyY5pdftuiN0XAe3ti9e5fs2rVLAgluVvTbbzvETvz9s8PN8nBjssRix88wpdq0aaMcPXo0yd8TX1u2bJa///77nhzLbry/bRYRkZ/AnT+PHj0iadOm07uomncIhj17/pBhw4ZKkyYPSyC5efOmtG/fTu+0iztIFixYUMLCwpy22bNnj9y+fVseeOABx3O4a2VUVJRUqlRJAsWyZUslIuKMPPBAFbGDQPjsvvpqjezfv1+qVasWsJ/h/v37tA4rVgycaz0QvPPO2/L44+2kSJEiSfqe+Prww8nSsGEjvUs5+YZBPhEFjDt37siQIa/Kxo0/SeXK90tMTLQcOXJUWrZsKQMGvCSBbMeOX+XMmdOyZctWj7ctX7LkS7l48aJToBiIypUrJ/nz5xe7SEmfXXJ+hqtWrdI6ZJCf/OrUqXtPAnxKGAb5RBQwFiyYr0O3K1euljx58jh6UVevXn3XtoZhyF9//SXh4eHaA4TeVdOVK1dk48aN+n3q1Kn1tdKlSzu9HykXSKdo3LiJ7N69W4O4WrVqS6ZMmfT1gwcPyokTxyVPnrxSpkwZCQkJibXs0dHRup9z585J4cKFpWTJko7X9u37U3744QcNEL/77jsJCQmWpk2bOb3/3+OdkOvXr8lXX32lz1WvXt3x+o0bN2Tfvn1y48Z1qVChomTOnPmuMnhb5uPHj8tffx2URo0aOz1/7NhR+euvQ9K4cWP5++9DcuDAQX0+U6aMUrJkKcdnYkL9GYZIiRIlZOfOndprXa9ePSlduozcvHnDsZ0v+ypVqlSc53no0F9y7NgxDUKKFy8R73oIxM/OhB7vX3/9VctTpkxZj9vFtd/w8FP6mWfNmlXKlSsrqVKl1uddP0MzZQnHDA0N0WOeOXNGLl++7Bg98PYz9HTMuJj7L1myhI5aXLlyVapWrSoZMmSQa9euye+//yapUqXSDoI0adL4VBeJeY36en6eyoX97Ny5Sxo0aKCjSGZHyLp163S/hQsXkR9++F5/BtKlS6spW2nSpJX7778/1utn27ZtcvbsWQkKCpIcOXLoaKn5e8/04IMPSoEC//1ONY+Dusa5p02bRhtjqG8r/A5APV26dEmKFi3mtqGAhhw+Kxw7tmuX4sYgn4gCBoJ2/FGw/nFNmzattGvX7q6g7Lnnesm1a1clQ4aMsn37Nhk+fIS0a9deX8cf/A0b1uv3t2/f0gCuRImS8vHHUzToN9N+Xn11sKYjXL16VQoUKCCVKlWW4OBgGTToJf0jjT9+CHzTp88gH330keTMmcttufEH8/nne+kfLwS8OF7NmjVl4sR39I/twYN/yZ9/7tXADOXCH0bXQPHw4b/l1KmTcvv2HUfZzWATAUiHDu0lX758cvZspERGnpXPPpstxYoVc5yvL2VGnfTv/6I2psx9wOTJk/WPNIJ8jKCY5cAf7J07f5fnn+8tPXr0dEpHOXBgvwaxCAiKFi2qQb5rqocv+7p167bH88Tn9MorgzTPvWLFitpQK1euvIwf/0a86iEQPzvAeXfv3k1/DhDoHTp0SH9mrGlt3ux32rSpMmvWJzr6cP36da3fSZM+0JQk18/w9OlweeaZbvo9fkZxzLCwf49pBvnefIaxHTMu2D/mCuDnHg17NKzQoB848GX5+OP/6TGQR440v/nzF+jvDm/rIrGuUV/OL65yZcuWXaZM+Vi2b98qo0e/pu+ZPPkD+eabr2XJkmX6+I03xuu+Dx8+rB0ZqJ9ChQrLtGnTJX369G7rEQE2fteiowSfKxrMb7/9rtSqVctjus6/xyksJ0+e1LpHIytnzpwyd+7njt+pyKvv16+PNjQwCoSfpdq1a+vPJ36vwtatv8iLL/aTIkWKasPl4sUL+vuD4skgIgoQixcvNipUKG/MnDnDOHnypNtt1q1ba5QvX9aYM2eO4zl8X6vWgx73e/36daNVq5ZO7zH3M3XqFKdtx4wZZTz/fC/j9u1b+jg6Otro3/9FY/DgVzzuf/jwoUb79u2Ma9eu6eMTJ04YNWpUMxYtWujYZuXKFcZDD9WJ9fzHjBltDBjQ3+m5YcOGGlWq3G8cOnRIH8fExBjdu3czRowYnqAyt23b2pg8+QPH46tXr+pxvvvuO7fb//nnXqNy5YrG8ePHncpWqVIFY9++P522HTdurNGvXx+Px/a0r7jOc/jwYcajjzY3IiMjHc+tX78uxX12Q4a8anTp0tm4efOmPj5w4IB+Dr16Pev1fm/fvq2fwc8//+x4z9GjR4yDBw+6/QwHD35Zj3nr1r/7++uvg/p+6zHjOt+4jrlq1Upj/vz5Hs/b3P+RI0f+f3+3jMaNGxrVq1fVz838Wa9bt46xZMmXCarj+FyjcZ2fK2/KZZYDv6+2bNmsn/O2bdscrzdp0sioV6+uERn5jz6+cOGCPjdlyseObf793Tfb47nOnTvHePjhxk7Pub4H+2zdupVx7dpVfXzp0iWjZs0axooVKxxlb9myhdPvU2yD/eL3Oty5c8do1uxhY+LEtxzbLFgwX38Pz5gx3WP5yDP25BNRwHj88cfl0qWLMm/ePJk06T3Jnj2H1Kz5oPTs2csphQK9Qh06dHA8Rk/ihAmX5MKFC5ItWzZ9LiYmRnu10BuJnre8efPKnj277zpm585dHN+jFxupQR07dpLvv/9ee7rwhUmWnlb0wevffvutjBw52tFzhlGB5s1b6Eos7dv/V874wvmZk9IwxF6lSlXZsmVLvMsMjz7aUnsm+/V7UR+vW7dWe+TQE29CLySG5s+fPyfR0THaa4tebWtqFHp6vRly92ZfsZ3nnTu35euvv5Jhw0ZoD6IJE/ZS0meH1/Ha2LHjHSkpSB+pW7eujiR4u1/8DOHzRtoWUjPwGKMCno6JFJFx495w9NpiZKxu3Yc0hcfb843rmLgm467P6o7eZaTBlC1bTveDzw3QO4z6QO+0r3Wc0GvUlzr1tlw4P/yMjh49Svfdrdszd02uRr2ZIxJIEWrb9nH59ttvdCTCE4wGYTQG6VY4j1OnTsn58+cle/bsHt+DuVEYaQCkKCGlCwskAEbXMJqA8n/33beO8ylYsJCORGA0du/evTr68swzPRz7xOjrBx+87/GYFDsG+UQUMPDHBsPj+MKwO4bM5837Qp54oqMsWbLU8QcTwY0159YMPMyAA7nCzz7bQ/P5EYwgjxR/xO7ciXI6HgICa4oD/shh6BhD0diHladVS8z3mEGGCYHB5s2bJTFkzpzF6THO1zzX+JQZEMiiIYVc+sqVK2vA8fDDTR11iUBj1KiReh7IFcbzSFnB8axy5fov4PbE233Ffp4X9PsiRQq7PUZK+ezwHlzX+fPnc3o+f/4CcuTIEa/3i1SkN998SyZOnCgzZ86QqlWrySOPPKLXgLtjosx3HzO/Bnbenq8vx/TENf8d+3dNS4lPHSfGNeprnXr72Xft+pSmAOFzf+GFPnfty3WCNB5jrpIn+LnH79Xy5e+T7NmzaYPj3zKdizXIj+3cMX8AjZpNmzY5bYNGR7Fi/zaKkBqE39vWRjrqDB0wFD8M8okoIKG3Dl9YKrNOnVqyfv166d79vx6g2MyYMV17lGbM+EQbDoA/4PhDFBs0BrA9ep2aNXvE66ADf6guX77k9DzyerNlyypJLT5lBtQPgok1a1ZLgQL5Zdu2rfLJJ586XkcObt++/ZxGOvA5oHfO2b/1Gxvv9+UZGmM4T+TOp+TPLnPmTBpMoQfWyvrY2/1iFARfyAXHRHX0Fp8+fVqefrqb22Mi/93TMb3l7TETi7d1kRjXqC/n58tnj99nmPiNRscXX3wuzzzT3el1d9eCOaLpCp0nn3wyU3P6zcUIkJ+/YcMGnVQcX5gbhdHTIUOGOgXxrgE/GgVorJjzJdyVn7zHm2ERUcBAEO76RxWrSeA519UfYoPJlOj1NwN8TID7+WfnHiZ38IcXK3MsXrzornJ4ugESJmLed18FTXcxYUIkGiW+LqeIHknX9IekKLOpRYtHdRLfypUrNeivUqWKo/xIfcLkOOuKHJ4C7Ngk1r5wnpgYjbJamT2tKeWzQ4pKhQoVtIwm9Ahbe1C92S8CLTRmAD8rXbp0lQYNGurKKO6OWb58eQ0ETQg4vfmZsvLlmInFm7pIrGvUl/Pz9rNHGsz06dN08uro0WN04i16/63+DdD/2wdSq7BvT78b/00j+m9EDOk1CYWfF4yM4nysEPhjgjJgcjG2sV5HSOFBI4jihz35RBQwsE42gs769RvoihH4g7l06RIdQvdlSB89aWPHvia5c+eWLFmy6Brm3q7gMGLESOnZs7t07/6MNG3a9P/vdPqLFCxYQPPB3XnllcHSo8czEhwcogEY8mGxnCLmEvgCw+c4XywliqFx6zKMiV1mQJ2OHz9Opk6dIk8+2dnRKELvdr169eWtt96Up556SgNp9CCay/j5IjH3NWzYcD3PPn1ekPr162uaA5ZcnTdvQYr67Pr3HyC9ej2rwRp6Y1esWC6GEePTfrGyS5cuT2oQivku5p2kx44d5/aYL77YX3r3fl6Pie1Xr16lwfH/XzJe8fWYiSWuukisa9TX8/PmM8IKYJ06PSG1a9fR9+AeIq+++oosWvSlI2URnSN9+/bRnwn8PGAewZgxYzze/yBXrtzy0ksDpEmTJjoHAXNdEgqjYpjbMmrUCF1pqnLlBzS4X79+naZfYrQiS5as0rPnszJmzChdMhQN47lz5zilTJJvGOQTUcB47rnnNT0Hfxh27NihvV2YaIb8cXN4F8v2uQb8+COBPyJYKxpatWql78Wt2bH+fffuPfXGWlj+zeRuP4CgafnylRo4/fHHHzrE3KVLF8cfWXeQ075o0WJZvny5/Pbbbzo5EEswWofMkSdrThL1pFmzZnLr1k3tvcMkQAQKWIfbNYDDxD8sTZeQMpv1hjrHOt2tW7dxeu2ttybIwoULNGc/a9YsuiQfAjvrREJ3ZXN3I6X47sv1PLHfZctWaDCNfWHJzqlTp6e4z6569Roye/ZcfQ8mT3br1l0nJlvzsOPaL9YoX7hwsb6O80aQNn36TF1j3d1nWLNmLfn009myatVKPWbXrk/rz9fVq/+l8MR1vnEdMy7u9o/Pz3VNfKydnyNHTp/qODGuUV/PL65yYaQEjcWXXhro1NAdP368TvZFUG82wJDOgyUr8Xtt/vyFTuW23tgKgfUXX8yT+fPnyfbt27UDZc6cz+Xjjz9yGi11vRkWjlWo0H8TkAHpftbljh977DHtrUcK4G+/7dBlRjFHAfOiTPh9g8m4mzdv0s8Iy4ti6VLe7TZ+grDETjzfS0RERKSjG0jbMW9+hEYFVltp376901rydG89/HBj6dXr+bvuJUIpA3vyiYiIKEHOnj0nQ4YM1huBYVUV9HKLGHrDJCJKHpx4S0RERAmCOTKjRo3RfPUDBw5osL906TJNMaHk4y6NhlIOpusQEREREdkMe/KJiIiIiGyGQT4RERERkc0wyCciIiIishkG+URERERENsMgn4iIiIjIZhjkExERERHZDIN8IiIiIiKbYZBPRERERGQzDPKJiIiIiMRe/g+ZBZ1kgQpFEQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -807,7 +805,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.16" + "version": "3.14.10" } }, "nbformat": 4, diff --git a/docs/examples/tradespace/PlanDeployment.ipynb b/docs/examples/tradespace/PlanDeployment.ipynb index a3554960..d9f059ae 100644 --- a/docs/examples/tradespace/PlanDeployment.ipynb +++ b/docs/examples/tradespace/PlanDeployment.ipynb @@ -38,10 +38,10 @@ "id": "6bc87f54", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:56.501748Z", - "iopub.status.busy": "2026-11-14T15:43:56.501748Z", - "iopub.status.idle": "2026-11-14T15:43:59.159942Z", - "shell.execute_reply": "2026-11-14T15:43:59.159942Z" + "iopub.execute_input": "2026-11-15T04:33:55.747657Z", + "iopub.status.busy": "2026-11-15T04:33:55.747134Z", + "iopub.status.idle": "2026-11-15T04:33:58.254783Z", + "shell.execute_reply": "2026-11-15T04:33:58.254272Z" } }, "outputs": [ @@ -207,18 +207,17 @@ } ], "source": [ - "from trade_space_example import OBJECTIVES, cost_study, describe, space\n", - "from tatc.tradespace import Requirement, aggregate, summarize\n", + "from trade_space_example import OBJECTIVES, cost_study\n", + "from tatc.tradespace import Requirement, summarize\n", "\n", "summary = summarize(cost_study.run(), OBJECTIVES, statistics=[\"accurate\"])\n", - "summary[\"description\"] = space.designs_of(summary).map(describe)\n", "front = summary[summary.pareto]\n", "leaders = front.sort_values(\"sufficient\", ascending=False).drop_duplicates([\"satellites\", \"planes\"])\n", "\n", "phased_study = cost_study.replace(phases=[Requirement(\"sufficient\", \">=\", 50)])\n", "phased = phased_study.run(leaders)\n", "PHASED = [\"deployed\", \"sufficient\", \"sufficient mission\", \"sufficient time\"]\n", - "deployed = aggregate(phased, PHASED, design_columns=[]).set_index(\"design\")[PHASED]\n", + "deployed = summarize(phased, statistics=PHASED).set_index(\"design\")[PHASED]\n", "leaders = leaders.set_index(\"design\")[[\"description\", \"satellites\", \"planes\"]].join(deployed)\n", "leaders[\"lost\"] = leaders[\"sufficient\"] - leaders[\"sufficient mission\"]\n", "leaders.sort_values([\"satellites\", \"planes\"]).round(1)" @@ -238,16 +237,16 @@ "id": "c7af361b", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:59.159942Z", - "iopub.status.busy": "2026-11-14T15:43:59.159942Z", - "iopub.status.idle": "2026-11-14T15:43:59.716373Z", - "shell.execute_reply": "2026-11-14T15:43:59.716373Z" + "iopub.execute_input": "2026-11-15T04:33:58.256178Z", + "iopub.status.busy": "2026-11-15T04:33:58.255956Z", + "iopub.status.idle": "2026-11-15T04:33:58.764620Z", + "shell.execute_reply": "2026-11-15T04:33:58.763942Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -334,10 +333,10 @@ "id": "eec3e4ab", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:59.718378Z", - "iopub.status.busy": "2026-11-14T15:43:59.718378Z", - "iopub.status.idle": "2026-11-14T15:43:59.764094Z", - "shell.execute_reply": "2026-11-14T15:43:59.764094Z" + "iopub.execute_input": "2026-11-15T04:33:58.765902Z", + "iopub.status.busy": "2026-11-15T04:33:58.765713Z", + "iopub.status.idle": "2026-11-15T04:33:58.822545Z", + "shell.execute_reply": "2026-11-15T04:33:58.822090Z" } }, "outputs": [ @@ -510,16 +509,16 @@ "id": "37d6f8ba", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:59.765601Z", - "iopub.status.busy": "2026-11-14T15:43:59.765601Z", - "iopub.status.idle": "2026-11-14T15:43:59.891361Z", - "shell.execute_reply": "2026-11-14T15:43:59.891361Z" + "iopub.execute_input": "2026-11-15T04:33:58.823820Z", + "iopub.status.busy": "2026-11-15T04:33:58.823645Z", + "iopub.status.idle": "2026-11-15T04:33:58.946765Z", + "shell.execute_reply": "2026-11-15T04:33:58.946118Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -602,7 +601,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.16" + "version": "3.14.10" } }, "nbformat": 4, diff --git a/docs/examples/tradespace/PlanForFailures.ipynb b/docs/examples/tradespace/PlanForFailures.ipynb index 10baacdd..7468033f 100644 --- a/docs/examples/tradespace/PlanForFailures.ipynb +++ b/docs/examples/tradespace/PlanForFailures.ipynb @@ -35,10 +35,10 @@ "id": "e20ee309", "metadata": { "execution": { - "iopub.execute_input": "2026-11-15T00:10:38.284584Z", - "iopub.status.busy": "2026-11-15T00:10:38.284584Z", - "iopub.status.idle": "2026-11-15T00:10:40.023692Z", - "shell.execute_reply": "2026-11-15T00:10:40.023692Z" + "iopub.execute_input": "2026-11-15T04:34:00.788084Z", + "iopub.status.busy": "2026-11-15T04:34:00.787934Z", + "iopub.status.idle": "2026-11-15T04:34:02.611928Z", + "shell.execute_reply": "2026-11-15T04:34:02.611440Z" } }, "outputs": [ @@ -74,16 +74,16 @@ "id": "7c437e44", "metadata": { "execution": { - "iopub.execute_input": "2026-11-15T00:10:40.023692Z", - "iopub.status.busy": "2026-11-15T00:10:40.023692Z", - "iopub.status.idle": "2026-11-15T00:10:40.468161Z", - "shell.execute_reply": "2026-11-15T00:10:40.468161Z" + "iopub.execute_input": "2026-11-15T04:34:02.613340Z", + "iopub.status.busy": "2026-11-15T04:34:02.613080Z", + "iopub.status.idle": "2026-11-15T04:34:03.063793Z", + "shell.execute_reply": "2026-11-15T04:34:03.063133Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -132,7 +132,7 @@ "\n", "The policy is a decision of each design: `policy_space` declares whether to restore failed satellites, the numbers of spares in each plane and on the ground (none or one of each), and the policy's other fields (here, half a year of procurement, and a spare produced again once it is used). `space.extend` adds the policy to the design space, with the seed of the failures (`failure_seed`, drawn for each replicate).\n", "\n", - "`Failures` simulate 20 histories of the failures of each replicate, restored by the design's policy. The study evaluates each history by the phases in which its satellites operate, and gives the means over the histories and their quantiles: here, the share accurately sampled in the worst 10% of the histories (`accurate mission histories p10`), and the cost at 70% confidence (`cost histories p70`). The designs are the efficient designs by accuracy of `ExplainTradeSpace`, each with each policy." + "`Failures` simulate 20 histories of the failures of each replicate, restored by the design's policy (which the mission plan reads from the design's value `policy`). The study evaluates each history by the phases in which its satellites operate, and gives the means over the histories and other `statistics` over them: here, two quantiles (`Quantile`), the share accurately sampled in the worst 10% of the histories (`accurate mission histories p10`), and the cost at 70% confidence (`cost histories p70`). The designs are the efficient designs by accuracy of `ExplainTradeSpace`, each with each policy (`failure_space.enumerate` extends each with every policy)." ] }, { @@ -141,10 +141,10 @@ "id": "35efa3e2", "metadata": { "execution": { - "iopub.execute_input": "2026-11-15T00:10:40.468161Z", - "iopub.status.busy": "2026-11-15T00:10:40.468161Z", - "iopub.status.idle": "2026-11-15T00:10:41.517904Z", - "shell.execute_reply": "2026-11-15T00:10:41.517904Z" + "iopub.execute_input": "2026-11-15T04:34:03.065253Z", + "iopub.status.busy": "2026-11-15T04:34:03.064964Z", + "iopub.status.idle": "2026-11-15T04:34:03.867962Z", + "shell.execute_reply": "2026-11-15T04:34:03.867436Z" } }, "outputs": [ @@ -157,14 +157,12 @@ } ], "source": [ - "import dataclasses\n", - "\n", - "from trade_space_example import ACCURACY, PLAN, cost_space, cost_study, describe, space\n", + "from trade_space_example import ACCURACY, cost_space, cost_study\n", "from tatc.tradespace import (\n", " Failures,\n", " Integer,\n", + " Quantile,\n", " Uncertain,\n", - " aggregate,\n", " pareto_front,\n", " policy_space,\n", " summarize,\n", @@ -178,22 +176,15 @@ "failure_space = cost_space.extend(failure_seed=Uncertain.seed(), policy=POLICY)\n", "FAILURES = Failures(\n", " FAILURE_MODEL,\n", - " histories=20,\n", " seed=\"failure_seed\",\n", - " quantiles={\"accurate mission\": 0.1, \"cost\": 0.7},\n", - ")\n", - "# the plan configures the policy (and spares in orbit) of each design from its values `policy`\n", - "failure_study = cost_study.replace(\n", - " space=failure_space, plan=dataclasses.replace(PLAN, policy=\"policy\"), failures=FAILURES\n", + " histories=20,\n", + " statistics=[Quantile(\"accurate mission\", 0.1), Quantile(\"cost\", 0.7)],\n", ")\n", + "# the plan configures the policy (and spares in orbit) of each design from its values `policy`, by default\n", + "failure_study = cost_study.replace(space=failure_space, failures=FAILURES)\n", "\n", "# the efficient designs, each with each policy\n", - "with_policies, base_of = [], {}\n", - "for base in cost_space.designs_of(efficient):\n", - " for policy in POLICY.enumerate():\n", - " design = failure_space.design(base, policy=policy)\n", - " with_policies.append(design)\n", - " base_of[design.key] = base.key\n", + "with_policies = failure_space.enumerate(cost_space.designs_of(efficient))\n", "trades = failure_study.run(with_policies)\n", "print(f\"{len(with_policies)} designs and policies x 5 replicates x 20 histories\")" ] @@ -212,10 +203,10 @@ "id": "4c9a47e8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-15T00:10:41.517904Z", - "iopub.status.busy": "2026-11-15T00:10:41.517904Z", - "iopub.status.idle": "2026-11-15T00:10:41.565279Z", - "shell.execute_reply": "2026-11-15T00:10:41.564567Z" + "iopub.execute_input": "2026-11-15T04:34:03.869200Z", + "iopub.status.busy": "2026-11-15T04:34:03.869025Z", + "iopub.status.idle": "2026-11-15T04:34:03.897198Z", + "shell.execute_reply": "2026-11-15T04:34:03.896609Z" } }, "outputs": [ @@ -489,17 +480,15 @@ " \"accurate p10\": \"accurate mission histories p10\",\n", " \"cost p70\": \"cost histories p70\",\n", "}\n", - "traded = aggregate(trades, statistics=ROBUST).set_index(\"design\")\n", + "traded = summarize(trades, statistics=ROBUST).set_index(\"design\")\n", "traded[\"policy\"] = pd.Categorical(traded.apply(describe_policy, axis=1), POLICIES)\n", - "traded[\"base\"] = [base_of[key] for key in traded.index]\n", - "bases = efficient.set_index(\"design\").loc[traded.base] # the base design of each row\n", - "traded[\"description\"] = space.designs_of(bases).map(describe).to_numpy()\n", - "traded[\"full constellation\"] = bases.accurate.to_numpy()\n", + "# the share accurately sampled by the design without failures (of the same description)\n", + "traded[\"full constellation\"] = traded.description.map(efficient.set_index(\"description\").accurate)\n", "\n", "# four of the designs, with each policy: two satellites in two planes, four in two, six in three, and nine in three\n", "shown = efficient.drop_duplicates([\"satellites\", \"planes\"]).set_index([\"satellites\", \"planes\"])\n", - "shown = shown.loc[[(2, 2), (4, 2), (6, 3), (9, 3)], \"design\"]\n", - "table = traded[traded.base.isin(shown)].sort_values([\"satellites\", \"policy\"])\n", + "shown = shown.loc[[(2, 2), (4, 2), (6, 3), (9, 3)], \"description\"]\n", + "table = traded[traded.description.isin(shown)].sort_values([\"satellites\", \"policy\"])\n", "table.round(1).set_index([\"description\", \"full constellation\", \"policy\"])[list(ROBUST)]" ] }, @@ -532,10 +521,10 @@ "id": "a41c39e2", "metadata": { "execution": { - "iopub.execute_input": "2026-11-15T00:10:41.565279Z", - "iopub.status.busy": "2026-11-15T00:10:41.565279Z", - "iopub.status.idle": "2026-11-15T00:10:41.580602Z", - "shell.execute_reply": "2026-11-15T00:10:41.580602Z" + "iopub.execute_input": "2026-11-15T04:34:03.898629Z", + "iopub.status.busy": "2026-11-15T04:34:03.898442Z", + "iopub.status.idle": "2026-11-15T04:34:03.904828Z", + "shell.execute_reply": "2026-11-15T04:34:03.904302Z" } }, "outputs": [ @@ -802,16 +791,16 @@ "id": "58d5e989", "metadata": { "execution": { - "iopub.execute_input": "2026-11-15T00:10:41.580602Z", - "iopub.status.busy": "2026-11-15T00:10:41.580602Z", - "iopub.status.idle": "2026-11-15T00:10:41.928280Z", - "shell.execute_reply": "2026-11-15T00:10:41.928280Z" + "iopub.execute_input": "2026-11-15T04:34:03.906370Z", + "iopub.status.busy": "2026-11-15T04:34:03.906192Z", + "iopub.status.idle": "2026-11-15T04:34:04.172772Z", + "shell.execute_reply": "2026-11-15T04:34:04.172204Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -862,10 +851,10 @@ "id": "c687c0ed", "metadata": { "execution": { - "iopub.execute_input": "2026-11-15T00:10:41.928280Z", - "iopub.status.busy": "2026-11-15T00:10:41.928280Z", - "iopub.status.idle": "2026-11-15T00:10:42.227942Z", - "shell.execute_reply": "2026-11-15T00:10:42.227942Z" + "iopub.execute_input": "2026-11-15T04:34:04.174001Z", + "iopub.status.busy": "2026-11-15T04:34:04.173827Z", + "iopub.status.idle": "2026-11-15T04:34:04.490658Z", + "shell.execute_reply": "2026-11-15T04:34:04.490076Z" } }, "outputs": [ @@ -917,11 +906,11 @@ " \n", " \n", " points_seed\n", - " 88.7\n", - " 35.9\n", + " 88.2\n", + " 35.6\n", " 0.0\n", - " 8.6\n", - " 4.6\n", + " 8.5\n", + " 4.5\n", " 0.0\n", " \n", " \n", @@ -949,19 +938,19 @@ "text/plain": [ " accurate mission accurate mission histories p10 \\\n", "parameter \n", - "points_seed 88.7 35.9 \n", + "points_seed 88.2 35.6 \n", "cost_growth 0.0 0.0 \n", "failure_seed 3.7 65.5 \n", "\n", " cost histories p70 accurate mission se \\\n", "parameter \n", - "points_seed 0.0 8.6 \n", + "points_seed 0.0 8.5 \n", "cost_growth 78.7 0.0 \n", "failure_seed 37.2 0.7 \n", "\n", " accurate mission histories p10 se cost histories p70 se \n", "parameter \n", - "points_seed 4.6 0.0 \n", + "points_seed 4.5 0.0 \n", "cost_growth 0.0 19.0 \n", "failure_seed 6.9 7.6 " ] @@ -977,9 +966,7 @@ "from tatc.tradespace import attribute_variance\n", "\n", "began = time.perf_counter()\n", - "attribution = attribute_variance(\n", - " failure_study, list(ROBUST.values()), failure_space.designs_of(trades, keys=chosen.index), sample_size=20\n", - ")\n", + "attribution = attribute_variance(failure_study, list(ROBUST.values()), chosen, sample_size=20)\n", "print(f\"{len(attribution.results)} evaluations in {time.perf_counter() - began:.0f} s\")\n", "attribution.summary.mul(100).round(1)" ] @@ -998,16 +985,16 @@ "id": "608307dd", "metadata": { "execution": { - "iopub.execute_input": "2026-11-15T00:10:42.227942Z", - "iopub.status.busy": "2026-11-15T00:10:42.227942Z", - "iopub.status.idle": "2026-11-15T00:10:42.308254Z", - "shell.execute_reply": "2026-11-15T00:10:42.308254Z" + "iopub.execute_input": "2026-11-15T04:34:04.491869Z", + "iopub.status.busy": "2026-11-15T04:34:04.491714Z", + "iopub.status.idle": "2026-11-15T04:34:04.565050Z", + "shell.execute_reply": "2026-11-15T04:34:04.564583Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1041,7 +1028,7 @@ "id": "da3c8d4e", "metadata": {}, "source": [ - "The sample of points spreads the mean shares accurately sampled (89% of their variance between replicates), and the failures hardly do (4%), as each replicate averages 20 histories. The share in the worst 10% of the histories is spread mostly by the failures (66%, and 36% by the points), as a quantile of 20 histories is a noisy estimate. Both are noise of the estimates, with different remedies: more points would sharpen the means, and more histories the worst 10%, which is cheap.\n", + "The sample of points spreads the mean shares accurately sampled (88% of their variance between replicates), and the failures hardly do (4%), as each replicate averages 20 histories. The share in the worst 10% of the histories is spread mostly by the failures (66%, and 36% by the points), as a quantile of 20 histories is a noisy estimate. Both are noise of the estimates, with different remedies: more points would sharpen the means, and more histories the worst 10%, which is cheap.\n", "\n", "The cost at 70% confidence is spread by the growth of the cost of development (79%), a risk of the mission, and by the failures (37%), which cost replacements and spares. These shares are the least certain, with standard errors of 19 and 8 points. The total shares of each objective sum to about 100% within their errors, so the parameters hardly interact." ] @@ -1060,10 +1047,10 @@ "id": "d53fe0cc", "metadata": { "execution": { - "iopub.execute_input": "2026-11-15T00:10:42.308254Z", - "iopub.status.busy": "2026-11-15T00:10:42.308254Z", - "iopub.status.idle": "2026-11-15T00:10:42.593461Z", - "shell.execute_reply": "2026-11-15T00:10:42.593461Z" + "iopub.execute_input": "2026-11-15T04:34:04.566350Z", + "iopub.status.busy": "2026-11-15T04:34:04.566189Z", + "iopub.status.idle": "2026-11-15T04:34:04.766270Z", + "shell.execute_reply": "2026-11-15T04:34:04.765745Z" } }, "outputs": [ @@ -1108,8 +1095,8 @@ " \n", " \n", " points_seed\n", - " 95.8\n", - " 42.7\n", + " 95.6\n", + " 42.5\n", " 0.0\n", " 9.7\n", " 7.2\n", @@ -1140,7 +1127,7 @@ "text/plain": [ " accurate mission accurate mission histories p10 \\\n", "parameter \n", - "points_seed 95.8 42.7 \n", + "points_seed 95.6 42.5 \n", "cost_growth 0.0 0.0 \n", "failure_seed 2.5 72.7 \n", "\n", @@ -1219,7 +1206,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.16" + "version": "3.14.10" } }, "nbformat": 4, diff --git a/docs/examples/tradespace/RankUncertainDesigns.ipynb b/docs/examples/tradespace/RankUncertainDesigns.ipynb index 9d423db6..96b64398 100644 --- a/docs/examples/tradespace/RankUncertainDesigns.ipynb +++ b/docs/examples/tradespace/RankUncertainDesigns.ipynb @@ -25,10 +25,10 @@ "id": "cc653395", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:22.553883Z", - "iopub.status.busy": "2026-11-14T15:43:22.553883Z", - "iopub.status.idle": "2026-11-14T15:43:24.983545Z", - "shell.execute_reply": "2026-11-14T15:43:24.983545Z" + "iopub.execute_input": "2026-11-15T04:33:23.769368Z", + "iopub.status.busy": "2026-11-15T04:33:23.769164Z", + "iopub.status.idle": "2026-11-15T04:33:26.588267Z", + "shell.execute_reply": "2026-11-15T04:33:26.587582Z" } }, "outputs": [ @@ -41,7 +41,7 @@ } ], "source": [ - "from trade_space_example import OBJECTIVES, describe, designs, space, study\n", + "from trade_space_example import OBJECTIVES, designs, study\n", "\n", "results = study.run(designs)\n", "print(f\"{len(results)} evaluations: {len(designs)} designs x {study.replicates} replicates\")" @@ -63,10 +63,10 @@ "id": "4aef9718", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:24.985548Z", - "iopub.status.busy": "2026-11-14T15:43:24.985548Z", - "iopub.status.idle": "2026-11-14T15:43:26.232628Z", - "shell.execute_reply": "2026-11-14T15:43:26.232628Z" + "iopub.execute_input": "2026-11-15T04:33:26.589701Z", + "iopub.status.busy": "2026-11-15T04:33:26.589494Z", + "iopub.status.idle": "2026-11-15T04:33:27.738671Z", + "shell.execute_reply": "2026-11-15T04:33:27.737770Z" } }, "outputs": [ @@ -284,7 +284,6 @@ "from tatc.tradespace import pareto_probability\n", "\n", "probability = pareto_probability(results, OBJECTIVES, n_resamples=1000)\n", - "probability[\"description\"] = space.designs_of(probability).map(describe)\n", "candidates = probability[probability.pareto_probability >= 0.1].sort_values([\"satellites\", \"planes\", \"sufficient\"])\n", "candidates[[\"description\", \"satellites\", \"planes\", \"sufficient\", \"pareto\", \"pareto_probability\"]].round(2)" ] @@ -303,16 +302,16 @@ "id": "19cf5721", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:26.234633Z", - "iopub.status.busy": "2026-11-14T15:43:26.234633Z", - "iopub.status.idle": "2026-11-14T15:43:26.673639Z", - "shell.execute_reply": "2026-11-14T15:43:26.673639Z" + "iopub.execute_input": "2026-11-15T04:33:27.740851Z", + "iopub.status.busy": "2026-11-15T04:33:27.740534Z", + "iopub.status.idle": "2026-11-15T04:33:28.244008Z", + "shell.execute_reply": "2026-11-15T04:33:28.243354Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -374,10 +373,10 @@ "id": "104737eb", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:26.675397Z", - "iopub.status.busy": "2026-11-14T15:43:26.675397Z", - "iopub.status.idle": "2026-11-14T15:43:40.110219Z", - "shell.execute_reply": "2026-11-14T15:43:40.110219Z" + "iopub.execute_input": "2026-11-15T04:33:28.245498Z", + "iopub.status.busy": "2026-11-15T04:33:28.245214Z", + "iopub.status.idle": "2026-11-15T04:33:41.571948Z", + "shell.execute_reply": "2026-11-15T04:33:41.571317Z" } }, "outputs": [ @@ -421,47 +420,47 @@ " 0\n", " 0\n", " 31\n", - " 2\n", - " 29\n", - " 145\n", + " 1\n", + " 30\n", + " 150\n", " \n", " \n", " 1\n", " 1\n", " 16\n", - " 11\n", - " 5\n", - " 25\n", + " 10\n", + " 6\n", + " 30\n", " \n", " \n", " 2\n", " 2\n", - " 14\n", + " 13\n", " 11\n", - " 3\n", - " 15\n", + " 2\n", + " 10\n", " \n", " \n", " 3\n", " 3\n", - " 14\n", - " 12\n", + " 13\n", + " 11\n", " 2\n", " 10\n", " \n", " \n", " 4\n", " 4\n", - " 14\n", " 13\n", + " 12\n", " 1\n", " 5\n", " \n", " \n", " 5\n", " 5\n", - " 14\n", " 13\n", + " 12\n", " 1\n", " 5\n", " \n", @@ -469,9 +468,9 @@ " 6\n", " 6\n", " 14\n", - " 12\n", - " 2\n", - " 10\n", + " 13\n", + " 1\n", + " 5\n", " \n", " \n", " 7\n", @@ -487,13 +486,13 @@ ], "text/plain": [ " round uncertain indifferent refined evaluations\n", - "0 0 31 2 29 145\n", - "1 1 16 11 5 25\n", - "2 2 14 11 3 15\n", - "3 3 14 12 2 10\n", - "4 4 14 13 1 5\n", - "5 5 14 13 1 5\n", - "6 6 14 12 2 10\n", + "0 0 31 1 30 150\n", + "1 1 16 10 6 30\n", + "2 2 13 11 2 10\n", + "3 3 13 11 2 10\n", + "4 4 13 12 1 5\n", + "5 5 13 12 1 5\n", + "6 6 14 13 1 5\n", "7 7 13 12 0 0" ] }, @@ -518,10 +517,10 @@ "id": "355e4987", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:40.110219Z", - "iopub.status.busy": "2026-11-14T15:43:40.110219Z", - "iopub.status.idle": "2026-11-14T15:43:40.283707Z", - "shell.execute_reply": "2026-11-14T15:43:40.283707Z" + "iopub.execute_input": "2026-11-15T04:33:41.573221Z", + "iopub.status.busy": "2026-11-15T04:33:41.573061Z", + "iopub.status.idle": "2026-11-15T04:33:41.579685Z", + "shell.execute_reply": "2026-11-15T04:33:41.579251Z" } }, "outputs": [ @@ -899,7 +898,7 @@ " 800 km, 60 deg FOR, Walker 45 deg: 4 x 1 (spac...\n", " 4.0\n", " 4.0\n", - " 67.07\n", + " 67.13\n", " 15\n", " False\n", " 0.02\n", @@ -974,7 +973,7 @@ "971 38.48 25 True 0.89 True \n", "966 67.60 10 False 0.02 False \n", "981 65.90 10 False 0.00 False \n", - "980 67.07 15 False 0.02 False " + "980 67.13 15 False 0.02 False " ] }, "execution_count": 5, @@ -984,7 +983,6 @@ ], "source": [ "refined = refinement.summary\n", - "refined[\"description\"] = space.designs_of(refined).map(describe)\n", "print(f\"{refined.pareto.sum()} designs are efficient within the tolerance; the designs refined:\")\n", "refined[refined.replicates > 5].sort_values([\"satellites\", \"planes\", \"sufficient\"])[\n", " [\"description\", \"satellites\", \"planes\", \"sufficient\", \"replicates\", \"pareto\", \"pareto_probability\", \"indifferent\"]\n", @@ -1017,10 +1015,10 @@ "id": "807da56f", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:40.286945Z", - "iopub.status.busy": "2026-11-14T15:43:40.286945Z", - "iopub.status.idle": "2026-11-14T15:43:40.378440Z", - "shell.execute_reply": "2026-11-14T15:43:40.378440Z" + "iopub.execute_input": "2026-11-15T04:33:41.580774Z", + "iopub.status.busy": "2026-11-15T04:33:41.580611Z", + "iopub.status.idle": "2026-11-15T04:33:41.671547Z", + "shell.execute_reply": "2026-11-15T04:33:41.670833Z" } }, "outputs": [ @@ -1156,7 +1154,6 @@ "\n", "confirmation = confirm(study, CRITERIA, refinement.results, replicates=20) # 20 new replicates of the front\n", "confirmed = confirmation.summary\n", - "confirmed[\"description\"] = space.designs_of(confirmed).map(describe)\n", "print(f\"{len(confirmed)} designs confirmed, of which {confirmed.pareto.sum()} are efficient by the new replicates\")\n", "print(f\"mean optimism: {confirmation.optimism['sufficient']:.2f} percentage points\")\n", "print(\n", @@ -1183,16 +1180,16 @@ "id": "99289e48", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:40.378440Z", - "iopub.status.busy": "2026-11-14T15:43:40.378440Z", - "iopub.status.idle": "2026-11-14T15:43:40.457984Z", - "shell.execute_reply": "2026-11-14T15:43:40.457984Z" + "iopub.execute_input": "2026-11-15T04:33:41.672900Z", + "iopub.status.busy": "2026-11-15T04:33:41.672729Z", + "iopub.status.idle": "2026-11-15T04:33:41.745212Z", + "shell.execute_reply": "2026-11-15T04:33:41.744748Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1251,10 +1248,10 @@ "id": "419f7f85", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:40.457984Z", - "iopub.status.busy": "2026-11-14T15:43:40.457984Z", - "iopub.status.idle": "2026-11-14T15:43:41.777398Z", - "shell.execute_reply": "2026-11-14T15:43:41.777398Z" + "iopub.execute_input": "2026-11-15T04:33:41.746646Z", + "iopub.status.busy": "2026-11-15T04:33:41.746465Z", + "iopub.status.idle": "2026-11-15T04:33:42.854613Z", + "shell.execute_reply": "2026-11-15T04:33:42.854193Z" } }, "outputs": [ @@ -1371,7 +1368,6 @@ " requirements=[Requirement(\"reliability\", \">=\", 0.8)],\n", ")\n", "reliable = pareto_probability(refinement.results, RELIABLE, n_resamples=1000)\n", - "reliable[\"description\"] = space.designs_of(reliable).map(describe)\n", "print(f\"{reliable.meets_requirements.sum()} of {len(reliable)} designs meet the requirement\")\n", "reliable[reliable.pareto_probability >= 0.1].sort_values([\"satellites\", \"planes\"])[\n", " [\"description\", \"satellites\", \"planes\", \"sufficient p20\", \"reliability\", \"replicates\", \"pareto_probability\"]\n", @@ -1392,16 +1388,16 @@ "id": "da41d282", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:41.777398Z", - "iopub.status.busy": "2026-11-14T15:43:41.777398Z", - "iopub.status.idle": "2026-11-14T15:43:41.888212Z", - "shell.execute_reply": "2026-11-14T15:43:41.888212Z" + "iopub.execute_input": "2026-11-15T04:33:42.856153Z", + "iopub.status.busy": "2026-11-15T04:33:42.855969Z", + "iopub.status.idle": "2026-11-15T04:33:42.943777Z", + "shell.execute_reply": "2026-11-15T04:33:42.943175Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1482,7 +1478,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.16" + "version": "3.14.10" } }, "nbformat": 4, diff --git a/docs/examples/tradespace/SearchTradeSpace.ipynb b/docs/examples/tradespace/SearchTradeSpace.ipynb index 35da1428..6a941d0d 100644 --- a/docs/examples/tradespace/SearchTradeSpace.ipynb +++ b/docs/examples/tradespace/SearchTradeSpace.ipynb @@ -34,10 +34,10 @@ "id": "01692fbc", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:14.742854Z", - "iopub.status.busy": "2026-11-14T15:43:14.741854Z", - "iopub.status.idle": "2026-11-14T15:43:17.184511Z", - "shell.execute_reply": "2026-11-14T15:43:17.184511Z" + "iopub.execute_input": "2026-11-15T04:33:16.312337Z", + "iopub.status.busy": "2026-11-15T04:33:16.311948Z", + "iopub.status.idle": "2026-11-15T04:33:18.460744Z", + "shell.execute_reply": "2026-11-15T04:33:18.460174Z" } }, "outputs": [ @@ -79,10 +79,10 @@ "id": "35495471", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:17.184511Z", - "iopub.status.busy": "2026-11-14T15:43:17.184511Z", - "iopub.status.idle": "2026-11-14T15:43:17.753797Z", - "shell.execute_reply": "2026-11-14T15:43:17.753797Z" + "iopub.execute_input": "2026-11-15T04:33:18.462112Z", + "iopub.status.busy": "2026-11-15T04:33:18.461888Z", + "iopub.status.idle": "2026-11-15T04:33:19.142843Z", + "shell.execute_reply": "2026-11-15T04:33:19.142420Z" } }, "outputs": [ @@ -245,10 +245,10 @@ "id": "01e8217c", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:17.753797Z", - "iopub.status.busy": "2026-11-14T15:43:17.753797Z", - "iopub.status.idle": "2026-11-14T15:43:19.561285Z", - "shell.execute_reply": "2026-11-14T15:43:19.561285Z" + "iopub.execute_input": "2026-11-15T04:33:19.144181Z", + "iopub.status.busy": "2026-11-15T04:33:19.144044Z", + "iopub.status.idle": "2026-11-15T04:33:21.033385Z", + "shell.execute_reply": "2026-11-15T04:33:21.032872Z" } }, "outputs": [ @@ -285,8 +285,8 @@ " \n", " \n", " pymoo (NSGA-II)\n", - " 166.0\n", - " 100.0\n", + " 157.0\n", + " 99.5\n", " \n", " \n", " Latin hypercube sample\n", @@ -300,7 +300,7 @@ "text/plain": [ " designs evaluated hypervolume (%)\n", "Optuna (NSGA-II) 143.0 92.1\n", - "pymoo (NSGA-II) 166.0 100.0\n", + "pymoo (NSGA-II) 157.0 99.5\n", "Latin hypercube sample 176.0 79.3" ] }, @@ -325,7 +325,9 @@ " sampler=optuna.samplers.NSGAIISampler(population_size=20, seed=1),\n", " batch_size=20,\n", " ).results,\n", - " \"pymoo (NSGA-II)\": optimize_pymoo(study, OBJECTIVES, NSGA2(pop_size=20), (\"n_gen\", BUDGET // 20), seed=1).results,\n", + " \"pymoo (NSGA-II)\": optimize_pymoo(\n", + " study, OBJECTIVES, algorithm=NSGA2(pop_size=20), termination=(\"n_gen\", BUDGET // 20), seed=1\n", + " ).results,\n", " \"Latin hypercube sample\": study.run(space.sample(BUDGET, method=\"lhs\", seed=1)),\n", "}\n", "# the hypervolume (% of the true front's) of the designs evaluated so far, after each evaluation\n", @@ -347,16 +349,16 @@ "id": "ce572cad", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:19.561285Z", - "iopub.status.busy": "2026-11-14T15:43:19.561285Z", - "iopub.status.idle": "2026-11-14T15:43:20.050928Z", - "shell.execute_reply": "2026-11-14T15:43:20.050928Z" + "iopub.execute_input": "2026-11-15T04:33:21.034557Z", + "iopub.status.busy": "2026-11-15T04:33:21.034396Z", + "iopub.status.idle": "2026-11-15T04:33:21.458279Z", + "shell.execute_reply": "2026-11-15T04:33:21.457700Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -394,16 +396,16 @@ "id": "d8c9d612", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:20.050928Z", - "iopub.status.busy": "2026-11-14T15:43:20.050928Z", - "iopub.status.idle": "2026-11-14T15:43:20.303984Z", - "shell.execute_reply": "2026-11-14T15:43:20.303984Z" + "iopub.execute_input": "2026-11-15T04:33:21.459515Z", + "iopub.status.busy": "2026-11-15T04:33:21.459276Z", + "iopub.status.idle": "2026-11-15T04:33:21.643244Z", + "shell.execute_reply": "2026-11-15T04:33:21.642747Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -425,7 +427,6 @@ " highlight=evaluated, # the designs the search evaluated, over the others in gray\n", " label=\"evaluated\",\n", " others=\"not evaluated\",\n", - " front=\"pareto\",\n", " front_label=\"true front\",\n", " jitter=0.18, # spreads the designs of each number of satellites, for legibility\n", " legend=\"upper left\" if ax is axes[0] else None,\n", @@ -442,7 +443,7 @@ "id": "d796b1b2", "metadata": {}, "source": [ - "Both optimizers find more of the front than a sample of as many designs. pymoo's proposals gather at the top of each column of designs, near the front, while the sample's spread over the space. pymoo finds the whole front with 166 designs, 15% of the space (its other 34 proposals violate the constraint on the number of satellites). Optuna finds 92% of the hypervolume with 143 designs, and the sample 79% with 176. The searches stop at their budget, not when they converge: a larger budget, or screening first, would bring Optuna's closer to the true front." + "Both optimizers find more of the front than a sample of as many designs. pymoo's proposals gather at the top of each column of designs, near the front, while the sample's spread over the space. pymoo finds 5 of the 7 designs of the front and 99.5% of its hypervolume with 157 designs, 14% of the space (its other 43 proposals violate the constraint on the number of satellites). Optuna finds 92% of the hypervolume with 143 designs, and the sample 79% with 176. The searches stop at their budget, not when they converge: a larger budget, or screening first, would bring Optuna's closer to the true front." ] }, { @@ -488,7 +489,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.16" + "version": "3.14.10" } }, "nbformat": 4, diff --git a/docs/examples/tradespace/TradeCostAndUtility.ipynb b/docs/examples/tradespace/TradeCostAndUtility.ipynb index 5b9f3a2b..f5e38114 100644 --- a/docs/examples/tradespace/TradeCostAndUtility.ipynb +++ b/docs/examples/tradespace/TradeCostAndUtility.ipynb @@ -40,10 +40,10 @@ "id": "216ec565", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:51.170741Z", - "iopub.status.busy": "2026-11-14T15:43:51.170741Z", - "iopub.status.idle": "2026-11-14T15:43:53.762661Z", - "shell.execute_reply": "2026-11-14T15:43:53.762661Z" + "iopub.execute_input": "2026-11-15T04:33:51.182542Z", + "iopub.status.busy": "2026-11-15T04:33:51.182353Z", + "iopub.status.idle": "2026-11-15T04:33:53.363002Z", + "shell.execute_reply": "2026-11-15T04:33:53.362553Z" } }, "outputs": [ @@ -172,7 +172,7 @@ } ], "source": [ - "from trade_space_example import PLANE_GROUPS, accuracy_study, describe, space\n", + "from trade_space_example import PLANE_GROUPS, accuracy_study, space\n", "from tatc.tradespace import (\n", " CostModel,\n", " DeploymentSchedule,\n", @@ -186,8 +186,8 @@ "SCHEDULE = DeploymentSchedule(years=5, development_years=3, production_rate=4, launch_interval=0.5, launch_capacity=3)\n", "COST_MODEL = CostModel(\n", " satellites={ # by field of regard\n", - " 30: SatelliteCost(development=40, first_unit=12, learning_rate=0.9, mass=60),\n", - " 60: SatelliteCost(development=60, first_unit=18, learning_rate=0.9, mass=90),\n", + " 30: SatelliteCost(development=40, first_unit=12, learning_rate=0.9),\n", + " 60: SatelliteCost(development=60, first_unit=18, learning_rate=0.9),\n", " },\n", " launch=LaunchCost(per_launch=8),\n", " operations=OperationsCost(per_year=3, per_satellite_year=0.5),\n", @@ -215,7 +215,7 @@ "* minimize the cost at 70% confidence, and maximize the share of points sufficiently sampled;\n", "* require the cost at 70% confidence to be within a budget of 150 million dollars (a `Requirement`).\n", "\n", - "`aggregate` gives the statistics of the criteria for each design, and whether it is efficient among those that meet the requirement (`pareto`)." + "`summarize` gives the statistics of the criteria for each design, and whether it is efficient among those that meet the requirement (`pareto`)." ] }, { @@ -224,10 +224,10 @@ "id": "80fc3006", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:53.762661Z", - "iopub.status.busy": "2026-11-14T15:43:53.762661Z", - "iopub.status.idle": "2026-11-14T15:43:54.255400Z", - "shell.execute_reply": "2026-11-14T15:43:54.255400Z" + "iopub.execute_input": "2026-11-15T04:33:53.364678Z", + "iopub.status.busy": "2026-11-15T04:33:53.364478Z", + "iopub.status.idle": "2026-11-15T04:33:53.800712Z", + "shell.execute_reply": "2026-11-15T04:33:53.800185Z" } }, "outputs": [ @@ -240,7 +240,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -252,7 +252,7 @@ "source": [ "import matplotlib.pyplot as plt\n", "\n", - "from tatc.tradespace import GRAY, Criteria, Quantile, Requirement, aggregate, plot_designs, use_style\n", + "from tatc.tradespace import GRAY, Criteria, Quantile, Requirement, plot_designs, summarize, use_style\n", "\n", "use_style() # the style of the plots of trade studies\n", "\n", @@ -262,11 +262,11 @@ " statistics=[Quantile(\"cost\", 0.7)], # named cost p70\n", " requirements=[Requirement(\"cost p70\", \"<=\", BUDGET)],\n", ")\n", - "costed = aggregate(results, COST, statistics=[\"cost development\"]) # and whether each design is efficient\n", + "costed = summarize(results, COST, statistics=[\"cost development\"]) # and whether each design is efficient\n", "print(f\"{costed.meets_requirements.sum()} of {len(costed)} designs cost at most {BUDGET} at 70% confidence\")\n", "\n", "groups = costed.planes.clip(upper=3) # 3 or 4 planes share a color\n", - "ax = plot_designs(costed, \"cost p70\", \"sufficient\", by=groups, front=\"pareto\", names=PLANE_GROUPS, legend=\"upper left\")\n", + "ax = plot_designs(costed, \"cost p70\", \"sufficient\", by=groups, names=PLANE_GROUPS, legend=\"upper left\")\n", "ax.axvline(BUDGET, color=GRAY, lw=1, ls=\"--\")\n", "ax.set(xlabel=\"Cost at 70% confidence (millions of dollars)\", ylabel=\"Points sufficiently sampled (%)\", ylim=(0, 105))\n", "ax.set_title(\"Every design, with the efficient designs within the budget ringed\")\n", @@ -287,10 +287,10 @@ "id": "c732c5b8", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:54.255400Z", - "iopub.status.busy": "2026-11-14T15:43:54.255400Z", - "iopub.status.idle": "2026-11-14T15:43:54.271836Z", - "shell.execute_reply": "2026-11-14T15:43:54.271836Z" + "iopub.execute_input": "2026-11-15T04:33:53.801943Z", + "iopub.status.busy": "2026-11-15T04:33:53.801696Z", + "iopub.status.idle": "2026-11-15T04:33:53.808125Z", + "shell.execute_reply": "2026-11-15T04:33:53.807686Z" } }, "outputs": [ @@ -461,7 +461,6 @@ "source": [ "front = costed[costed.pareto].sort_values(\"cost p70\")\n", "front = front.drop_duplicates([\"cost p70\", \"sufficient\"]).reset_index(drop=True) # one of the designs that tie\n", - "front[\"description\"] = space.designs_of(front).map(describe)\n", "front[\n", " [\"description\", \"satellites\", \"planes\", \"deployed\", \"cost development\", \"cost launch\", \"cost p70\", \"sufficient\"]\n", "].round(1)" @@ -503,16 +502,16 @@ "id": "ae075375", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:54.273566Z", - "iopub.status.busy": "2026-11-14T15:43:54.273566Z", - "iopub.status.idle": "2026-11-14T15:43:54.636789Z", - "shell.execute_reply": "2026-11-14T15:43:54.636280Z" + "iopub.execute_input": "2026-11-15T04:33:53.809265Z", + "iopub.status.busy": "2026-11-15T04:33:53.809093Z", + "iopub.status.idle": "2026-11-15T04:33:53.975889Z", + "shell.execute_reply": "2026-11-15T04:33:53.975244Z" } }, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABFcAAAHNCAYAAADbm5R/AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQd4VGXWx//3Tp9MekISIPQmKiCCKBYsFOvasO5aV9eCvaxtdb9ddd1mXXXta9t1XXtBsYBiAxUUsdFLaAnpyfSZe+/3nDOZYQIBkskkM8mcn+Z5c+60O+8Mec897zn/oxiGYUAQBEEQBEEQBEEQBEFICDWxhwmCIAiCIAiCIAiCIAiEBFcEQRAEQRAEQRAEQRA6gQRXBEEQBEEQBEEQBEEQOoEEVwRBEARBEARBEARBEDqBBFcEQRAEQRAEQRAEQRA6gQRXBEEQBEEQBEEQBEEQOoEEVwRBEARBEARBEARBEDqBBFcEQRAEQRAEQRAEQRA6gQRXBEEQBEEQBEEQBEEQOoEEVwShl/Dxxx9DURQ0NDS0+zH/93//h3Hjxu3yPoceeiiuuuoqpDuVlZWYNm0asrKykJeXt9NjNEevv/560uZHEARBEDKZTPc/BEEQokhwRRC6mUceeQTZ2dkIh8OxY263GxaLhR2JthyW1atX7/Z5J0+ejC1btiA3Nzep5/vqq6/i9ttvR7pz77338vtfsmQJVqxYsdNjZB911FHtes7rrrsOc+fO7dLz7ql0JEglCIIgpB7xP4R0RDayhN6EBFcEoZs57LDD2JlZtGhR7Ninn36K0tJSfPnll/D7/bHjH330EQYMGIChQ4fu9nmtVis/BzlDyaSgoICdsXSHHMB9990Xw4cPR58+fXZ6jObIZrO16zldLhcKCwu79LwFQRAEoTsQ/6NnYBhGqwCYIAg9BwmuCEI3M3LkSJSVlfGuUBT6/fjjj8fgwYOxcOHCVsfJGSJ0Xcddd93F93E4HBg7dixefvnlXablPv744ygvL4fT6cSJJ56Ie+65J1YeE89zzz2HQYMG8a7T6aefjubm5p2m5dL9/vSnP+H8889np4ecr8cee6zV833xxRe8C2G32zFhwgTOcKBzowySnfHwww9zEIQeU1JSgpkzZ7Z6zfvuu6/V/en5abcjevsrr7yCZ599ll/n3HPPbfNYWxkXGzduxBlnnMFOHJUP0fmSk7mz3ZQnnngCe+yxB5/nqFGj+LyjrFu3jp+fdtvoc6N5p89pwYIFrZ7j888/53ml2/Pz8zFjxgzU19fzuVIwJxAItLr/CSecgLPOOqvNeYu+5v/+9z8cfPDB/N2YOHEiZ+p8/fXX/H4oSETZOtXV1bHH0ffpj3/8I/r378/BJnqfc+bMid0eDAZx2WWX8XeV3uvAgQP5+xedb4K+U/TaUVsQBEFIX8T/aBs6B7ovPScFic4880xs3bq11X1+/PFHHHvsscjJyeH70Xobn9Xz1FNPYc899+T1lOaY1s/4NTr+9Wme6Fj0c4jO37vvvssbQvQcn332GT8/fTbkE9E6Tmv7hx9+2Oq8yF+44YYbeK7pccOGDcOTTz7JARr6/e9//3ur+9N50GutWrWqzbkgX4l8Dppnel36zMhXoGDP9ddfz74S+Q3/+te/Wj3u+++/x+GHH87fD/JjfvOb33AgLwq9x/322y9Wpn3ggQdi/fr1ePrpp/GHP/wB3333HZ8X/dAxQeixGIIgdDtnnnmmMX369Jg9ceJE46WXXjIuvvhi47bbbuNjXq/XsNlsxtNPP832HXfcYYwaNcqYM2eOsXr1auNf//oX3/7xxx/z7R999JFB/6Tr6+vZ/uyzzwxVVY2//e1vxvLly42HHnrIKCgoMHJzc2Ov+/vf/95wuVzGSSedZHz//ffGJ598YpSWlho333xz7D5Tpkwxrrzyypg9cOBAfh56vpUrVxp33XUXv86yZcv49sbGRr79V7/6lfHjjz8a77zzjjFixAg+t2+//bbN+fj6668Nk8lk/Oc//zHWrVtnfPPNN8b999/f6jXvvffeVo8ZO3Ysnz+xdetW48gjjzROPfVUY8uWLUZDQ0Obxwg6j9dee41/b25uNoYMGWIcfPDBxqeffsrv58UXXzS++OKL2PzQ60R5/vnnjbKyMuOVV14x1qxZwyO91+hntHbtWn5++pzefvttnveZM2fy+YdCIb4PzQF9bpdccomxZMkS44cffjD+8Y9/GNXV1fyZ0+fzv//9L/aaVVVVhtlsNubNm9fm3MW/Jn03fvrpJ2P//fc39t13X+PQQw/l7wHN57Bhw/j7FeWee+4xcnJyjBdeeIE/u9/+9reGxWIxVqxYwbfT96a8vJy/E/SZ0PzQ5xOdb3pN+g7S3JItCIIgpD/if+zIk08+yfel97ZgwQLjgAMOMI466qjY7Rs3buTnpXMlf4Xe01NPPRV73Ycfftiw2+3Gfffdx7d99dVXMZ8lukbHvz7NEx2jeYufvzFjxhjvv/++sWrVKqO2tpZ9hEceeYTnh9bm3/3ud/w669evjz0X+Ti0Vr/66qt8/h9++KHx3//+l2+78847jdGjR7d6r1dccYVxyCGH7HQuzjnnHCM7O9uYNWsWvz+aGzq3GTNm8PPRedx+++3sL2zYsIEf43a72TeKfpZz5841Bg8ezM9FkP9Dn/11113H7438FPpu0fug79q1115r7LnnnuxP0A8dE4SeigRXBCEFPP7440ZWVhYvOE1NTXzxTBeodPEaXfRocaIFjRYfv99vOJ3O2EV/lF//+tfGGWec0aZzc9pppxnHHHNMq/v/8pe/3MG5oeelc4hy/fXXG5MmTdqlc0OOSxRd140+ffoY//znP9mmsbCw0PD5fK3e766cGwpS0IV+/HnEs7vgCnH88cfHFvJdHYsPrjz66KPsRJAT0xbbB1eGDh0aCzBEISeDHLF4J+qJJ56I3U4OHh37+eef2abP68ADDzR2BgVd4p26u+++mwNANM9t0dZrUsCEjtF3KAo5oSNHjozZffv2ZUcpHnKyL730Uv798ssvNw4//PCdvm78PAqCIAg9A/E/dg8FUOgxtAFD3HTTTRwsCAaDbd6f1tNbbrmlzds6Elx5/fXXd3tuFISgDRmCAjn0uA8++KDN+27atIk3rr788ku26fyLiopiQbO2IJ+J5lnTtNgx8h1oEypKOBzm7xD5GsRjjz1m5Ofnc5AlyuzZsznwVVlZyT4WnWc0GLc7X0sQejJSFiQIKYBSXT0eD5dtUL3ziBEjUFxcjClTpsTqnimFcsiQIZz2SumbXq+XO99Qamj0h8pIdiY2t3z5ck7BjGd7O5pmG1/TTOms26fDbs+YMWNiv1MKJ6XRRh9Dr0u3U0rurl43HnpfVHZC75fKX/7973/z++1qKD12n3324TTX3UGfF831r3/961afwR133LHDZxA/PzSfRHR+6DWPOOKInb7OhRdeiPfffx+bNm1im9JjKU13d7Xs8a9JqbzE3nvv3epY9ByampqwefNmTsuNh+yff/6Zf6fXpHOlNPIrrriCz0kQBEHo2Yj/sSOLFy/Gcccdx++XzofmgqioqOCR1kIqAyLh3+2h16b1dFfrenuh0qR4qKyGhPWpFJlKaWjeaY2OPy+TyRQ73+3p27cvjjnmGC5ZIt566y0uIzrllFN2eR5U3qSqaiv/Id6foNek0p/ovNM5UakYlfzE+xNUTkafCflY5FNQCTTN8/33388CyILQGzGn+gQEIROhOliqWSXBONLaiC6MtBBS3SzVDNNtVL9KROtWZ8+ejX79+rV6rvaKs+6M7Z0FclZoQUz2Y3YFOTPffPMNO3R0EX/bbbex3gk5f+RQ0CIfSZbYRigUQmeh2uD2Ev0MqI580qRJrW4jR2Nn8xMNikTnZ3evScEeclLIcZ0+fTrXedPnvjvaes3tj3XkMxo/fjzWrl3LNeBU433qqadi6tSprersBUEQhJ6F+B+toUATXfTTD23sUKCJghdkk/bY7tbt3a3p0SBFvA+zM/8lPjhBUGDlgw8+YN0U+tzotUiPrj3nFeWCCy7gTSvqnkg6Kaeddhrr4HR0jjs77/TatFFD2m4vvvgifve73/F723///dv9HILQE5DMFUFIESQUR8EE+olvgXjIIYfwBe1XX30VE5MbPXo0OzG04NMCG/9DzlBbUMYBBSfi2d7uCuh1SdgsXpS1Pa9rNpv54v2vf/0rli5dyiJw8+bN49vI2Ynf5aDMC7rw7yy0w0U7P3V1dbu9L+3ckPO5Zs2aHT4DEvnryGvurr0zOUOUsULOCM3Jzj7jRCFBPnovJKwbD9n0XYu/HzliFFAiZ4gEgqNzRY6WpmlJPS9BEASh6xH/YxvLli1DbW0t/vznP3N2CgnVb589Q+s2Zfm0FRShzSHKwNnZuk7+CxHvw+xKXHf7NZkyPkgQmDJHKEuHfKModIwCHPPnz9/pcxx99NEctPnnP//JgQ0SA042lFlDgrQUqIo/dwos0WcSv3l00003cQBvr732wn/+859YtynxJ4TeggRXBCFFkONCavC0yMandNLvjz76KO9MRJ0bWrxpB+Pqq6/GM888w6m4lOnxj3/8g+22uPzyy/HOO++wQv/KlSv5OclpSnarxO0hlX1a7EkpnlJF33vvvZha/c5e++2338YDDzzAc0Hq8ZS1Qc8RXZRpB43U/Mm5IcfpnHPO2SFbJBGoSxA5K6SMT44ABU4ogLB9d58opGhPHRPoXKkbD50LBUBojtsLORbk7F166aUcRCLHjpyempqaVnNIXYwoqNEVjhBBqv9/+ctfOGhCabs33ngjz/+VV17Jt9N7euGFF/j86L2+9NJLPFfRbg9RZ7KyspJ3PwVBEISegfgf26BSILq4p/dDPsCbb76J22+/vdV9qPMPbepQNyNqY03viXwSWjsJyrS9++672Teg26LzE80uoewMCt7QOVEghLI22gN1UKTug/Q5UfAi+v6i0DpM/hD5CdQViTadKGBG3QOjkK9EARryPej5DjjgACSbX/7yl1yKRefyww8/cOYTfQcoY4Y2pui86PXJtyIfjzKUaZ4oKBN9H3Qfep/kC23fMVEQehISXBGEFEGOi8/n492fqEZG1LmhVoTRlolRaLG/9dZb+eKeFqQjjzyS03R3ljVB9a6PPPIIOzdUZkI7FuQcxdcidwWU7UB1vbRIUjvEW265hct8iJ29Nl2wkwNBQRR6b3TedGFPdb8ELco0L9QGkeqHKRgydOjQTp8rOVS0yPfp04d3d2gXiBygnQVuKKOEWjFTQIXuS+dEGSYdyVyh+nZ6TXKUqBacHJ033niDM3eiUEvKk08+meur6b12BZSee8011+Daa6/l90LfD3IqyfmKOtSURUQ14NT+kXbLyFmOpjiTI0kpvbRzSbtRgiAIQs9A/I/WmSW0jtMGAmXpkA+wffti0hehTFoqkaI5onbJtPkRLZWhoMJ9992Hhx9+mP0W8lUoeBCFNE+olTE9jlpLk1Zbe6D5y8/Px+TJk1mrhEqVqGQ3HtqcoVIh2rChrBvSbYvPICFIK44CZueddx66AiozokAWZbaSv0DnQxo0Dz74YOx22qghv4Z8IAp+zZo1CxdddBHfTsfpO0XfS/o8yP8ThJ6KQqq2qT4JQRC6B1p0aYGjDJDuhOqYaVFvbGzskM5JJkOOCTlptBMmCIIgCD0Z8T9SB805+RQbNmxoFUwTBCH5iKCtIPRiaPeFFP6p3pZScimFl3ZWuhoq66FOAyR+RxkaN9xwAwuiZqpj0xGoxCZaC98dn5UgCIIgJBvxP1IPlddUV1dz2RJ1CJLAiiB0PRJcEYReDInSUWkHpfmSs0FZEFTa0tWQDgel4tJIqcW0qN95551d/rq9ASqxoQAL6aHEC8EJgiAIQk9B/I/UQ+U1VBJEJVIUdBIEoeuRsiBBEARBEARBEARBEIROIIK2giAIgiAIgiAIgiAInUCCK4IgCIIgCIIgCIIgCJ1AgiuCIAiCIAiCIAiCIAidIOOCKyQx09TUxKMgCIIgCEIyET9DEARBEDKTjAuukGp5bm4uVq5cBl3XkanQe9+yZaPMQYbPAV0AzJkzm8dMRr4LMgeEzEEEmYfk+BmNjY3IZOR7JHNAiJ8RQb4LMgeEzAF6/RxkXHBFEIRteDxufP/9Uh4FQRAEQRCSifgZgiBkEhJcEQRBEARBEARBEARB6KnBlU8++QTHHXcc+vbtC0VR8Prrr+/2MR9//DHGjx8Pm82GYcOG4emnn+6WcxUEQRAEQRAEQRAEQUi74IrH48HYsWPx0EMPtev+a9euxTHHHIPDDjsMS5YswVVXXYULLrgA7733XpefqyD0RoqKijFz5ik8CoIgCIIgJBPxMwRB6GrWrVuHCy+8AL/4xXE46aQTcMcdt0PTNKQCM1LIUUcdxT/t5ZFHHsHgwYNx9913s73HHnvgs88+w7333osZM2Z04ZkKQu/EZDLBbrfzKAiCIAiCkEzEzxAEYWdUVVVh4cKFrMmUleXCpEmTUFpaivby/fff45JLLkJDQ0Or4ytWrMB///sC9t57bzz//H+69e9PSoMrHWXBggWYOnVqq2MUVKEMlp0RCAT4J0q8WnlvVSluD9H3LnOQ2XNQV1eLjz76CNOnH4mCgkJkKvJdkDkgZA66bh4+/fQTLFq0CBaLBQcffDDGjh2HZKOqqUnG3ZmfQfOXyd8l+fckc0CInxFBvgsyB4TMAfi9r169Gn/+819Y7iM+w4SCIIceeih+85uLOYlid37FrFmXtjrmcDj4+YLBYCz4ctBBk/HJJ58lJcDSHj+jRwVXKisrUVJS0uoY2eTI+Hw+ntDtueuuu/CHP/yhzeerrq5EpiNzkNlzUFtbi02bNqKycjNCoW0XB5lKJn8XosgcyBxEy3bffPMxLFiwkFsL084z7QAdc8zRKCoqatdzkINz551/whdffNHKeXrssUdhtVpZc+3iiy9K2jmXlfVHKtiZn1FTU4VAwItMR/49ZfYciJ/Rmkz+LkSROcjsOfj660W8ZkY3JUaNGoXi4mLU1NTg559/xty5c7ky5dZbb8WkSfu1+Rx03X/ZZbNi9pFHRpItogGUDRs28uM3bdrEPsyxxx6Np5/+V7f4GT0quJIIN910E6655pqYTYGY8vJy/r24uDRlO13pEDWkf9gyB5k+BwqP+flFKCkpQ6Yi3wWZA0LmADAMA88//xwefPAf7LzE89133+GFF17ASSedjBtvvImzUHYGPfaIIw6D2912+1XaVXrllVfw9ddf4+2330Fv9DOKikqQl5eHTEX+PckcEOJnRJDvgswBkelzsGbNavzxj3/kwMoBB0zG9df/lhvURKGMlr///W/4/PPPcMcdd+Df/34Bw4cP3+F5rrzycvZXiL/85W8xmRHayNnga8A+++yLd999D2eccRp+/PFHDrLQ36Kysq7/G9SjgitUg0W1WfGQnZOT02bWCkFdheinLehLnYlf7HhkDjJ7DlRViY2ZOgfxZPJ3IYrMQWbPwcMPP8Q/BGmckRDlgAEDUFdXj7feeoNLe1566X+oqanGvffeD7O5bTeCdpGigZXCwiLcdNPNOPLII9n+17/+hX/+8yF4vV5UVFSw8/Piiy+hp7IzPyOTv0fxyDxk9hyIn9GaTP4uRJE5yNw5ePrpf8Hv92PcuLF48MGHYmsnBUq8WpADLQ899DAuueRiLFjwBd//rrv+3GbHYaJPnz7c7IaYs+lH3PnTe2gI+pBndeCW0TPw9NPPYuLEffn2G2/8LZ577t9d/h571Kd6wAEHcKpQPB988AEfFwRBEAQhcSiLJBpYIdX9119/E+eccy4OO+xwnHzyyeykPPzwP9kZIg2F5557ts3neeutN1FfX8e/H3jgQZg//5NYYIU477zz8NVXi9C/fyS9lnaVtmzZ3C3vURAEQRCE7qexsQHvvvsu/37eeefHsl83eRvw0Ir5+MtP7/NYFXTjiiuu5NvmzHkX9fX1rZ6HslOipca/+U2ktJjsm5e+ifWeOjSEvDySTSXI0WwVErntDlIaXKFdLWqpTD/RVsv0O+1kRVNtzz777Nj9L774YqxZswa//e1vsWzZMjz88MP43//+h6uvvjpl70EQejIuVzbGj9+XR0EQMpt///t5Hk888USceuqpUBQllsa81d/M4yGHTMENN9zIx1944T9ttjr8+9//ziNltTz66GOx46FQCItr1vNIvPnm27Hbrrvuui5+d4IgpALxMwRBIJYuXcrlQAMHDsIee4yKZaw8s/ZLzK1ajs+r1/JI9l577YUhQ4awv0AlyfHElyyPGhURvV3nrkVNwAMdBqhYiEayN3jquMKFCIfD6PXBFUov3mefffiHoJpl+v22225je8uWLbFASzRFefbs2ZytMnbsWG7J/MQTT0gbZkFIkKysLIwePZpHQRAyl7q6Onz00Tz+/ayzzokdX1xbgV8teAanffYkj2T/4hfHIzc3F5s3b8bChQt2eK7a2hoeKRAT5cFlH2P0u3fipM8e55Fs2lGikiPi559/6oZ3KQhCdyN+hiAIBJUCE4WFhbHNG084gA+2/Izv6jdhVfNWHsn2hoNcUhz/uCgulyv2+7x5c2NBmkhYZRt8RDdikiLkc/T64Aq1WuLJ2O7n6aef5ttppBZN2z/m22+/5cgXid6ce+65KTp7Qej5UN3j+vXreRQEIXPZuHEDZ6FQ+mxUXI4yVa7/9lV8Xr0aq9zVPJJNDsp++03i+9Dfj52x776ROmfaebp3xUfw6yHeTaKRbDo+aNCgbt1REgShexE/QxAEIppBQt3Doq2oye9Y761DyNDYP6CR7VCI7xd53I5Zb1Gt1Rdf/C+PfRzZsCkWREI24JHsYF0TGhoa+NiUKYeiO+hRmiuCICS//pH6xNMoCB2FFiwSG5s161Kcd965uPLKK/Daa6/u0GVGSH90PbLjEy+wV+Vtwmp3DTs8fB8YbG/1NsXuF3WQ2mL9+nU8fte4CUE9zM8S/SH7x6ZKbr24/esKgtB7ED9DSDeoNe/Spd9xBcW6detiXWeErmXcuH04wEKZJNSOmagNetn/UFrCIjSSPe+zTzg7lrJUqKxwe84440wePR4Pbr31d8i2OnB0v9FwKmZQiIXGGaUjcd6vfhV7zB//eHu3vE/xZgRBEIQOQTsN9957Dw4//FBumTd//sf4+uuvMHfuh7zIUQve6G6C0DPo27cvj+TMUBYLURv0bJdkGwmM1Pia8c03i9nu16/fDs/ldDp5fPvtiKbKUGdhyz5SPAoGOfJZP43ojvaIgiAIQuZCgqbkoxx22BSceeYZOPfcs3HssUfj1FNn4uWXX47pgQldg8PhwAknnMi/P/7442hqakSRLQt2UyTjRG0JsdiDBp55+BG+3/HHnxDzKeK58sqrYLfb+Xfa1Js+fSoGb/CjyJ6NLMWCrPd/wmcX3YWmpia+z7Rp0zKjLEgQBEHoWVCmws0334Qnn3wCwWAQo0aNYoHTv/71b7j88iv4YpsWs9tv/yMee+zRVJ+u0E6onSF19qEdvBdeeIGPjcopQZbJ2mpHiey1C79FdXU1100fdNBBOzzXGWf8MlYn/fjjj3JHgL62nFbpumT/7sYbY5kvt99+Z7e9V0EQBCGzmD37bQ6i0IU4lajRmkdlqXTB/fPPP+P//u82XHTRbzgTQug6zjvvfBQXF3Op4Fln/QpffPQJphYPh9NkhcVQ4PypCjlPfILVq1ahqKgI55//6zafx2Qy4d1334sFTEin9clb/4zGa58CbnkRwfk/QmspNx4/fjzuvff+bnuPElwRBEEQ2g11aCMnhTrB/PWvf8dLL72Cs846G0cffQwuuuhivPPOHA6yEA88cD+39xV6BmeeGQmKPP/8c/jwww/5M/7dnkci22SDVTHxeL51BO666098v1NOORUWy447QVdccQU/lrj//vtxw1VX46jiERiX3RfDsoowOpQN68Mf4uN5EQHd/Px8TJgwoVvfqyAIgpAZfP75Z7jpphtZ2+vggw/Bc8/9G3PnfoS3334H8+Z9jGuvvY6zI7766ktcc83Vuyx3FTpHcXExHnnkMQ6cUJfg6667BouuuQ+FD36M7D+/A9N/Pod3cw3f79FHH0dJSckun2vhwq94Y6it0mLFbsXFV16BZ5+NdELsLiLejyAIGQldAOXnF8QuhARhV5DD8fzzz/LvV111NY4++mj+neuVAz7A5uDdBAqybNiwAa+//hpfqE+cODHFZy60h0MOOQSnnnoa/ve/F/GXv/yVnU4KoPxnwC/w85b1+PqDj/HvuX9iB3Wffcbjwgt/0+bz0HfgxRdfwsyZJ/F3Y/78+cD8+TBbLdANA3pom3it1WrD7NnvduO7FAShOxE/Q0gltAZR+TL5L1Ricvvtd7S6EM/Ly+NsigkTJuL888/lQAz9UBBG6BqGDx+Ohx9+iANcL7/8Empra4GmZr6NMmJnzjyFNVUoALM7KHPl0Ucf48/3uEduRf3q9VCsVjjGDEHJwP64dP+z0d3IXzpByGCozdkxxxwTa3cmCLti8eLFLP5GLTXpopvQ6ioR+HoODHcDFFcebBOPhKmglDu5UXCF2vuSaGl7FkkhtVBrxN/97lYWkCOhYtLRoZ/tOfzww3HXXX+BzWbb6XONHDmSU3bPOeesWBvEcLB1PTt1JXrhhRdjqv+CIPQ+xM8QUu23rFy5ktcZKmGOBlZIO26DrwHljjzeENh7773Zr3n22We4NFaCK11Lfn4+Zs26DBdffDE+X/oN3lu3FH4LMGjoUJw0eF8UOfM69Hz0uf7xtItwz/J5qA96kW914pqRh6dELF+CK4IgCEK7WLt2DY8TJ+7HARbaEYoGVggayXZMPwfDhg1H//79sXHjRlRUVEhwpYdAjghlJZEo8fz5n+KjDz9AY201HGYV+wwbiNMvnIW99j+4Xc9Fnz/tTNXV1eEPf/g/VFSsh6KqGL3HnrjlllskqCIIgiB0KSS4T8yYMSPWCnjOph9x50/voTkcQLbZhltGz8CR/fbEySfP5ODKZ599yhmakm3V9ZjNFvyQHYBzZDlItrbJCOK1jd9h1vBDeMOnI+xbOADPTjoLm3wN6NcSNEsF8q0RhAyGdpT/859/48wzz5ZuHcJuidYhxxasgC8WWInCdtDPJUJRx0Tql3seJPZHu0q/LlcRWr0URsAHxeaAZcsSGMZBHXJ6CgoK8Nu7/sgOU3RHqc4IoB8kuCIIvR3xM4RUEu0WU14+IJaxEg2sEDSSPa10FAYMGBDzWTweN3JzO5Y9IXQcrxZkv4A268KGBrNiYtunheA0d6y7zyZvQys/48T+Y9GvgxkwyUCCK4KQ0RgtF77bN1wVhB0pLY04xkuXfsctC802B5cC6c31gBYGTGao2fmA1c4ONemuRB5XmuIzFxLBCHgRWr4IWkN17PNFOBgJtNid7X8ew2CHpy7gQdjQeUx0Z0oQhJ6G+BlCYlD2yEcffYQXX/wv+x2BQIA1UqZNm47TTjudtTt2RzRDknU9AC4FigZWopC92dcIizsY97j2r3FC4jhNVpgUFYvq1sOvh2FXzZhQOBAOk6VDzxP1MyiwQtCYKj9DugUJgiAI7eLAAyez2Bi14aVuMrRgWYaPh7ZlDcJrvueRbDpOoqi0Q0RdYKg8ROh5kLOiNdbA8Llh+L08sk0Cxh3cmarw1GFJw0YsqqvgkWzamRIEQRCE7dm8eRNOOeVkXH31lVi4cAG8Xi/7FBQk+e9/X8CJJx6PP/3pTj62K0iolpgz510Eg0HWWKFSIBhGZC0zDLb7OnLx5ptv8H3HjBkTa/ErdD0GBV6j8Q+lxU4wAyaeaAZMdyPBFUEQBKFdUNvdqJDtHXf8ET/99BNCK7+BqWwozEPH8Ej23Llz8eSTT/D9Tj/9jBSftZAw5HeGg0AowBkrNLLdQRyqBZt8jfBT9gvAI9m0QyUIgiAI8dTUVOO8885lIVrKVLngggvx2mtvsIbXY489wZkrtIlD5Wbki+wq4H/ooYdyO1/S/iKhdiprvnjoQdAMgy/IaSSbNo3+/e9Iy97TTz+zG99tZuPVgtxFcGxuP4zN68cj2R0NilAGDJUC0XchpId5JLujGTDJQDwbQRAEod38+tcX4IsvPsfSpUvxq1+diWmjB+HYfUYgP8uBTfXNeH3Re/hsRQUvbNQhYvr0Gak+ZSFBePcoTA6O0rKrpLDd0cwVnx5CP0cufOFgLO2XbPrdqcruoCAIgrCNe+65B5s2bWINlKeeerpVaTEFSiZPnox33nkHN9xwPV566SX2Mw44YHKbz0XabxdffAmLqj/wwP3weDwIHzwSM8vHwR0OIEu1YOmib/Dsk7/jrJghQ4aw+K3QPThNVqiKgm8aNsJLOismS0JlQRRsO6BwcOtuQX0PT0npsQRXBCGDKSgoxLHHHsejILQHql9+9NHHcd111+Lzzz/D7CUr+Gd7KMPl5ptvSUkbPCE5KMEAFKuN9RJ8KuDQAdVqg0KZLHB1yHkakFUAl9nGmitmRUWBLSslO0qCIHQv4mcIHaG+vh7vvvsO/37XXX+JBVY4qB/wsVg+XTAfffTR+OabxVwi9N///nenwZWoP7J582Y8/vhjnFWrPmtGyZ7DoNosaFy/Be7KGr5f//7leOSRR2Gz2brp3QqEOxTAJk9DbPNlVE7Hdfro+7Ggdi0G2/Jghwlltmy2xxeUd3uARYIrgpDBWCwWTrmkURDaS3Z2Njsg3333Hf773L/w9ZcL4fUHkO104LDDj8BpZ5/Puz9Cz0bJKcDWvoPxlhJAg0lFnqbjOMOGfBIt7sjzKAqr9m+v4i9itoLQ+xE/Q+gI77//Hgvmjx69J8aOHcvHtLpKBL6ew90ISUTfNvFImApKccYZZ3Bw5aOP5qG5uZl9k51x5ZVXYeTIkXjyySfx888/YcuSZbHbzA4bTjnhZFxyyaXc3U7oPjzhAIvZNob9COkaAmqYbW84iCyLrUPlRbM3/YAfGrdw1q0CBXvlluH8IQd0uOtQZ5HgiiBkME1NjViwYAEOP3wq8vI6dsEkZDZ0YTxu3DiMG3d/ZEeJ2i9b7XLB3Iugz/KDSYehccXXUEJ+NFrs+GDERIxK4DOmdoik2k911JSxIt8TQcgMxM8QOsLWrVt5jAZWyL+IBlbYdjew7Zh+DoYOHYasrCwu9aGSnl0FV4gjjzyKS4iue/tJLPn+O/iDAThzc3DQlENw8/hfyLqUAnRdx9rmGvgNjXXegobGdqTDWPsxa8CPLYEVgkayTZrR7dEOydcWhAzG5/Nh9epVPApCopBDorSk6gq9B9oJanTlwLbP4bCNO5xHshNV36fvB+0gyfdEEDIH8TOEjkCCswR19mECvlhgJQrbQT9fgFO75qi2Sns1wAJl2fBOGADPpMFw71mCat0n3etSRHPAj0BLYIWh6i9DQzOVgHWArxs2QN+uyxDZS5o2o7uR4IogCIIgCDtV3yfCLSn9qVLfFwRBEHo/w4cP5/GTT+ZzeRBrrLjyWt2Hbauddd8CgQBnrPTp06ddz29XzFjasBl+XeNAP41k25RIUEfoXuo89S2BFWPbjwE0+hs79DwTcvu3eXxsdhm6GwmuCIIgCGkFpQFTHW5Hu9IIySWqvr+8eSsW1W3gkWzJPBEEQRC6AmqdXFhYyK2R33rrTV5vSGMlGmCJaq5Q1gq1ViZOOOFEWK3t09WoDXlhM5lZWJ18DBrJrg9JZlUqGFlYjixNg2KQTgp4JHtoXr8OPU+jEYR1u7AG2c1G92ckieaKIAiCkDZs8jbsIHxKeh1C9xNV3x+Z3SfW5SdV6vuCIAhC78diseKXv/wVt02+447b4XK5MG3adNZYiWq7+f1+3Pn7W/Hll1+yUPLpp5/e7ucvsmYhz+JAfcAbW+fILmjJ0hS6F7MWwrVbG3BPcQ4CqgqbruOa6iaYdSr3ar8QrQ0qNHJL4vbkyN4+4NIdSHBFEDIYpzMLe+65J4+CkGrIyaHASl3Ag7Ch8Ug2CaHKxXxqNFcoyEVzb2lJmSabatO7W31fEISeifgZQkc5//xf44cffsC8eXNxzTVXY/jwETjmmGOQk5OD1atXc0ZLU1MTVFXFnXfehYEDB7X7uWk9G5ZdjI3eBoQ1HRbVxLb4GKnjoJCBrXUerDYpGKoZbHeU+rA/lo0U7RZENnUhykX3/u2R4IogZDBUp7rPPuN3q7AuCN11MV/hqcOq5mr+nTQ/yOmRi/nUaq5QQCVKZzRXyOmJfq7iyApCZiB+htBRSJz2nnvuxX333cutlleuXIH77lvR6j79+5fj5ptvxiGHTOnQc9MapBsGSu3ZsfWIbPEzUoTNgScH9McnYTf8AH6gQInZhb9a7R16mgHOfPSxu1Djd/PnqSoKiuyulGQ+S3BFEDKYYDCAyspK5OcXwm53pPp0hAzHoVqwxl2DCm99rAyFFki7KktVKqAACJVlvVLxLbb4m1Bmz2E7kcCIlHsJQmYifoaQaIDluuuux4UX/gZvvvkmli5dAp/Hg4KiYkybNg0HHngQZ64k4mds8jUiSD6GauaRbPEzUoMnHMBndgsCASsUXefSoM9sFnjDQbg6EGChLlO/3/No3PnTe2gK+ZFjseOW0TNi3ae6E/kmCUIGU19fjw8//AClpX1RViZOj5BaaBfJF24tPkY27ShlqbaUnVcmU+lrwhdbV6Mq2IwSazYOLB7a4aBItNyrxtcMtxaEpmlS7iUIGYL4GUJnyM3NxZnHTMPJxRr0xhqouUWw7TkiocBKtBVzP0cufOEg/HqYgypk0+9OVTJXuhuvFkJIC8OgltqGDugqQuYw+30udCx75ch+e2Ja6Shs9jWiryM3JYEVQoIrgiAIQtpgM5tRZGRBgw4TVLaF1EDdGG767g0u09IMHeuVerbnHDqrQ44tBc0W167Hl7XrENA12FQTJhUOgm+IpGELgiAIuw7O++e/hNDqpTACPig2BwxfM5wnXJZQcJ7KgAZkFcBltsUyZAtsWQmXuwqdo9DiRP/GBmwwAWEFMBsa2/mWxAKxFFApdxUglUgrZkEQBCEtyDLbMCK7DxrCPlQHPDySLRfgqaHK14QVzVsRNDRoMHgku9rX3KHnscGEL2rWoikcQEAP80h2KlT8BUEQhJ6D4fcitHwRtJpN0Bu28kg2BVo6U+5KARUSs6Ux0XJXIQk01+OKn3/E0OZm9PH7eSQb7gb0VGRLUBAEQUgbciwOlNlz4dOCcJisbAupwRMM8M5ePGR7QiQ7l9vu51nvqeMU33jI3uitx6Cc4qSdryAIgtD7Mle0xhoYPnekbEShlrsKH08UKm2lslRahyhjRQIrqc2QHVtXhwdqa/Czy4U93G5YFJWP91QkuCIIGYyqmuB0OnkUhERhJ4d2kWyOTjkpVD5C5Sf75PePpeuSLSr+qUFRqZmhwm0NY8egQFWSlHGSuG8sCEIPQfwMobMYugZQgJ58DQqskN1JyFcRvyL1KIqCeX2Kcd+woXBbLHCFQrhq1Wqc2IMDXhJcEYQMpri4GCeddDKPgpAIWl0lAl/PgeFugOLKg23ikTAVlHaq9W9dwJOU1r9C5xjkKkSRyYrakA+GokAxDBRaHB2uZ6YWiSYo0OOiKWRLtyBB6P2InyF0FkU1waBuPi3BFbKF3oFhseG+ESPgNkU2bSjAQvYJlp7bxEAKngVBEISEM1YosKI318MIh3jkQEuC6bq0g3FA4WAsb96KRXUVPJItKbupgeb9d5V1KAtpyAlrPJLd0c+jXvOj2J7d6hjZjVogyWcsCIIg9CZovaEOQYozG4rdySPbnfQLyE+hNsCdKS8SOs9GI4gmiwU+kwlek4lHsrfoQfRUJHNFEDKY6upqvPrqK5g583SUlJSk+nSEnkbAx+Jy2pZ1MRV/U9kgIOjnEqGOQk7Ogtq1GJndJ1YLTfb4gnIJsKSC5nocXlWFg1c3YotJQZlmwOLKjQjN5RR0qBsAlRbRJ0hubGQ0Eu4GIAhCz0H8DKEzUEDFMnICwtQtKOiDYnXAPHQM+xuJssnbgNc2fof6oJezY0nQVjIpU0N/xQpdAUKqGvMPLLqOsh7cFluCK4KQwei6Bq/Xy6MgdBTDaodWtZ4DLNDCgMkMqAqneSoJaq5UeOq49a9fD8OumjEsu1g0V1KE4cqD7mmC6q5Hv5Z0bJ3q3bPaL2Yb/VwDWpj1WiisQiPZ9Lm6TJLeLQi9GfEzhM5AGyuOKafA73DBaKqFklMI+35HJbzhQps40cAKQSPZJHArmzjdj1cLISsUQrPNFis/Jtunh9BTvT4JrgiCIAiJEfDB8LphBLyApgEmE9ucuWJ3dvjpHKoFm3yNfNFN+hw0kk1BFiEFBH0sHEi7SZSq6yD1frpAos/XkdXup/GEg9zGmToAxJ7a0OANB+Gy2rvo5AVBEITeAOm4OaafA7jrAVc+VDVxVQsK9kcDK1HIlk2c1GAEvXCbLbDqRizDlWwj4E/s+QyDP2PS8EtVsEw8VkEQBCHhRczwu6GQ8Ji5RcXf7064hpl2KvIsdqxuro6VBQ1xFXIWi7MHp4j2WAJ+VFotmN1nEGosVhSFgjimwY38DgZXssxWuMw2NNH3pSVzhWxxZAVBEIRUCOfHB1hEOD91+LNyYIWCMGW5KYBqgO2A09Vjy71E0FYQBEFICNoVUFz5QFS5XzWxnehuAWWuVPmbEWpJH6eRbMlcSV1Z0P/6luKzwkJ8l5fDI9kdLQtyWeyYVjoKBVYnO7Y0kp3Vg7sBCIIgCN0nnE+BFbbdDZ0WzqeLbrr4JqIX4VISlBpKHDkozylumX+FR7KLHa1F8BMt90qFYLF4rIKQweTn52Pq1Gk8CkIiQnPmAaMQaKoFwgagqmwnKjRHqZyUscJBm5ZFlmz6yVLlQry78fma8V1RH/iDXhi6Ab9FwXdZufD73XC52r8bRJ/jZSOmoK8jF1t8jShz5OKk8nHizApCBiB+htDp8mN3Q+QiOartRoGWBIXzCcpmII2VaIasrEWpQ1EU7F0yDDXQ4QsH4DDb2O7oZ5JO5V4SXBGEDMZqtaG0tJRHQUgUVVFhqBQM6XwypM1kRh+bizVXVChsCynCZkfQakOtSQEpr5igwGyyAgnopJAzSwEWcWYFIbMQP0PoFDYHDNWE8JqlQDAAWG0wDxmT0DoUD61BUpqaerykj2K24ui+e8KvhWBv8Q86GhRJp3IvKQsShAymubkZ3377DY+C0FEMvxfaljVcA63m9eGRbGrLnAhZZhv2LRjAiytBI9niAKUG+jyc2YVQWsQDaSQ70c8j6sxKYEUQMgfxM4TOsv2KIStI78HZEhQhzC2+RiJBkXQq95ItQUHIYLxeD3788Ufss88E5OZ2TEdBEKLw0pWErBVaBI8sHY0fG7bwbgYFV8iWi/HUQALDg812hPwBeHUNTtWEwQX2hAWG00HFXxCE7kX8DKFT0GaNrsE8cE9ADwOkwRbtWpdgWZCQPiiKggMKB+OeZXNRG/Sg0JqFa0YdkZCPkC7lXhJcEQRBEBLWXLEMGYNQXLou2YlqrtDF94LatRiVU4KwocOsqGyPLyiXi/EUYFfMKF3zE6xaEAFFgc0wULDmJ9gObBEw7oEq/oIgCEIPwubgrFjWWWkpE2a7k2VBQnpgGAbeq/wZ3nCQg2Y0kp2o35cO5V5SFiQIgiAkBC1i9imnwLrngTAPHcMj2YkGQqKCZPR4C3UeUpSYIJnQ/SjuBkysb8RqmwXfO6w8kq14Gnusir8gCILQcyA/gFovc0ClJbDCdic3XGj98YQDsg6lGE84gK+rVsLXUAWtsZZHsjnY0kORzBVBEAQhYUwFpXDMOCeSomu1d8rhSSdBMiHSivnr/FwMDQQRbnEYyD6og62Y00nFXxAEQeiBfsb05PgZsUzKDUuwNdCMPrZsnFg+TjIpU4RhGPA3VmNrOIAwDJi1IEoatR4d9JLMFUHIYBwOB4YOHcajICQKt06m1N1OOjzpJEgmAH4jDPewsVAtNlB4i0ayA4aWsGBdFAmaCUJmIH6GkE5+Bl20P7P2S3yw+Wd8Vr2aR7J78sV8T8YRCsPm83BHQvIsaCTbHqYtnY6jaRrWuWt5TBWSuSIIGUxOTi4OOOAAHgUhHUgXQTIhEhQp6jMQ1a58uH1NcDlyUOTMSVjFf3vNFflsBaH3I36GkAw4+EHitp0MsFAZyvubf0KFrx66YUBVFDSG/bhyxKHIski78O7Gp4dh1g00qyrCigKzYcCsh1k439XB55qz6Ufc+dN7aAz5kGtx4JbRM3Bkvz3R3UhwRRAymFAohIaGBhQUFMNmk0VFSA/SQZBMiHwO+WYHHt30GfzcvcmKG/eY1qNV/AVB6F7EzxA6i1ZXicDXc2C4G2KaK1QqlNBzaRo2+Bqg6ZQjQUEbRGzKdJBkym7HbndhSZYdQf40gKCisG2zZXXoeejzu/X7t1ET8EA3dDSHAmxPKx0Fk6njIvydQcqCBCGDqaurxdtvv8WjIAjC9s7KP5fNheJzwxEI8Eh2oum20aCZBFYEIXMQP0PobMZKNLDCtrshYidYxlMX8nFERQdiP2Q30HGh21nvroWfXAL2CxQeyd7gqevY83jqUB1wI2xo0GHwSPZGTz26GwmuCIIgCILQprPS7G0CDHY/eSQ7Fc6KIAiCkIEEfLHAShS2Sdw2Afrbc2EoaMmTiIxkl9lzknCyQkepixe7j9t3aQh17PO1q2YYsU81Atk2tfuLdCS4IgiCIAjCDpSHDdh1DT5VhUdVeCS7rybCf4IgCEI3QBorLW2Yo7BttSf0dHVhH5yqFSoUvpankeyGcGLBGqFz7FNQvq0aq8W1IHvvvL4dep5sqx0O1RIJlrX8kO1K8HvSGURzRRAEQRCEHVBzCzEyqOEzhwmaosBkGGyrOQWpPjVBEIS0pLm5mcugvv/+ewQCARQUFGD69BkYP358qk+tR0JlpKSx4vvyHRh1lVAKSmGfeGTC5aVOE11w22BSFM5soBCLw2KV7nUpwmw242TDhv8avkhpkG7gZMXBxzsCBVKoHCgesimjpbuR4IogZDQKVJUS2EQDQRCE1vj0EJr79MfQ+koEdA021cQ2qfhndbNAnCAIPZXM8DPC4TAeeOB+vPDCf+DztdbvoGPUjvrSSy/GtGkd25EXAL1hK7SV30J310Ot3QJ95ISEBW1dFjsO7TMcH29dCb8Wht1kZls6BaUGzevGj/5mOKwmhA0KTBj4MdAMzeeB2dn+fkEV3noENY3/ylCIhUayN3kbMDCnCN2JBFcEIYMpKSnBmWf+kkdBEITtCVptqM8tQFgLw2wyw2oVB1QQhPaTCX4GBVauueYqzJs3j+2hQ4fiqKOORlaWC6tWrcQ778zG6tWrcMMNN8Jmc+DQQw9L9Sn3GHRdh3f24zA8jVAUlUeys2fd3xK06xiU8XL5iEPR15bD7ZgHOPJx8sDxIrSeIrb63VhjpZBKRKuEconIrgm4UdqB4AplHqmqAkPf9jmSbU9BRpIEVwRBEARB2AGnKS5VusWJJVvSpwVBELbx2GOPcmCFWk3/6U93cRlQ/MX6tddeh9tuuxUffvgBrr/+Orz11myUliaWeZFxNNfBcDdGxEp1PbIWuRsBErXtTImqosBCJSMSVEkpit0BTVXhjyvpsVOxltXRoecpceRgmKsYq5qroRk6TIrKdrEjG92NCNoKQgZTW1uD2bNn8ygI6QK1WPSEAwm3WhSSVxY0xFWEAc58lNqzeSSbyoIEQRDaQ2/3M0hXhcp+iNtu+z1mzIjogdD6Zfi9PObk5OAvf/krRo0aySVDL730v1Sfds8huwCw2aE11ECr38oj2dhO5La90Ofx9NqF+GjrCnxTv4FHssXfSA2FFifJrLSC7HxLx4IrlMV0zcjDUWrLRo7ZziPZiWQ3dRbJXBGEDIZSWevr63gUhHSA6mNf2/gd6oNe5FudOLH/WPRzJuZECZ3PXBmQVQCX2YawocOsqCiwZUnmiiAI7aa3+xlz536I+vp6zkQ55phj+ZhWV4nA13O4ZTB1tiFBVkteH8yceQruuOMOvPzyS7j00lkwiXbVbqFAleLMBbw/AroGqCa2Ey3joY2bL6rXoMrXhJChw6KoCOoavOGg6K6kgI1NVbDpGjQq6WF5YQM2XccWdzUGFvRr9/NQcGyVpwYz+o7mDSASsiWbjnd3yZdkrgiCIAhpAS2C0cAKQSPZsqOUGsghoeAWBVQsqolHsqU2XRAEIcLy5ct5POyww7nDCa1X0cAKQSPbhoEDD5zMfz9ra2s54CTsHt3ngbZxOeDIAhwuHsnW/RE/oaPQ51Dlb0ZTOACvFuSRbPEzUkO5PRcFugGXpiNb03gkmzRxOgJ9luQzUqaK02zlkWyfFkJ3I5krgiAIQloQXRzjiS6OtFgK3Q9lDc0afgh/BpSxIoEVQRCEbYTDkYs30lthAr5YYCUK20E/Z6rQD2XxhEK9M5Mn6QR9MEIBnj+uF6EMB1qHyKaAi9CjMWdl49yAGffZggioKmetnBuwdqhTUDTTlrKd431IslORaSvBFUEQBCEtSKfFUdgGBVQkuCUIgrAjffpEuiD98MP3kQM2B5cCxQdYyIbVjtWr13BghTJc8vPzU3XKPYvsAigWGww/tbc2AENhO1HNFVrPSuzZLJAb0jXOyiRbNg5S1w2qwd+I4+qb4VEVZOkGGhzZfLwjZXPRTNvty8pT8blKWZAgZDC5uXk4+OBDeBSEVBNdHGlRJFK5OArbEIFhQRASpbf7GSRgSxeBixYtwsqVK3m9Io0VDqi0BFbYVhS89dabfGzq1Gmw2+0pPvOegRoKwNR3GBC90Kbsn77DoIaDCT1fltmGvfP6stYKKXzQSLZsIKQGT30l6kM+qDCQrek8ku1trE440/baUUfwmCq9PslcEYQMhhb3gQMHyiIvpA1ShpJeiMCwIAidobf7GSRke/jhR+CDD97Hb397PZ588ikUFJTCPu1soLkeyM5n/Ye3334b7747hx9z+ulnpPScKVBOZbiULZrua6xhtQNaCGphv22tmLUQDIsNiZ55jsWBUnsuvFoATpONbSE1OOzZyAsEUG9SEVYVmA0D+YEA7LasHptpK8EVQchgPB4PfvrpJ7hcucjO7v5e8IKQroujsHOBYQp+pbtDLghCepAJfsb111+Pb7/9BitXrsDJJ5+IU39xLA4rMsHhqcW6oAVvrKzC+x/N5/uecsqpmDBhQsrOtacFzJWgH2pBKQzSWAkGAKuNbYV0WGwdD4pQUKkh6EVkCVN4JFu03VKDyWTCRN2Mf+Y40WAxIS+k4ZIGb4/upCXBFUHIYNzuZnzzzWKMHr1Xr3V6hK6Hy0UCvkituVx09zqBYfp8w4YGs2ISgWFBEDpEJvgZffv2w1NPPY1Zsy7Bhg0b8NCT/8JDbdzvhBOOx80334JU0SMD5jYHTEX9oFAmgx4GVDPU7IiGTSI4VAtWu2uwwduAsKHDHFShKiq37hVSgM2Bb4eMxLCGKoSCYVhMVnw7pBxTEvx80wH5JgmCIAgJo9VVxtpORmvLTQWlqT4tIQlQyrhJUbGobj38epidzwmFAxMWGO5JqeiCIAgdYciQIXjjjbfw7ltv4IV778DPjSFoBpBjVjClxIZf/vlxFJaWpHRHvid25Itq2GzvZyS6htAc+Kk9r2G06IgZbNMcZKktHZ+EbsOnh9BcPhwmswk6ddSy2tFcNoR9Dqeant/J3SHBFUEQBCEhyDGJOjxsuxvYdkw/Ry6eewnUUSFW2K602BmQii4IgtBRrFYrjj5wEg78yAkjHIZGF1q0FppMyC4rRp2RHh356gKeSNaGoqLAlpX2Hflow4b8Cm6/bLUnwb9QoFOnGkOHrlBvF/FXUvmdtDiy8V1uHvzhIOxmKyY4stP+O7krpFuQIAiCkBgBX6t2kwTb5AAJPR7a4dMNA2Ny+mJ0TimPZNMOXyKp6LV+N7zhII9kS/chQRB6HdwlKKLlYeZrdvo7pwBZuak+Mw5KHFA4GMuaqvBl7Toeye4xmyFJWDPoYj6sh1Ef8KAp5OeR7J58Md9rNnFUtVObOOmCZK4IQgZjs9nQr19/HgWhw5DGiiuvVYCF2092slZW13XUBD0osmZxlwUhNZATSi2YP65aAS+ljZssOLRkRIedUArS/Ny4BYvrNsS6QO1bUJ7WqeiCICSHTPMzeM0ioVVveFtgxeZIi7WMAtpzKn/iMhi6lqWR7PEF5WkdYElm+TGtaVv97sjFfMvHs7Ul8O/qwTofPX0TZ1xe/1g2VXQTp6f6Byn/l/7QQw9h0KBB3KJt0qRJ+Oqrr3Z5//vuuw8jR46Ew+FAeXk5rr76avj9sksqCImQl5ePww47jEdBSLQWmgMqLYGVztRCE4trK3DWwmdx7sLneCRbSJ0j/m3dBnY8G4M+HsnuaMaJXTHjm/oNqAt64A4HeCTbpvTcbgCCILSPTPQzFLOFFsjIlbuiROw0gAILi+sqWM+CRFxpJJsCCz2t/DjRzEdPOMg6H6QnZlFNPJKdznPQm3G2lKqR30ifB41k9+RMopQGV1588UVcc801+P3vf49vvvkGY8eOxYwZM7B169Y27/+f//wHN954I9//559/xpNPPsnPcfPNN3f7uQtCb0DTNA5O0igIiUC7R/ZpZ8Mx7SweOyNmSxkr9yyfhzq/GyE9zCPZdFzofrb6m7GqaSuCehiaofNIdg3t+nUAykJqDPp5Jyqgh3kku247YUVBEHofGelnqCbAYgNo551GstMFIxKwoL/pHKAwMqv8OMtshcts4+ASXcjTSHZPzZLo6SiKwhpsFFAhopps6ZxJldZlQffccw8uvPBCnHfeeWw/8sgjmD17Np566ikOomzPF198gQMPPBBnnnkm25TxcsYZZ+DLL7/c6WsEAgH+idLU1BT7PZMd9uh7lznI7DmgQObLL7+EM888G2VlZchU5LuQ+BxQum7w6/egN9ZAzS2CdeKMhAMsdDG/0VOPqkAzNF2DSTVxOQpdzBfZXehq5HuAVu8/4A8gYLS+ICLbH/BD78DnYdEBjxbZFYy6S2Sb9eTOdarS7nfmZ9B7y+Tvkvx7kjnIRD+DAhZKVi4MX0vpCWWukN2SaZHK7wK1IR6RXYyPtq7kkiC7yYLD+gznTnDdcV6J/HswKDhF87dd+bFutkJJ4JwpU2JqyUh8vHVFrEz10D6Rctd0nYPehr7dHJTZc3DJ0INinwcFVtJ1ftrjZ6QsuBIMBrF48WLcdNNNrU546tSpWLBgQZuPmTx5Mp5//nkuHdpvv/2wZs0avPPOOzjrrLN2+jp33XUX/vCHP7R5W3V1JTIdmYPMnoP6+tqWsQaqmu7bF11PJn8XEpoDw4A69zkoFT8DoQDv0LlrtkA/4qyWlOiOEQ6HUeNvRliPXNCHNY3tQG0dqszbAuNdjXwPIqzbtCwiIBj/WRoG1lcsg6XPkHY/T4W3ASbeIKUODQZUKGyvrlyf1I5BZWX9k/ZcHWFnfkZNTRUCAcnOkX9PmT0HGedn6DpMVNJgsUHRNRiqCbrJgtrGBhbsTOV3gQI8Pp8XukaBXwM6dLarqjZ3a6ZAh+dg0Dio338CeJsBZzb0QePQtHVLwq9/Wv5I5GgKqoJulFhdOCp/BLZ24vkSIZP/JuxqDpqR3rTHz0hZcKWmpoZTBEtKSlodJ3vZsmVtPoYyVuhxBx10EP+BIEf84osv3mVZEAVvqPQofkeJtFqI4uLStBCYSgUUEaQvtcxBps9BZDHNzy9CSUnv31HaGfJdSGwOdL8HzRuXQW+uBbQwYDJD3bgM2Xn5UO2RFM+OZq4U2bNRFWhCWNdhVlUU2bJhKyzotsyVTP8exM/DpOH7wbFqDnxxTrfDMDBx5H7ccrS9FGklyF5uR21LGRAFWLKtDowdMBImUxqlyyfIzvyMoqIS5OVlbrtp+fckc5CJfobh98JbPhxhsxlG0A/Faoe5bDDsefmoaWpM6XfBHfKjYpUHRY5sFg1VFQUVYQ+yC4uQRRki0fdgGCw0SlkeyQy6JPzvoaQvjOFjktaKma48x5SPaJUp0V3I3wT0+jnoUd2CPv74Y/zpT3/Cww8/zOK3q1atwpVXXonbb78dt956a5uPIXXynSmU0wfaGz/UjiBzkNlzoKpKbMzUOYgnk78LicwBZyI01UbSnw0dIJV3SoGmOuYE5rGPPRvFdheLnoZUDRbFxDYFVrrzc5HvQQSz2Yz8UAg+CqSQ82kYbNPxjswPOeomzleJNWdgu7fM8878jN7y/jqLzENmz0Gm+RmGIwum4v5Q7FkAZWGqJqjZLRsOTY0p/S7Q69KfclqjTS0BBRriz2mTtwGvbfwO9UFvTP8imRmG0fPo6BxwmUjQl9TOS64UBvcz+W9Cb5+DlL2joqIi3rGqqqpqdZzs0tK26/UpgEIlQBdccAH23ntvnHjiiRxsoZTcdK3NEgRB6NWQ86iFIpkrNLaU9CQCOXzDsothMZlYZI5GsnuysFlPprp2IxotFi7hMekGj2TX1G3u0PNs8DUgaGgR+YGWH7I3+xq77NwFQRBS2UWPAioKZXNm53e6i16yyDLbsG/BANhNkb11GsmOirlSIDwaWCFoJDvRzjzJIrRmKZofuhJND1/DI9mCkK6kLHOFUor33XdfzJ07FyeccAIfowAJ2Zdddlmbj/F6vTtEuKIpxan+hy8IPZHi4j449dTTeBSERFBUEwyqL2/ZoSM7USgNmZy/o0pHc4tIEtmjv/mUuitK/ikgKxeaonCGkkG7nQbAoTNnToeepp8tBwEt0vozCtmltuzkn7MgCGlFJvoZJOrumH5OqzKWdNgEpvM4d/D+yDHbUR1wo9jmwknl42KBH1qDKaDC0guGDrOisp3KNZjmzTv7cRjuSDCeRrKzZ93fK7MehJ5PSsuCqEb5nHPOwYQJE1ig9r777oPH44l1Dzr77LPRr18/zkwhjjvuOO4wtM8++8TKgiibhY73hrptQehuaGGiQKcsUEIisENmcwLuehbx46IPmzPhHTqq76Y05LqABxYK1CgK21QTLXQ/xfZsDpjpVPJFny6nnZg6rH9Tr/m5vKvS3xSr8ye7UQugyCKfrSD0ZjLVz4isjw6kG1Tic9mIKW3qjdAaTH+fF9dvgF8LxzJbUroGN9fFAitR2KbuQTkFnQra1AQ9KLJmZdx3U+jFwZXTTjsN1dXVuO2221BZWYlx48Zhzpw5MZHbioqKVl/43/3ud/xHgMZNmzahuLiYAyt33nlnCt+FIPRc6uvrMHfuhzjqqGNRWFiU6tMRehiG1Q4jHOALbuqCQMXbZHPrxASgv+8HFA7GPcvnxeq9r+l7eFqkU2ciW30tnZvi5p/sal8zyrLz2/085LwOdhUh22SDBp31VkhQscDacdFjQRB6FuJnpCcGK2DtiEKZiroBzdB5JDulZBdAceVCp4AKbeKQTocrF3AlrgOzuLaitZ8x8nDsWzggqactZC4pF7SlEqCdlQGRgG08JKL3+9//nn8EQUhOS/QtW7bwKAgdRXHXQ7VlQXeEYOgalwSRrXgaE9pRolTkBbVrMTK7TywlmezxBeUSYEkB3uZqTkZS451wA/BRd6gOBFdok4Sc1+2dWdktFITej/gZ6QUL1m5Ygq2BZvSxZePE8nExwVoqC2qIdnVryVhsSHFZEK0T9oNPgue1f8DweaA4smA/6ryE1w/KWKG1iDJkqXMdjWQ/t//ZsiYJvSO4IgiCIPRQsgug5hVxC2bqJEMZDmp2XsI7StF6bwqkUKcgItX13plMuasPCkNB1FosMKgLlGGgMBRCv+ziDj8X7QqS81oX9HLGijixgiD0ZlgLMhDpbpMumwN0Ts+s/RKLatfHdM2awgHcNHo6n6NDtWC1uwYV3nre4KhTIlqXdL9UnrNWtR6WvQ4CwkHAbGWbjicyr1QKVOVvQkPQF9vECRkar00dLXkVhLYQ70YQBEFICHK6nMdcyAEVhVJ1s/MidoIXzlHNlXhEcyV1WKwW3FjVgDJ/ADmhEI9kWxLUSaHvRXe31RYEQehutLpK+N5/Bt7Zj/FIdjrgCQdigRWCRrK9FLRo2eBoCvng0YL8u6fFpg2OlBHwwXA3RNr2Wu08ks1iwQlQaHGyoHpIC3MWC41k51vSTx9H6JlI5oogCIKQMJYhY1i1n8XlXHmdunCmXagT+4+NtYKkwArZ6bLrl2koNieOHjAOh65agi2hIMosVjiHjYOShiKNgiAI6QBlVAS+ngO9uQHQwjCaG9i2TT0LaYECGLqOMHSYaY/d1Prcm0MBzlShkhkVCtsp7chKmT+uPOjN9TyfaGlvTV2YEsFvhNHfkYevfI2sK2NSVIx2lCFgaHDGT4YgJIgEVwQhg8nOzsHEifvxKAiJwgGVTqj2x0O135cOOxi1QQ8KRcU/pVBQyz7lFMDuQklzDZzZRbBPOkqCXYIgtJuM8zMCPmg1m6BVrgOCAcBqg6l0UMKZFskky2xDP0cu5jatQEjXuCvfETkjYmW39Lc9x2JHQ8iLsK7DrKroY89O6d98LhMePj7WjpnEbW3jL0z4nOyKGRt9Dcg222IBJLJtLaXIgtBZJLgiCBmM0+nEyJEjeRSEtBHb2y5zJSq2J3Q/lXY7XhsyGHX+IhTYs3Gi3Y5+CT4X7X5SqjmVf0mARhAyg0zzM6iLnk5lQBRYIYIBthPtopdM6G/wFl8Ta6uQrhnpjZAd1S+hv818yprGWR16S8ZKKktz6dxCK7+BqWwoQOVMqplt8+C9E1pHakNe2Exm+DRTTHOF7PqQD0Um0VwROo9sCQpCBuPz+bBmzRoeBaEzzo/h93Y6dZgeT4EVUu8P6WEeyU5pSnIGE/08yOlUWpzPRD8PCpo9tPIT3LNsHo9kC4LQ+8k0P0MJ+qEWlHLGCmO1sa2EWoItKYTEXL1aCCX2bJQ5cngkm8Rco5os9DtlrFBWC41kRzVZUqm5QnEUWodo7IzmSpE1CyX2HPSxuVBqz+aRbBJaF4RkIJkrgpDBNDU14osvPseQIcOQlZWV6tPJeDZt2oTPP/8Mzc3N/HlQKvXQoUORzpBQH9WTs/PjyoNt4pEwkWOZAJTVUOGpw6rm6lgng2HZxdItKEVEuzfFk0j3pliQpuW5aCR71vBDJINFEHo5Gedn2BwwFfWDYbEDAS9gc8KUW5iwRkgyocACZYTS32AqhyHIjgYWKNBCOFoyWKLQ33wX7CnVXOGASgtkJzqfVGp8zcjDuf1yNEOWbClBFpKFBFcEQcgo/H4/Vq5cyWNOTg6GDx+e6lPCzz//hAcffBCffDJ/h6yA/fabhEsuuRQTJ05Eugr3RZ0eGsl2TD8noYtmSlXe5Gts1cmA7FS2gcxkot2b4gMsiXRvSlaQRhAEId2htc9UMhD+z9+E4XNDcbhgO+nytAgk7y6wUGxzYVBWAdZ56mIlM2QX2lIXFKN5o02b7TdxOjOf+xYOwHP7n81ZORRYksCKkEzEYxUEISPYvHkTnn/+ebz++mtoamqKHe/fvxynnHIKDj30kJSc1+eff44rr7ycgz3EhAkT0bdvX9TU1GDhwgX46qsvsXjxItx++534xS9+gbSiJV03nli6bgIdZXx6iMX2fOFIG0i6uCebgixOVS7Cu5tkdW9KVpBGEAQh3aH2vr55L8CgdZBKWIJ+tk17HYx0gAILz046Cxu99fx3ONu6ba2mIMNNo2fg7mVzscXfhDJ7Dq4ddUTKgw+UDUubNuxbWO1JCVTReyqyi8aKkHwkuCIIQq/n66+/xhVXXMblNkR+fj7y8vJQVVWFjRs34N5778Grr76Cxx9/kgMb3cW6detw1VVXcGDlwAMPwo033oTBgwfHbt+yZQvuu+8ezJ49G7feegvKy8uxzz77IG1IcrouXYTnWh0wEMneoZFsuQhPHcno3iQttgVByBSMplpo1RthUNtgQweMcMSmVsJpAOldPbP2SyyqXc/Bn30LBuDcwfvHhOOr/c1Y765FcziAYDjEdjrA60UCmzaC0N1IcEUQMhiLxYKioiIeeytUAjRr1iXwer3Ye++9cemlsziQQReJdOzdd9/FQw/9A+vXr8cll1yEF174L5zO7kmBfeaZp1nkb8KECVwWZLFYW3VVKS0txZ///FeEwxree28OnnjicTz00MNIF7oiXVdp+U9VqCI88p/Q87s30WNIY4VKgShYJoEVQcgMMsHPaAVtEIRDgKeJFnNaKGFk5UQ2HfypFbVl/asNS/BVzTp4tADMULG4rgI5ZjsuGzGFs27u/Ok9ePQQ+0g0kj2tdBRMpt7Vqli61wldhQRXBCGDKSgoxJFHHsVjb+Whhx7kIAqJwz7yyKOw2ba1Q6TWkCeffDImTZqEM888HatXr8Yrr7yCs846u8vPy+124+233+LfL730slhgpa2L2csvv4KDK6TJQqK3/fol2gw3vdN1ydGh9o/j8vvH6r3JFm2O1JBsIVpu9SmfoyBkFJngZ2zfihkUXGnJwOQxHEqLVsy0xn7fuAXLmqug6RpMqooSWw6qA25eZ7f6mzljJR6yN/saUe4qQCphPbqAL5Ix28lgSLI2DQShLUTBRxCEXktlZSU++mge/37LLbfEAivbtw6mUqBf/epX/Pt///sC7950NcuWLeOslZKS0phY7c4uZgcOHIixY8fy7UuWfIt0gxwdJQkOT1Sbg56H2kDSKNocqSMqREvfO2qNTWNUiFYQBEHYEaVuCxRas8w2wBwZyVYatqb61GBXzPipcQs0XUfI0OEPh7DR1wALFF5nyx15yKbzjoPsvo5cpLoroe/9Z+Cd/RiPZCfKzvys7ZsJCEKiSHBFEDKYqqpKPP/8czz2Rj777DNomoZx4/bBsGHDd7lIH3HE4bDb7VweRD9djd/v4zE/Py8WlNhVV5W8vHy2KSDTW4lqc+RZHAjpGo+izZE6KNhlUlQsqd+IRXUbeCRbgl2CILSX3u5n7EBhXyj21togbOeXINXUhrywqWYolE3DejAGVD0Mvy+iq0KlP7eMngGX2cbBBhrJTmVJ0M66EiYaDGm9aaDJpoGQdCS4IghCr6WpqZFHEoKNX6T15nquiaYxukhTiVA0bTm+m1BXkZsb2QnavHkzgsFgq8yN+EWfbGpFXFERCfjk5vb+1NVoKEVCKqmHxYXjPpCo2LAgCIKwI6RVohYPAOhincqDtBDbqe64QxRZs5BtscHQwzAZAIXJcwwFalUFvOGIH7J3fj+cWr4PppeO4pHstO1KmADkZ6mKgiUNtGlQwSPZsmkgJIvU/0sXBEHoIihgQtTV1UUOBHzQajYhvP4nhNd8zyPZtEiHw+FYMMbh6HpF+j32GI2SkhIO5Lz//nt8jDI0DigcjOXNW3nRp5HsxYsXY+3atXxe+++/P3or0XTdOs7eMXiUdN3UQTt8umFgXF5/TCgYwCPZssMnCILQNrrPA726AnC4AGc2j2Tr/tZZqamAfIz+1mzoJANDmbwAsqAgPxyCQ4ts6NCa2xj2I8fq4DHla3BLV8J4OtOVkB8f2SmIwPsHspUjJA8JrgiC0GuJapksXLiA9VdIaE6nMqBgi2BbMMA2Cc198cUXLDJbWFiIwYMHdfm5mc1mnHLKqfz7/fffx22hyYFZULsWI7P78MUsjR9X/Ig///lPfL9jjz0O2dnZSDe217DpzMV8hacO39ZtwIKatTySLRfzqUE0cARBEDpI0Ac9FABCQaBlZDvBTItk4gkHsCnoxgDFAio0pr6IfsPAVHsh66btqjQ51V0JowGWznYljBfO502D/P4x4XxBSAYSXBEEodcydOgwTJgwkXVXHnjgfs5cUQtKAWuLYJvVxravsR7PP/9vPjRz5imxzj1dzZln/hKDBg3Cli1bcOaZZ+DfL76ArU317DSomoGKz7/Fyzf8BcuXL+egz29+8xukG6RZ433vaXjeeIjHzgjNOVQLfm6sxM/NVVjnqeORbCqLElKngUMBFSLaVUE0cARBEHZCdgEU1RIpC9LCPLK9XfZFKlFtTqiaDoTp/MIwDxwd6ebWqjQ5ImKeDgH1aFdC57EX8Uh2osimgdDViMcqCBlMYWERjj/+eB57KxdffDF+85vFePPNN9hRuGBMGUoG7gnoYUA1Y1m9D3+fdRmX3eTnF+D008/otnPLycnBo48+josv/g2//p/vuANmqwXWnCwE3V6E/ZEa6D59+uDhhx9BWVlfpBM0n775LyG8ZmkkG8hqg+FzI+uEyxK6AKddtS2+JuiGzs+tQ2ebasFdnUgBFhKH2lNS62Xa1SPnUwIrgiB0hEzwM+JRgn6oWTnQSCRW1wDVxLZC2SspJstsw74F5Xi1biPcJtpfV2E1VPxv9ULctsdBrAtDpcj3LJuL2qAHhdYsXDPqiLT4u8/nYHMkbdNg+1bM6fAehd6BBFcEIYOh0pTs7Bweeyv7738Afv/7P+APf/g93nrrTcyerWKfIf2RZzNjQ70bKzZH2iNSuc1DDz2E4uLibj2/fv364YUXXsQrr7yMF1/8LyoqKhCuiYi3WfJcOO6kE3HVuRehoKAA6QaVAsUCK0QwwLYR8EGxR7IdOoJXCyFohBGk2m8YXAcdNIX5wt4FCa6kCt7RNHdPNpcgCL2LTPAzdsBsgWLPimSvcFtmS9r8LZ9ZMhpvrvwCdiigHkA5CvCt5oHX24SsrFzMqfyJNzqoVIZGsscXlPeq4INsGghdSQb9pRMEYXsaGxu4XfHUqdM5a6O3cvLJJ6O8vD8ee+wx1l9ZvKoidpvFYsGMGUdi5syTsNdee6fk/FwuF84551z86ldn4a5PX0F1fR0UmwV5ffugyJmD/PxIG+beTqHFiZCmQYPecsRgO9/S9QLDgiAIQvLJFD+jlQCr1cYSqYai8kh2ZwRYk0nf3D7IV8wIGSGEYaAJCuyqic+PgilfVK9Bpa8JYUOHWVERql7D2aNZlpZy6l6CbBoIXYUEVwQhg/H7/Vi3bi2PvZ399pvEP1R+880338Dn8yIvLw+TJx/IY1XV5lSfIvxGGEZRNoqKsncQk0tHJ4CyUyxDxiAUVxZENgnjJUJtyAtVVaBoSixzhez6kA/F5vQT8hUEQRB2TSb5GdGyIFPJQBi6DiXgB2x2ttOhLChaGpSVUwQ0VUExdIoywJldyD4GBVeqfM1oDgdia7Dia5aOfYLQASS4IghCRjF48GD+iUfXo5kSqSUqtBav1p/OQmu082OfcgoURzb0phqoOUWw7Ze4ir9DNYN8OKuicpdE3vkzIIK2giAIQs/A5oCpqB8UW1ZM203N7lzr4GSy2l0DP21i2Jwww0CpPRdD88rgp3Pldb31/aViRhA6hnisgiAIaUJPFFpjFf8Z50TaTFrtnTpXEtPr78xDhbee671NSsSm44IgCIKQ7kRbBwe+ngPD3dDp1sHJhDJQ5mz5CTaTGSX2bOgwYDWZMcCZz5s4HkNHH3s2b26EdI276ZCdDucuCD0FCa4IgiCkET1RaC1ZKv6UrjylZDgW11bAHQ7ARZ0NCgekZUmUIAiCIOyqdXD8pkM6ZMh6tSAaQj4McxVjlbsafi3MmSlH9t2Tz5HW4MnFQ3gNpvtSNq2swYLQMSS4IggZTFaWC3vvPYZHIX3IVKE1et/nDt4fOWY7qgNuFNtcOKl8XI8IMAmCIAg7ktF+RppplURLj4lxef1ZtJbW2aGuotZrsMmGzf5G9LXn4qQB+8gaLAgdQIIrgpDBUJeasWPH8igIicJidwFfpEtCJ52waOZObdCLQqtTSoIEQRB6MJnoZ2h1lTuWBeX1SZvS41cqvsUWfxPK7DltbmBEQkIkLC8IQkeR4IogZDCBQACbN29GXl4hHA5pdyskx4mklOhE2eRt2EFzhgIugiAIQs8j0/wM2myIrolsuxvYtk09C+kAtVn+snYdtvqbUWjLwuSiIbE1ls796bULsbiugkuGlpuq0KwFcPPoGSnPXknmJo4gdCWyJSgIGUxDQz3mzZvLoyAky4lMtG0jPS4aWCFoJFvaQAqCIPRMMs7PCPh4LaR1ywiHIiOtkaS/kmJI9+Wun97Dj02VWOepw+L6Dbh88f+wwV3Ht1Mr5mhghaCRbG84mPJNHN/7z8A7+zEeyRaEdEWCK4IgCEKnnMh4OuNEkoBefBtqgmwS9xUEQRCEtMfmgKGaEF73I0KrlvBIdjq0YiYts1XN1WgIeuHXQ/BrIS4PenTVZ9s2MbbfyzB61yaOIHQ1ElwRBEEQEoPSc12tS3bYTtCJjBfbi0I2dU0SBEEQhJ6A4fdAr98KvbGGR7LTAYdqhicUYCFbCk3QD/3+feNmzk6hbkETCgfCrkZUI2gkO6UC+0nexBGErkY0VwRByDikdjc50NyRxsoOwn0JzmlUbG97zRX5jARBEITO4vF48Pbbb+HNN99gHRhVNWHw4EE4+eRTMHXqEbBYOh9EMPxeaJtX83qoGDqgqGwb5HOkAXobGR/uUIBHWmvPGTwJOWYbtgbc6GNz4cRUd+xr2cSJD7B0ZhNHELoaCa4IQgZjMpngcmXzmCmkq4p/RwJDVD5DWR7pEHQg8VrH9HMiu0hWe1K6BV067GDpFiQIgtALSBc/46OP5uHmm29Cc3Nzq+NVVZVYuHAhSktL8cADD2L06NFJeT1eCZX0Wr+8WggqrdHbxVe2+Bpj2SrcsW/EFC7HpazRVPsZyd7EEYSuRoIrgpDBFBUV44QTTuAxE0h3Ff/2dNJ5dcMSrpsutrm4hWLadNJJUv2zdAsSBEHoPaSDn0GCuldddSULug4aNAinnXYG9t13X2iahvnzP8bLL7+EyspKnHfeOXjmmWcxatQeCb+WYnfCPGQMwquXcraKYnOwTSPQurylu8kyW3ljxheOCNZGoY5A1b5mlLaU+VLgIqWlQF28iSMIXUl6hVQFQRC6kh5Su0tBIFLtjxdsi7ZI/GjrCiyqq+CR7FSLuiVTxV+6BQmCIAjJxO12c8YKBVaOP/4EvP76mzjrrLM4Q2XvvffGZZddjrfffgcTJkzgsqGbbrqxU2sOZ1qMnQJYbZEDVhvb6RAQcFns2K9gwA7H6d3WBTy79EFSDc0fBajSYR4FYVdIcEUQMpjq6q146aX/8ZgRRGt341okplvtLmVuPLhiPv7y0wc8kp2uLRKTreIv3YIEQRB6F6n2M0hjhQIsgwcPxh/+8EeYzeYdAggulwv33/8AHA4HVq5ciUWLFiX8evR8oZXfwNx3KCzDx/FIdjoEKigwMaV4eMSg84n+tIjHE+RzPLTyE9yzbB6PUR9EEIT2IcEVQchgaCcnEAjwmAmQY2EZPh7aljUIr/meR7LTZSdkt9kpadYiMdmZQNItSBAEoXeRaj/j9ddf5/H008+IBVbaCiDk5ubh2GOP49vfeOO1JKyLUW0TJW0yZOkzeGPzUvql1XGbpvE6G80epSyWkB7mUbJHBaFjSHBFEISMIbqjZCobCvPQMTymy45Sq+yUcAi6ofMYzU5JyxaJSW7FHO0WFA2wSLcgQRAEoTNQVyBi330n8Ng6gKC1CiBMnDix5TFbEn9B0lZRTQit+wGhVUt4JDsdMmRrgh40+N2w6pSx0nLQAPr5A1Cbajh7tMJThyX1G7GobgOPZEv2qCC0HxG0FQQhc4jPtIgmg6TJjlKUgBbmFohhQ4dZUVGiZKdti8SuUPHnTgXDD0mbTgWCIAhCz0VVI2tINHMmGkBY5a7m8lq7yYxhrmJec8JhrdVjEkX3uaHXV8EIBqBYbWynA0XWLGTbs2BuBjRygoxI1sqUJjecRf25O98mXyP8ekv5sR5mO7qpIwjC7pF/LYIgZA4tO0rh1d/FVPwtQ8emxY5StCxm+xIYsqPH0q1FYlep+KdbpwJBEAQhNaxfvw5z585FXV0d7HY7xo0bh8mTD+RAQHsYNGgwampq8Omnn7CIrUO1RAIIcfpl0QAC3Sf6mEQx/F6EK5YBmgZeDjWNbfI5Ug2trSNzSrGupgIGBVAMA0N8Ppzp6MOtsinw1M+RC58WjAWeyKYgi1OVNVkQ2oMEVwQhg8nPL8CMGUfymCnwjlLD1rTbUSJ8eghDXEXQDYOdHAq2kB3v2KRj4IEDKtxmUhAEQRA672csX74cf//737BgwRc73Na/fzkuuOBCnHzyybsN6M+cOROLFn2N//3vRe4SZFgjAQNfOMhrKwVVyF6zYT0++OD92GMShQXz3fWATlkwCo9kp0P5MfkVDkXBIYoVPygqYOiwuOwIGTm8QeK02jEgqwBZJiv8egh21YJCuystdM94/ihAJR2DhDRHgiuCkMFYrVYUFxfzmAnQjhKJ2MKZC8WmASYT2+mwo0RQMGWbYxNx+tLFsREEQRCE7vAzFi9ehEsuuRher5cvpA866CAMGTIEjY1NmDdvLjZu3ID/+7/bsG7dWlx77XW7vNiePn0G7rnnblRVVeGKKy7H3Xffu8M6a2kK4OrbLkc4HOaWzKNG7ZHw+6VzUV350BqrOWuF/Ayy0yEgQD6GV9fxvhpGkEuPgX4GMNemYi+LDaqi4IDCwbhn+Tzu1Ee6Z9f02zvl567VVe5QfkxZs4KQjkhwRRAymObmJm45eMghh7JSfkYQCkKPd3ryS5AuKFHHZtlc1AY9KLRmpYVjIwiCIAjd4WdUV1fj8ssv48DKpEmT8Ic/3I7+/fvHbvf5fodnn30G//jHA3j66X9x0OWkk07e6fNRUOe+++7Hr399PhYuXIjp06di/+mHY1WxAnfAB+3njWj+ZiW0cBglJaW4666/dOr9KnYnLCMnAFR+7PdG7KFjuQwZaEh59scydxXClLWia9AMAw2GhobcQg40ORQLFtSuxcjsPjHdN7LHF5SnzA+hc44GVth2N7BN5cjiGwnpiHQLEoQMhpyXZct+5jEjsDmgk+q9twnwNfPIdpporpAT8V7lz5y6Gy0NIjsd0okFQRAEoav9jBdf/C+ampqwxx574KGH/hkLrHC5jd/LuisXXXQxLrvscj7+5JNP7LbN85gxY/H0089i8OAh8Hg8mPvaW1j/2JuofeYDNHz1MwdWxo8fj+ef/zfKyso69X7pgt86dso2v8JqZzsdAgHULSgQDsFlGHAqKhyqirDJDGtDNWfwkM9BGSt0rhbVxCPZKe0WFN+IAOnZiEAQ4pHMFUEQMgZyzAx3I0DK94oOKCrb6VIWRK2YP69ejSp/c2TXKKgiqK+OtGK22FJ9eoIgCILQZVBZzssvv8S/n3/+BRxI2VlZyNlnn41//esprF+/Hl9+uRAHHDB5l8+955574s0338L8Lz7F3557HN7aeiiqiuyyYgw5fBLuPPrcpOiZcabFd/Nh0MU/+RhBP9uOgXsiHboFFVgd8FPGCs0rFLgMBTODBpRQgDVXqBSI2lNHM1cKbFmpLU0mjRVXXqsAC9npsikmCNsjwRVBEDKHIAVRqPegIyI2p5oidprsgJBTRuVA5NQQNJKdaZkrRpygbzrs9gmCIAhdD+miUGcfi8WCqVOP2G1ZyKGHHobZs9/G0qVLdxtcIWg9mTL5YPxQbHBGRhQKKCQrgMDdgtYshRHwA9SRKOBvsVO/iUMdln41aH/8X00F3EaYLwLHwAyTMxKsUNrSXOl7eErXYXptCqZtH1wT30BIVyS4IghCxqDkFEaE5irXApRGrKpQSwdDyc4H/JWpPj12FgotWajUmmK7RmTHOxG9PfCwyduA1zZ+F3PsTuw/lltQC4IgCL0bvz+y0eFwOGCxWHdbFpKTk8N2MBhs92vQuknrymsblmBroBl9bNlsJ3M91ZsboNduivkZKOyHdID8h1WeapRlFyGruRZmQ8NmkwnvlJXh8pbbo5orVApEAadUa64QJF5LwTTeCGsJAglCuiLBFUHIYBwOJ0aMGMFjpmBQpko0EYR/TZ+skCyzDWPy+6Gm0h0LrpAdTVXu7YEHcuyi74+gkexZww8RZ0oQBKGX+xkFBZF2zc3NzdiyZUtE/2QXZSErV65kOz8/v8PnFVn5laR7ALrF1iKaH468iKGzrSeh5Kiz0MbMGncNNoQ8CFktsCg25NuyUKOCgynkD1V46rCquTrWSWlYdjHfloySqc7APgCLAgtCeiOCtoKQwdCuz377TYrt/vR2jKZaGI11XAcd/SHbaK5HupBtsaOvMxcl9mweyd5V4KE3lQxFxfTiSbmYniAIgtAtfgYFSSZMmMjrWlR7JVoWwgGVlsAK2WvWrMGiRV9zqcsRR0RKiNpDdC1tCPlYtJXGpK6ltZsj3QgVUyRrhUay66uQahyqBSuatvK62hj0ojbgQY3fjWKbi7NU6PZNvkZeczVD55FsCrIIgtA+JLgiCBlMKBRCbW0tj5mAYbXDoIt3LRjZVdKCbBtpIhZLwYUGDi4oUNnRU9gmBycTAg9U6kQZOeTkhnSNx2TWwguCIAjp7WecfvrpPFK75SVLlrQqC3EeexGPfls2brvtVr5typQpKCvr2+7z6fK11JUPxWwBTCbAZOaR7axcpINoflWgGYquw9ANDqA0+puxty/AQSyfHkKexY76kJeF9Wkkm7JYBEFoHxJcEYQMpq6uFu+++w6PGQFvTG1fXpI+5Sa8a9S4Fb76SqCplkeyadcoGniglpPecIDH3hZ4iIrpLW/eikV1FTySLSVBgiAImeFnTJs2HQceeBB8Ph8uuOB83HvvPdi8eVNk7du6Ca+++gpOP/00fPfdEs6Gueaa6zp0PtG1NJ5krqUmpwuWvQ+CwmU0Co9kmxxZSDVeLQTdMKBqGiyGAatuwGwAn3z3PjRNYx+kIeRHgcWJUns2j2RL5oogtB/51yIIQsaghPxQKHuFskKoI4+isk0tCNMB2lEraW6AW9MQoPJiTWObdtSoFfOwrCK8uH4xmsMBZJttuGX0jLQIPPB8UicEqo3vxPnEi+lFNWfSQUxPEARB6B5MJhPuvfdeXHvtNfj000/x5JNP8I/NpCCkGdBj+iyFePjhf2Lw4MEdev6YoO12+mXJWmPoebKOvxS+0kEwajZDKeoLx6Sj02INo/KfEosddUojDAr8wEC2psMfDsLXVAMlOw/9HLnwhYMxzRWy6XenmnrNGEHoCUhwRRCEjOoWZCodiHDVhkhZkMkMU0l52nQLcoY1lIc0OGGGX9NhV1UUhjQ4NA26Scdz67+Gy2yDg85bMbE9vWwPrjlPFVpd5Q4tEimFOxGi6drkhFqoTj0uXTvVYnqCIAhC9+B0ZuHBBx/GvHnz8OKLL2DhwoUIaBFNlFK7ihOG5uOMh19HYWFhQs9PQvAklB7tiJPswAetgVlHntequw1l3qQaOo+hOSVY3lQFrSVvN0fTUWCywpFTxL7EgKwC9jOiGxwFtqxelSErCF2NBFcEQcgYyHFwHH4G3K8+AMPngWKzs53K4EQ8it2JiYoN//BuQb0K5OvAkc4yKDYHqgNuVPmb0BD0xZyekKGhLuhFkd2VkvOlTJNoYIVtdwPbVBOfiLMaTdeOr4fvbaVPgiAIQvsyWKZNm4bDxozExv87HU2+IGwmA/kWFarFQK4eaducKLRGdXnQPs0E50lzZXOgGYMceajz1HOJkN9kwjETf8HzTXRlVo8gZAISXBGEDIYzBCzJ37VJVygYoFWth3XvQ4BwADDb2DaniQNE5/cVghga0hDWwjCbzGxPNgwUWpwIaGGESegVQNjQ2M63pLA1YcDXqj0mwTbt1iXQMrGr07UFQRCEnuVn6M5cuJQwXA56fMtzaEHojuwd1k/KfqQgfarXjLYyOpW8PkgLDMBud6GP1QnF0OGw2DFgxH7dltUjCL0dCa4IQgbTp08JTjvtdB4zgpZgADsLJNCmKNuCAWmA19uEBkODicqXWjRhyPb5mgGbHcNcRfiybj130qEWkmQHDCojiuw4dTukseLKaxVg4XaZ1kj76EQQx04QBKH30Fk/gzXRFBUwtLiDaiuttE3ehh2C8rSWpFNGp23qWUg1WWYbRuaU4KOqFfBrIdhNZowvHLRDBk+3ZPUIQi9FgiuCIGQOlE2hmhBa9R20gA8mmwPWYWM7FQxIJk5nzrayGHImo2UxLTt0QUPHQEc+NOgwQWU7lSr+5IDRjtwOO3SdDIiIYycIgtB7WbduHVatWgVNC6OkpBRjxoxJuDyXghnRwApBI9kUpE9JcL5lE4cTYlu03ZBGmzguiw1lFgfcPg+smg+2wHJoAyphLixL9akJQq9AgiuCkMHU1tbgrbfexIknzkRxcZqkrHYxzQ1NCGzZDCUchGG2wlY0GPY00oQ5efxxeOWbt2I7cGTTcaqVJtV+bygAtxaA3WRJCxV/Eu6zTzsbcNcDrvyk6NekU3q3IAiCkBw/44cffsCzzz6Lr7/+qtV9BgwYgNNPP4N/rNbW65lhse2oXWIYkeNxQui0bkT1yFIqhN6yiRNesxQIBgCrDZYhY9JiE4fmStN1DGysw0q/BwEYWBz048dPXsCYE66OrbckvlsT9KDImpU2mnSC0FOQ4IogZDDhcBiNjY08ZgK6z4OmlT/CpmvcgtDQNbYL/dsEVFPNgL7DcUXJlaj11KEwqyAmMkeBBpOiYou/EV4thGaTH6NyS1Mu9prMbkHplt4tCIIgJMfPeO65Z/DUU//iY3TBvueee7IWy4oVK1BRUYG//vUv+Oijj/DQQw9xt6AoqreRgxXQ4rrtqCaoVC7ryuG1UVUULK7fAL8W5lKXfQsG7HZt7Mog/vYqbumh6hbxI/IUMz4PuLHVrHLHILth4JWGCuzl98LkyMLi2grcs3xebA2+ZuTh2LdwQKpPXRB6DBJcEQQhY/AEdVi9dbCGvZGdMD0Iw6vAG0x9i8TdBRfIEfy+YTMaQn5oho6grrFNx1OV3ZHsbkFpl94tCIIgJIXXX3+Dx7POOhtnn30OysoiZSherwdvvfUW7rnnbs5ouf766/Hggw/F/uYbBWUxHdsYCmDECcQqfKDFMFrsVAXxAz4ougbzwNGArnEgiOx0KAuiOR2bU4ZHLCaQYo0JBnJDBpbYLfCGg8jSHbHACkEj2c/tf7ZksAhCO5F/KYIgZAxOqwJVbe10ke2wpMeFezS4UBfwsGgtjWTTcWrFXOlvYo0V2n2ikezagCc9uwUlQHx6N71/GqPp3YIgCELPIxgMxn6/9trrcMMNN3Jghf6+G34vHA4nC94+/vgTXBI0f/7HWLJkSewxqqeBO/tti7AobKvepm2lLoaOcfn9MaFgAI9k72zd2FkQn44nU+idAhmKyRwZOyn0nizoPS5yV7EgPl0A6lCw1WJCyO6AYnNwKRDPi2FAJ1H9ljW4rmWuBEHYPRJcEQQhY1AVFfbCYoSsWQiZ7TySnS47MuQkVnjqsKR+I76qXccj2Vw7brJwLTl1OOIdPUVhO6VlQS1OZDydcSKj6d1LGjZiUV0Fj2SnuvRJEARBSIwvvljAY3FxMWesRMtJfe8/A+/sx3gke8yYsTjmmGP59v/+9z+xxxsWe0s6CgVXImsg2VHNFVo3KPuEWz5TloiiRITgd7JuRIP48SQziB8Veo+ujckSek8G9N7d4QAsNicUKjlWVRgmE2w5xaxPQxorNG9bA25s8TXxSHaB1ZnqUxeEHkN6XFEIgpAScnPzMGXKoTxmAordCefoicgu64+sPiU8kk07NumAQ7VgtbsGFd56VPqbeSSbslRcFjsOKxkR6w5EI9lZLQ5mKugKJ5LSuQ3d4J1HGneX3i0IgiCkL99++w3mzfsIhx12OGuI7ayclI6feOJJfOyLL76IPZ4zPyhgT5sglHmqqmxH1xkaqayHAipEtMxnZ+tQNBgTz66CMZ0RendMPYvHzuiQJRN679lWO/LsLrhsLjitDuTbczCioD+L49OcsXB+OMiBGBrJTofAkCD0FFKuuULCVX/7299QWVmJsWPH4h//+Af222+/nd6/oaEBt9xyC1599VXU1dVh4MCBuO+++3D00Ud363kLQm/AbrejvLycx0yAHATHlFOgOFwwmmqh5BTCvt9RaeM4kDNDgnzxkE07ahREuWzEFPS152Czv4nHkwbsk/JzJ6eRNFa4FCjO4U30/TcEvRFnuuXzakhl1wdBEAShU7jdzdiwYSNKS0t3W05aVha5j9vtjt1G64CaXwJdUWFoISgmC9S84lZrDemlkDYXrRUUJNnVOhQNxry2YQm2BprRx5a9y2BMIlAmjv+rd2E01kDJLYr4GXEaMamC3uOp5ePxRfUaztaxKCYU2VzIawkuUVfCjd4GDHTmI2RofDvZrMeSwo0cQehJpDS48uKLL+Kaa67BI488gkmTJnGQZMaMGVi+fDn69OnTZt3mtGnT+LaXX34Z/fr1w/r165GXlxm77oKQbDweN3744Xu4XDnIzs5BJkDBAOeMc1sFA6jtYLpgM5lQbM1CGDrMUNmOdyAvG3louxzI7oTPIwnZP5S5s8nXyDtoVMJFI9nRbB1BEAShZ5GdnY299toLW7ZsblVOGh9giZaTbtlSybbL5dp2m90Jy8gJCK/+DkbQz1kr5qFjd8g4pXWoI0H4iMIK9Q1MLpSB45v/EkKrvwMCfsBmh+Fzw/GLS5EOkB8xzp6PQN0WBPUwzOEwjOyS2O0BPYzqoCfW1rokTcqmBaGnkNJ/Mffccw8uvPBCnHfeeRg9ejQHWZxOJ5566qk270/HKVvl9ddfx4EHHohBgwZhypQpnPEiCELHod0hEo6L3yXKBDgzghy8NAlORMky2zAiuw/qQz5s9bt5JDveYYw6kOl27snAp4c4BTm+9IlsCrIIgiAIPY9x48Zj3333wccffwxN03ZZTvraa6/yscmTJ++QcWrZ60BYho3jkTNQE1wDo4K2DSEfa7TQmExBWxLpDS1fBKNmM/TGah7ZDviQDlB2SrBqLfbWDAwzTNgzrCNQuYazU1gsf7vyKLJF90wQ2k/KtgMpC2Xx4sW46aabYsdIVHLq1KlYsCAifrU9b775Jg444ADMmjULb7zxBotjnXnmmbjhhhu4jrMtAoEA/0RpaoqoixPptFvd3UTfu8xBps+BERszex7S47vAzh39T10USHOkxabzijqS9Dsp+pPwXDKFeNNhDuyKGeXOfGSZrLFdswJbFmyKqVvOKx3mIB3oqfOQKmHqnfkZNH89bQ6TSU/9HiUTmQNg//0n4eWX16G6uhrPPPM0zj33PC6RsU09q1UGKW30zJ79Nj+GugfFzxndn7RLdpVxSusllZZSgGBXgRcKLlAnvnjI9oQCSSk/1ajTXXMd9JYSX0MLQ22u48BSOnwX7MEQtgY8+FgJIaQAVgM4NADYQiF4DB1Ds4r4XD1aAFkmG9sceEnC3Mi/B5mDnj4H7fEzUhZcqamp4X+8JSXbUtEIspctW9bmY9asWYN58+bhl7/8Jd555x2sWrUKl156KUKhEH7/+9+3+Zi77roLf/jDH9q8rbo6kn6YycgcZPYc1NfXtow1UNVkJ8emMRS0CPkB6kIQ54Sl+rvgCQfxTc06BLUQO4o0kr1u83p2bJY2V+LxTYvQGPIj12LHhf0mYEx2coXyUj0HB9lKMMe9Et6QH06LHQfllGDr1i3deg6pnoN0oafNQ1lZ/5S87s78jJqaKgQC0sK0p32PuoJMngOPpzn2+z333I1169bg5JNPjpX/+3w+fPjhh3jiiSd545WCMaWlfVBV1VJG1A4qA82YU7sSDSE/8ix2HFk4HKW27DbvS2urJRjm+0ahxzTVVKM5GRmhAS9MZhsUdyOga4BqQtiZg7rarVwSlervwiZvAwdWPC1vNawAXyGEytoaqCYTzKEwQuEQdE1DyAixnbS5aSHVc5AOyBygR85Be/yMHlXIThEu+mP82GOPcabKvvvui02bNrEg7s6CK5QZQ7ou8TtKJOBJFBeXpk0L1lTMJX2pZQ4yfQ4ii2V+fhFKSsqQCZDQXHDRe1zvTenI1gkzeFcsHb4LzUEfmn4KweB2yyqoV06THuLzouDKs2s+gBcaLBYLj89Wf49nhoxLyjmny78HCrePKR+REl2ZdJmDVCPz0DF25mcUFZVktCacfI9kDuL9jBNOOIHL+1999TW8/vobLAdAa9mKFSvg8UQySSZOnIj77vsHSwS0FwqWvLxqFUJWM7KsLlBD5c8CVbi0fMRO149f5WTh9U1LWdSVOgWd0G8MSp15SfvMmx0uaE01gKFzdyOzw4W8vgNRW7s1pd8FmqvHf/wOflUBeRjRDtdNqopwbhbKswqQVeeCNWCDoamwmizIynKhpKRvUtZi+fcgc5AJc5Cy4EpRUREHSKqqqlodJzumKL4dZWVl/Ic4vgRojz324E5DFO22WndMWbPZbPzTFvSB9sYPtSPIHGT2HDgcDgwYMIDHTJgDcixCi98HPI0RR8HTyDanJ6fBd4H+tlFAgToYaLoOk6qy40fH68I+1mAhdBhQobDdEPajyL5N/K+zpHoOop+TYih8HqnQlkmHOUgHZB7ax878DJm/CDIPmT0HUT9j2rSjMH78vnj22Wfx1Vdf4ocffojdhzp/nn76GVwO1JYvvyuozId0U+LXCrIDhsYlQm1R7irg7ntdEsRnbRUDis0JaCGA9UoMqOFgyr8LNFcUUKI85WhBBp0JleAW2lzwGySlD+yT3z9Wmkv2ruYyETL530MUmQP02jlIWXCF/nhS5sncuXM5mh2NZJF92WWXtfkYErH9z3/+w/eLfhgU8aagS0f/GAuCAN5VPeSQKZmzu7qLFpDpAHXLcYcDrbRwyCZhV3IA6We9py7m9AzMKkCBtf07fD0BSlkmccHojiK1yKTuBoIgCELP9jMOPfQw/lm3bh1Wr16NsM+Dkv4DMGbMmIQvsuiin9YKWjOikL07EdaOdhdKjPQSnicfo8JXDwsM+KOV4AYwRbdwq2Wak+hcUhvm9s6lIAjbSGm4iNJoH3/8cTzzzDP4+eefcckll3BqIHUPIs4+++xWgrd0O3ULuvLKKzmoMnv2bPzpT39igVtBEDoOi5Z5PDGhtV5PSwvIeKItINMBEqqlwInVZOIuBjSSXRf0stNDnYMoqELQSHZv6hoU7eIQdZJpTGYXB0EQBCH1fkZ5jh0HhDfgoMAajKhaAqNha8LPT2sgBeHzLQ6E9DCPZKdsbSQ/w9o6k43tNPAzSPDXHw7CZSigRtZ0loV0faVZoYQC2+ayZdMmusHRm/wMQehqUqq5ctppp7F6+G233calPePGjcOcOXNiIrcVFRWtItlUw/zee+/h6quv5ih3v379ONBC3YIEQeg4NTXV3PrwV786B2VlfdHbibaA9H/1LozGGii5RbEWkOmA02SBibRWuFuQwam7ZNOuEXdBMFtxVNlobk1M2Sz095HSmrt+9617oPcYv/tIkN2b3qMgCEIm+xm0tgW+nhPLIqWRbMf0czq1FkdC8ErL2I77t7O7UEdRgn6oucUIb91EkSUuCyKbghfpgM1kRR7NUzgMDQZMJL1iMcWCP5QpOmv4ISnRPROE3kDKBW2pBGhnZUAff/zxDseoFfPChQu74cwEQeitKORYkGhsmqXsZpltKLQ6URf0QDN0DqyQTYGF+HRdp2rtlem6iaZ3C4IgCL2gPNdG+RRtwxmMpGdCmSFxF/zRjEfSWaGMTxrJpgDBzgIDXVl+aljtCFeuBdz1EUHboI9tw9K2/mN3+xgjsovxZs16BFVwYKU4GMRcpQljSOusZb66p2RKEHonvU9FRhAEYSfEdsw8DVBMZh7ZTpOyE9pFI7FaqnWmsh8ayaYdpExI182E9ygIgpDRJFCeS13+fO89A88bD/NI9vYZjyxYr2s8RjMe2yIajKn2NqHG7+YxmeWnus8DvWYzvVD0BdnW/enRlt0OFXZNg1M3kGUANsWEWk8jvN6mVJ+aIPQKUp65IgiC0G2kuaAtOXfNoQBnahiUjkvtmUOBmNOXCem6mfAeBUEQMpVoeW60NIgCK7sqz6X1zz//JYRWL4UR8EGxOWD4muE84bJIhoXJClVRsLh+A/xaGHaTGfsWDNhpxiMFYz7bugpf11XEMkQnFgzA+UMOSE62RjRjRTVFAiz0vsj2NKZc4JbeO51B/7AGDwzuBESdsrM1XTJEBSFJSHBFEISM2zHTmxsALQyYzFCz00fQlhzFQlsWqvzNCOthmFUz2/FOZzqm6+4sXbtTz9nuynlBEAShJ2EqKGWNFd7YsNp3uW4Yfi9CyxdBa6xu0TAxAeFgJNBij2Q5colvXPebXZX8Wg0Vi+s2IKxHBHbDhsa2xUjO2qUU9QNsWUBz3bbgirMASkEpUFOFVEKBqEJnLvLsLqzU/aDcHpthYGRBMdSWuRQEoXNIcEUQMpg+fUpwxhln8pgJkANnGT4e3rcfh95cDzU7H7ZjL0yb7Aiqh57sKsGXDdXwGmE4FTMmFQ1rFUzpKhG+RKH07O13IMlxThRpxSwIgtD7/Qxev3ahsRK/5umUDUKBFQpWaBrb0YxOWg8pA2Vcfn/urkcltWTvTAh9pacGukEFt5EgPgViyF7rrcOI3M77QvS+TDkF0LyNgE4ZLCrb6bBe0zkc328M/r1mIbRACIpBZcgq/p3jwglxmiuCICSOaK4IQgbDToDJlDELKjljwe/mQw/62KaR7HTRXCEO3boVDl1nH5JGsuMDDw+t/AT3LJvHI9mpZGddHxKdT2nFLAiCkBl+BnfE80e0Unb3eNhdMAJ+GH4Pj2RHny8qhM6bJ2rkdXYlhD48qwiqovIFkAolMioqBjsLkvOGm+ugqCaoZUOglg7ikWxsV5KcKqwmMwKGAZvJBrvZDsNix/qgG7UBT6pPTRB6BRJcEYQMpq6uDu+//z6PmQCnF69ZCiUUhKKqPJJN6cXpcn4fuCvhDXihBfw8kk3nl5aBhyRr2OyqFbMgCILQO/wMFqh9/xl4Zz/GY7xA7Q5QdguV8Yb8XA7EI9kt5bwdFUIPKjr2zuvLxUSR/BWF7ZCSpLU0uwCKKzcSwDGTHozKNrYT8U0VDUEvvHoITVqAf9w0p4BorghCkpCyIEHIYEKhILZureJRSD1uVcEnhh8brSZoUGCCAU/YD4+iQN1F4CFlGiwtGjbxAZbddX3YFdKKWRAEoXf7GTvLeCQNlrYCItx9h4IvJArLD9DZpu47qtPVYSF0h2qBw2zFCFcx3FoQLpOVbbuanEsiVVXhPOZCeGc/DsPdyIEVsul4qqG5f79yGayqCd6WsqgwNORbHGmn5SYIPRUJrgiCkDGQ+J15yBiE1ywFggHAamObug8AqU/ZNfw+bLaYEWjZTwtDwWaLiTNXnNn5aRd46GjXh/Y8H+04bq+5killa4IgCL2eloxHzrpsEZZHNOOxDQ0Wvakukq0ST8jPumloCa50RAjdp4fgCQWw3LMVumFwpyGnxQa/HoZTTU6AwTJkDLJn3R95X648DqzopL+SYig7dKu/iTskUVel6Ps3qyoHprJUW6pPURB6PBJcEQQhY6CLdMeUU+C3u6DXV0HNL4F90lFpc/HuMakcWNHizidg6PCqKnJaAg+vbliCzb5G9HXkpkXgoSNdH9qDtGIWBEHoxVArZdW0wybHTjMerXTBT+tAfOBEASy2hITQqVvQ942bobWU1NJIdrK6BcXOkNYuek9ptIZFs0MpuEK/0wyQTo3dJFkrgpAsEspRe+21V+HzpYdGgSAIQodRAMVsjvhraYQ9GEJYaf1nmWxbOKI5UulrwoKatfi2fgOPZKcD5ERS9k+yAiHRdtMSWBG6A/FpBKF72f4v+67+0quOrEh2Szwmc6x1cFSPrC7ggTcc5HFXemQr3NXcTSgestd4apEsOqQp043QmnrqgH0xKKsAZtXEgZUSezYmFg6UsiBBSGVw5d5778Whhx6CW2/9Hb799ttknYsgCN1MdnYOJk3an8dMYFutdyNvgtHYme42yWYzQjv8USa7yghzSvE9y+fxzhydLY1kp0OqsSD0ZMSnEYRu9DNIQF7XYB64J8xDx/BI9k6F0FlzdrvwS5xNpS7LGivxzuYf8e6Wn3gke2dC6P0duW0Gd8rsOUn1M6hsiUp6aUwnP6N/Vj7uGz8TZw7YF9NKRuLI0j1wzuBJspkhCKksC5o37yN8/PHHeOON13DeeeegvLwcJ5xwIo4//ngUFRUn69wEQehinE4nhg8fzmNGEPBBq9kErXJdLB3ZVDoo4e42yWZkdh84DMBDleOUDWIYcEDBUFcRaoIeVPmb0BD0IWzoMCsqQoaGuqAXRfbWdeeCILQf8WkEoRv9jBYhdNYjaclI2ZUQOnfzo+BLrDRIYZuPO12wK2Z817CJNVMIGsm2KaY2n89lsSPH4kBdkFbayLOSnRVXZtQpAj6EN65EeM33MEIBKBYqe9obtjTxMwgKpFBLZovJ3GZQhQJBFLSi0iEJughCN2SumM1mTJ06Ff/4x0P48MN5OPnkmXj77bcxdeoRuOyyWZg3b67spgpCD8Dr9WLlypU8ZgKG1c5dBoyAH4au88h2spyqTqKGAtiv2QOTYXBghUay1XAQhRYnAlqYAysEjWSTyr8gCIkjPo0gdJ+fERVC54BKS2BlV0LofLiNsqDo/WtDXthMZt5wIGgkuz7Udqkf3T/P6oBTtXAAhkayd3b/jqJbbAhX/MyBFQre0Ei2niZlN1xGtWEJqvzN/Dtt0MSXUZF+zYMr5uMvP33AI9mCIHSjoG1RURHGjx+P9evX8c/KlStwyy03IycnB7fffif222+/zr6EIAhdRHNzE778ciGGDx8Jl6v3Zz8oQT8UZw6MynUw6HcSYC0ZACUUQDrgCQdhDQVRGDLDZ1Lh0HS2qY5ctZgxNq8fFtVV8M4ctY0kO2BocKLtHTpBEDqG+DSC0PV+RkeE0JWcwsi6rdVRZICjLWQr2fl8e5E1CyX2HFgUE3cLUqCgwJaFAmvbGbm0UUFdcqj9cjRzhexkbVQo7nqEFSv8IS9A2TSqGXanFYqnEenAquZqLp+q9DfxXNHc7ZlbGhORf3rtQiyurYhlrjSF/bh59AzJYBGErg6u1NTU4K233sTrr7+GjRs34vDDj8BDDz2MAw6YzNHpRx75J2655SZ88MHcRF9CEAQh6ZkrWs1m6J6mSFpxKMh2umSuOFQzvs9xoYnaNipASFHZpkCK2WTFqNxS9LFnw6+FYDdZ2IFMZStmQegtiE8jCG0TCASwYsVyuN1uuFzZGDVqJCyWzmdh8MV6G62X28rotAwbh+CqJbFyXrIpoxMmB7c5vmbk4bh72VzUBj0cVCGbjreF3whjTF5fLK7fAL8W5pbEZCdro8Jw5aNWd8Kp10MhbTfdYDs/KxfwpbY0iLJTXly/GGvdtQjpYf4MSMw3z2JnP8MTDuCL6jWc1RItPw7oYd7gSVrZlCD0chIKrsyadSk+//wzDBo0CDNnnoJf/OIXyM3d1vKM6irPOedc/OtfTyXzXAVBEDqF4fciVFcFLRSmrSpANaDXVUVqt9OAWtWA22KBn/ffIjtqbpMJ9YqBPi2tmLdvNym7SYLQOcSnEYQd2bp1K55//jm8+uoraGjYVhpSUFCImTNn4pe//BUKCwu7/kRsDqgFpTAVlAFBL2B1sh2v0VLqyMEBRYOxxdeIMkcu2zuDsjH2yC1DodmJ2pAHhZYs9MnKTdpGhS8E1Dj7o7+7CiZNh24yR+yIJExKoeDJ13XrudQqbBgwDB3hkA8us50zYin4UhvwtCo/JjtdxHgFodcGVwoKCvD0089i3Lhxu7zPe++935lzEwRBSCpGwIugPwCzoUGhAIahsJ0uwRXKXPGqKjs83M1IAbyKyjtKRD9nHmYNPySWviuBFUHoPOLTCEJrfvrpJ1x88UWoq4u0J87Pz+eSOQq40LHHHnsUb7zxOh555DEWq+1qaKVTVIVLbKBSMcs2oq2YadPBrKo8kk1rZVtrJB3LNzvw6ObP4NdDsKsW3LjHtKStp07DD7PdgfWlk2HSg9BUK2xWFQ4jADdSD71LjTTdWiwFKhpDXvYzvIaOQltWq8wVssXXEIQuFrSdMGEiRo8evcPxUCiIN954g3+nf4h9+/ZL5OkFQegmKLW3T5+SpKT49gQ81jxA11scsxYHTdfhtaZHK2qvFuLab6bFlyE7vqUk/W11mkXBXxCShfg0grCNzZs34eKLf8NBlOHDR+CBB/6Bjz6aj9deewMff/wJ7r33PgwePARVVVW46KILUV1d3bV+xm5aN5M2SIWnDkvqN2JR3QYeyd5ZK2ZN0/DI6s9gorXUZOWRbDqeDBS7E4MH9YHNosBQTDySrbSjBKqryTLbMK6gHHZFhUKbTLqGbF1DuSmSuUK3Ty4eggHOfJTas3kkm3wOQRC6MLhy6623oLm5eYfjHo+XbxMEoWdAu7HTp0/nMRNwhRoRdORBM1mhqyYeyc4K7fj3LFVsHzSRIIogdC3i0wjCNp544gnU1dVhjz32wHPPPc/6Q9RRi7BYLJg2bTqef/55DB06lDNZnnnm6a71M1paN9NSqHCXoNatmx2qBZt8ja1aMZMdzfjcng2+BjSHAxFhXH4yhe3NvuQIztJzFo6ZiNGmLdhTW8kj2emwltM5/HrwARgU0uE0FJC8cImuwFWzmeeLbj938P44rGQE9iscxCPZ6XDugtCrgyuUgtfWP7TKysqM6DgiCL0F+rdMuzWZUk9LXQeySvvBk90PTa7ISHa060CqyTJbYY6mrLR8JGTLrpEgdB3i0whCBBKtJWFn4vrrfxv7/tO/EdLriPoKpEl09dXX8O+vvfYq/H5/l/kZsdbNWXkwwmEe41s3+/QQ+jlyWZiWoJHsaLBle8odecg2txZnJbuvIxfJgN5naOU3MPUdCtuwsTySnS5+VmVTNbboIXhhgJpjB0l1lzomtmQCUfnxZSOm4MbR03kkWxCELtJcmTnzJP5jxpHPX58Ps3mbqram6di0aSMOOuigjjylIAgpZOvWKrzwwn/wq1+dg7KyvujtUPeAghN+A/vbjyPsboDZlQfnsRfutKtAd8POl6HFAiuRsbVTSr9HWyTKbpIgJI74NILQmkWLFsHn86G8vBwTJ0bajm/yNuwgpE4X3AcffAj69OnD2StLly7daZvyZPkZLPOutIxx0Fo4IKsALrMtphOyq056JpMJt4yegTt/eo8zViiwQjYdTwoBHww3CQDTek7nakTsluBFKtF1HXev+QxecnkMgMJPW6CjwWyGz2RC1nblx4IgdHFwhVIDiWXLluHAAw9kBf0olCrYr18/TJs2LYHTEAQh0wmFQpg3by5effVVbNhQwUGE/v3LceKJJ2HatKlJ04WxDBkD16z7gLpKgDoQmEzscKQDXm8zNTBioblotyCyff5m5Nid7OS+umEJqgNuFNtcOKl8nOwqCUKCiE8jCK1pbm7isV+//nyBHS8WS8SLxdLaScESCq40NUUe1xXQOQS+ngN4GrksiEayHdPPiQVHO9pJ78h+e2Ja6SguBaKMlaQFVgibA4ZqQnj1UhbLJ60V0oqJ726UKmqCHjQEfQioCkIaifoDmgKssluT1i1JEDKdDgVXLr10Fo/kcBx55FGw2aTnuSAInWfp0u9wzTVXcxp+PBs2bMCCBV/w7tjf/34Pxo8f3+nX0uoq2TGjnSSq2+b04rw+SAeysnJgU1T4DT22N0e205HDDubTaxdicW0F3OEA79I1hf24efQMyWARhAQQn0YQWhMNMNbWRroEUZZkNLAShexox7ra2ho+lpW1LTDZXjgjk8RqSVNlV2tYLBMk7rHRTJAWkVjaZLh02MGoDXpQaM1qVzYqZ7La23ffjmL4PdDrq2CEAlAsNrbTgSJrFvKsDugkCEzbN9SAiVoue5vhDQfhSoMAkCBkZCvm448/IflnIghCRvL990s5JZ9SkQsLC3HKKadi8uTJfNvChQvx0kv/452xCy/8NR5//MlOBViiO2B6cwOghWE0N7Btm3oW0gFS6rdY7EDIyztK5G+STem5VO8+v2olKrz1CFPnBNXEQZarRhyGLItcFApCoohPIwgRxo3bh8VrV65cwe2YSdSWMkHiAyxkU2Dlm28WY+PGjXA4HNhzz706vsnx1RzojTVQc4tg2+9ImApKdyloGx9giRe03VXp0s7o6P07guH3Qtu8GsjKgUJZsarKNmWxpBoKJF06cBIu2roGhqHBZBgoDoZhoaQVClZJcEUQui+4Mnny/pg9+13udU+/74ovvljY+TMTBKHXQyJ3119/HQdW9t//ADzwwANwOqNVv8D48fvivPPO56yWTz/9BNdffy3mzHmfU/YTIuCDVrMJWuU6IBgArDaYSgelRS10NGU3TDtJ1CYREZFNsuuCXthUEzZ46+FvaS8Z1nS206WkSRB6EuLTCMKO0AbH9Okz8M47s3Hffffi4Yf/2WbJDZXxPvDA/fyYY445Fjk5OR3a5PDPfwmhNUtj67Dha4bzhMvazGCJCtrukHHact9dlS619XwdvX8iGKEg0FQHQ9egqCYYecVIFyaXjcLJ1TVY7LAhrKiw6zrGNrtht28T7xZtN0HohuDKDTfciKysyEXPb397g/xjE4ReQFFRMWua0JgKKGBCO1+5ubm4//5tgZX4hZ12xe6++x4cddQMVFVV4aOP5rHzlwiG1Q6dtFbIoSOCAbaNNMn8cKhmBPVtArY0kk0tEj1aEPp23QbIpvTsbERSowVBaB/i0whC2/z61xew/tkXX3yOyy67FNdeez0HHqKlQMuXL8Otf/0rFi9ezP+Gzj33vA75GZTZEQusEMEA26xPYm+7vIiyWkhjJZpdEf/vdVelS22Jsnb0/h2GMm2sNujRxn+0YWK1pU1WiOppwJn1HmQHgqi0mFAa0nCcNwTV2wTkFHRpVo8gZALmRNJmTzjhxK46H0EQuhEScSPnKKlibh3gtdde4/Gkk06OXejsbGGfOfMUPProI9z2MdHgihL0Qy0ohUYOWsuOGdkKtSFMA8hhdKgWBJQQB07UFpuOU5vmbLMdRtgXu41sUfQXhI4jPo2QSVCG4+eff8aC8RUV67nstH///jjxxBNxyCFTWvkAI0eOxN1334trrrkKn332Gf/svffe6NOnBFu2bOZyIYI2PmhTZNCgQQn5Gdz1p6Vspj2hTQ6otGisxEObMOQr1AU87eoWFL1/W6VOyYD8DFPJQH5vRtAPxWpnO138DGQXQMkpgGrSYDGrUFUdCnVKo9KrbsjqEYTeTruDK263u91P6nJtSy0TBCF9aWhowCefzMe0aUehoKCg219/48YNPE6aNInHXS3skybtz8GVjRs3Jf6CNgdMRf2g2JwACbqpJqjZ+Wmzo0TOS67JgoagHungCIPtSHDFhmllozCvcjn8epizWQ4vHSl6K4KQAOLTCJkCdcO67rprsG7dulbHV6xYzhkqFGQhwfi99tqmmzJlyhQ8//y/8eijj3K26Pfff08KaXwbabJMnToNF198MYYNG95hP4OyU0xlQxD6aQGMYICzPMwDR3NXnUSg9fGAwsG4Z9ncmKDtNaOO2GkwIJHuQon6GaFgGGarOe38jA/GH4jGFV/DEgqg0eHAByMmYpSidH1WjyBkAO0OrhxwwKTd/uGhCyO6z9KlPyTj3ARB6GICAT8qKip4TAXRvylR3ZBdLeyGEblPZ/yf3dVupxq7Yobb1xQRs+W/qWDbppj4HC8bMYXbRm7xNaLMkcutmNPl3AWhJyE+jZAJLF++HOeeezYHE0kXhbK0SDCevtckGP/qq69wae55552Dp556mjNUouyxx2jcd9/93MVv0aKv4XZ7kJ3t4s2QjpQSt+VnqA4Xd+lT6JjNznai0L/T9yp/Zj+BoJHs8QXlO/03Ttmw8aVOyVxH6bkaRh6Ble++BcPtg+LKwvAJR6A0TdZq8rMaXTmw7nN4rMyqUVEiAZQuzuoRhEyg3cEV+qMrCIKQTAYOHMS7ap9//jmnJrdO79VgVkyx9F5KTY48ZmCnXpNqt6k7UF29FwX5Tk5VThdR2JrmWn7f5MZQ4gq5YmTXeerQJ7cPO4QUYOkKh1AQMgnxaYTeDq1rlLFCgZV99hmPBx98iPXNohx44EG46KKLceWVl+PLL7/kMqB3332PM1PiKS0txbHHHpe8E6OuOboGy6C9AD0MqOZIJmlca+WOQJ30FtWu54xOEoOnkWxqLbyrzE5aP7siG4OCPbPXOdBQfiLswUb4rblYsc6C88tba6alilYBlJb5jgZQujyrRxAygHYHVyZOnNi1ZyIIQsZBWivvvTcHb7zxOi655FLk5eVF0nuXz4st7Nf0PRzNzc28w0acfPLMTr3mkgovHv6wBg1eDXlOEy6dWoQx/dMjXdfpzIZNNUMnh7MFsh327C53CAUhkxCfRujtLFiwAGvXruWytgcffDAWWGHBdApw2Bx82wMPPMiC8Vu2bMHHH3+MqVOndu2JtbRWBrVWNpnbbK3cFvHnvcPF/vbX/imMBXiDBkI1W7D3pvmwBBoRsuViTb8p8IXSQxR2dwGUrszqEYRMwNyR1MLhw4dzj3T6fVeQGJYgCMLuOOCAAzBkyBCsWbMGs2Zdgn/84yEsqF2Lkdl9YsJ0H6//Afff9wIaGxtRXl6Ogw8+pFM7edHACkEj2Q+f3RfpQLbVgcNKSFflZ/gNDXbFxLYrTWq1BaG3ID6N0NuJbkiQeHNubuTCXqur3KEsNquglDc6nnjicbzyystdHlxJpDy3rfOmLFSC9Mj2LRiAxbUVsS6DZKdqE8JhAYZtno/G2jpougGTWodhynzYzXugGenB7gIosokjCN0QXJk58yR8/PEnKCws5N/pH160XWg8Up8sCD0H2rUaN25cygQb6cLmnnvuxdlnn4XvvvsORx45HX0PGofSMZGLmaofVmLd/EUI+fzcbeDee+/rVGejWrceCawYBmx6AAHVxna9Nz3Kgujv50klo7C2ajVq9ACKVCvb8Y5PfJtq2VEShMQQn0bo7WzYUMHj5MkH8kjf72iAgm13A9vU4pjuQ8GVqMh8V/sZu2qtvD3R89ab6wEtDKO5Pnbe9Dj6ObJ0NH6o34zmsJ+zPclO2foY8MEWbGp1iG16r2mEBFAEIcXBlffeez/WTYR+FwSh55OV5cJee+3NYxSv18vic6FQEEVFRSgr69qsDuo28Oyzz+G6667FqlWrsOr9L/gnnkGDBuPvf78bo0aN6tRrFbpUDDTVYWTlJ3BpTXCbcrC89BDkO8tR7UF6tMv88SMM1wyU62bYYbA9YeBYDkTtrE21IAgdQ3waIeMI+GKBlShsU7vgLgxEtOVn7Kq18g4EfNBqNkHbshZGwMddhUxlg2MaLRR8mVP5EwJ6GAoUHsnelaBtV+JV7PBZclCU3QjdAFQFbPsU6ewnCJlAu4Mrffv2i/2+efMWjkJvL3oVDoexZMmSVvcVBCF98fv92LBhA3JzC7gjwL///TzeeutNDrBEGTt2LE477QwcffTRO/ybT2aA5bXX3sBXX32JJ154DktWLUNY1+DsU4DfnH42zpr+Cw4udBZytC4u+AZLq9wIULBFcbOtKOOQDni9TajwNWB12Ac/DNihYKgWgs/XDKczZ6dtqiWDRRA6hvg0Qm+Hymh/+uknLFy4gFsrR7VO4gMsUa2TBQsiGxrUlrkr/Qyn09k+DZU4DKsdWtV6aLWbAU0DKHtVVWFYbCytQoK2X1SvQZW/GSFdQ53q5QDL7gRtu4osm4qaYYejaNU82INN8Ftz2HZaVbS/AbwgCD2VhK6Uzj//XHz00XxOp42HFMnpNkmhFYSeQWNjA+bP/xibNm3B7bf/EcFgkI+TsKzD4UB1dTWX69DP7Nlvc1lOvHOUTMi52m+/SfjQ1YDa2rGx0peNhbtOGe4QAR9KzR6U7OWCP2TAbqGUYk/apOva7S5sDvs5sEL/+xWDbZsta5dtqiW1VxASR3waoTdCbZffe+89vP76aywYT62Y29I68fm8ePnll/kxJ554Upf5GeXlA2P+w640VHaAAjDBQCQYE/0JBiLrtt3Jx7f6m9EUopXTgKJR/kpL8CYFkL9y+IHDMdtZDHezF65sJ47ZJ082QQQhQ0hoK5j+YLX1R6KhoYEvyARB6Fk88MD9HFjZf//98eSTT+HTTz/HBx/MxYcfzsXll1/B/64///wzXH/9dV3atph2oBbXVbRqqUg27UAlhZadO/r75bCqkXrtdnQp6C78fjf6KhbYQyGuLaeR7EDAE2ufGE+0faIgCIkjPo3QG6FWywMHDuRue1dccRmPUa0T57EX8RiwZ+Oqq65CXV0tSkpKcdhhh3f5ee1M+2VXwRC6pSVkwuP299z+oSmKq8Tom2fBBYcW4aIjy3kkWxCEzKBDmStXXnkFj+SE3HLLzbBat+2W6rqGFStWYNy4fZJ/loIgdAlRZ0bTNBx99DG4664/txKMLSoqxkUXXcwZJRdccD7vPlH6MDltXXdSu7GT0aXgqznQG2ug5hbttktBd+JwZKOfxw17wIMwDJihoNAWyWjZXftEQRA6hvg0Qm+GSmlJq+ycc87GokWLuN0yZaZMnjyZb6NWzdRRqK6uDna7ncXlLRZLSrVf2tRgoWMkOB3wclmQYQqxHd0UoX+/JY5sGD4DIUODRTGxvbu1savF4Vkw1pq+6/Ou3r8I5wtCNwVXsrNdsX901LnDbt9Wy0h/kMeMGYuZM0/pxOkIgtCdrFy5kker1YJbbrklFljZvhZ6n3324X/bpMny4ov/7bLgCrVUnFA4EItq13PWil01s53sshdKHaZNMB7TCCXoxzH1zXjLaqDBpCJP03CMtxlKKACYnLttnygIQvsRn0bo7eyxx2g8/fSzuOaaq7kT0L/+9RT/xFNaWoq7776X9dW6hV1ov7QJidhSdpnNCVAWq9nKdrQsiPyGMXn9UON3I2zoMCsq27vyGzJdHJ7f/4YlqPM1ocCRgxPLx8Xef6bPjSB0a3Dljjv+xCOJu5133vmSLisIPZyvv/6aU98nTdofubl5u6yFPuWUSHBl/vz5LPTYFeK2FCw4Z/AkZJtt2OxrRF9HLk4qH5e0IEI0HRmeRigmM49k26aehXShTDHh154A6hUN+QZgsrYW5JP2iYKQHMSnETKB0aNHY/bsd/Dpp59wpgp1A6S1sF+//pzJcuihh+42Y6UzmQzkK+Tm5sZ8hlgG6XZ+xi5FbcMhGAFPRNBWC8EIt77Yd1ls6OvMjW08kL2r99Id4vDtFeztbui8Xl3xGao3/Mzdl7baHHjV58ZlY4/h20U4XxA6R4eujiZP3j/2+/PPPxf7PTs7GwMHDsK5557H6YaCIPQMmpqa8MYbb2HWrMt2WQtNtdn0bzxaQuTxuGPBmPaQiGNmUbeVJyU7HZmdHi0MUIAlmo6cBih2J7YO2RNv1K1FNXQUQ8XxBYOR2552lYIgdAjxaYRMgbJSDz30MP7pKJ3NZCgsLMJxx/2Cx9j5tGi/8Nprte+2W5Dud4P7GhO6wTZ1CyLIt9ANA/vkl8cyV8jemdh7d4jDt7VJpeT1QTpA2nbVa7+D1lgT84Oqw0F495zGGb0inC8I3RhcueGGG9s83tTUjJ9++hGzZl3C3UQS+eMtCEL3E92pra+v3y74gB2CD/WNzbHH2e2OLnHMWu8oGcnfNbE5YKgmBFZ+C/i8gMMJ2/B90kbQlnipvBxfqU1wayG4TBYE+5Xj5lSflCD0QsSnEYRd05VZHvz4dmwcKO56KCYrS9myc0JC9LRR42kEcgpiYu90bqS3sjux9/j7d4U4/M42qdIlQ9YRCiOnbivq0dKcQIvY9nAYqt3ZpXMjCJlAh4Irxx9/wi5vHzVqFB5//HFxRAShh7DHHnvgjDNOw4IFnyMUCsJMjo5qQnjN0kirQ6sNliFjOPjw1lv/5sfstdfesNl2nnLbGceMdpQqPHVY1Vwd01wZll2c3B2lyvUwNiyPpBebTNCyC5Au0I7S/KbNqDABmqLCpAK+ps24KhxE1i7SnAVB6Dji0wjCrklGlsfWrVWs1Xb66b9EaWlZh8/BcOUDWhD4f/bOA06usur/v3unl+0lvQcCAZJAIBQJQaoISBEEVIoIr0pTwVfE1/rq34KI8EpRAWkWiiDSkd6kh1CTkN4323enl3vv/3POnTuZ3Z2+syXZ88X12TM7M/fO3ew8Z075HUMzBe5p1eIwfDX881LF3odcHD6fYO8ogF7n8cEoHvPY0WVTUafpOD4SN6cninC+IAyaioomLFlyOP74xz9U8ikFQRhCFi5ciFWrVqCnpxd333036w5kG9bT3t6WLps/44wzhswx86gObIn0cGCFoJVsCrJUAi0cRGLlW9yzzS9M09nWIiGMBmjM9eZwNzRD5+wcrWQP5fhrQRCyIz6NMNapRJUHJVkSiUTeUcuFhN5hdwG0L/KXyrYl9E6UKvY+pOLwpQr2jkD78ZSpe+Ora99HJBGHx+HkJJqSqiIS4XxBGEXBlXg8Pjxj3ARBqAiZorTXXvtbRAK9+HxDHP5pcwFdg6GoWLZ2M35167loa2vDtGnTcNxxnx0yxyyiJzDJQ6J0cUS1JNw2O9sUZPGqg69c0QOdZvbIcvJoiUehB6ktagg0XkokoifhstkRj9MgZiqCVuBy2vn1V430yQnCGEN8GmGsMxoqGTgok4xB8VSZwRVFZbt/sIbsYDLGyZhizm+oxOHLEewdTug8PEtOh+Lxw9HbAaW6Ae5Fxw0cxzzKpikKwpgMrpAK+R577FnJpxQEYRg44YQTcNddd+HmW27B7U4HDpw5CV6XA59sa8eaVlOPZcKECbj55j/C7XYPmWNGwZipvnr47a60MF29y1exfl+FMkeqyhUraVQVisMNxBMYaZpcfv7qjodZkE9VFLYbXL6KTG0QBKF4xKcRhKGrZCh2mg63q/jrYHS3AZrBrctkZz7mnY6N+O3yZ9AWD6LJ6ccVex6FhQ1TMVJkE+wdTRWodH7eY8/LKigso5gFYRiDK1df/eustwcCASxf/jE2bNiAO+64a5CnJAjCcPPlL5+NOXP2xO2334bVq1fjxRXr0z9zu1w4/oQTcckll6KpqWlIHbOhzpKpNY0A9WkHutLCeGSr1fVA+3aMBpT0/1PWiGpX0MfpeXDTMrTFghx0oTHV4vQIQnmITyMIxVHpKo9s03ToA3/WY7u9sE/bE3Hat6ll2GZn22pjoaDFTz54DKuCbdxKuynczfa/DvsaVEqmjBDFCvaOpvMbrjHVgrArU1JwZfny5Vlv9/t9OPjgQ3Dddf+HyZMnV+rcBEEYYurrG7jNh0YknnTSSfjc5z6Hd99dio8//hjxSBiN48azmGN1dfWgMlClOGZD2e+rJmJwTN8LiZXvAMk4YHeyrdL3owAKmrTGgnCoNEpS4coVsjtiITS6/bhj3et4p3NjumWqNxnF9+ceK06PIJSB+DTCaIECeqtWrUIsFkVdXT123333EQ0MDIWfQWvmNB090M2TaoyAOU2HKj1yitC6fbDVjYMRj0Bxeti2aI0GzMAKtTJT4MbQ2G6PBtHsze+7CMM/ploQdnVKCq7cfvsdQ3cmgiAMO6Qn0NDQkNYVIMdmv/0W8tdQZKCKZah6oQ2nG0YkAMXtgaE5oNjsbBujZBKPR7WzExPXNfMGqoDWEtxDTpOErMAKQSvZYZkkJAhlIT6NMNKsWbOaW3Ife+xRRKM7pslMnToVZ5xxJr7whTPg8Yze6ody/AxKxGjtW6BtWwcjFuEKFNuEGWaLSrZKD7qPrsE+3dSC47YgWjPuT220CdJjSaGQ6K2QF6r4CYd74fVWpwN5Qz2mWhDGAvLuIwhjmN7eXrz55hu8lsOODFQXjGSCVw60lDkVYMihEYnxGDfbKIrKK9mjaUSil6p10s1BKdvK5mUb5SQIgiDsdDz77DP4whdOxwMP/IMDK+PGjcduu+0Gr9eLjRs34je/uRrnnns2Ojo6sCv5GZTk0LZvgNaxFXpPO69k50xypKbvsPaKzRSrzZy+Qy2yNQ53n32T7EytMqEvG7Z8gt889jv8+t+/x/WPX4eNW1f1ac2mgAoho5gFoXQkuCIIY5hIJIxPPvmE17JIZaAS6z5EfOU7vJI9WoIV2VAcTlbHV2uaeCV7tEAOzARPDeqdXlTb3bySTbf77C7s3zANTsWGhJ7klWwp1RUEQdi5WLp0Kb7znSsQi8W4Be2uu+7GM888i3/+81944YUX8aMf/Rj19fXconvxxRfx5KpKQckPIxoetiTIAD8jleTg5ACdA/0vT5LDmr4Dbw30cIDXzOk7USOJRQ3T0Oz2o9rh5pXsmJGqABX6sCnYie++fR+eSfbgPSSwKR7EA0sfSQvuWq3ZV+xxJK+i6yYIIzgtSBCEsQVloBLrP4beso5qTHnyjhGPcgZqNOY5WBhv5jwk174PkDPndLFtCuN1j/TpcQDlkKaZeLt9A+upUIBl/0YzgMItW7WT8fiWD1M/S7AtGSVBEISdi+uuuxaJRAJHH30MfvOba2C373DHvV4ftwMdcMAifPnLX8SHH36AJ554gnXRBku5bbyVnlJnSrZbwR2joL+Q3Lgc0f88DCMS5BHC9gnT0+dN57RnzQQ0u6oQ1ZPcRtvg9ksrS47f422rXsZqPYYkDNgUIGEk4YuHEIkE4CPB/yFszRaEsYBUrgiCUDZ6JASdKlX0lJOkG2zr0TIrYTIcANIYqXRmjRwGz5LT4djrENhnzeOV7NESoKDzWFg7hYVt26MBXsm2xjjesvY/7DxS2TOtZI+m8Y6CIAhCflauXMmVKxRQueqq76cDK/0rSmbMmIHzzvsKf3/vvX8f9HEzhWSNZJLXYtp4aUrdjatewrUrnuOV7EFByQyny2zvSX2RbbX59EfTNIT+8TsYvR1APMIr2XR7ZisLBVQoIECrtLJkh/yq9wPboSkKIjDQCwPrFA26zQmPp2qkT08QdgmkckUQhPIJ0mhEHbDZdow2JjvUA3j9ZWW9yHHrP4q5kmWplO3yHnueWYLsdKcDF6MBOo+7V70CXzgIj56EmtDYPmbCnhxo2RDqRNLQ+ZxpJZsmCTWJUyQIgrBT8NJLL/J62GGHobm5OW9Fyamnfh7XX38d3n//fXR1daGurq78A6faeJPb1gExEoN1w55PSHaIRvMq8Shs46axr0CVrorTzbaSiGU9D4MSNjSGOUli7hQIUkydt84WoGnSkE8Z3BXhduhENO232cZPl2smCBVCgiuCMIYh4bw99tiT13JQGidxq43R25l2epTqeigZZcalBEuGwpHLet70XDmcyZGEAigdXVt5goJh6DAUlW0KoJCwrV1ROahiQbaUPguCIOxcY5eJSZMm96koocAK28Edo4lpyg7tz+FwGIFA76CCK5aQrN6+lUcgw2aHRq28edp4KzGad4CfQdOByHdwedPTf9SqupyVK4av1rwfaaiYbgagKzD6jVmWVpbiWo/n103CxnAXvIoKm6JgvLsGdm+VjFsWhAohbUGCMIapqqrG/vvvz2vZQQpycKzAR8q2AiG5giW5ypDzOXKVZLgF/YqlQVfgioTRblOw3W7nlew6Q4Hf4canx+3O/eQErWTLGGZBEISdByvIkJ4CRMH0VGDFgu14FMFgMD2iudwkSBo6TjgIIxaCEQubaziYV4DeGs2bSamjefv7GZZALQVUaPoPrZkCtf3hMcE8+cf6OSVHfOnxwULx0DX+6sxDsHtVM5rcfkzy1GGvmgmod/kkUSMIFUIqVwRhDEMTCNra2lBX1wi3O3vWKB/U+2z0tAFWNQVVW/S0waAS3pqGkrNeliOX+ZhSHblCZCu/VmrN0uzR4PjUajo+dNmRVBTYDQP7aMl0X/oluy/BRHc1tkZ7eT116r5SyisIgjCK2LZtK+677z4899yz6OnpgdPpxMKF++Oss87CPvvMw6JFi/h+9HMaT1xVVcV7UWaAxRo1/Og/7+F20RkzZqKhoXFQ50XJBJ1adjM10kI9eZMMlp5J/+rTUvadbH4GtTy5jz4HIF+hqi5voISOZWucCK1TJQEWbkOmx4/2vY+vayxijpIeRedK5zLVW4fVgTZ0GmE4bDacMW3hqDpHQdiZkeCKIIxhuro68dRTT6KpaRwmTJhY8uOTFPSIBPveGAkiqdphKyNYUglHLh+5yq9dR52N0UDIpmKF3wuvloCmm0r+ZIdVFVVWX/nuS9ARD6HBKZk7QRCE0QIFQUgf5fbb/zxAx2vr1ofxyCMP45BDPsXTgXbbbXesWvUJbrzxBha1pSB//6A/aaz8+c+38ePPPPPMEfvwO1g9k2x+RilTi6j12DFnf2D1e1xxQ+1EjtnzU1P+yqfSE5B2hiQOVxNvWoZPAq1odPmg08wmw8B/2tdiv3pTPF8QhMEhwRVBEMqnY1v227tbgaqasoIl5MhdNHsxOuJhNDi9lQ0g5Cm/Hg1E9CSCDgd6FX2HPrDdwZOBqoZB7FcQBEEoHfqA+stf/gJ///vf2D7wwANx+ulfwNSp07Bu3Wq88sp/OMDwn/+8igsvvAAXXHAhrrzyv/HXv/4F8XgMX/vaNzDumHN5LyINlLfeehM///nPsXXrVkyePBknnXTyoM+RKyB9NTAiIbPaVFHZLuYDdSX1TPJpzGQ7F24jmr8EyU2fsAgrBVXI7n/f0SKcP5qTOHR9WmMB9inIwVBTkwdJ7000VwShMkhwRRB2ctrb27m0mPqxx40bN7yZB38OcT1fddlZryENIFB5bo7y69FAvd2DCE9E2NFeTnat3T1sYr+CIAhCaVDQhAIr9F7885//v3QwhCpY6uqqcdxxJ+Dcc8/lwMrHH3+ElStX4Morr8Kvf/1L3H///XjwwQex334LuUVo7do1WL9+PT9+3LjxuPnmP8Lv3zF9b1D7H2t0GaYwLAzTLmL/q2iVR74kR7ZpQYaBxKqlsE2YaU64cbjZts/YJ30u7DdsWsaBg2ZXFU6ZsmDkhPNHcRKHfn90fUizjQMspN9ms6PJ5RfNFUGoEBJcEYSdEOphfvTRR3DPPfewo2Yxbdo0fOELZ/D4RnLShhouyyVnJLNnm7JjziwOkunN5cVyejpjISQNjddKOj2WkF70zSd4jCNNNconpDfcbI72QFGpXCVDuk9VsC3aiwaPn51AukY0MYgmBZU6tUEQBEGoPH/7m1mxctZZX+xTZWIGJRK80sScn/zkp/jmNy/DAw/8A88++zxmzpyBW2+9lStV6MuCkiUnnHAivvGNi9DU1FSZkyT9D0OH4vYB9MGaxNGpgoU+9Lu9w5fwKDXJkRohrW1bz5P02O+YMD0djKFre+e6N/B2xwYOGFDgoDcZw1Vzj8m6t1diAlIxr08PdCOpG7CrCtSq0ZHE4WriKQv4+rzVsQG6lsTCuik4dcqCUeMHCcLOjgRXBGEnrFS5+OKL8NFHH7JNGyJltWhU44YNG/Cb31zNpcaU7Zo1a1be56KWG5fLNaD1plghNjXcA9gdQDJhBljovnYH1EgA8FeX7JiR07Mx1MlCa5aTNLuqqaIBBL27FfEVb0Pv6YBasxnO3RfCNgp6oQlqg3Kp9j5jMZ2qna8bZZxURcE7XZsQ1ZKcbVpYP1WyTYIgCCNIZ2cnXnrpRf7+i1/8Uvp22vse3LQMm7taMTm0gT/AHn74pzFx4kRu93nxxRdw7LGfwac+dSjWrFmDDz/8gCcD0bhl0mapSLVKPxSHE2p1Q3q/Jjsflajy6O9nWEmOAZokOZ7PGiFNARZrhDRUJT1COpSMpQMrBK1kh5PxrNP0hlo4n15H95wjseqJR9Kvb7f9j8T4URK8IP/rizXToa1+H0EtDE8wAq1+NiAtxoJQESS4Igg7ERRA+cY3vobly5ejtrYW55//VZx88imor69HOBzCY489httuuxWbN2/GhRd+FX//+73cKpSLpqZm7gunNVOIjSs7etqh1DTCvei43EJzjZPYUaMMjdXDTRkaqggpxzHzqA5sifT0cZLItsYPDxYq0Q7efy20besAXYPWtY3tqituxWigyunBUePn4JmWlYjrSQ6skO1PZbwUciWtAiDyjfuEYQRBEIThpqWlhfe65uZmTJ8+veDeR5ODSOB2y5Yt6eegREihZMhgIWFY+8x5SK4hYdgIFKeb7XzCsJWo8sjmZ5BPQRorXH3idOcP1KRHSIfT04LSI6Stipv+D8/zdMMhnP/Yeg+6p54KuxZD0ubCJ+vtOH9K4erd4WBTsBPfW/oPdOtxUOgpkQjhgaWP4JvjvyUi+YJQAUbFX9GNN97IGxKNaCMRsDff3FEamQ9qiaA3w5NPHrzQlyDsDNx//30cWKFgyl/+8jcOrtD3hNfrYweGAirkpLW2tuIPf7ipZKcg8uL9SHz0HyTXfsAr2blGNdpsNvhO+zbUmkZ23Gglm24v5JhlI6InMMlTw1UZBK1kW8GWwaL3tEPbthZIxM0MWCLOtt7bidEAvZ+dO+Mg7Fs3GdN9DbySTbfTtdQMHQvqJmP/+qm8kp3rWgqCIAhDj0qtnJSYoA/+KfLtfdb9slWMGlGz9XMosIRhzfYUhddswrDZqjwyqVSVBwvsFjGm2LwuQcDSh3G42Lauk8/u4irOTL+B7HzBH0sL7oo9juS1ksLw4biB7rDGlUFJu5tXsiOJkQ+u0DW7f/1b6NbinKeJwsAaaOiMhxChimNBEHb+4Mq9996Lyy+/HD/+8Y+xdOlSzJ8/H8ceeyx/MMwHiX195zvfweLFi4ftXAVhJKGqi3vvvYe/v/TSy9IZMmvDpNJYWqmk+H/+54d8+6OPPopAIPeG2d7ehoceeohXfp5oGMm17wPxmHmHeIxtynLlwrXg06j58f2o/e4dvJJdrmNG95/qq8f8mkmYXzuJV7IrVa7Lvhi1MOkaXVBzTSaK0oMZDuj391rHOuxe1YwDGqbxSjbdbl1LckQdqo3XSpYyC4IgCKUzceIk2O12dHR04KOPPsq799k0A6+//hrbmXs4VYxG/n0nwo/9iVeyK80OYdhZsM/Yi1ey8wVzrCoP67WUU+XR388oNZjEx3L7Tb8kHjFXtz99DrSeN+MgfLp5d0480Ep2oXO0JiBVWmvE61RQ6zUTTBZkexwjX2lKQb+goYEaqsivo2qgSDwCv2KDxzP0On2CMBYY8eDKtddeiwsvvBBf+cpXMHfuXPzhD39gIa8///nPOR9DUf8vfelL+OlPf4qZM2cO6/kKwkixatUqbNy4kf8+jj/++D593TeuegnXrniOV7IPOOAAzJgxA5FIhKcY5PtbCgYDfTJu5UCVKrbGiemKlXIdM7r94IYZWNG7HW91buCV7Eo5P1z+zNktY8eXzZ5VgHcksDRnlnVvxtKuTbySTdnOSji5giAIQmWprq7GMcccy9/fddcdvOZ6v6aEB2m0ULvuoYcuzju6t+IVLJYw7MaPoW1Ybq6kY1Jgis1gqzyy+RklBZMs4fxkzEyO0Ep2hkAsndMluy/B9+Yew2slK1FKhX73xy+oSQdYaCV7NOzVFPSrd3oxC3a4U/++6jQdp6BwBZEgCDuB5gpNPHnnnXdw1VVXpW+jMsmjjjoKr71mRvaz8b//+7/c2/rVr34VL7/8ct5jxGIx/rKgkbWZlQBjFeu1yzUYHdeAgiBPP/1vrF27lh0QcryOO+44NDQ0pu9DWTFiwoSJcLs9fN7kfJFgnlV+TNN1yL5o9mIOPK5bt44duVyvUdeN9MrP53TDNmMfaFStkojxmEaySTiu3Os0wV2Nb8w6tM8o5lzPxSWrG9/BulA7IloSwUSU7QW1kyqy8bOzSpMSaNxxSiOGbMuJHel/Cy7YsCbQho2hLiT1JOyqHSoUOKHyuZVyLXfmv4eRQq7Bzn0dRkovIJefQddvZ7uGlWRn/XdUDjQl6PHHH2Pds6lTp+FrX/s6v19/feansGn7ZkwZN5n92l/+8v/x/c888yz+98r7bjQMPdDV5/mMQBf0aDivHkqp6HYntI4WGLGoWbUZM9jWbA6oRfyOSPuMq01KDPoM8DMMg3Xd+DVTe25vJ9vuo8/Jus9rkaCp60baa4opxEu2FgkBHl/Z51jR8dL9GF9tw/mL67gViCpWMvfqkf57+FzjbviH/iq8zmr4DQMnGx5MpGLeCv97y8ZouQYjiVwD7NTXoBg/wz7SU0+sD5KZkL1ixYqsj3nllVdw2223YdmyZUUd45e//CVXuGSjra3yZZc7G3INRvYaJBIJ3HXXXXj00ccQDAb7/Ozaa3/LbW9f//rXWFclEjF/3tPTjZaWLSkdjgRPIsgkFApiw7aN6OhoZzsWi2L79q1Zj9/VZQZsurraoaopZ2TuYqiaAQS7AH8d9LmLEWzdNqjXSW+gncko6u3uvG9MwUQMz25bwdNw+LVoGtsXNMzLqvpfMrEwbA43FIMEeM3KFcPhRmdHK2fHRvrvIZSMo7O3HcFYAMnUG3SnpvPv0+ofZ10cPQkPTRUagkzTSF+D0YBcg53zOkyYMHlEjpvLz2hv344YiXCOcXa2f0flMH58Ey644AIeq3zzzTfhX/96CMcd9xlMmjQZgUAvnnnmGXzwgTnhj7QFjzvu2B37smFANVQgnNHC661CoKvTrNCoFPEIVE2D2rbJrACxO6B7qhDZsn5IxwQP8DPoPDaugtK+GUhEAYcbRuNk9G5el/08Ap2w6UkoNJkwhaEn0U7nXVVX1jm1xAJ4smMVuhNR1Drc+EzDbhjvGpq2mMAo+3twGAa+qPsQDQfgZln8GEJeZ+X/veVhpK/BaECuAXbKa1CMn7FTTQsi7Yizzz4bt9xyCxobd2T080FVMaTpkplRmjJlCn/f1DR+zCpj04dd+kct12DkrgFlOi+99GK8/vrrbJMTtmTJEu7dpuDh+++/h+effx4rV67En/98Bw444CCuWKGg5ObN27D//vvzB20a8dh/pKBbdeL99z9gm0qPx42bmPUcdN3cSOvqGjFu3ATzxnETYew2rzgV//Tz6ABloarqBlzLdzo34trlz6ItHkST04/L9zySxeayEulFQgGihgadHE5FgU2xo6qhEU0V6AemYG4PCcDyS1LM/2kJ1EyYis7OthH/e+iJhtEbDSD1awHF9MluaGhGtdubHmvdFguiyeXPO9Z6Z/t7GA3INTCR61AaufyMxsZxPNVtrDLW/h1ddtm3uLL0uut+x6OWb7utb3s7tc2eeurn8b3vXQWHo69Wlvbp081WoNSUPhpNnGtK32D2v0BXC3Qav0zBegVwdLWgauK0AS29lazy6O9n0L+LQKAdem+7WUGjBqG63KiaND3rvxO9aTx66ydAbzGn/EG1wVY/FfUz9yzr3xW9ln+sXo2E0w6f0w+ShH8lth0XTdl9SFtjRtPfg/bpLyD+9lPpUdHO/Y+t+L+30X4NRgq5Btjlr8GIBlcoQEJv6Nu3b+9zO9njxw/8I1+zZg0L2Z544onp26ySIvpASh9C+4+yc7lc/JUN+oXuir/UUpBrMHLX4Oqrf82BFdJQ+dnPfo6jjz6mz3mQMN53v/sdbNiwAZdeegn+8Y8HcOKJJ+D+++/HH/94M/bb7xb+d3/qlAV9RgqePGke/vSb6/hv44ADFmH27N1yngNVxBxxxJG8Zh6bS2rJyVDVgs5GYu37CD92C4xgDxR/DbzHXwjHzHn8MzqHn374BFYHWpE0dGwOd7P98GFfy3rNm91VZsmwTiKzZgWw13Ci0e2vyO/I6O2AomswyLGk9w56fboGNdw7Kv4e1FA3TwBKqCoMzigZ0HQdaiQAxePDXRve5GAVVfbQRISAFsP35x5bUYdwpK/BaECugYlch+LI5WfI9Rt71+GMM87EiSd+Do8//jiee+5ZrjSl137QQQfjtNNOH1CpbWHQNVJU6Kl1SK5ZoJNbfdV4FIauQSFhdGr9jQSgVptTB7NhBfUzxxaXEtQf4GeQQH6CdFNSd6A1EYOajEO1RitnQPubfdxUxLevNytOUzZ9fsjc+4oNAJH4f3ci0uc+ZMcMjR87Fv4e1MaJsB97XklJtF3tGow0cg2wy16DEQ2uOJ1OLFy4EM8++2x6nDJ9GCP7kksuGXD/PfbYAx98YGbjLX7wgx9wRcv111+frkgRhNEOVZ/8858P8ve/+911+NSnDt0R1CDHw+XBXnvthdtuux2nnnoyVq36BC+//BLOPvtcPPLII3jjjTdw+eXfxlVXfR+TJkxgkTnS4YgHQ7jp+hvxj3/cz89HZcr5oA8EEydO7PPBgITlLHE9ymjky6DR36sVWOHzD/awXXXx9fyG2RoNYFWgFbHUKGUKsJDdHg2i2Vud1emJknhryqaV7HAyjipbBXqBnR5oUKFRDzj3gRuwka43lSJHd2gmjBhU+QOFy3YpbEwhFrLhq+FrYwVWCFrJpmtTkZYpQRAEYdBQwuS0007jL9ojqf2HqkdzfYhIC9qGuqHY7LyS7Tnm3Mp+6K2qh1rbCJ1E3FNBCrWqFvDnDpTQuVmBFYJWssnnKPbcsvkZisMJtaohXYlCds5ziIahbd/AeiAGnbvdwTZNu1FSwRgOAG1ahtZYAM2uKpwyZUHOAJA1yal/xe9Ym7zHv78h1lgRhLHIiLcFUSntueeeyy0OixYtwnXXXYdQKMTTg4hzzjkHkyZN4p5mt9uNvffeu8/jrZLb/rcLwmjmwQcfQDKZ5NHjVmAlW1CDKriojPiOO27nMcw33/xHXHPNb/Htb3+Ls2IvvPA8Fi8+jP9GSPCWbEtYkUqPrefOBem8vPfeezjkkGqeeJBrakFOJy/QmQ6sWLBNj6+uN0c/kvOUAdm5xOY64mEOwFizfAiyyQmqqoQT4PKgy16PKgQ5cEPVIWTXcZ9339cxElAmbnxVI/RgO79uu6KwTbfzuOj+l210TJAWBEEQyoVG4qb2XAu2qaqggh9+KbhDlaX9K03zZY6pEoT2X9qzzT1JZZuSOZYOWCH6+xkUELFNmInEx6/BiMegOF2wT5+bU0yVjq33tMMgAVsSq03EoSvtaT+C1jvXvYG3OzYgqidZ1LY3GcNVc4/J6rdYk5z6V+PItBxBEHaJ4MoZZ5yBtrY2/OhHP0JLSwsWLFiAJ598Ml06SaNnd8WSIWFs8+GHprDdZz7zWV7zBTU++9njObhiVW0dfvincfvtd+L666/DW2+9iRdffGFAhddFF13MZbiFIPHbDz54H/Pn78tOT8lOXlU9O2g63SfVZqP6d2TC/A4Xap0edMbCHBygRpdalydnpcVkdw30VHCFj03VMYY5JacSREIRdLvHwRnphC0Zg2Z3sR0N5x9FOVz47C7MGz8bHdt16Ik4XA4n5o2bnXZi92+Y1seBJLtYB1cQBEEYhbg8nFDJ3HvJHgqRWWrZpcpSToD4awv611TlQdpn73RtSrejkmZaKVUeA/wMen0eP5TaZig0ucjlZrs4uGG47/MnY+l9kaCV7HxVnVTVQlMVKaHT4PTK5wxBEHad4ApBLUDZ2oCIF17o+8GxP3fccccQnZUgDB1WdUlVVcqhyBPU8PvN+2SO+qQg5O2334E1a1bjxRdfZAFFn8/HGitUDVN2BqZEJ48cEvfiUxF68Pcwwr1QvNVwH3d+2lHxO9z4VNNMPNvyCeJ6Ek7VznYuh6cjEYZKbTrcFJM6BlR0JSJo7icAWA4enwd+PYSYoxqwa4BiY9vtdSMYHvnKFUKx/iM9mNR/fLui4NwZB6La7kJrLIhmErSdskCybYIgCDsx9B5Olar9K1eH6r2dn5f29CKfn/egjIyHtSeVDbXz6Boc0/fa0RZEa44kDp2v6quBFg0CVAirmnaf69P/lAqc4mB1ZIohs81b9mlBGDuMiuCKIIw1SNiNWLVqVcGgBumtZD4mk1mzZvPXSDl5XHHz7vPQaVJQMg5D09h2zj88/ZgJnlrMqW7mMcM+u5PtfDhoakHSrF5RLLtCqIkYGpvrEF29CQqdr90Jd/MMFtIbDVAGbmXvdtQ7vaArQOEVsq0MHDl/F+++hEuyKXMoDpsgCMLOD+maUaXqUAuMlqKpZrUFkcj6grrJ6bYgsktpCxpAyt/h6hmbvXClDt3f64cS9AE07Y/2Pq8/fX+q+KRqmkyxd7JznV8ldGTKuc5UqSMIwq6P1MEJwghwzDHH8PrQQ/9ENBpNBzXYwUg5GlZQ47777ks95thhdfK8J3yN13yOlxYJIv7BKwCJrJJToiXZ1qg3OsMx27duCg5qnMGr5Zhlg6YFTfPWwVAVHkdMK9k0LagSGE433Mkgqhrq4W1q5pVsYzQJwpJvR5k6RTWvaT9fj/5NkNMogRVBEIRdB3pPJ92RoXpvt9qPKRliJBO8cgAghwZapvgrnZODKkwUZdDir/n8naz3j0eh1jRx27FhtR/XNEGhiUOp5ztvxkH4dPPu2L9+Kq9k53q+TB2ZhJ7k1dKRqQS52rzzXWdBEHYdpHJFEEaAww5bwur5W7duxc9//r/46U9/ljVzRVN/Xn31Ff7+9NO/UPHzIJHo6dNn8FqWijxVrJBDQl/W+GbyZ0I9gNffR5XfoZgVKPkcMzruvvVT0BkLpTNQZFfK2WQnrX48DFrjMcDpYtty0kaaUjNwgiAIglAUsQi09i3QWtYDqf3PNn56XuHcSoi/ZvMzSqnUoaQInbPR28HabkYsbNoOVzr3wFWdux2GjngIDU5fXg0V8ktsioq3O/vql1VsWlA+7TpBEHZ5JLgiCCMATX/5n//5IS699GI89NBD2Lx5M8499zwOuqhONwve/u1vf8UjjzzM97/wwv/C1KlTK34eNTW1OPTQQ3kti4aJrFsCI5bqyaYAiw2oG1eWY0YZJd0wMNlXl24jIntQJciZuDywNU6C4vKme73VqrohEQ4sBysD51ed2BTpxhRPLU6btp9UqQiCIOziDLVGBwUp9M4WGCQiS/tfzDDtjCBFNqzARbntqLn8jGKTOHo0BK1tC6nbp24w2NajYajUHlSGhgpP37NeBkvKGDulQLEgCKMPCa4IwgixZMkSXH31b/D971+Ft99+m78o20JfNKbZ4itfOR+XXnrZkJwDHScQ6EVDQzOcTmfJTh5pmFBwQm+n3mUaFaywzRomdnvJjplHdWBLpAcxXYNdtfFKNmWWKqop8+aTiPd2wemvG1LhwHJoifTizc4N6IgGsC3Sg0ObZ1dcaE8QBEEYPZSqhVJu5SbsTq5eQTIB2B1Q65rNys0CQQ6rHbWSfkbRUIUsTQKibdoSYyM7VSFbqoaKlcRZULtDR6aSSZzhFigWBGF0IZorgjCCfOYzx+Hhhx/F+ed/FbW1tdB1nR0Rh8OBE0/8HP7617/jiiu+M2SbckdHO/71r3/xmunkRZ66E6F/3cQr2bkgp8ZIxLm8mJw2WsnO1ltcTGYooicwyVOTDqbQSrY1YrESbFcb8FfX8bjdfSqvZI8W6Pd/7QdPoKN9E9DbwSvZdLsgCIKwc0F7YVhL5NXbGC6NDt3hgtayDordAcXt4ZVsvYiAAp0LCa6Xc07Z/IySK2RJ+NbQzfZjWslOVchaGiqZ5NNQGQodmcFo140Ug/mdCoKQG6lcEYQRZvLkybj88itw2WXfRFdXFwdXaDKQyzX8Iqu0yUZfvB+Jte+ne7KNSADeky/JHeDR4gBlvizNFWffyTullOuS0zPVVw+/3ZXOKNW7fBVzeuj1PbasB90RHbC7eSX7/MV1GA20xYLo6NlulmwTusZ2RyyEJk/VSJ+eIAiCUCS09z24aRk2d7VicmgDTp2yIPvel0+joxjtsyJRgl1Q7C4YatQUobfZ2FaoAqS6Pu/rGOqxxflIV8hSNS0o0aD2qZDN1HazKKTtNlgdmWIJwwUvRh8j/TsVhF0ZqVwRhFGC3W5HU1MTJkyYMCKBFcKIhjmwQj3ZpMpPq2lHst+f/qOfWZkPqmQhRzFl5yrXzZUpsZweGkVMz15fYacnHDfQHdb4PO1J87zJjiRGR+am0VBRq/WtUiG7Xt6qBUEQdhpK2vus0cQZDIlGR1U9FF+VubenvshGv2Nnex0kMp/QNV7z7eFDAR+LEg7+GsBXY666lj4Hy2+gIAFRTLDEale+Yo8jea10YGFrdwK3vtiBm55t45Xs0UKpfpkgCKUhlSuCIPSB23p6O2DoGhTVBtQ25byvHgkD1BaUSSLOQnPUC5058tCqRLHKdfP1NqdcpkpKzDFep4IJRgcaVz8Hd7wXUWc12mcfAY+jEQGMPKrHh0vd4/D76HZ0KjrqDZVt1e3tV2Ye52yd9HALgiCMPvK1qvTf+yyNjugbT7DALE2wGwqNDh717K0BIoG0oDvZ+Y5Dr2NjqBOrg23pCXaz/U2VE5kv9rz9dUBXq9kSpNjYzjzvckR3B6MjU1SFLCVyAF5HU4VsX79Mg12xFeWXCYJQHJIOFQShbwaNWoFSfgmtZOfMoMWzV7Rwm1CqzUdVFCzr2ow3O9bzSnaucl0ro9KdiHAvNK2VzqgclXgNNXovVD3JK9mjBXL2piw4CoscVZhnOHgl23IUqZT3xlUv4doVz/FKtiAIgjC6sFpVMsnXqqJ3tyKxaimSGz7ilexKo0dCSG74GFBUc6qforLNyZACIvORRBwJPclrpUTmWbMtan7Iz4fi9kKtaQLCPWZgKNzDttKvZcoKlox00iFdIZvBaKqQtUZRkz/2ducmXsmupOaMIIxlJLgiCGOYcePG48tfPptXa5qAbdw02BomQq1t4pVsniaQBYX6tG22vjdSH3dGmXEwEcPWSA9aogFeyc5FqcJ0JROLwBdqwZ7aOuylreKVbO5tHwWQk/lwcCuC0/dE9awFvJLNTqiU8gqCIOwUlNKqQoLl4cdu4ek3CgU+Qj1sV1rInFt2KThBeiuGxivZudp+LZF5l2LDhnAX1oc6eSW7FJH5/n5GWjj/33ci/NifeM0nnE/XQdvyCUABHbuDV7IHe32GStCVKmRrvX39IrI9jtFTaTqko6gFYYwjbUGCsAtQsVYRlwe2xklQXD5z1KFqh1qVu/dbVVQoHj+MUG9a0JZsGidNkOOysnc7a6foMKBCYTucjMPncOXM9lFf95AI2jrdXHZtkEAeTzqKmXaWcxkJrOAS/w5pGkJGcImcn3JarARBEIThh1pVLpq9GBu2bcS0CVNh65+IsAh0wgj2mB9wKWBA+2ewByBR2zxCsyVD+zgFbzIhO4+2i1uxY1WwDU7VBgds/HmcbAqwlEuu6Ug0VSer/9KxFUY8lqpUMWcxk42u7UDjxFEn6Eqv4fgFNenWIAqskD3SFTXDNYpaEMY6UrkiCDs5g2kV6ezswJNPPsFrZu83BVQUmxlYydf7TberDROhVDdA8dXwynbm/elbuh+XIlOfUe7zoccd3DADKwOteLtzI69kV8opococxVvNzpze08Yr2bkqc0ZTKXm6xaqbSnk38pqvxUoQBEEYWWjvKqgBUlUPuNzQezug97TzSnY+odlyoKQHVaPC6TSD906nWaWaSoZkoyMRhstmhz01sphWsrsSuatdCvkZ1nQkrshMmmOq09ORskE+hceXMszryHZqFHOpDEcV6MRaBy5Y0oCLj2rilezRwnCMohaEsYwEVwRhJ2awTkIikUB7ezuvFrb68ZxB8p7wNV7JztcL7ZyzvxlQqWnilWyrF9pnd2Fh/VQWwSNoJTtXdoTO+7WOdZhT1Yz966fySnalnB6qXDHCvVD8Ndz2RCvZo6VypVApuWLW75pwVe/oyIQJgiAI5UHv77bxM6BQ24th8Mp2pQVtab/e62DYJ+0G27ipvJLdX7skk0anD+Pc1Why+tDk8vFKtjnRD+X5GS4PDNXGei/JtR/wSnauChqq+PGdcikUt8+8Pm4f2zkrgQow5O3HmRowTnXUVKxYlDNdSRCE4pG2IEEYIxMJBrQRxU0djzx3Knh82oyd85cgsWklEAtDcbnZTgcDFAXnzTgI1XY32mJBNLn8OHXKgpybeLmvp5TKFZrEQCOmNdKXcbjZHi2VK5ml5JFwLzze6nRWka6NZuhYULejlJdsKeUVBEHYiSHNE0OHQpP5YhEz2EFTcaiSI0/go1Ro33UvOR1w+6F3tUCtGw/3gcfl/VBN+8/Z0w7A//v4KQSSMVTZXfjmtAPyVrsUdS4F7P7Yp+4J50EnQG/dCLV5KtvlMtTtxzsD5UxXEgShOCS4Igg7MZaTkBmQKFTeubU7ke4F9uu9A35OwnJWPzQJ01JbUK7qFe6dfu9FGOQEKiqvZNtn7JPerK1gweZINyZ7avNmm6zWl3e6NqXHPlKlS8WcHpcHId94rLMpiNuScNrsmOEbB2+envPhxrr+1G8fzbj+mb9rR6rfXUp5BUEQRrsemtn6UkgLTEkmuB0XyURaC2xIPvJyd27+Ft30uRkGVofacdS4OQgmY/DbXWzT7WV/IKdgkq7BPm2vtLYbj4bOEUyiY0VfvB/Jte8D8Rj0ji2IxkLwnnxJWedgtR9fu/K5tObK5ROPGHMBhqEaRS0IYx1pCxKEnZhSyzvJSbECK0Qgaq6W45dLaC6XY0hjFMnhURJxKKrKK9mZ0wfe6diIc964G994+15eyc77mlKtLzpl7oag9eUZx8HoUathqHZeyR4t5Lv+6d+1w8MjMWmVUl5BEITRCemf3bT6Zfxp81u85tJDS1dU2p0wKBBjdw5JRaUVpEh8+B8k1n3IK9n5Aj9UMbkx1In3urfgo94WXskeVAuNy5OaKGikKmQN086R5CA/I5EKrDDxGNv5phzlY6jbjzOPE4rpMtFPEMYYUrkiCGOovJNagazACuOsQrRhEZze6j5Cc5mkhebKKE+mUYlWdoigley7Dzona1kxOXLdNBHHOjbAdqVaX+j1b1MasG32abBrMSRtLhbZjSRGifNTxPU3z1SRwYmCIAg7mR4a7dUD9mh6b6eJLd3bzak4ziAwaVbeKT5lnRMFKVa+Da27zRzHzFUycQ5SkB5LNjyqA1siPenRy7SS7aZqkyKprq7BIYd8ileChVR32w+hR2+BEeiEUlUP3wkXDluiIHMqn1UFWunJe5kVwta0oPHV5U9YEgRh50EqVwShAD093XjllZfx9NP/xptvvoFYbPToc/Qv7yzknHidCm/0aWwu+Jqmo67K2y+jlPHceTJK5JA5Zs4DnClBWKeLbUsgrz0eyqqh0tnvtv6OXExP8nShWBmOXFGvX1GQtNNYStP2OEZJ9Uee6285692JCCv801rpCQeCIAjC4ClFNJXew7WWddwaw3u4rrE9FJUUNI3IiARhxMK8sp3nOBE9gUmemj6i9GRbwZZi8Hg8mDlzJq/WecTfe9FMGtDrjUfZznUe5GfY+/kZZOcT4i13Kl8l6F8hTCvZslcLwthAKlcEIQdr1qzG7bf/GU888USfgEptbS1OOeVUnHvueWhsbMTOBDlulEGxNv5qRxyT9LWIRMbB7/enRzHH3nySnS61prHgKGYSyFM8VdB726FWN8K1aMf9adKAJRynw4AKhYXjck0asBy5iBZPa65YjpxXdVbu9b/bjWAgBH+Vj+3R0lqTvv79NG/o9lAyNqRiv4IgCEJlyBRNLfgBPtAJxKJQqhpM7RGanBOLsu4Wqusrel46PT8FeOiDvqKYdoHXMdVXz1or5Yq/hsNhrFy5ElVVtexnpNt8EjEoisqr1eaTrYKGx1kvOR1Rjx9GbweU6ga4F+UX4s2H1WJrVRZVelrOgArhVIBl1FTICoIwpEhwRRCy8PLLL+Hyy7+NSMTs6Z02bRrq6xuwZctmtLa2ctDl8ccfx5/+dAtmzZqFnYmJtQ5csKSBN/ru9m3461/fxv7z92Knx8IwxU7MtQA8uvnYc80slNPdx0HJOmlg98NzThqohCNXiHF6B74UexLxaBeczjq49M8AaMZoga6n++hzgEAXUFWXvlbliBcLgiAIw4/1Af7BTcsQCgXzf4CvqgdcbqB1MwyqXqHgSvNkoF8VY0XOS7Wx3pgVXOFjDXEgIhDoxVtvvYk5c/bs42eUAou6H3teVj9jtE3LsSpkMwMsVoVsoGJHEQRhtCLBFUHox/LlH+Pb3/4WotEoDjzwQFx22bcwb9483nw1TePAy29/ew3WrVuHr3/9v3D//Q9wNcvOBLcRORX09HMoLEFVhHrMqQWhHrY9x5yb1/ngn+VQ+afJAkeP3wNRLQG3zZF30sBQZ5TSgrGhbjhsCq9ku446G6OFXNOahvraCIIgCJXDmpS3YdtGTJswNeekPHoPt02YCb2jxaxcsdnZrvR7Oz0fVaOSH2NVyJBd6DiVDkRYbT7W9J+S2nwq2FozVNNy+lcIW5orslcLwthAgiuC0I+bb76JAyuHHnoofv/7G+Fw7KgMIOfo8MM/jQUL9sWXvnQWNmzYgHvu+Tu+/vVvVOTY3JNLCvikvTESG3GFBW0zheM8KSemUCvLUGaU8r6+UYAV/NECnQhrSXgDnX2CW5az3hEPocHpy1kBJAiCIIw8vPcV2sdiEahONxwLPg1QG5GL3tuVsvfdvEGNqXtAD3TCiGlQHA62i9UuKaaStajzKKPNJ1fSYWeoEKaKFXptJPAvCMKujwRXBCGDbdu24oUXXuDvv/vd76UDK/2DHlSpctFFF+PKK7+L+++/DxdccCHs9sH9OY0K5yElqJoZgMgnaFtK37kVLCmmzWeoMkqVfn0VJxbBpo5NeCTSji7oqIOKE+Mh7J5ysmmUZ//KFQq4CIIgCDspFNxQbdDWpXRHXB6os+YNzb7EAQz6sM9Gys5PufsO+U2kP5JNyLWUNp90xWlq36a1mIra0VIhLAjC2ELSnoKQweuvv87ZBapMIXV7K+gR+fedCD/2J17JJo4++hjuH96+fTtWr149qOPmch6KVZen+5Hgaalq9E6nExMmTOA1U1AV3hro0Qiv+QRtC0GPm+1rxNMtK/D41o94JXukHCLr9VkTeTIFY0cDusOFR+Ld6ICOXkXhlWzd7sw52lMmEAiCIOzc6JEgtK4W6N2t5hoJVvwYJCSrbVjOgra8a2gJtimgk/MxqX2HEiQJPclrMfsOjSK+9cUO3PRsG/71XgQNTTv8DAvadymQVHD/HeUVp4IgCJlI5YogZBAMmg4NBRwKZUzIUWhoaODHkGDdSLXjDKaaoa6uHkceeRSvFuTcJVYthRHsgtKxFc45CwtW0ORqZ6JA1a1r/4NQwgz80Er2MRP2HLGWFhbgPaavAO9oKdeNRAJ43+fFW6oDCShwwMABugPRaJAFD2VakCAIwq4FBT2SG1fASKSm+CQSpp1jek7Zx6GRzzyKOQQYOgxFhabkH8VMrb0bQ51YHWjjqX1u1Y7ZVU15953+o4gDuh+RhsWora0b0opTrpTR4lwxO1oSJoIgjD2kckUQMvD5fLxu395SMOiRSMTR2dnZ53Flk3IeMimmXaVvVkkrOqtkQUGFeDyeDi7QGn7sFlPQlkYkhnrYzhd8yFXZQ7TFglgTbEdQi/OYZVrJ7sgYTzkSFJ0xG2ZcLh+WOoAETXBQVV7Jdjq96RarTGRakCAIwujF/MCfyLsn08/0nnYgFgbiEV7JHoqqRCMZ59HHSJgr23nwqA5sifRwYIWglWwKshQ9itjQ0RuKIxTLP/Z5MBWnlGS6cdVLuHbFc7ySLQiCMBJIcEUQMjjwwIN4w166dCnWr1+fN+jxzDPPIhAIoKmpCbNmzR6RdhUrq7SsezPe7tzIK9mUVSqGtrZW3HffvbwyJHQX7OGSYUPXzTXYA/QLMFlYlT3Jnk5ooQCvme1MHtWOmJ5MC+HRSnY+x2wssyXWC8VOWTe6VmY7PNktsUB6WpAVYJFpQYIgCKMX+oB/0+qX8afNb/Ga9wM/Te+hfVtLmivZFYb34WQiQ2tFYTtfEIeSIpM8NXDT9ECAV7KtYEu+UcRpop3wbXoIwe62QVecek/4Gq+Z1bTlti4JgiAMBfIJRxAymDRpEg47bAlefPEFXHPNb3D99f/HQY7+QrO9vb246aYb+TGnnXZ6n4lClWxXKUQ6q0QOGfkwWuGsUl6q6rn9RG/bDNC4RpsNtqbJQL8AU5pYBIk173MbEZUyw+GAsdt+8KTamaj1hxyxTeFuJHUNdtXGtky5yc4UTy38DjdiugYlNa6a7ImemqGfpCQIgiBUhMwP/ElDT3/gp/fvvO/bFBAYovd1JR6FYnfAoMoVKkZVFbYVsuHP+hiqmJzqq4fP5ky3BTW4/XkrJvuPIq5y20CN04Me4UyPz9ImXU7rkiAIwlAhn3AEoR80Vpn0VF544XlccslFWNnSmc6YuI46G68vX43zzjsH69atxbhx43DmmWeNWLtKOquUCqbQWiirVOj4tvEzeHIBO3mqje1c56PZnUh88jYQDQFanFeytZTj5bO7sH/9NNQ43Ozk0Eq2ODzZoaDTXjUToMFAEjqvZGcGo6xJShJYEQRBGJ3sqCrdgvcDLbwWVVU6lO/rnDyhyUR2TpzwSnau5Elqvzm4YQY+Cbbhve4tvJJdaP+xRhFffFQTTtqvGkNJOa1LgiAIQ4W88whCP/bZZx/89rfX4jvfuQIvv/wyf82ePZvFazdt2oStW7fy/agd6Oab/8i3jxTlZJXyQqK0hg61tjk9EpLsXMK6etuWgYr98Sj0jm3AuCls+h0uTPLUpoXmyBayQxOfOuNh7F7VzBo6DtXGdjgZh0+umyAIwk6B9YE/lgqm0Jr3Az8lNGjfpv2W9M7IrjBqIgZb42Qku9vNtiNKnjROhkq6KzZPzgqc1zrWYU5VM1fg2BWV7f3qpxQMsFijiHuGOBFgJZkiWpyrdzNbl7yqJHIEQRheJLgiCFn49KePwF//+nf8+c+34d//fopHLVvjlmn88kknnYzzz/8qV65UklxTdwplla5d+Vx6WtDlk/Ypu6rBcLqhd7ZASSagUI91MsG24XBRd3b28+3f12wY6V5nCqjohoH5tZPSwR+ypVw3D9wOr8CZ6nHPeuEFQRCEUUv6A38yjkQiAbfNkfMDP73fqzWN0Eg4nlp8bXa2K12dqDtc0Ns3p4I3dGCVbd3uRK5QDu3h5FvQuTgU26icUmclmfx2VzoAVO/yidi7IAgjggRXBCEHe+yxB66++jf47nevxPvvv4dIJILq6mosXLg/vN7KjUe0oCk7/bVdihmBXG5WiWhsbGLNGFqtnmy1fjw0qkaJxwCni23uyc5SuWKraQCoooJ7tlM4XLBV16edHpUEgrs3I0TVF3Yn9m+YNuJOD08/CnRymfRo0n+hNqqF9VPxTsdGRJMxuFP2aHFiBUEQhNKqSnuDvaj2V+esKqVxy/Zpe0IPdAGGBtgdbHPlaCUJdEKPBE3B3JS2C9skWE97eY7XQUkbSzumnMBFfz+j0lhi76RpYyWZROxdEISRQoIrglCAxsZGHHHEkUN6DGvqjjX2mVaySesln4NQblaJggsdQR11XgVutxs26r8mXB7YGidBcfkA6l9W7VCrco+EVj0+qOOmQt+6Ll3OTLbq3hF82h7pxcreViQMjc9xircOI0li7fs8XpqmICn+GniPvxC26XtjNEC/x7PrZsGz9iO0JcJocnhx2uxZ4iQKgiDsRFgf+B/ctAzhcIgDEvk+8CtuH2x142DEI1CcHrYrjW53mW28VrUprdTGm6dyxaqO/e2KZ9ERD6HB6cMVexxZ0p5E/kUfP2MIELF3QRBGCxJcEYTRQCzCARX2eVJlwZxNyqF10j+rRAEVC7LzZZWWbQzjpmfaWcW/0RXCfPtSnH7S8aivb0iPhO5fQZPTIYxH4Zi+FxIOD4xoiB1Cx6SZ6UqXYCKKNzs2wKnaYIcKFQrboUQM/hwBm6GEgkpWYIWglWzfN36H0QAF2Ro/eBUXxhV0wod6aoX/4FUYE2aLsygIgrATQR/4L5q9GBu2bcS0CVNzBxdI34ym6U2fm9ZCIbvQ/l8qvC+TlouSpLnMZsspHYsrT6ty7klPtnyMqJbgu9NKdrHVsUR3dxeef/55fOYzn2U/Y6iwxN4FQRBGEgmuCMJogBX8bUiufT/djuOYOS9nxUi55bAUXLACK0QoEkVvbAsikR2itNSK5D76HIBKlKvq8rfNpCpd4PSYrUFWS1DqvMNaAjE9yasBAwr9pyicXfJj+IMrVBZtBVYs2E5VDI04sQi2BDvwqBJDF3TUQcUJwQ7MrrCTLQiCIAw9tN8VrKQgjTWa2EP7UEpri+0KJyB4EqG3GkY4kK40VbxVeduPSGT9nc6NrBWjKiqvZBcjsk6BmXDcQDQaxZYtmxGLZbQPjwGs10+ivpIcEYSxgwRXBGGUYBSwC2XHrJLdfMEQagWyAiuZBKJ6Wdov3I60235IZLTZuBcelXYkGp0+FrENIZ5+DNn1zspr1hRFVT2fox7sYWFd0oNR/TXmKMpIC0YaEhR+1KWgK27+PijAQvY3cwgKC4IgCDs3VsVo5I3HYZCgPCU48lSMlgu18Tr3ORSJj16DkYhCcbjh2OvgPm28lXJOtnYn8NiyHvY3/HovxhqZr7/Wa8PxC2owvnro2qIEQRg9jB4lR0EYy1hlwdPmwj5rHq/psuACbAl346bVL+MPq1/hlexcNPhV3uj7U+VW82q/WNN/+kO3J1YthTp+JmyTd+eVbOv+USPJ5cN1Tk+qhcnDdoxE+/JAj6eMWa7jlgsFnkJLvoItMQ+29yR5JXu0iNrShIne8VNh2J2I6xqvZFO2UBAEQdg10btboa16F8kNH/NK9pC0zXzmK3B+6mQ49jmMV7LzBXFIZJ1E6K0R0rSSna/9hvZtK7BABKLmWun9fLTS//XTSvZYef2CMNaRyhVBGA2kyoINnhZgFF0WTJu11RJE0Eo2Cbtlc5goiHDRUY3p1qAqtw2gNmxVKU/7JRZBcvMqFok1YlEoLrfZzpS6PwVU9qyZgCanH0EtDr/NiUZPVV5NGAoO9W9zouqcSkDX6+9bJmHZuCvhiPUi4arGgi0+fGuv0eH00PWyQ8FSI4qwmoTXiGIRzLJyQRAEYdfD0gLTaK/VdF7Jrrr4+iEJ/CuqAtXl5rXgfRUF5844EFV2F7ZGejDRU4NTpyzIL7QfN7JWyMb65Qg42BCLmP5PBap0uA1Hi/M+WszzlXr/Ysn2+smOJEaHnyEIwtAiwRVBGAVY7TWZU2xc+11YcMO3pgVlUmha0IKpXvzhvMnoCuuwa/V4++2F8Pur+mi/JNa8B8QoQOKGc9b8nEEe3eFCYvUyGL0dHBQyIgG2rekD1qSBa1c+lw6WnDh5Xs7XVWqwqFRCMR3LNkYQ0xTE7DWARgK/EYRTbTgjDb3+7m2r0aInEFUMuPUE23S79GwLgiDsggQ6oXVsg97dBmgajdcB4hEzsUEaZhXCqkxFqAcKJU5CPUVNJbQem7nmgzRGqEI2HWBw+KA0z0dDbVVZ7cfFUGpSZiiTOANeP8C2x6EgUJEjCIIwmhkdtfCCMMax2mtsE2ZxWxCtme01haYFZVJoWhBB2bAGvx1VVVWYO3cufL4dYx/1SBBGdyv0njZzjQRzn3dvB4xwjymOR+dq6GxzBU7qdb3WsQ5zqpqxf/1UXsnO9bryBYsqwWgPT4RCPfgkGUYtVIyDjVeyw+Gx17MuCIIwFtB9tdB7O4FEHKAW0EScbd1bXdkDpSpTM2E7T/sx7dV3rHsdL7Suwrtdm3glO59vQoEa0hixWpBrq/046uC94ff7y2o/LoSVlOmMhZDQNV7JztfOnC2JU6m2nQGvP6W5IgkSQRgbSOWKIIwG0k4PBShogzd2OD15lPxLnRbUH1Lx37BhA2pq6uH1emFEw9C2rYXiq4HiNegAbBukCZNF9M5sH9LSrUwsdKdpaSfFCpZwZY5iK1hZU85o6VLwulTsO82LdzeEEUsYcDkUtr1OFblDSMOIy82tWIqW3BEIogzjCIytFgRBEIYeJdjFe6RhJSkUc7qMEuoBahoq3n6s9XaZvoXTDVt1Xd79hbTP/tO2FtujASQNHXZFNScAFpgWNLHWga8eVo/OkA63EsWHH36CaLSR/Yy8QZ4ypuKRn7Ex1InVgbZ0m8/sqqacfkY5Fb+lQq//giUN3ApEFSv0+6T2L0EQdn0kuCIIowGXB0a/Ucz2IkYxE1TKSm0z5BgUHPnYj56ebrz88kuYNm2G6fSkoJHJ5OAVPu8c55c6bytYQpkkyzGrd/lyBkvSwaJNy9AaC6DZVVVSsKgQ9DxnHlTHAr5tgSSaquyjKqPkd7ixaOJcvLn1Y8S0JFw2O9uFRl4KgiAIOyc0JY4TEnaHmaBQzOoKo8Lv+7TP2cZNQ/TVh2FEglA8fjhPvTTv/kfn0ZGqCCEShsZ2oSqPvtOCOhFcnuFnWBpzGQGWwYye9qgOrAm2Y2O4K+1n0GuyRHiHO4nTR0DYOTp8C0EQhg8JrgjCKIG2YHZYqAXGcJbUwsKbeAkZFxZyixsDHCSqTiFB2sQaEqiNQHF52KY1G2qCAkFuILN1yOmGmjRHL2fTXLl84hGF+7vNRxc9jnpXySjRuZw390hU++vRGulBM4kHTt131AR/BEEQdjVoH3z77bfxwAP/wIYN67l4ZNKkSTjllFNwyCGfGvJpcqqist6I1rE1rblCdqWPS/tc5Lm/w4hHzSqZeJRtx7wlOY9Fe0+Vw4XueDgduGh2+wsGZPpPC0r7Nxmjp/trrhSl+5JFAJcqUaIkwJ8B2ZRw8qmuilf8CoIg5EOCK4IwGohFWOBN79qech6CbBdbJluK6n3fjFJfLQ96rHP+EiQ2fWIK6jndbOcUoPXXmWEh1ZYuZ+agiK9mgOaK5ZiRTeOYsz2n1QvdnYjAodp4raSg7c6QUaJKpEvmHF5WJZIgCIJQPOvWrcN3vnM5Vq5c2ef2Dz/8AE899SSmTZuGq6++BnvttVdZz2/uzYn8GiWU1NjrYIDE4aMhKG4fHLMX5ExqlAtppGnb1nHVCgvQU9svnRtppOVoPyKfwqWaFR3WKyA7X5VHMdOCKHhEQrpWe1Khfa6QAK7LZkOzyw8dBlQobBfaZy+avRgd8RAanL4hD6AJgjB2kOCKMOYgnZE333wD7e3tiEbDOPjgQzFjxowRPaf01J1ApxmkiIb6TN3JRymq94UySpawrn3iTIDKgGlyENkz9sk+2jnUDbW6HnpXIp1xI1slAdbq+n69zUbB3ubh6IXeGSi1EkkQBEEoPbBy9tlfQnd3NzweD0444UQceuih/EH7zTffxEMP/ZM1yc477xzcfvud2HvvvUt6ftqbH9y0DJu7WjE5tIFHGGfbm7mSY/4SJDet5LZgCqqQXenAOvkZpKu2QyPNYDufn0F7MumuxHUNGgnWKwbbuapCck3LIVzZPnEUISKbSwDXmnLks7uwsH4q3uncyBUrbpud7Xx76FBOCxIEYWwjwRVhzEAO1K233oJ//vNB9PT09PnZQQcdhPPPvwCHHHJISeWolcLo7TSn7lB7SqoCJD11p7Yx9+NKHF08IKOk2qE5a6FZbwUpoTl+LAmpFhKaq6rnvm3QCElFB6jXmWzqn05lvWyKirc7NyCqJ7kHev+GaTmzXqVqtOyqlFKJJAiCIJT+Hvvf/30F+wVz5+6Fa675LdraWhGJRFBTU4PLL78CF110Mb75zcs4GfPtb38Tjz/+JByO4vaiUvbmHUmNWWnNtXxJjXLhNl4Spk9VrnClqdubbuPN1Uq0LdrLFSFswzDtPK201rQcK5FT5XVCqanrc+1KGsVcQACX22lnHIRquxttsSCaXH4OZOWsuC3RbxIEQSgFCa4IY4KtW7fgggu+io0bN7I9fvx4zJ69Gzo7O7B8+XK8/vrr/HXlld/D2Wef0+exJTkBZWJqrdDUnZTDkrILicaVWukxIKPkqoVz5jGYOC4VwClHaC5JVSsJMzBEDhjZma+NbrP8FRLqy6OkktZoWfFsulz38j2OHFMOj2TUBEEQhpZ33nkHK1asgMvlwm677YbTTjsV4fCOvbS5uRmnnXY6fv7z/4ezzjoD27ZtwwsvPI+jjz6mqOcvaW+mtuD2LdBa1qeDK7bx08uenpMLpboB9gkzkNy+yRz5rNphHzcFSlVdnteRgJ6hlUKQTa+jCp6itM1ctka0tnrR0NBYVCXKAFJ+iU7JJtJWsdmh0jln+CXcTrv7kqLaaYerQtbStiO/ayz5MIIw1pEmQ2FMtAF94xtf58DKxIkTccMNN+Kpp57GTTfdjOuvv46zUZ///Gl831//+ld4+ul/px+bywkoFPQoFe6tTlWKpKGRvAUcK6vSI5N8qvdWRokCLAStR8zZ4YhYQnMcUEkFVvIJzVEPtx7sAtx+gCpW3H62ueIm5cSQI7agdjL2r5/Kq+WYZX0+w8BTLcsRSsa5BJlWsit9vUcrVkaNKncSepJXssfK6xcEQRgOSLyW0DQN//rXQxxYGdfUhN0nNqPa40JraytuuulGfPWrX0kHVP7xD/MxxVDK3kzTgnTWWIuZN8RjbFd6WhC1O/lOvgT2SbNgqx3HK9n59EZ8dieqHW7YoUClgUZQ2C42CJF168pXiZIF8j8cu+0HbdtaJNd+wCvZ/f0Sq522UCCjVL+pHEjb7tYXO3DTs228ki0IwthAKleEXZ7HHnsMa9asQWNjI+68825MmDAh7VRRVmb6xKn4yU9+yiMC7777Lvz+9/+Ho4462tygU04AOwipjAnytcmUCR/L7TOrPnSDxgewXchJsFTvqa/bKoctpHqfmVHq6WjB3/72d4z74jnp61KS0JyTroECJKI7ztteNWAUM2WFHIqtoBNDvdyvtq7B9mgvEoYOhxJGolVDePf4mBhHTMGojaFOrA60pduoZlc1jTnNGUEQhKFk5coVvCaTSey33364+OJLsHfXciDUg3hSw/PL1+Hm597Bpk2b8Pzzz/N9SX+lWKy9+YGN76Jb70Gtw5Nzb1biUaj145Gk1uMY+RZu3ocVauOpsKgtTf+ruvh6gII59eNhKyD86ne4Mb92Il5oXQXNMPj8yS60H/cRzjc6EVrxML5k+RklVshabVO2CbPSFTeDaZsa6mlB/bXtaCX7/MW5K4QEQdh1kOCKsMtz771/5/Wcc85NBxCyCc2Rc/WPf9yPtWvX4q233sSiRQeajo1qQ3LNeyz8xqr+s+bnb5MpA9rUbXXjwPKy1P9MAnN1zUVv9hldN0Ufj0pVSXnG7J3uN5KZjluEU0fXQ61tghYJkZtKoRm2rYqbtBOzaRlaYwE0u6ryOjHklGyPBdCbjHH7kEKvKBYYM5UbHtWBLZEeDqwQtJJNQRZBEAShMrS0tPA6Z84c3Hrrn+HQkwg/9jrf5rTbcOw+s7Fw+kRc8JdnsC113/77ZDHw/DyFd7LcULDBW22Kyyupx3irK+5nlNPmTHtvTyKKWocXCUPjJAnZdHu+fbyPcH5Eg6Lr5vjnckYxp7XgzIpePsYgk1zURkQaK0MxlS/btCSyKaElCMKuj7QFCbs0gUAAH3/8MX9/8smn5BUz8/l8OOaYY/k20l+x0Lpakdy6Btr2jeba1Vrx86Qgha15qjn+mByGeITtQm1B6deSGl1M63C2kVDGzdY4yWwJoioWj59tzrhlnqd57zJc06GBrk8oRs7eaDkjk4iewCRPDU87IGgl2wq2CIIgCIMPrPT29vL3pLfidDrND+m+GuiJOH/R3tA0YSK+cdHF6cdRW3GxZO7NJMxeaG82p/YBRjJpas1W4HVmOycKaOiBbj4OrYXanNvjIa7wHeeuwkRPDa9kd/bTLCl3FLP3hK/xmlfHLlXpkklBLbgiKLaNqFQsbbtMyPY4RHdFEMYCElwRdmlCIaqoAOx2O+rr6wuKmTU1NfV5nB4Jcfkpi83SvqhpbOs0zrCCkHNDfcSgoAS1HyVibBcraMtlszo5ZUb6tQwH1CtuhHvZ0SFRPC71Dfeme8UtB7M7FfzpLuRgKgo7b1V2F7cU0Up2JZ2f0dwLTa95qq++j0YN2WNtWpIgCMJQ8eqrr6a/f+GFFzjQondth97RgsT7LyO+7AUkNy5nXY8jjtghqH7IIZ8q+hj5/IwBxCJItqznPV9v32xqi7C4bXYNkrJJCecm13+ExOplvJKd7ziNTl9WfZL6frcVCi5kG8XMFT1FTGAsVQtupMmmbUf2aD1fQRAqi9SaC7s0VVVV6b5qEqijCQCZ434tLB2QrVu39nmcEQvDiIZ2qLIZBtsG9UZ7fBU7T72nw3RyVJv5RXGc9i3Qezuh5hnFXOqo46GoXDFoqtH2dWYAymaD4atO94qXqsrvs7twSNNMvNOxMT2KeGHD1IrpjYz2Xuih7gUXBEEY6wSDAV6pWjUYDOKb37wUvzp6HziWvwaD2nJVFUY8huBHb+LHT9+STgbMmzev6GNYfkZHNIiEbk7+q3f5su7Nmt3JrcfpSXvJBNuazVFRJ52SIdr2DdA6tqT3a9JJo2RIrh2GxG7PnnYA/t/HT6E3EWUx28t2PzyvCO6AUcxuG4IZ04bKoSQtuFFAprYdVazQ+eYbXy0Iwq6DBFeEXRpynvbddz+8++5SPPjgA/j617/RRwQ2FAqmP8D29PTgmWee5scdeuhiXhWXFwpVZ4R6zAALZVo8voLtOqVjQKGS4AwXh+ziHln8qOP+1Nc34IQTTuS1HMgp1DZ/Yh6Yg0IK25ZTmCloW+w0o/NmHIRquzst0Et6OJVypHaGXuih7AUXBEEY65B4PTFjxoyUxtpbOO2DZTh+khsHNrqhqgqWrlqFRx7+GK29O5IwNTV9W1PyQe/bBzfMwLUrnkVrqAfNRhSXT8ouwKp0bjMDONT+mfIzDMMJpbsVaCy+FakgpF1CE4kMqwcJpk0BC3f2ShQ6r3e6N6He4YFTtcFvc7J97MS5RQvnq3oN1s0q388oVQtutGBp2wmCMLaQ4Iqwy3PmmWdycOWuu+7Escd+hh0q+gB70ezF2LBtI6ZNmMqb4I9+8QPE43HsueeemD9//g7B1vrx0KhSJZXpIbvSwRW1phHqhOnQtq0DdI0DFWSr1WYrUy6sUcfzayalK1esUcfFVHs4HA7U1tbyWg7sFNL5UsbNcgrtjrRTWE4lBv1uLtl9yZAEF6xy5cwAi9ULbeYyRwdWL7ggCIJQWRYtWsTrRx99hP/7vxvwy1/8HFu3bcNf1iTwlzV9dwK/38/VLTRtcObMmUUfg4ISr3Wsw+5VzRivelDtq2J7v/opA/Y0o34C32bQRD3OqpiVDkZtc4Vecb9zSydgCicVaILff9rWYns0gKSho0eJsh1OFp7gZwUXdN05KD9DEARhZ0I0V4RdnmOOOQb77LMP91Wfe+7ZeOCBBxCJRHjjpw/vy5cvx7e+dRkeeughLnX91rcuTzs/lmCrqdzv4jWbYOtgoeN6jz0X8NcBDjevZOcrvUWqMkRVFLzXswXvdW/hlexi24J6e3vw2muv8drfMaTpSIU0X/S68WZgha6X9ZVMQK8xtWsyKzGu2ONIXskeKaE56YUWBEEY20ybNh0HHXQw72+PPvoI/vXwo/h/R+yBA5vcmORRMdGjYr9GD374ncsxbtw4fsxpp51eUnCgFM0VWzIO2+TdzWAHJStgsG2rtHYa6ZuQH5Pa1mklO58wLF2jjlgIyVRrE61klyIGn8vPEARB2BWRyhVhl8fhcOKGG27CN77xNZ4c9OMf/xDXXHM1pkyZwq1AW7ZsSYve/u///hyf+tSn+vYot2+BEerlkl1S2Gc7T49yObAg7boPYa9thOH2csUM2c75hxcWezN7gVJPlLKLOB61yITDYaxZsxoHH/wp1NbWlTyq0RbuMcuJA13p48NXDVskADj6Vt2U0q40lEgvtCAIwtjmoosuwttvv4WnnnqSpwN9dfZu+M0EP/TuVhi6gQ+TXtz40L+wZs0arlo588yzSnp+Sw9tafcmBKNh+BO9OCCHHhr5GQrpnzRPA0jzhRILpF9WYT+DkkVqTRO0jm1Q4ho5PWxbGmlZH6MorLNCYvSaofNrai5RZJ6SWf39DEEQhF0VCa4IY4KGhgbcccdduOeev+O+++7F5s2b0yOaKahy7LHH4pxzzsNee+3V53FUvaF3tgBaPNWjrLNdaUFbOk5y7ftAIg6FxvAm4mzTcSjQki87Rg7PgrrJXLJLIx/JztcWRNNxLKE5v96bdVQjBVbYDpqjGklILpszpXlrgHCw30kFoXmq0mVxW8LdA9qCiqleGUqkF1oQBGHsst9+C/GLX/wS3//+VXj6uefw9HPA3EY/6lw2bA7EsKHXnKBDUwZvvvkPHGApFUooZMih5UwwUNADFHTp2gYkEpQRAhrG5w16DGa6n0pTd6w23tR0v1y7IU/tc7jht7tYmJem/pG9K0yw4yRTSjh/KKpXrSQW+RpSHSsIYwcJrghjSsTu/PO/ivPO+wr3Wnd0tLOg7YEHHpzTcaLghkGOj0p/KmYvNNmVDq6US9/JR0ZBwdj+03ICUc10+qwSX3q9qcBK+jFk0zXI4uQZ7VvN0dGZaEkYFJAaNyU9ipnOL2lovJJN7UHibAiCIAgjxWc/ezwmTZqMW275E1588QV83L4jUeB22HDsvN3wjZ/8BpNnzCr5udN6aLWT0BvsRbW/Oqcemu5wIbl1tanrRtuiprGt250YONB4kJUr9eNNn4aEbJ0uU0MuTxAnoicwy9/YJxBBNmm8edWdVxdsqJM+mUksq/14fHUlf5uCIIxWJLgijDlIx4Q0WKgVZPv2rZyZygUJ1ypuH4xwIBVbUdiutKAtVac4Zs5DgqpXUk4P2YWOkzmRoCMeQoPTh8v3ODJn4CLbtBwiZsVH6PX6a6H1dqZHHtpIVDdnT7aZ/UqPqjZPasfxtDg2hjqxOtCWFtydXdVUtOCuIAiCIAwVJF5/ww03cnvwG3ddj3BPF6q9HiyaOQnVTePgmV68iG2uxIddtfGenDPxEejkalUz00HaZTBtSmzUDG7CTh9cHlMzzuUzJxOpdqhVtXk1V+h1TPXVw6PY0Z2MotbuRpO3elRWrhRbiWIlfSxNHFormfTpn8SilezzF0tLlCCMBSS4IoxZzI04kVeYTfX44NznUMQ/+k866OHc6xCoeVp1yoE2dPeS06E7vTBa1kEZPwPug48vuNHTuT/VshyhRIzbgWglO9tEgqzTcuweKPV7oK7arMKhx9jGTUP0Pw/DiIR47LTzlEtznoeteQrg8QPhjPYijx+21PhIj+rAlkgPB1YIWsmmIIsgCIIgjAYmTZqEk752OaJvPgGjpx1KTSPrjZX7YdualPePDUvRluzERLs796Q8pwcKJRvYF0lNCyI7T9Cj3HOi19RfUy3fa+SgkN2DP255BVE9AbfqwPf2PLqk6+L1+rjlmtbRUImST2y4EkmfbEkssknnTRCEXR/5hCOMSWgjfnDTMmzuasXk0AacOmVB1o2YtTk+8xWodeOhd2+HWjsO7gOPG5KWFgrgxJ77WyqI8xrs1XXwLD614JjEV1vXYHu0FwlDh0NRkWhdg/Du2cckWtNy0uWqNdVYNHchqqur+edUzRN9+UEobj8UlxdQVLYd85ZknVxEz6f4arhvO32bb8f0HSopnuSpQUSLI6ol4bbZ2d7ZS4oFQRCEXQ8ShDdoX6uAlGxLpBdvdG7AtlAnOpQEDm2endXPoCSOY+9DEPvgldT+74Rz78oncQgSpycNNasytZAvo2ka/rDmFdjIF6KKEIDtM6cthCbPRcEAAIRLSURBVI1EeIugqqoK++67H69DQamVKFZVUWaAJV87dakMSGKlJhOSgH7fQd+CIOyKyChmYcyRayPOVcHCzsix58J3/IW85pqcMxiSySRCD90ARMNmuW40zDbdXui1bI8F0JuMcTaGVrLzVeNY03IuPqoJZx/kgxFqRZwcOiLQCSPYww6UoqhmlXKwxyxPzoLe0wGDSprtLp5wQCvZOrUVZZQUL6idjP3rp/LKJcajsKRYEARBGJuwmPubT0Lvaed2GSNkirmXMnI4E0pU/PLjp7Ay0IqORIRXsrNNpqMAgHPPA6HQvmjovLI9RLpknBShFuAinn9TpBuBZMo/SEH21kjxY5XJv2hpadnhZ1SYUsZeZ1YVUUCFsCpdKnW9rSQWBVQIS3NFdOYEYWwwKoIrN954I6ZPnw63240DDzwQb775Zs773nLLLVi8eDHq6ur466ijjsp7f0EY7EZMo4mj/74L4Sdu55XsSmNsXZMKrGjklZlrNAxj+4ZinyHlBBolTMtR0d3djWeeeRpdXalRylX1UPw1fe9LNk0XyHHcjHtmPQ45LfUuH08ZoLWSTowgCIIgDBatZT3iH73KumfJtR9Aj4R2iLmXQVssiPWhTiRJ4N0weCW7g8Xn+0IBl/BTd5qJiniMV7KzBWIqAT0vBZGKef4pnlp4bHb2m6hSllayJ3r6+gn5IP+ij5+Rgq4LTUosN4DVvxIlk0KVKFRBRJUtV+xxJK+VnmCYmcSilWxBEMYGIx5cuffee3H55Zfjxz/+MZYuXcriYjQWt7W1Nev9X3jhBZx11ll4/vnn8dprr2HKlCk45phjWIxMECq9EdOmH33xfsQ/fAWJ1e/ySvZgnYEBx+FqGGPAl1HTlPdxpkieB2oqWKGm7HKDF9T64z3+wnSAhVays7UE8f1rGqGyvgoFhKjKRmdbJRHcYXJiBEEQBGFQVSvvvQAjEYfe2w6tfTMSy9+AodjK1j3xpvwJao2N6EleiWx+BgU6tG1rTRFb2kcTcbatCtBKQsGjwA3fRM8N3+KVRfTzQHv/3Orx0ChAZOi8kp3LJygWSlJF/n0nwo/9idfBJK2sJE6tw8PjomktNomTazx2JbCSWJJMEoSxxYhrrlx77bW48MIL8ZWvfIXtP/zhD3jsscfw5z//Gd/73vcG3P+vf/1rH/vWW2/FAw88gGeffRbnnHPOgPvHYjH+sujt3aENMVRZgZ0B67WP1Wtw0sR9uBUohCBvxGRzFqVf0ESPhhBf+Tb07jazmkS1wUgm4IqEKtoPzf3d1FaTmSWzm4r3+X5HbsWOarsbPpsLSVWHXVHZdim2on63um6kV+v+tul7w/eN35mtQP5adqJyPRddL/v0fZAIB2DEolBcbrbp9v6PIRHbbNd4NDDW/x4IuQZyDXb26zDYD3zlksvP4AqBnewajsV/R1Q9oQe6zb0pda4GVZxoCT73cj4ck5j7eHcVgskodBic+CCb9sH+10PTdCCZMH2MlKAtkoCma1AreO3ouMF/3gC9bTMfSw90sl31zZty/u0EE1F0xSOY7WtE3NDgVGxsB+PRrLpumdD1jMR3+AKWn8FJKxIOTrUbG4Eutt1Hn1N2IIKPYfkXKf8j37870t17aMv7aQHckyfNG/LEz87y9zCUyDWQa7CzX4Ni/IwRDa7E43G88847uOqqq/qcNLX6UFVKMYTDYSQSiZzjdH/5y1/ipz/9adaftbVVvr1jZ2OsXgP6h39a9WxE/dPZ2VECYWwP9G0VYqIh2LrboCTjpq1r0Lrb0LZ9K1BJsblwAHbKWmWSiKO9ZQvg9ed+mJbABJsXYVsYYU2D12Zje2PLpqJ0Tbq6OlJrO1Q1S9AjUuDfRzwCNakBuy8CEjHA4UIyqSG0eV3FJx0MB2P17yETuQZyDXbW6zBhwuQROW4uP6O9fTtisSz7yhhj1P87MgyonduhtqwHNBpRbINROw7hUAjBMvcy2punO6qhu5IIaDFU2VxsZ92bI0FOjHBExTwhFpPv7O4GYtnblcsi0Ak7tRprmjmZSNGgb9+AtrXLgarsY4JDyTiCsTDa4iGuXKHzbNJ9aG3dlneyzvaAjudWJtAbMVCldPf1M8hv2N6v2jwUQm+Z15oCKn/Z9i66E2ZyanMkgr+EXsG5E/bNGqzpf/9QKIi/BHPff8z9PQwDcg3kGuys16AYP2NEgyvt7e2sRD5u3Lg+t5O9YsWKop7jyiuvxMSJEzkgkw0K3FDbUWZGiVqJiKamwZc27qxQtJD+Ucs1yH8NqHIlUNNoitylKleoFaZ+3MSKVq7EWzYgOKA81UCd1wPnOHOscTbISfC3LUNXcCsiRhIxww6/14dpE6YW5SQoig1erxeNjc1obu77d1gMnIEaNymVgTKDQDTe0T15xk5VCit/D3INCLkGJnIdSiOXn9HYOA61tWO3DXJn+XdE59kb6IBOAQ7VRhsjlHgY7uZJ8JS5l5l783voDG7lAEVCMTDP68+6NydDAfTS5B1NSQU9FMBmQ0PzBNjzJFdKRauqRq+iwCDdl9RxaLpf46TpsHl8Oa+Nc40LkVgvV9LYVBucDhe/jly/U3rtj6zoRFJ1gqYvJyNxqHYPGhqaMG7c+H5+AwbtN5AWTKLDDp9zx7WikFR1Y1PWAFCp9x9rfw9DiVwDuQZj4RqMeFvQYPjVr36Fe+65h3VYSAw3Gy6Xi7+yQb/QXfGXWgpyDfJfA8Xjh3OPAxBf8x4QiwIuN5yz5rMjUsnggUpjj/u3y1A2zeXJ+/uhN6jVwXYkDYPPh1ay6ftifq8UUDn11M/zmnl/Lq2NRYAiJgq4Fx1nTlUIdrOD5DrgMwNGNNJ5tsdDaHT6RvW/N/l7kGtAyDUwketQHLn8DLl+O8l1CHRCTcRg1DTAoBZgquyIhuCYsnvR44b7Q3veqmAbEqmy90TKzrY327Q44KC2YKpepfurbNu0BN+X9uNw3OARv4PxOwwKoFDwKBNKGLm9OX8/JGDLgSKbEwlVh0MxzydmaPCp2T9ChGI6eiIZ7VSeeoQmnYCquub0cYrxG4rF73CzWH7/0crUtpTtepV6/zH39zAMyDWQa7ArX4MRDa40Njbym+n27dv73E72+PH5x91ec801HFx55plnMG/evCE+U2GsQhute8npgMcPo3M7lPpx7BRUegM2nNkDgEaBnmYKWFD5cbPLb/Z1Q2G7Mx5Go7u8jBcJyw1wevKMn+ZR1ceca+rFON0Drs07HRtx7crn0r3Nl885AgsbppZ1boIgCIJQUarqAV8NjK7tZpJDVcjrR/yTpXDu/amy9nvam3sSEfP5Ul9kZ92b6fgUUDFIc4UFX0zbX4ut3Qk8tqwH3WEtPdK33MkzSrALqq8aGgV8qP3JZmdbCfUAGSL0/XHZ7Why+aFBhw0q2/mgIBCdK52zRbVHgcehFO03lCNo+89Ny9AaC6DZVZVX0DZ9/83vpf0SmWIoCEKlGNFwkdPpxMKFC1mMNjPaT/bBBx+c83FXX301fvazn+HJJ5/E/vvvP0xnK+xqcDZISxQlsMriaClxu6FAJaeOe64zUFSove15H0eVIDz5iLJh9HieFuRFfb9pSLloa2vDgw8+wCvBGalUYIXtYLdpF7hG5JQoWapc6HpZgRWCVrJ3RhErQRAEYdeDMqeuAz/L2ifQEoChQ/XVQFv/AQyq4CyDBocXMS0JDWZVKa1k1zk8WQV1SYekD/EI9Gg4HVghaCW7bFH4qnpua7bVNsJWP45XsimIkwuf3YU5VePQlYigNRbilex87TP0eikIRAEWPix6YF//CEsBFOM3lIt5VZSi5v/IFENBEIaKEa/FoT7lW265BXfeeSeWL1+Ob3zjGwiFQunpQTQBKFPw9te//jV++MMf8jSh6dOno6Wlhb+CweAIvgphZ4OU4m9a/TL+tPktXsnOGYB58nYkXv0XEu+/zCvZFZ94M2GmmS3LhOzmqQWdQqoEsUZLW5Uhhcrs6PypdFfTkiwKrfOUAhp7EenTB833JTtzilGJ2bvM0luCbMre5YOCL63RgARhBEEQhCGF9kOtbRPgrQbcPsDth0Ei9oPY5qNGEvNrJ8GdEq+llWxqpxlw/ECnWUmSiZZEqKuLAyp0fgnNnIRDdiRR3omRX+A9/kKo/loolLzx15p2AX/B73Bhgqeapx3RSnYhqLrmgiUNuPioJpy0rx+xaGSHn1Fh6LpQFUp3IgKHauOV7GKSQhQkkooVQRB2Kc2VM844g7PmP/rRjzhIsmDBAq5IsURuN27c2OeN/+abb+YpQ6eddlqf5/nxj3+Mn/zkJ8N+/sLOh7URZ1ZTkE3ZiwGVF5EQ4h+8AiMSAHQDRiLKtn5KOKcAXDkoFLyg/mXq9bagKUY8gSd/CTC12Nx14NnYEunGJE9twb7lzDJjv75jNDlDWSR/7QChuUIK/rk0WqzKmv69zfkqa6SNSBAEYezQ09ONJ554Aps2beTKgylTpuK4445DTU3N8JxALAKNJgVR9Ug8xpOQDY8f9ulzubKiHLw2J/aoGc/tNJ3BbtT7a9Hg9mef4pdjUo+3thaqEsGyTVHEEgZcDgULpnr6tNeUimPmPFRdfD1Ae7y/tmBghTRXdMPAvnVT0tOCyI5oiYLirxy8cCroGeLgBZ1jtiROMecoCIKwywVXiEsuuYS/skFitZmsX79+mM5K2FWxNmIKCJCzQGuujZhKgo1oiAMrnMbSqYQ3ZJYKVzC4gmCXOSGAWnusaQH0Rb3QBaYFUNVN/97hXCWu9FopsNIVSiKpA71RjcvXrAwPOUOksdJfcyVfZiefRotVWdM/WJJzOlOONqK7DzqnoqJXlRIIFARBEMojEAjgmmt+g0cffQSxWKzPz6655mqceOKJuOKK/4bfX7mJOdnQHS5om1YAio11SKDrUAwDriVfKHt/sHQ9Hty0DOFwiAVUc+l6UEsviecbod4dU3w8ft7z+t+/EvsV76V5NFb6B4lo3+6kCUMpyM4aJBohrHPsn8QZTecoCMLYYVQEVwRhuDdim6JiafcmBKNh+BO9OKBhWtaNmPuB7Q6zJ5prhKlHuKbsbFZOGiaax0kmASV1HLsDqBtXVBUOOT4UKKI1VxUOQQGFzZ1xrG2LcyasVoljN0rcZVQklyI0l0ujhR5vPY6qTig4Qq1AVLGSL0iSr42oXIHe/mQTCBxfXd6UAkEQBKF0uru78ZWvnIdVqz5he86cOTjoIFNr77XXXsMnn6zE/fffj/fffx9//vMdQ1rFQkKvBrWgkgCtpnNLruHywjbIfZ6SHN+YdShWbFmLPSbNhD2HECxPEGqYCI2qV6kdye6EWteMSIJOx8A+k92IJgy4HQrb1BZEiYFyKWUaIP384IYZfRMkE48YVUkJEagVBGE0IcEVYUxikMhc6nslZWfF5YFBowvNO5nlwmQXaJMpFVsyDvusBUisfhdIJLgViGwaxYg8yvxUhbMx1InVgTb+ngJHs6uacpbDehzAtu4kB1aIHt2Hde7DMK6xb1kyOyXFOJb5NFoyHk/P57E7Cjo75bQRlYJVudNfIPD8xdnLsoVdk56Ihg82RdIBtn2meFDjqUyA7bLLLsPDDz+MDRs24N133+VW11KhFlf68HnddddV5JwEYbTx3e/+NwdWaGrk1VdfgwMOOCC9P9D79JtvvsH3WblyJb73ve/i5pv/OGTnovtqTTFb2uDpHCj4EOhEIhqGq8gKj1xVpQ9ufBfru7ZjemQLTp26b9aqUsXthX3qHtADnTB0DYrdzravygubGsbS9WFE4gY8TgX7TfcNqi2IK03ffBJ6TzuL2boW5Z8GSL+L1zrWYU5Vc7otiOz96qcU3M+tCtHa2locddTRqKsbun3WEqgl34cSZRJYEQRhpJDgijDmsHqISVyuN9iLan917h7iQCcUTYNB5cLUE0Tlu6SLQgGEmobKnZTLA/uEGUjS80bCgMfLdqEgjkd1YG2wHetDHUjoGou5qTQ+mjJgWaBM2IRaByIJnQMsTocLPn8zdLXMvuSURose6Nox2pH6xzPOu5S2pVLbiEqFHD1LIJDaouwqBiUQKOx8fLQlgife7+XPTxavrwnhuHnV2HNCYaHGQpAe2He/+10ceuihg34uQdgV+fjjj/Gf/7zKlRy33HIbdttttwEVFQceeBD/7AtfOA0vv/wyVqxYgT322GNIzkcNmS2tRizMk4I4wGJ3IvHaw3B+7htlfVCn13LnujfwVscGrpBdm+hFQIvjqrnHZG8N8vhhqxvHVbIUbCGbCESS2N6TRCxpwGVX2C4XOqfoi/cjsfZ9U1vG6WI9Oe/Jl+R8jVYbNf3cwX5QcXommRWiNR4ViyY1w+kc/PtrMQK1owVpPxaEsYkEV4QxR2YPsV218aaXqz/XcLphUPVIurLFYNsoQi2/VOgINlWFYbdBobWIx5Djsy3Sg454iANEFFjxRBzs+PjUgedIm/zkegd8LhVJ3YAtGYKt80Mko02Au/RRhOxw7bYfwo/dAiPYA8VfA9d+F/bJQBYrHmxRShtRqdDrpyFM2QQCAxU7ijCaK1b6B1YIsun2ibXlZ6ktDjvssKKrUz744AN0dXVh69at/AHzjjvuQEND36At3Yem6NFUr2g0ii9+8Yv4wQ9+kH4OmrJHP1uzZg3Gjx+Pf/zjH6ivN1/HNddcg/vuuw/JZBLNzc344x//iGnTpg36NQrCYLjvvnt5PeaYY9OBlWzaXbvvvjuOPPIoPPXUk/yYH/3ox0NzQjSi2FcLvbOFzsTcjHUNem/HgCrMYgklY3i7YwNi7D+AV7LDyTh8/f2HWAR6OCUun9rvyA4FwljdGketz5aWYiM7HNfhc5VeaUeBGwqsGLEooCeBmJGyIxzQqZSeyYAK0Z5ePLP2fUxvruYqlrGAtB8LwthlxEcxC8JI9edmji/O1Z+rcJmwyo4WZ7RopeqVSmchqL0m3JsKqCi8kl1oBLKmaWiJBtgZVLlnCWzT7dmg86ZNvs5ng8OmoNoRh9G5AhGqlikDHhG5ailsE2bBPmser2RbArn5VPzzQQEV0lipZGDFYigEAoWdA2oFyjWdk27/cHN5I8fLhTLyf/vb3zgrP2XKFFx11VUD7jN9+nQ8++yzWLp0Kd555x088MADeP3119M/f+ONNzgoQ9UAVgCFoOellgrSr6DHfulLX8JFF100rK9PELLx4Ycf8EoTgfJpd9Htxx332dRjPhyy82HNkwkzd+zzNC45HkFyw4rBJVL6by05thpK4lBgx6BqEi3JKwd6UscmP4QSJ+yPDBIjEuKx01rrZl7JrpS/1L9CNE0ywn5GV2/+Y+0q5Go/LjQaWhCEXQOpXBHGJNSWctHsxdiwbSOmTZiac3yxTo4WjWfMJB7hqTaVzEFYzpWSiJuZq0TcdLYcrrzuVGciwj/XU6oxSuqrOxFBdY5M1MRaBy5Y0sCtMN3tSfx1+SBOPKW5wn4WTVnop7ky2lT8yekzBQI9XLljV3cIBAq7Pn0c/iz00M+rh+10cPzxx3O1CfFf//VfOPXUUwfcJxKJcFBk2bJlHGzctGkTf3/QQQfxzz/zmc+kq10OPvhgrnQhHnroIbz11ltYuHAh27kCroIw3FiTgXw+f0HtLr/fnMoXp8DDkJ1QBHqCAhsZfyOGAb1tE/RoGGqBiX3Z8NldWFg/Fe90bEQikYDb5mA7W9uKEo+yoK62bW26vVbxLYBPTWDfaV68uyGcrrQk2+tUy/czokGehsToOtuFAkil6plQhShVa/R/v3WNkU8cA4JLqb1H/AxBGBtI5YowZmGR1UKOAmmJZOshoBHJlTyXeBRq/Xjodgf0ZJJXshVy+PIwxVPLk492NC2B7YmewpMV8iVRKMNCJcQFMy0pzZU+r4XslOZKOVkv6/hUVl3pTI/l9NHhqXKHVrIHIxAo7DzQ7zofNQV+PtRk+7v4/ve/z6KfJI773nvv4fDDD+f2IAu3e4e+EQWJqQWIoL8dqoShQAx9UdDFCrwIwkhiBQOtSUH59pFPPjHvU1c3+Ja9fEGHZPumjPbfFMnEgKBPKX/L5804CIc374Z5/nG8kp3tb1yzO5Fc/xEfjytnkgm2dbsTZx5Uh8W7+7D3ZDevZJc9HjrYBdXtAzw+s9XJ42NbKcKfsfRMijm2VSFrvd9WuW1jqkrU8jO4slczeBU/QxDGDhJcEXYKEok4tmzZgo0bNyAUClVObIz0U/J9gCdx1my1vb4Kj4UkR4eCJN2t0HvbeOV2pAKCthE9AVs/h4XsKPVT5+kFvvXFDtz0bBv+tTTV550B9b5H/n0nwo/9iVeyc0HOEvXGW46x1Suf6URZWa8r9jiS11xitpkCuDeuegnXrniOV7IrRX+nz+qFHitO31iHpgLl+lXT7fQBZjh5/PHHsX37dv7+1ltvxVFHHTXgPqTJMnnyZBb/pDafp59+uqjnPvnkk/GHP/wBnZ2dbFP2nAI0gjDSkNYKce+99/D+m2sfIe6//z5ejz3WtIcCSm7YGiZl+cHg9npr77t46kF59z6jfQuQsAKmqTeoRBRGxt5rtymV0ZapaYStpgm2umZeyUa/wFYlsCpkLz6qCSftN4zlgKMA+vd8wEwvVm+PY9mGCK9ki58hCGODMVKkJ+ysUDCFNARI0M7K1lJpPIncnXXWWTjggEVlbVg8InHTMmzuasXk0AacOmVBVsdHJX0Vrx8GZXZSinJkV1oLhKfXbFoJIxzg0mSDMldkpxzPXAQTMQ6k2DICQGSHEjH4swRmrF7grpCGpGagV3PAVjMjnf3O1fvuOebcnOdBYxzp59wK5HRn164pUsW/HAHcUslsi6JMEj0vtXkJuz40bpmmAvUXtaV/WnQ7/Tw6MN5YEl/72tfw2GOPoaWlBcceeyyqqqqwevXqrPddvHgxC9RS4NgStO0PideeffbZuPPOOzFr1iwcccQRRZ0Haax0dHTg05/+NNtU0XL++edj3333HdwLFIRBcuKJn8Pvfnct1q5di9///v9w6aWXDdhHiOuu+x3WrVsHr9eLE088cehOiKb1VdVxBQmS8fTNSuOknC3DFa2QdZrJFXMbTzX4UrLF7uT9uieic6UlrWTT/lXOfkh+i/f4CxF+9Bae8Kf6a9guxp+hPbI9HkKj01e0/8P7vlNB3OvFrFmz4fGULgy8M0J+zFtrw5g9zpVuPyZ7n0lDOy1JEITRgQRXhFHLzTffhJtuunFAZQlt8k8//W/+OuOMM/H97/9PSQ6Q9QGepgXR+GJac32AZ6G7miZopIVijRquaeozDacSo/aM3g7o3a1QqPfZYTpXZBvUlpRn5DMd067YUporBgvekZ1zrGLcwObOBNa2xcwebrsd4/0L4fBUF+x9zzcxgY9XxkSFAeeXEsDlYJOhw66oRY19LBXL6RPGHntN8mByvZPFbUljhVqBqKKFAiuVCLJZgrLFQBUpNN2nPzQFyIKCIbnEPDPvR1xyySV97Msuu4y/BGE0QQHHK6/8Hn7ykx/jT3/6Iws6UwCRxi+TiOvrr72Gu+++Cy+//BLf/3vfuwo+n6m9MmTQHm93mLortDV4a+CatxhKBfa1QthqG6E2Toa+fUMqiQO2Y556dIc7eD+MxA14nEpau6Pc/UutbYZtt32hkr9R28x2IUg35tqVz/FeTK29l885gqf6FUt1dQ3rQdE6ljRXrPZjQjRXBGHsIMEVYVRCGatbb70lbc+ZMwdz5uyB7dtbeDqGBZUVO51OdtRK+QC/MdSJVYFW9ERCqEn2Yreq5uwf4KkX3OvnMYVGMgnFbmebMmvZRu1RVURZOD1QbHbWWzExoJJAbIG2oGZ3FWb46rEq0AYtNYqZbJq0kw2PA9jWneDAChFLxNHT3Qs7aHqPPd37nhlgydRQGWpIAJdewztdmxDVknDb7CwCOFICuMKuCQVSDt29dJFKQRAqw2mnnc7VqL/+9a/w0ksv8pdVEWEFOcm+6qrv49RTPz+k50L6Ytq2Ndwio3e3mVODtAQcex48LK0cnCSZMgdxagcm3RW7g22fS0UkruPllUHEkpQMUbB4jr9s7Q6rMlUJ90KhPT3cW7AylX4XVmCFoJXsuw86p+gKFmpJ7O7uRn19E1yuXb96I5ugr6W5EhjRMxMEYTgQzRVhVI5ptAIrEydOxBNPPIUHHvgnfvGLX+K2227H448/mS51JyjDtWbNmqKf36M6sCbYjo2hLrTFQ7yS7Vbt2YVma5rSk3CsyhWq5KDASmcwiXBM53Uwo/ZUjw/2mfOhkFZKLMIr2WqOiT/p81MUzKkex0EIh2rjlexcjlIkAUyotfPUAaJWDWK3yNPY1tpZtIbKUMPjJjMUeisxflIQRhtUdXLdddeN9GkIwojx5S+fjYceehhnnfVFrkyhD/L0Rd9Tu9w///kv/tmwQCLukcAOpXddR/zDl4dlfC4Fd/SuFqhNk6GOm8Yr2TSpaM32GJKpgjpayS77nPJVpuaAWoEyp/0RZHf2uy0fnZ0dePTRR3gdC4i2myCMbaRyRRh1XH31r3klAccHH3wIfr8/Pb2GmDJlCn73u+tx8cUX4dVXX0lXsFB7ULGVK72JKEJaHEldYzV3sqlyxae6Bo4u7GljDRS2kwm2Q4YTn2zrwrsbM0YkTvUOqlyXBOa08TNZ30Xx1bBdCJqosybYAbfq4ClBDsXGdjgZhy/LeEU6N2qJoIwYOWq2aAhY33dEYjEaKuWJB8e5MiXf89F9NEPHgrrJ6bYgsivdFiQIgiCMPKQj9D//8wN8+/TPYtuDf4AR7kVdfQOqP/c5OGbOGpZzoMpU27S5SG5ZnWrLITF5F7QNH8OgZEeBJMeghfMzNN5g25Hz7Arp7FM0+mnyjKkNRXZXWEeDv4zcaKoylfRW0m3OJNqfpzKVNFaoFSgzwEJ2fWoCoJAd0XYThLGLVK4Io4r29rb0RAuaDkCBFZpWE3roBvTe9C3+Cj90A5TedlxyyaXpx5HgbbGQkxNIRrlShdpNaCU7q/MTi0APB4FoBIiFeSXbrUfw3sYwukJJhGIar2S7bOVnlJIt67k0We/cxivZ+TJK1mvZHu1FbzLKARVayc7lyFkZlTqfnXuBqz3ZRySSTb3mlQiskHjwDZ+8iF9//DSv+ab/UPCFHDc6LlXi0Eq2tAUJgiDsmtCHzsRTt6PBiKLR44QtEkD4sVuG7cMo7TPuT50MuLym3goLyZvJlMFAe91Nq1/Gnza/xWuuvY+CN46Z8zigwzhdbNfX+7jqgbXfVPMDOtl13vJcd95Xd9sP2ra1SK79gFey8+3z1PpDGiu0DxOW5koxLUHkh4Ri+rBU/4xGTG03VSpWBGGMIZUrwqji/fffT2/EBxxwAH8fffMJJNe8zyWy5PHE17wHxVOFvY89l6tYNm3axP28xUIbXYPTh+16gJ03u2pjO9sGSMfXA52AFjczWobONk3bCcV1rv6wMkpkU0apsar06QI0pSC55j0a6WFOCkgm2dZsjoJ/pBEtjpieNGcMGKZdKKPy1cPq0RnSEetN4m/LMWTQ9btj3et4p3NjWkOFAkDfn3tszqlCp0yen54YRI4c2eKcCIIg7KIEOmEEe/rcxDa1rFTXD8sp2MZPh61pEvTWzbzPKyQMT8GOMvXGMoXzqQqzkHC+e8np7Nfove1QqxvhWvQZFuq/6KhG3PRMO7ce1/vtbJc7rZDOKbFqKWwTZgLxGAdxyLbP2CfvHkvitaSxQq1AVLFSzPEzNen8+iBHsAmCIOxESHBFGFVEIpH09729vVzRobVuRLJto1k9QhMKXV5orRu4qsOaIOBwFF/Z4LO78KmmWXizfT16okHUuP1Y1Dg9a9sJB3qoekSn0AUFV8C2w2ZA08Ej9qzJiWRntteUgtK5zZQZ4XSZGa3hpyWBu8aJOR9HwaFIKrtmuUZk58v49XF6jF4o7CgNTfCC2paswApBK9m52pYIGolNDii1AhUcYSkIgiDs3FTVQ/HX9AmwkI2U9tdwQPpqtuZp0GMxrlhRPF7Yxk2DkoiVNQkvUzi/NxpGdaInt3C+1Y577MB23OZqB/ab5sKWbjsm1drYLhvyp9q3QOOqWDO4QkGlQtMACQqo5BLKz+Y3WT4GEYhSsEoK5QVBGBvIu50wqqip2TGq7/HHH4PucEHraoUSi5lBB92AEY9C625HQrFhw4YN6b7tYiGn5djxe8Kj2qEbBq9kZ62kSERJ/MUMepgPZtumJbgChNujFbNNmuxyM0pomAjVV21mycjJcbpNu25c3od1JiKwqSrrrahQeCW7O7EjSJXX6UEd1N1PQ3NzX30XS+OmIuW8/Z/CKLKc1p5fn0UQRhs0/eTkk0/G7rvvjvnz5+Poo4/G6tWrS36eO+64g59HEMYCtG96j7/QDKikAitkl72flkFiy2rEV7wBo2Ud0LHFFJb3pvbkMiDh/LXBdmwIdaE1FuR1bQ7h/D5k7Lm0//79tU68uiqC5VujvJJd7r7MGnKdLWZghYjH2DZyJDr6npbByZJijm2NIk7jaUBo6udRVYSOnCAIws6OVK4Io4qFC/dHVVUVAoEAVqxYgeeffgqLSOiVhOZiEbMXmrIttU14+MF/pCtdvvrVC4o+BjkH929ayo5OMBlHNKixvV/9lIEf5imjZnfBUELpChWyvfX1OHQOsHR9CMGoDr9bxX7TfdxfWw5U/us75VKEHvw99HAAqreKbbo9H1O9dWh0+dARC3GgiMYYN7h8XP1RlNNDFUIRg0XX/KlDkcYNjWekKQLWtCDKqpUDVQnt3zANb3Vs4HYlj83JtojTCiOJHupFcsNH0IM9UP01sE/bywxmVoD/+q//wnHHHcfvJTfccAMuuOACvPDCCxV5bkHYVSGNkaqLrzdbgfy1wxpYoUrP4P3XAj3t5hhmKNDbNsPgitXyoMqVnngE4WQMCV2DI6mznU0439p3qQXa6GmHUtMI96LjEPE24c21IbT2atB0AzZVQVzTEY7r8LlKbz/m6Yf146HFoqZQr8vDdqHqHNKKeXDTMrTFgmhy+XHqlAU5fYxco4irPUrZI6QFQRB2JqRyRRhVeDwenHLKqWn7u9//Ph5ftR0al5Sajo4OFa9t7cXPf/Urtuvq6nDEEUcWfYxgIoqnti1HazyIoBbjlewQORhZnBHF4eSxjGbljM62mozjiLl+eBwqBzRoJXswlRZqdQOUhglQa1JrdUPBx1Dw5ZLZS+BMZcNoJTtXUMZyetLEuuFreRrh3s504MkKrLAd7DbtMjNlVpWQNyVIS2uuKiFBGA6SG5Yj8tQdSCx/A9qmFbySTbcPFrfbjc9+9rPpf98HHXQQ1q9fn7M65YgjjsDnPvc5zJ07F4cddljW+7a0tPDo+YULF2KvvfbCJZdckm77o+c46qijcNZZZ2GfffbB/vvvj7Vr16Yfe/fdd+PAAw/Efvvtx8//3nvv8e2vv/46P9+CBQuw99574+abbx70axeEwcJC6hWaUFcKek87dKpY4X0udWxqr40GC4rK54L2zK5EBFrKb6GV7Gx7Kd0WefF+JD76DwvN0kq2oevoDJqBFX4O3WC77IpSCqZ4q2GkzolWtUB1jqWb9nzrJ3i7cyOvZOc7h8xRxImkgSr0wrvt6TEzilkQhLGNVK4Io47zzz8fTz75JFpbtyMej+Pn/3wBN7tUHFxv42jgG11d2B4124EoiPDHP97CY5uLJZiIoTseYZE5gio+yKbgir+fk0EfYnhsYUZbENmapuHZj8KIJHSQ7Aqtz34UwPwp5U3YoePQdAQlHIBCVR1hc1oCZfLyZfDIwfmwdxu8qoPFbKkUmWy6PZdgLDk9VmtQldNAMNYNLaWJQtVBVmAlfQyyi+jJznV+r3Wsw5zqcenRymRnrRIShGGoWIm98zQLVvbB0Pl2V8OEih7v+uuvx0knnZTz56+++iqWLVuGPffcE1dffTVXvfz73//uc5/a2lo88sgj5uQ0TePnu++++3DmmWfyz9966y1+jhkzZuB73/sefv3rX+OPf/wjP/ff//53vPTSS3C5XHj55ZfxxS9+ER999BF++ctf4jvf+Q4HZYiurq6Kvm5BKJVKVkyWDo8IMpMoVt8qidpS0qLMtiBCN3SuWuH9WDfYzga14CbXvt+nXYdsNR5lEdvW3mS6coXsweydpXbplqObln5u1o+jNYlgTxeSLNgvCIKwayPBFSEv5HQ/+ugjWLt2DTRNx8SJE3HCCSdi8uTJQ3bMxsYm3Hrrbfiv/7qAs7ZER0zHo9v6OiZejwd/uuVWzvqWCmVsMp2KvlYG8QigJVKlwilPREsgFAxj2cYI4knqF1d4Jbvcct1ypyVQFc7z2z9B3NA4CEMr2dkCRRakDXPBkgZuBepuT+KvmQl7Gr/sr+0TYCG7XAeTSqNp6g+PgFTM60J2LlE/QRhKqBVoQGDFwtCRXP8x0DC1Isf6xS9+wXorzz77bM77HHLIIRxYISiw8oMf/IADKP0Dr1deeSVeeeUV/rDS2trK1SZWcOXggw/mwIr1/e9//3v+/l//+hdXqlDlikVnZye3UlIlzM9+9jOsWrWKq2cOPfTQirxmQSiHXBWTnmPOHZYgvFJdz5N6qFUm41bo4cFNuSk1kME/pwCPSgpqgM+lYtFML97dEOGRxmTvO81TdvsxJ0/CvWYoiVqcaaXXWCh5YqQmJ1KlC0dLCryOlLZbT0SHw6YgGNZTE67H1khmer3Uik0Vw5JMEoSxgwRXhKyEQiFcffWv8cgjD3P1SCY33ngDDjtsCX8QmDAh9ySbwTBz5kw88MCDuPfee3HPbTejNbTjHKrtCk7ZayIuvO4vqG3KL/iaDZ/dye0zupbgoIoChe2s04Ic7lQ2KwOy7ZSxibCPQX3ZCpWvVGBagk7OZcq5UimoUWBaQlhL8BjmcMZroU2cghd+uPMLxjoV9GQZCUkZw/4ZxHIdA6/NyeOUKaBiQTZNARKE4YY0VvJhhHuAwt14Bbnmmmvw4IMP4plnnoHX6x3Uc1177bUcUHnjjTe47ejyyy9n4VwLus2CKvms7DA59ueeey4HefrzrW99iytg6Py+//3vc7DmpptuGtR5CkLZpCom+bM3VUjY7GZiocyKyVJREzEoE2fB6G7bEQKx2aCvfQ96NAybx5xKWCokMO9UbdB0PS08nw3F7YVt4iwkPvwPC/ZTa5R970Ogur04ci8FK7ZGEY2DNUuO3Kuq7P04LWibiJvTexLxtKCtkkc3jSpPKWkT1ZMsyLtg3O55kyOWthv9PpOaAZtZwILYGCpcyZzKSO1RVDE8vrqMxJsgCDsdElwRBhAMBnH++V/Bxx9/xLapB7CExx2/8847+M9/XsWLL76A5cs/xh133IWpUyuT6e1PTU0tLjznbJymrMe6N19GOBqD165gcn0VfAd/Fr7G8pTnqcJjmq8OG4OdptCcasNUX13W9hueFpQl/eRTE9htnAsvrwwimjDgdihYPMdfdkaJju1efCqCD/wfjEgQiscP73HnFxT1a3T64LbZEUruCD6RXe8s/wMdj4Q8ZuBIyHKgx54yeT7+ufk9DrBQYIVsyeIIIwGJ1/atC+mL4t0xrWwwwRBqx6HABbX05OO1115j4e499tgDt956K1eU9NdLourB8ePHcxCFKvnuv/9+fP7zny94HqTl8qUvfQlf//rX+T2aKmCWLl3KuiwrV67EnDlzcOGFF2LKlCkcYBGEEYMCKKoNiTXvATEKqLjhnDV/UC05pQYdDAo6ZG72mgY9ETf3wTKCK7THjXNXcZAznkzAaXewnXPvowl9GVoobBsG3lobxuxxTgRjBvwuhe1y24/Tgrb0mlKjmIsRtK1yuDHRU8OVqJQwITsflLihFqZ3N4QRSxioVeLYjX7NY+QTR/+pjLSSff7iupE+NUEQhoEx8lYnlMKPf/wjDqyQUOxvf3stDjhgUZ+NnAQTv/3tb2LNmjW49NKL8eCDDxWcajMYp0cNdGBalROwUwDBABJR2GaW/wGdJ9jUT0NPLIJwIgavw7SzZWI0uxOG1RJkoWvQuPIimXbFBlvsyg7Yx6/DSCa4PYFWsp3zD8/7OqNGEvvVTcHbHRsR0ROsuUJ2zNDgha2oANbixYfxmgkfs0IZQ5oqcPFuh3E1DVWsSGBFGCloKlBixVvZW4MUFfbpc4FAsOzn37x5M6644gquvKNACUF6J1R1kqstiFp+qH2ooaEBd91114D7fPOb38Rpp53GYrbUlkkCtsWwePFi1nE55ZRTuJqFKhCPP/54Dq7QFKPnnnsOTqeT37t/+9vflv2aBaES6JEgjK7WdOUG2cN27GgIRvvWfrcaZktwgerRfH7Gp5pm4c32deiJhFDj8WFR44zsFbLRMLRta6H6agEvlXkobIcCYXyyLYZlG8OIJQ247AoWTPVySy8FMErG5YGtcRIUlw/QqafZDrUqf9svBVQ0Q8eCuslp3TSyC7X2ZrYAxVU/Ys0HDfAzdlWyTWUkm35vgiDs+khwRRjw4eDf/36Kv7/pppuxzz7zdmyU1I/s8vAHh1tv/TNOPvlzHGB5+eWXcPjh5geJihOLQKPjsmJ/amNKJhF99m9wLTi87HGNfocLE7016I6EUOvxsZ0Npasl1WyzY1MkO9K2Hau2u1DntXHpK8ULVm2Pla25okdCiL33IhDqMScWxMJse0+5LG9JMmWRJnprMTHcg0Ayiiq7m+1i224oGz5t2rQ+rQVDAbchicaKMMLQuGXXwqMHitoqKt/OkzMGEVwhLapSdAWqq6vx0EMPDbj9vPPO4y+Cqk7efPPNrI/PvB9xwgkn8JcF6bJY2iyZWLosgjAaYEHXjStgpERTaWWbxgW7B9dWVwx6TyeQUf2ZJhww24J8VWVPyvuweyt6lBC8dlfBSXn8s4yfu+0GPtoS4cAKQSvZLuqzKYNy2n4zW3st3bRCrb0UXKABR/tMdiOpU3uUG5HwFBi2/AK4uwrZRlGTTW1dgRE9M0EQhgMZxSz04f777+MPB4cc8ql0YIVU/CP/vhPhx/7EK9lNTU3pkcmkizKU8MZvTbOhzl1Vhd6+BQZN8SkDysT0xCMcMqEeaFrJpkzMgPvWz4DRz/EgO1k7xfwe5ET0l8ctHXLgQMJy1gczWsO95u1FTD/aFu1FezzMK9mFoN8xCeRRC9jHH3/MGjuCMBawT9sTnmPPg2PPA2GfuievZNPtgiAMP7Qf0X5OQRX+nlayh0kA1XBQ4D/7sbSObeU9p2HgqZbliGhxFoGllexsr4kCSPaZ87hNh3G62O5OuuG0my02BK1kd0eMQbf9ek/4Gq+FJjJZrb0UUCGKae21ggssZG9ToGhR+COfQM/QXtuVyRxFTViaK1K1KwhjA6lcEfqwcuUKXo855piCKv7HHnss7rjjdqxYkTluprKQ02FwtiSjAUfXodDo5TL7sal1Zkukh8XZKFZDK9kk1NYfL6KI9nOG6JpUOxOYUGPHSytjSCQNOOwKDpvjKltzhTddEvHTUq1PdGK2wiMXaUziyt7trLFiKfmTnW9MYqbQml/vRHD5O5g7d29UVZWenROEnbWCxTn34BE9h/5VJ4IwVuF9jvar3va0oDt8w/lhNM9xCowbzrc3v92xATEtCVVReSU7295Mr9Oz5HREPX4YvR1QqhvgXnQcvFU2NFc74LBT0Mksaqnz2lHnHVxetNS231Jbe63gAvkZbb1J1NmiCLa+h1BoAVfrjQUypzJSxQpdE9K9EgRh10eCK0If4nGzeiM94SKl4p8J2/Fo+j79pwlVEtIKMLZ80vdG0iSZNJuV9MuBtEnqHB6sCbSZmitGErP8jRxk8ap9W1eUzhZW+aeJQNY0HrLR3YpNnXboVPtK1Ss6sKkzwYGXchxCtaYBanUj9LbN6eAK2WqeMcw7TtJ8hPWVz0/sL7QWiGpjckSiIAiCMDpgQdlYuE/lJtk0xWY4ULkliHfCvj+wO2GvGcT4sP57cZ69mSpIvMeeN0BI/qKjGnHTM+3pqTNkl9sOPVhKrdBlv4L9k7HpX1hTGQVBGFtIcEXoQ2NjI6/UKvLZzx7P2Q3qy9WpBSc1IlGtquPN/6OPPu7zmCFh43LWWBlA25ayAxlUudKViHB5qw82OJ0utrNVrtB4RsXpgpLZnuN0odc3GS09m+FyUDZC4URbS08SnSENjVWlOz5cCk3tPCQMTAEbVWG7UNCDRPN2r2rGC62rENWSPCloft1uOfVNZESiIAiCMKoIdJoCq6TjQQLyKu2DSXMc82CCG0WiNk0CapqAnoxRzOQgzz247DHMtDcvrJ+Kdzo2IpFIwG1zsJ1PeyxbRQkJ2N587iRs7dYwsdY2ZMMD8rEl3I0HNy1DWyyIJpcfp05ZwNUshZI4PRGd24KCYV2SOIIgjBlEc0Xow3HHHcfrP//5IKLRqNkzu9t+rFyfXPsBr2QT9957D68chBkqpu5plgj3g6pnytVcocqVSZ4auBQbxzFoJZvbhPpBjoxt8u592pLIdrnNqpXeqI5ATOeVbBrJXBYdW83glacKIPE8Wsnu2l7wodUODya4azDeXcUr2YVGJH6wOYJlGyNY02pWHY2VEYmCIAjCKMNJexZpqyXM4ArrnynDNoqZ9nn/Gd8BPH4Wt6YpOkrzNNjHTyv7Ocl3Om/GQTi8aTbm+pt5JbvUhBC18f755S7c/Wonr2QPJxQQuWPd63i+9RO83bmRV7LzBUqyTcshJIkjCMJYQIIrQh8OO2wJj/vs6enBD3/4A275SaxaCtuEWbDPmsdr/JN38Mc//gHvvbcMdrsdn//854fsfOj5MW7mwB/EY2WXDJP6vaooaIn1oi0Z4pXsbOr3NMWHxHNhd5lZNbuLbbcegU01q5itL7Kpt7YsGiZC8fjY8VJIZJdWypjVjcv7MGtM4r51k7GoYTqv1pjEXGQ6RZrigOadwONiBUEQBGHYcXnM9AX116a+2B6m4AqTjAGJuDlFjAI8tFeSyDxPKhwEigI7BYrKqLKlvfqe17vw0sogJ0NoJXs4K0BIO+adzo2IJhPQDZ1Xskk7ppCgbRqbE/BPRLVP/AxBEHZ9JLgiDMjg/OQn/8vrE088ji9/6Sw8/upbCEZjiGoGXl+9Cd/+4z244QZzlOcVV/w3Ghubhux8KLiBcF/NFyZP8KAQ5Jh81L0N3Ykot9LQSnY2h4VGQbKDRUKzVEmixdnu6Q7D47TBbSc1fBqZqLBdroo/XW/fKZeaARXyxzw+tguVAFtjErnCSDXV+fONScwckbhgmge7T21EtOlQuHy5S3wFQRAEYUjbgtITAVOQ3U/vbajQNA3Bf95gBlgYA0brBiQ3rSo7iUP+xD83v8cjjBPQeSW7lMBIOKbj3Q1hxBKpUcwJg+1wfHiFUUmMtzUWREs0wCvZJU3Lqa3D0Ud+GnV1RWjICYIg7ORIM4AwgEMOOQTXXXc9vvvd/8bHy5fjJ8uXZ908L7/8Cpx99tlDezLxCJBttLCWNMcUe/0lPyX1DdPIYtJY0aCyQC3ZHbEQmqgdJwN2rDQtQ2iPPTFUVbthGEG4nCpcqeE+5DTVesoXL3Mt+DRsey8GWjcAVJJMVTsFsMYkUj/01kgPJnpq8o5JtDJKVLJLQSFD11HliMGpioq9MHbojkewrGszf+ChYOSCusmo5daEwUOT1lpaWlh0kiZw/d///R/23XdfDAWtra3YZ599cPDBB+Ohhx4q+fH0PtHV1YXaWgmuCiOH4XADyYRZNcI3kChYYtgEbQ2qTu3pGHC71raJEywoQ3eFqkpX9LTgLZoQRML5vS4c0DCNq0rz6a70OS9rNcykiDmReXgFUimB0z9ZQ3auBE62aTl2JLFlSw8HsUZKjFcQBGG4kHc5ISuf/vQReOKJJ3HppZdhfHNz+vZqjxtfPv3zePjhR/GVr5w/9CdSVc+K/dlQ8pSl5sNrc8Ce2uAtN4XsbM6CQoGd/s6AqiIWjWOvyR6uWCFoJTumle/4aJ0tiD/7F8Ree4RXsouhJdKL19rX4d2uTbySXWxGqQo90Fc/jI6O9rLPWxB2Jt7v3oIbPnkRL7etxoc9W3klm26vBPfddx/ef/99LFu2DJdffvmgxy3TxLRcfO1rX8MJJ5wwqOcXhBFHyVKNOojq1FLRfTWAMVAjBNGQmcQpA7di5/aZrkQYET3JK9mk8ZYLCqKEYnq6usXnUjG72YmusIbW3iSvZHudw+e6k0bdTH8jpnrrWNeNVrKzadRlg15Ke3sb/vGP+3kVBEHY1ZHgipATavf52te+jqeffR5vvfUOXn/pJbzyxtv43o9/hhkzZgzLOaiJGByzFwz8AU0xqh9f1nP6HW4c3rwbXKqN9UloJduXLUvmdEPnChekv8j2+jyYUOvAuGo7Gvw2XskuV3OFnKnYW09CD3TDSCZ5JbtQCbGu67h25XOcgad70ko23V4oo3TxUU04ab/qss5XEHbWipWHN38wYDQo2XQ7/XywZFaBkHZVriqyYDCI888/H3vvvTd//fSnP03/7PDDD8dll13GFSlUCZON2267jd+HFy9enPd86Pg/+MEPuHpm9913x1//+tes9/vOd76DAw44AAsWLODjr169ps9z/OIXv8CiRYv4mLfffnv6Z6tWrcLxxx/Pj503bx5uuOEGvj0SieCMM87A3LlzMX/+/JyvQxC0cMisXMkkmYBGbcHDgI0SNf2m9Jg/sJc1kZBoj4fSAQjr3Ybsznj2YA0J1d76YgdueraNV0u4lvXXUvehtdzzGUzlylRfPVf3ka4brWQXqlzJfD3/Wpo74SMIgrCrIW1BQkFoM3e73YBCc3uHd2Mnh8dW04SE2w9Eg+Ztqh323faDjTJbRbTOZHs9+1RPxCObP0CEeodTdjanhW4LqT74EIbCH8FMu15REIgksb03iVjSzDaRXTaxCLT2LdC2recyZIVe94TpppheNqcvw4HbHu3lD4VJQ4ddUZEwNHbgGuma5bkG1CLUM9y/T0EYQagVqH9gxYJuf697M/ZAeaNXMznnnHPw/PPP8/ePP/541vv87Gc/QywW4yoXCkQceuih2GOPPTggQXzyySd46aWX4HAM/BCzbt06/OEPf+Cf33vvvQXPh/7e3333Xaxduxb7778/PvWpT2H69Ol97nPllVfimmuu4e//9re/4Uc/+jGeffa59M9J9PrNN9/EihUrOJBCLaH0vGeddRb+8pe/8LmHw2EcdNBBOPDAA7F582Z0d3fj448/5sd3dnaWdA2FsYMRzP5vwwj1AA35Rd0rQlU9FG8NjCgFV3e8PygTZkGtri+7QtZGk4f46Uj1XmE7W1DCGl1sTdihleyzDqzFqu0x1PrsfB/6eyObNFd8ruEZyWy1Hlv6MdRGma/1ONvrCUQ1GcUsCMKYQYIrQkGoPYWrKILdUPy1cB3wGdjKrBop6/jUDx3LyPZUN8Ixa17ZkwSo7/eG1S9yEIL8A1rJPnPawgECskHDCUeCqkLU1Icyhe2uqA2rW+Oo8ao83IA6h8gu1+kxnG5o2zcg2b7Z1Hih81AV7jnPF/5ocHhZXI4CKwStZNflGccsCGMV+nCQD65ccQw+uHLXXXfxeuedd3LQIluA5ZlnnsFvf/tb1iDw+XwckHn66afTwZUvf/nLWQMr9AGFKl6oQsTjKe7v/IILLuB15syZOOywwzgo0z+4Qsf+/e9/j0AgwJVv7e19WwW/9KUv8UpBFNKDIl2Z3t5efPTRRzjzzDPT96PHU0CFKmqWL1+Oiy66CEuWLMFnP/vZos5VGHvo3prst9No5EFCfy8k5E7JhFwBAaqQtU+ajURvB2C1G6s2eA76bNkaIT67CxPc1QgmotBYL0VhO5veSrbRxWSTXslIVaxkMslbi4t3O4z1Yig4VOhcZBSzIAhjGQmuCEW1q1Bghe2g2a7iOebcYdnstXAQiZVv7xC6I7pboDvcZR9/Y7gLHbGw2TpjmK01ZG8Jd2NqVUOf+/qCLQiano3ZPMyjkgFnuA3xpIG23iQ03YBNVTC+dhBddrEI9HAQSjQCQ9egqDa2uXLF7c35sKiRxPzaSXibRiXqSRbpJTtmaPBieDJbgrCzQFnXfLCobQWTq+eeey6+/vWvo6OjAw0Nfd9b+tP//czvz/7BkgIaVO1iBWGovYgqRo488kg8++yzRZ1X/2Nt3LgRl1xyCd566y3MmjWL9WIoIJIJVy+moCA0acHQ/lBfX8/3zwYFWZ577jkOJH33u9/l+9XV1RV1jsLYwZZDJ8wWHVxbELWmWBUUpDNGemPUFpstuaGHA+kRzCYKYkufgXvJ6WUFWEirZKqvDm2xAAKJGKocLrZpn/aqzpxC8xZkU8vxgqkeLF0fQjhmwOtSsGCqd1g1V/pUuxYpxJvt9RAu+cQhCMIYQDRXhPzQKOJ+4xDZpg/9w4BBIxoTA48Ve+oOrkAphwanFyoUJGEgCZ1XsrN+8GqYCLtdRRIqkgpp3qtse5rHI6EZ6Ino6I2YK9mD0Vzhtieni1uCaCW7UBkt9UPvUTMex02Yi6PHzeGV7EL90BZNTc34whfO4FUQdnVIL2CHgkFf6Pb5tZMH9fzUBrN169a0TRN8KKhCAYj+HHXUUaybwiKWoRDuvvvuonRJampqOFizfv16/qJWHnpcvsCKpZFC93/55ZcH6LSQNgxVyUyYMIHP58Ybbyzq9c6ZMwfV1dV9NFhWr17NLUDUFkQfyD73uc/xOdLzbtq0qajnFcYWRl32Slijpqn858zRapN1TyU/h4RrM7XKDI2rSY1AV1nH96gObI8GENd1qAZ4JZsSIAVHF6cCQRTUmT/Vg46gKWhLK9kjWcVSDP1fT019Ez792S+guXkYWrwEQRBGGIkjC/kh4Vh/LbTeLvPDv9sPW3Vd2S05JVNV1y+blCLYDb1jG2zNk8sStJ3mq8OqQBu0VGCF7GyCtlQuvLl6DzTGPoLdSCCpONBSvQfcoSg6AhSWMaGVbGoL8rtLj1myaJ2/DkZPW7otiOxCThT9/OCGGWlRWwoQXT5pn6KdL3LenE6njEcUxgRUmfK5yfsMELWlwArdTj/fjvI+TFlBitNPP501VOhvqqmpCY8++mjWv8cf/vCHLFpLo5QJetwXvvAFDAUUiCZBWwri0Gjo/i1BdA7U2rPXXntxMOikk04q6nmpPYhe37e+9S387ne/4+M0NjayZssHH3yAq666ij/MUpULabSQ4K0g9EcNZa9cUSMBoLq8MeFWawr/+9NpIuCOVhuqrBgAVWVwhWrKpnUQ46BpFDO10VA7EP3900o2fflUV97RxZSkocdQVS2JwnaGdGiagUTKPmJP/6jfs+n1fPWwej73Wg/Q1pYY9ecsCIJQCSS4IhT+0O+tRuzpu4FYjFQN4Tvp4uHLnOQq3DB0aDY7iqvPGFiuu1tVM+srBBMx+B0utrOV64bhwgfqbLirG+FEFHG4EVVr0RC3I5IgAVkFhs3siSY7wsGV0s9JcXvhnLM/EmvegxGPQnG64Zg136xiyQM5jq91rMPu/qZ0WxDZ+9VPKep31NXViWeffQbHHXcCGhoaSz9xQdjJmFc7CVO99Sxu250Io9bh5YoWCqzkm7JVDNOmTWPR12Kgtp8///nPWX/2wgsvFH1MGvVcaNzzFVdcwQK6/cnM4l9//fX8RdB1uOCCr2S9H5Gpx0JtRI888siA5540aRKOO+64ol+HMHbR7Nl3ctrjy4UCKKoCLNsURSxhwOWglhpP1upS2n8ds/ZGbNtqIBE3W4BtNqj1EwYVEHDZ7Ghy+RFXYnA6XWznwxKat2gPJLG2Nc6tx+Rk0Ep2RzCJpuriWnRGisyWLL8SgGv7KzjpRPEzBEHY9ZHgipAXykSGH78NoJGI5HBEkmw7DzlpgPjrUJCvJFftP7qxhHLdrkQE9S4f/IqdnR6ys5XrUibrnbpDMV97BX6tF0FbNd6rOxTHuWzwOFR0JygzZia8/G4bPGX2QvNEpiWnQ/FUQe9th1rdCNeizxQWjtPi2BjqxOpgG6JaEm6bHbO1Js6OFdMfHY/HsW3bNl4FYSxAgQEKXnR2dnCFSYffj/CEifj0pz/NE3EEQRhelFB39ttJBwUTyn/efvtnrv2Ubvcc8UUkN66Atp1a1wyodePg3OOAggmOfIK2C+un4u2ODYghxnsz2fn25f7iu2ZIMxXYNPX082ScRg8DpgWFogi2bePpaIIgCLs6ElwR8qK3bTZ1TzIgu5iWnGJU+guRzBbwsJ7fW13Wc1LlyiRPDcLJGOJKnJ0esrNVrvhcKqbPnooX7SdDi0Vgc3mwYLoXjVV2VHtUdIZSwRUaYuRRByU0RxOYPMeea+rZOIsT7KVA0ZZID6LJBHQYvJKdNVAkCGMUei96992luOeee/Dvfz/FbSr9Ie2Qk046GUcccTjGjZuIXQUZfyqMevw5RI595e3xBPkeVOmxz2QPkroBu6qwnastyN4wAVXn/S9irz0CPdQLtaYB7kXHle270OM+M34uPurail4ovFeTnev5sonvjq+2Y3KdA2vb4umphNManGjwj+79XaYFCYIwlhnd79DCyMPTM2ikTmqjJD9dtQEF+pCLVekvhC3QlvNnSrgXqMo+wrGQCGyt05vqxTZ7ssnOJgJLjtCRe1VhxdYoOmIuNDhVtsl56I3oaWlMWskuV3Ml83ikc1NKoIjGLq8JtKXbgmb6G7MGigRhLEKjgb/znSvw6quvpG/be+99sNtuu8HjcSMYDGHp0ndYgPXuu+/ir3POORff+c5/i0aAIAwDBrW9lHB7qRNrHDZzpyY7n+g8BVhsx19YUoKjYMtuVTMaFRfq/TU5W3Zzie+SZsnkeie3AnGM1ADbo13QVqYFCYIwlpG3OiEvhr92oKAsBSR8uYMauRwFEmsr1SlQp+2VCl1kcbLKFJojWiI9WNnbiriWRGsijKm+gdM8rNfy3MdBhOMkfUsZGY3tCQfVcCCFTo1fkUI/K19zpVzSLU5OL1eukDhvzhYnQRhjdHV14fzzv4JVqz7hlp/jjz8BZ5xhCrf2b3+k4Ms99/wdL730Eu66605s374dV1/9m2FpfxSEMU339uy3k8B704RBTax59N1ubOtOYkKtne1iROJLSXAUbNkNtCEQDaNKC2G2nr1lN1ulB9mkufLexggsJShayQ7FNPjdo3ePt6695QdWuW0I5mnLEgRB2JUYve/OwqjA2LYm++3bNwBTdsv6s1yOQk6V/nzHt9I1A1DK7oUOJqL4T9s6aIYZHKGV7BCJ2/abghSO6XhjTRCtvRqXFHdHFCTXBPGlA6vNKQCpmSP0qsh2lzmKuVysFqeIFk9rruRqccpGVVU1DjhgEa+CsCsRjUZxySUXc2CFJtjcfPMfsOeec7PelwIohx22BIceuhj33PNX/OY31+Cpp55EXV0dfvCDHw77uQvCWIKEY7PeXje40b2tvQm8tS6MrpCGzV02LJrlK6uCthzSLbuaqQ1Ha66W3WyVHmSTsHRPxLxNSRXRkR0e5cGV/tOPtJgX7/jFzxAEYWwgNc9CXgxH9jIMI48om+UoUGAkoRlm202Wcly6PRTT82sCrFmW+2dUulsGoWQcgWQUcT2JpKHzSnY4OVDUVTcMdAY1JDWDe55pJZsUbOt9NlDVsvVF9nC3EVCLE1XdLKidjP3rp/JKdrYWp6yP93oxZ84cXgVhV4Lae957bxlrqdx22+05Ayv9IWHbX/3qas6yUiVLsdN/BEEoD9I3GeiOqlCrs1eUFgMFJm56ph09YZ0TH7SSPdiJYKUmPlypvZhWK/GRq9KjxqOyz0QrV9moqtnSZPCARF7J3lkqQMzpRyp8Pp/4GYIgjBkkuCLkRXNX5bjdn3dDPWCmF6u3x7F0XZhXsjMdAtJkueWFdlz/71Zeyc7KrAU5DlL+P11vytmhNhrri8gWkDCrUVQEohp6oxqvZHucCrcIUVCFHk0r2cOdTKJresrk+Tz5yKHaeCW7WOeLpqWsXbuWV0HYVaA2n3vvvYe//+53r+RxwaVw9NFH47TTTuPv77337yUff/r06fxhYsGCBZg7dy5uvPFGVIqHHnoIr7/+OoaCr371q3y+p556KtsXXHAB26eccgoefvhhfPvb3877+K1bt2Lx4sWDPo+f/OQnXHkkjA2Uzm08+rgPNhuU7tayn7MjqHMlCO/PullhSnZXWB/mxMckzKsaz2sxiQ8Krlg0VdkxodbB5259kT3aBW37I36GIAhjiZ3rHVoYdvT1H2S/fcNHQN1heXVKSH+E+mVoJXv+FI85XtAw8PfXOvHuhjAicYMDFYGojss/0zwgKGC324GqRiDQPtDxKrMtiMce2xzc+2zNNyQ7W0DC7QBiCZ0nDdB5033IDkU1bn9KJZW4LYhsmh7UVD28Gg2TvLW4eLfD+PWQ41ZKVqu3twf/+c+rmDlzNmeXBGFX4KWXXkRLSwtqa2tx3HGfLes5zjzzi7j//vvx7LPPorW1Fc3NzSU9/t577+XgyoYNGzBv3jwOOtBaCJpkxO97eYIr9LwHHXQQKglpzNA0pd7eXn4P+fDD9/g1kG3pznzuc5/L+xwTJ07Eyy+/POhz+elPf4pvfetbcLuHUcBKGDF00nAz+mm7GRp0T/bkTjE0+CkJomJjR5wrTu02BVMbnKjzqsOa+Hhw0zKEw6G8iQ/LJ1q2MYJYwsDq7aZP9K1jGmFXwX4GXR1ayd7ZED9DEISxxE74Ni0MJ5ojewBDc+Qu7ySdEgqcRBPU8gNeyWYBWGrLiel4c20IW7qSaO1N8kq29fNMjN6OlIxbPwbZfuNQbKxP4kytZGejM2TA67LxBCBy1GgluzdKgRbAToOTVHMdyUpdLr+1j/4pAoIwHFBQhDj11M+zkG05UOXJfvvtx8GOhx76Z9nnMm3aNH6uJ598EgcccAAHRmh97bXX+lS6XHnllVi0aBHOPfdcJBIJfO9732Ob7v+FL3yBxXkff/xxriD5zW9+w7ffeuut/HiySaR3n332wZe+9CX09PTkPJ+7774bBx54IL+2ww47DO+99x66u7u5HYqqRRYuXIhf//rXOO20M9L2r371K9xxxx04+eST089z++238znMnz8f+++/P9avX89fFNCyeOutt3DEEUfwz/fdd9/078W6349//GN+/tmzZ/NrI77+9a////bOAzyKquvjZ9MTkpCE3gXkVRCkEzoISBIRQZAq0gQERJoi0pEuHQRB+CgiUqVXBaVIhwBSBUF6bwmkt/me/9nMsrvZ3WxI3c35Pc9k9s7cnXLn7tyT0y4BKKNwfCi2BPvGITYmqTeqxoEcTITqWgvGwnzejmzcgcyBNcoZOUbC8NH79Tr0WeGqvEbZFLg+VbECsEb51tNYehwWz4ohZ0fIGRouw4gjCIIgZE3Ec0WwiIObaSWKgwWLIsSDmLgEznQfG48YYaK8OfW6mqLQo+faEBsoXyDr8HxApnKvuLiTxtEpaUpbZzfSxEYTkfnwJItCl7sXJUQkUAzFkYujE5dNCV2wfiH+OSRCvQJtPHTJvC5UxM+Frj6M5lws0PWgbGvuuoJgj/z3nzYRd/3676TqOPj+yZMn6epV04m9reHs2bP0zz//sPLi66+/5m0I6+ncuTNvV3ny5AkdPXqU30MTJkxgC6+a72Xs2LE0fPhwDi+C9wiUDvDsADt27KDFixezsgYKix49erBiZt68eUmu5eDBg7RypXZGJCid4GXSvn17On/+PCs3cNzTp09zXoqGDetT48ZBXAZQrqjs3buXxowZQ4cOHaICBQpQREQEb9dXhEBhg2vBcVHn8ePHrNCpWbMm74cCCJ488FKB4qlfv3703nvv0fz58+nHH3/ka9NX1Aj2SwJyuBnnQklI0G5PBsgN8BpFrjf9MRwKC4Qkx8VrjTzwXkEZRpwcrhnnXYprSs6jVN2j5qnTTh2tIXcnyFJq0nykz9eWZUpjQRCErIu8ou2MsLAwWrJkMd28eZOcnBypcuWqHD//qolWFTNJY5UYKDZMAyEnLp7oWUS8TvHg5+mUJKEtHycx1MYcDu45yKlsLYo9spUoDmE8GiJnZ3IqUJw0Xr6vdE85nFypnE9BehwdxlMxOzs6ctl4ekSAa8vv40yX70dTTLxCLgnaMtrz9XyudOdZLCuSXJy0ZfEcEYTMB6EsIGdO81PGW0POnD4Gx0sJbdq0IXd3d07iCOUHPE/q1avHShSE/Vy6dIlzEKAOgLJFfX8g9AfKh3Xr1nE5JiaGvVtMsXv3bj6Xqojo1asXtWrVymTdTZs2sacKPFdUnj59muJcCNu2baNPPvmElSbAVKJKKF6QZyEoKMhgO+67RIkSHPKj5napUaNGqhRYgo0THpKYsVUPlMNDiTzNzzCDXG2Y7vfR8zjK462dalmdDUhJSKB7IbGkkIYcEsN3UdYmtM1a06t7uDqQr4cj/XU7kuLjteln6vzPkzzcnDjvyq2nMZzXDfeB+8voxPmCIAiC9YhyxU6AxXDAgP505szfBh4gW7ZsoQkTxtH77zel0aO/TfmgbE6Jwl4j5sOC4LWiXgbWKMNihLAauKq4Omso+oWSKDAo5OplOgM+tnkGdaUwhSj2/EFkqiSnfEUpx4d9UiVgwAoEaYvPyGuN2XuBAFfYz1lnUUL5yYs4Xhfxc6b4BCJHB62gl9FWsdTi7OzM09RiLQj2gtqfEV6TGtTvu7gkb0E3l3NFVY74+fnRnj17OCQIyhoofqKjo3XKFU/Pl154eId///331Lhx4xSfV/892rdvX/ZSUcOBcFyEHcEzJr3BuRCqBCWLMQgLgueMeq3I6YIkxEL2RDv7IPuv6m3VWJyVEP1r1ZFn2txt0Qnk7orE8wk0ICAP96vIWIzLGoqLSdApJtydHSg6jujVM7mkD1D4nLsdqXPewRplNyeFZyF8Eemg8wJG2ZShKisjcoYgCNkJUX/bAdeuXaOgoACedhQCB5QOuXPnIV9fX51gv379Ovrww2YpnobQ0cu05dfR07y7NtxxjfOnoMwJbpEk1klhZQsEHoA1yq6OpqdkdvTLT94fDyHfkWvId9gv5D1gPjmXSD4xpNnri4umSy8ecIK5vK6evEbZ1FTMuhCnxDhnrFFWrxRCHOKgbdVjxc8vFwUGBvFaEOwF1WPlzp3bqTrO3bt3DI73qiB3Cd7DRYsW5TIUJ5ZAbpMZM2bowm2wRugOwNTS+jlVGjVqRGvWrNF51yCkRlXKzJ49m8N6sCAfC0KKli9fzp6NAOPBiRMnUnw/TZs25ePcu3dPd33qtaog/AdjEzxrVHAdaIfk8PLyspg3Rshc8Ew7duxATZs2oRYtmtOoUSPp2bOnr3w8BwcTScs0GosGFBg+jl4Np9tPY+nB8zheo6zKHgjp1WgUNn5AxsAa5YxKaJsSbj+Lo9BIbfgSzwqkEJevPY6jvN5OLGOgKbBGOSrpbM5ZGpEzBEHITmS9UUZIEUi22LZta7aA4h/8zp270LFjJ2jv3n30118HaceO33Qu4HC77tmzR4qO75gzt+nt3r4Ww4JgJdIHZbdEawsS2EYlJm5TQfluiHmJAffm6J6DHHPmShuX2ESvFQfVZ0Uxfy9uRun5Uc7l6UgVirqzBw7AGmUPF/lJCUJmU6tWbV5v2PDqiWhjY2No8+ZN/FnNE/KqQCEybtw4TlCLBK7JecIguS08XPDuRl4SzAyk5j5BOA6UKUgQi4S2CLvp0qULh9ZAgQIly8SJE00eF0liJ0+ezFMrIxEtPEswQ1BKQSJcJKMNCAjg4yDc6dGjRwZ1oNxH+BC8ZFAHUzojF4w1Cv4vv/ySp8OWhLZZi99++42qV69G/fv35VxEUJ5dvnyZ1q37lerUqU2dOn1ilfLMZG63HEbhPzm8zeZ8AzAkIRzoeWQchUfH8xpl1XMXyhcoWl5mS9MaeUwlzs9sfN01WmMT8s9p061wOa+XhpUsvjmcKJ+3M69RdhOfc0EQhCyLvKJtnMWLF1F4eDh//v77uVS/fn3+DAH2SVgCFSpUiBYtWkKDBw9iQRcu2oj5V71aksVMzhWz4UKc5N+B8no78xSIasJalFWliIujogsZUkEZ2zMC5FypkqsYHX9yg93+XR2duWwq5wpci1/L40rxikJRMQq5uWi4HB2voXY1/MjLLYS9WXJ7OtL7FX1szoPlwYP7tHz5z9ShQycqUKBgZl+OIKQJrVu3oZ9/Xkb79u2lO3fu8HswpWAKZiRhhTt7w4aNUvRdhL0Yg2S2akJbMGjQILP1kZMFCWOxGAOli+rFon8s/eNZom3btrwYg5wuSEKrUqRIEc7HooKcMFhUEF6ExRj9YyCB7Z9//pnsuRASpR/OCsUNFiHrgDC3sWO/1ZXz5MlLxYu/RhERkXTx4gUO6woODqbAwMa0c+fvKQql07h5kGPuQhSPWYMSk46grHE1PVshQG+JS0iguARtehZMNoSyypOweM79pg/ngguPJy/3rBWe4uDoSIV8nek2cqsk5qlDOTbBkQr4OFNkbALPIAQjDsrwXPFIeaRipiFyhiAI2QlRrqQRFy6cZ2Ec/6xXqFCRp5/MCFas+IXXmOpTVaycvhlBc3c9ogehcZQvpxN9/m4eGj9+Ilud4OkydepUGj9+fOqUKxZyrsDbI4erhlydNBSXoJCTg7asxglDAWGsRmGjTQYpJnCeTsX9ycvRha4/e0Cv+eajFkUrmjw/7gX5VnK4OujuxTcx5tnDx5m6189NkbEKl21NsSII9krx4sWpevUadOTIYVq4cAHnm0oJsL4jCS346KNWkitAyNbcunWTxo3TKvq8vLxp4cL/o7Jlyxr8XiZOnEBr165hT6MePbrR0qXLrD6+JiaKnAqXInJwIiU6gjSuHuRUsLh2RkAzChatg0diploTudN8PRK9QfRAOad71hunIV+8VciNHobGUAwbmojL8JA1J38IgiAIWRNRrqSSWbNmcqLAqCjD2RaQoK927do0e/Yc/pxewLIKunT5VOexMnLdPbr6UOuae/VRDD14fo829ivOVkRM7RkcbH2MvcbTtIeLJof5HASYFlE7faA2gBhrlKGEyOFqZsplc1MxpxOFPHyod6m6dOPeTSpWoKjZZwSFCWYgwIwEIRHx5OPhyGVVkYI1FDCCIGQtunb9lJUrv/66lj0lEDJpDVBADxs2hBXm8KiAF4wgZDaY0Wn8+HF0+fIlHitLlnydhg8fYZAIOb1AmBnOCSXj1q3bKFeuXLrfypWHcfR6XicaNWo0yx8IEYIHCzyTEA5nFa7uiZ4qHkQJ8XDlIAfMBujiZvl7iUNvYkTNyzmNidi7FOHI+goWlGPis954jba98RgGKw05OmjvRlsmi/KHIAiCkPUQ5Uoq+PDD5vTvv5dN7oOL7L59+zg++Y8/9lgvZLwi6jSdsHyoihUVlB89j6E8efJwOcZCSI8x5vKbWMx7oigUEoHkbPDmQAiQJrGslXLUxLbGmNueXkBAcXd0TlZQwdSH3erlEg8VQbAhkCdlwICBNGPGdJo6dQrnBOnVq7fFf0bv379PI0eOouPHj3NozsyZsyhv3rwZet2CoE9YWBi1a9eG85voc/HiRdq6dQuHb61atVo3bXhaA4XJoUMH+XNg4Hs6xcqaY09p5m+PeNx2d3Gg/gF5aNiw4bRx4waWf2B4GjFipFXnwJjqWjWQoo7tICX0MWk8fbic3Fgbn6CdcRCiRUJiWQUJ8k15rmRU+HFKQGjxg+fx5Or8Uq5CGUn0Rf4QBEGwLST75ivSpUsnnWLFzc2N+vTpQ+fOXeAF3ir58uXTWZsCAt5Nt+tQB1pMwQzuPzWcsUHlwbMI3QwR6tSf1uAAU4+zq+FGZ1eLyhXFwG8XGdqM95sWDrKy0KD1UHHI0tcoCEJS75U+fb7gzz/9tJQaNKhPY8eOoUuXLumm/kUoJzxc+vXry7OuQbGCd/qMGTM5tEgQMgvkvKldu5aBYgW5TFxcXo7Jt27dorp169C9e3fT5RoePXrIHirq1N4A5clbH1JoRALFxBGvUYZcgBBlcPbsmRSfi8N6NPib/DiboGg9YlnESFzYYzbRiPMsksjR6DAoPzcT6ZyZeDhrCHnz9e8FZXUSAJE/BEEQbAdRrryiwAMBXE3qdvTocerZs7duP/KtwFtFnQ7zxYsX9Msvy9PlWgoXLszrZct+4vXtEKMMbon89yCMzp07x59TkpxR451LGwLk4KTNGOfgxGUNXHbN4KDRUB5vR/Jyc2SBAGuUVcEgj5cTGQfhoOznKY5UGU2uXLmpWbNmvBYEewPvnJ49e9G0adM5DwumC169ehW1bPkhVajwNlWpUokqVixP3bp9Sn/8sZsVLphxZ8mSpfTOOxmTN0sQzPHee4EUFxfLnzFr1J49++jkydN08uQp2r//AFWpUoX3od82bfp+ulyDmjAfqF4rl+9FsSeFPihfeRClM95AaWktUIhEH99JSngIaRydeM1lC6HC0XFQQGg4ASw8UrBGGdtBIR8oIwy/g3J+76wn9uZwc6Q6b3hynjqANco5XNMvpDwjETlDEITsRNYbZWyAwYNfzviwZctWXb4OJHU7/G+YbirC6dNn6ixMP/wwN12upUePz3h9+/ZtWrJkEb1VwISCIiGBlk0ZyIIKLEu9e39u9fEdYqPJqcgbRLgPRydeo+wQZ366RQ9XB/Iv6UmFfDF9oBOvUVanKcY1eLgaSj0op8kUy0KKQOgDEhRiLQj2SkBAIG3evJUWLVpM777bmPs73odRUVozNkKF2rVrT+vXb6Tp06fRW2+9TNYpCJnBzp07OSQItGjRklasWMWhvVCk3HgcQzlz5uSksR06fMJ10JfXrFmd5teRP38B3ecdO3bw2tx0y9iuznzl5+dn/UmiI0kJezl7FOCyuYT6iQlr1TAgVZpA2ScxYW1IJBmE2QCUQ6OyphK4W/3c1KqaDzV6y4vXKNuLp4rIGYIgZCfkTfcKnDp1ktf58+fXxe9P23Gflv71jC0oiKTpXMeXvgzKT0FBQbRp00YKDQ1Nl2tp1qw5K27u3btH06ZNox279hH5diDyLqKtcOcQ0cVldDnykW7mCw8PD46jtgYFCeXiY8khTxFdojmUFWdXs467EAjaVvclLzcHevQijj1V9JOw4Z+aWKNgaJQzMqGtoCU0NIQOHDhAjRo1Jl/fFAjDgmBj4P3j71+dF1jVnz9/zmGbXl6e5OnpxUpyvBcfPEif8ApBSAnffTdJb1rusfx59/nnNHXbfQqNTKCc7g70VZP89M03Q1ipAsXG7Nmz0jwBM+SFggUL0t27d2nBgvnsgfA8yvRYfervM/TkyRP+3LVrN+tP4urOeVb0FSwoW0po+zRCISdHbQJYiA4cSuOooZBIhXJ7Ebk5Yeplw+tE2TWLSr0F7Xj2QZEzBEHITmQJV4G5c+dyQlbEufv7+/OMNpZYu3Ytvfnmm1wfLtzbt2+njESNP1ZDciDULNmvVawArFHG9urVq6frtcDbY926DZQ7t9bd8sKZE0T7+hNtbUO0tRVpTk4jTaJiBeFASNaYEjBFooNffnJwdSMHRyft2i+/dopEC6hJ2PoH5OU1yirhMQkUaxS9hHJGJ7QVtNbO69ev6Sz4gpAdwKwnCHHAOxyJQNNzRjdBeBWePNHOBFi5cmVew2MFMwHeehbPyg2sUcb2WrVqc530MuKoipIbN25wcuh83iZ+L1FPac6EQfwRCfzr1Klj9fHVhLasUElUrCSX0BZ5SrRhxxrydtfwGmU1TwmHGsUZKldQzspGHHvNrSJyhiAI2YlMV66sXr2aBg4cSKNGjaKTJ09S+fLlKSAggB4+fGiy/qFDh6hdu3b06aef0qlTp6h58+a8qPlEMgIHeG+w8POU18f+C3+ZxDURlIOvh9OVK1fT/XogyPz++272SnFzc9fmkVXiSKMk8HUobrmoV79vaNas2Sk/eOIUiU7F3iKnkm/zGuVkp0i0ICgoCQkUb6RHQdlabxpBEARBsGdUJUCBAgV5feNRFHus6IPyzcdRVKSI1tCTXoqDtm3bcs4isHTpEurV5SOim38SxUUShd0jCp5OtLsnRUZo87OMGTMuxedw9MtP7o07kcf7n/EaZWvylLi7OLKRCWv9PCVPwuLZo0UflJ+Fm85LJwiCIAh2oVyZPn06de/enbp06UJlypSh+fPnsxvq4sWLTdafNWsWBQYG0qBBg6h06dI0duxYqlSpEs2ZMyfDrrlYsaK8hiYeViMlzrQXhxIbTWvXamOgXV2NZtxJYzCDwOjR39Kv2w+Q4j+ClDKdSSnXg6j+TKJ3F9D7zVu90nFVi5KDlw8nmsPamikSLWGcCE8lysx2QRAEQchOqGPs5cvaWQnvPHphst69xy/owoULBt9JD9auXUclSpTgzw/v3yXN33NJs6MDafb0Ic3dg6RR4vn8Y8eOo0aNrE+arw++r0GIkBX3kVyeElcnxaTRKytOxSwIgiDYD5kafYqwmeDgYBoyZIhuGywQGJgPHz5s8jvYDk8XfeDpsnHjRpP1o6OjeVFR3WaRKC4kJOSVkqgixrlz5066KZmrNP+K4qOTZsZf9vMWevbsWeI1BvL50hsvx3jyKfgGPQl/Xbctl1MkeTpEUEjIy3aAlwhmMXJ1taINHNxIqdZMm1zOxY1iILyk4l5iI6MoITrMQPCBOBQT8ZxCQswnyk1rUtQGdkpo6HN21cXa3d2DsivSF6QNgLSBbbcDrtXLyyvDwyrMyRmpGfOR5wRhOOfOneU8JnvO3KX46KReF/vPRvHshXhmBQsWSlc5Y9my5bRx4wZavGQpPXx4X5d3TdE4EeWtQLO+7U/+5UvpriG9+xFGrFYVnCgy1lGbp4TCdaLJo6eRJuWMR09Dyd1B5IyMROQMLdIXpA2AtAHZdBtYJWcomcidO3c4auXQoUMG2wcNGqRUq1bN5HecnZ2VFStWGGybO3eukjdvXpP1R40axeeQRRZZZJFFFlnsewkNDVUyGpEzZJFFFllkkSV7LMnJGVk0b3raAa8YfU8XaMtgDapQoQLdunWL85VkRzBTRpEiRaQNpA2yfRsAaQdpAyBtYPvtAItSZssZ8NwoVqwY3bx5k6dMzq7Ycj9KK6QNpA1UpB2kDYC0Adl8GyQnZ2SqcgUz3GCWhgcPHhhsRxnTHJsC21NSH7lOjPOdqC5IeKC2+FDTEmkDaQMgbaBF2kHaAEgbaJF2sA5TcgaAYkXaT/oRkDaQNlCRdpA2ANIGZLdtkKmBTkjCimkG//jjDwPPEpRr1Khh8jvYrl8f7Nq1y2x9QRAEQRAEQRAEQRCE9CTTw4LgStupUyeqUqUKVatWjWbOnEnh4eE8exDo2LEjFSpUiCZOnMjlfv36Ub169WjatGnUpEkTWrVqFZ04cYIWLFiQyXciCIIgCIIgCIIgCEJ2JNOVK23atKFHjx7RyJEj6f79+5wLZefOnZQvXz7ej5hl/UzCNWvWpBUrVtDw4cNp6NChVKpUKZ4pqGzZslafE+67o0aNSvfpkbMy0gbSBkDaQIu0g7QBkDbQIu2QOqT9tEg7SBsAaQMt0g7SBkDagOy+DTTIapvZFyEIgiAIgiAIgiAIgmCr2Nbk0oIgCIIgCIIgCIIgCFkMUa4IgiAIgiAIgiAIgiCkAlGuCIIgCIIgCIIgCIIgpAJRrgiCIAiCIAiCIAiCIKQCu1WuvPbaa6TRaJIsn3/+Oe+vX79+kn09e/YkW2b//v3UtGlTKliwIN8PZlHSB7mLMStTgQIFyN3dnRo1akT//vuvQZ2nT5/Sxx9/TN7e3uTj40OffvophYWFkT20QWxsLA0ePJjKlStHOXLk4DqY6vvu3bvJ9p1JkyaRPfWFzp07J7nHwMDAbNMXgKn3A5YpU6bYTV/AFPZVq1YlLy8vyps3LzVv3pwuXbpkUCcqKorfi7ly5SJPT09q2bIlPXjwwKAOZm1r0qQJeXh48HEGDRpEcXFxZA9tgH7+xRdf0BtvvMHvxaJFi1Lfvn0pNDTU4Dim+sqqVavIXvqBNWOiLfeD9EDkDJEzRM4QOUPkDJEzRM4QOSNbKFeOHz9O9+7d0y27du3i7a1atdLV6d69u0GdyZMnky0THh5O5cuXp7lz55rcj/ubPXs2zZ8/n44ePcoDf0BAAL/0VDDInT9/nttr69atPHD06NEjA+8i/dogIiKCTp48SSNGjOD1+vXr+Yf/wQcfJKk7ZswYg76Bl6I99QUAIUf/HleuXGmw3577AtC/dyyLFy/mFz0GfXvpC/v27WOB5siRI/wcIfg3btyY20ZlwIABtGXLFlq7di3Xxz8BLVq00O2Pj4/ngS4mJoYOHTpEP/30Ey1dupT/gbKHNsD9Ypk6dSqdO3eO723nzp0s5BuzZMkSg74A4cFe+kFyY6Kt94P0QOSMpIicIXKGPiJniJwBRM4QOSNbyRlKNqFfv35KyZIllYSEBC7Xq1ePt9kreLQbNmzQlXHf+fPnV6ZMmaLbFhISori6uiorV67k8oULF/h7x48f19XZsWOHotFolDt37ii23gamOHbsGNe7ceOGbluxYsWUGTNmKPaCqXbo1KmT0qxZM7PfyY59Ae3RoEEDg2321hcePnzIbbFv3z7dO8DZ2VlZu3atrs7Fixe5zuHDh7m8fft2xcHBQbl//76uzrx58xRvb28lOjpasfU2MMWaNWsUFxcXJTY2NkV9yJbbILkx0d76QXogcobIGaYQOcM02bEviJyhReQMkTNMYS/9wG49V/SBBmz58uXUtWtX1hir/PLLL5Q7d24qW7YsDRkyhC0O9sq1a9fo/v377KKrkjNnTvL396fDhw9zGWu4ZVapUkVXB/UdHBzYAmWPwCUPfQL3rQ9cMuG+WLFiRXbftDWXNGvYu3cvu9zBTbFXr1705MkT3b7s1hfgnrpt2zaTVgR76guqC6qfnx+vg4OD2bqg/15488032WVV/70AF/d8+fLp6sAS/fz5c7Y42nobmKsDN3UnJyeD7bDKYMyoVq0aWyC1shDZTRtYGhPtrR+kNSJniJxhDpEzRM4AImeInGFcR+SMIXYpZxg+UTsFMZAhISEc/6nSvn17KlasGMdJnjlzhmNk4boJF057BAIP0O+walndhzUGQX3wo8cPQ61jT8BNGc+9Xbt2/IJTQRxkpUqV+L7hloYfP1zXpk+fTvYCXHXhklm8eHG6evUqDR06lIKCgvjF5ujomO36AlwPESeq76Zqb30hISGB+vfvT7Vq1eJBDeBZuri4JBH6jd8Lpt4b6j5bbwNjHj9+TGPHjk3img637QYNGnAc8O+//069e/fm3ADoI/bQBsmNifbUD9IDkTNEzjCFyBkiZ6iInCFyhorIGQXtWs7IFsqVRYsW8QsdD1NFv0NDS4bkaw0bNuQBoGTJkpl0pUJGAS1669atWSM8b948g30DBw7UfX777bd5UPjss884WZOrqyvZA23btjXo/7hP9HtYmfA7yG7AOoDYbzc3N7vtC7CGINb3wIEDlF1Jrg1gHUG8b5kyZWj06NEG+5BDQQXWRcQRw8Joa0KPuTaQMTF1iJwhGCNyhsgZ+oickT0QOYOyvZxh92FBN27coN27d1O3bt0s1oPbKrhy5QrZI/nz5+e1cXZulNV9WD98+NBgP1wTkeVarWNPAg/6BpIu6VuTzPUNtMP169fJXilRogS76an9P7v0BfDXX3+x5jy5d4Qt94U+ffpwssA9e/ZQ4cKFddvxLBHOAIu7pfeCqfeGus/W20DlxYsXbGmFZXHDhg3k7OycbF+4ffs2RUdHk720gaUx0V76QXogcoYWkTNeInJGUkTOEDlDH5EzRM7wt1M5w+6VK8i6DLdDaAktcfr0aV5Di2aPwC0THfOPP/4w0J4irrVGjRpcxhovP8RHqvz555/s3qX+AOxF4MHUkBCGEeOaHOgbiAE2dl+1J/DyRiy02v+zQ1/QtzhXrlyZM/7bW1+AxRQDHQZxPD+8B/TBfWNw138vQADEVHj674WzZ88aCMHqPwuwvNh6G6jvQmS1h8Vw8+bNSSyL5vqCr6+vTVgWrWmD5MZEW+8H6YnIGVpEztAicoZpRM4QOUNF5AyRM+xazlDsmPj4eKVo0aLK4MGDDbZfuXJFGTNmjHLixAnl2rVryqZNm5QSJUoodevWVWyZFy9eKKdOneIFj3b69On8Wc1QP2nSJMXHx4fv98yZM5y1vHjx4kpkZKTuGIGBgUrFihWVo0ePKgcOHFBKlSqltGvXTrGHNoiJiVE++OADpXDhwsrp06eVe/fu6RY1C/WhQ4c4azv2X716VVm+fLmSJ08epWPHjootYakdsO+rr77iLO3o/7t371YqVarEzzoqKipb9AWV0NBQxcPDg7ORG2MPfaFXr15Kzpw5lb179xr094iICF2dnj178nvyzz//5HdijRo1eFGJi4tTypYtqzRu3JjbYufOndwOQ4YMUeyhDdAH/P39lXLlyvHYoF8H9w42b96sLFy4UDl79qzy77//Kj/88AP3m5EjRyr20AbWjIm23g/SC5EzRM4QOUPkDJEzRM4QOUPkDBW7Vq789ttv/LK7dOmSwfabN2/yw/Tz8+MpAl9//XVl0KBB3PltmT179vD9Gi+YDk+dJnHEiBFKvnz5+L4bNmyYpG2ePHnCA5unpydPfdWlSxcePOyhDfBjNrUPC74HgoOD+QWIF4Sbm5tSunRpZcKECQbCgK23A150eHHhhYXp8TANYPfu3Q2mPrP3vqDy448/Ku7u7jxVoDH20BfM9fclS5bo6uCfnt69eyu+vr48kH/44Yc8IOpz/fp1JSgoiNsqd+7cypdffmkwfaAtt4G5foIF7wx1etAKFSrwbyFHjhxK+fLllfnz5/M/1vbQBtaOibbcD9ILkTNEzhA5Q+QMkTNEzhA5Q+QMFQ3+ZLb3jCAIgiAIgiAIgiAIgq1i9zlXBEEQBEEQBEEQBEEQ0hNRrgiCIAiCIAiCIAiCIKQCUa4IgiAIgiAIgiAIgiCkAlGuCIIgCIIgCIIgCIIgpAJRrgiCIAiCIAiCIAiCIKQCUa4IgiAIgiAIgiAIgiCkAlGuCIIgCIIgCIIgCIIgpAJRrgiCIAiCIAiCIAiCIKQCUa4IgpBm/Pfff9S+fVuqVKkCtWz5Id25c4fKli1D//xz0ex3jh07xnWeP39OWZ3Y2BgKCgqgU6dOpeo4w4YNpb59++jKnTt3okmTJurKjRs3op9/XqYro33++GM3ZWUiIyOpf/9+5O9fNUXPc+7cOdxXrMW4T2VU/0G/3rXr93Q9hyAIgmAZkTOsQ+SMl4icIWQkolwRsgyPHz+iCRPGUWBgY6pYsTw1bNiAPv+8Nx05cjhNjr9x4waqUcM/TY5lPChZejmbWn77baeu3r17d6lXr55UpUolqlu3Nk2dOoXi4uJ0+y9evEAffdSCqlatzO0RGhqi24d6rVt/RGfPnqGsAAYwd3d32rp1Gy1atITy589Pe/fuo9dfL0X2wOrVq6lQocJUsWLFVB3nm2+G0LhxE6yujzasU6cuZWU2bdpEJ08G0/LlK/h6vby8yJ7o0aMnzZgxnRISEjL7UgRBeEVEzhA5I6sjcoZ5RM4QbAFRrghZAggIrVu3oqNHj9KXX35FGzZsoh9//JGqVatG48ePI1tEHfD1l88/70MeHh5Up04drhMfH0+9e/ei2NhYWr78Fxo/fgJt2rSR5sz5XnecUaNGkr+/P61du47Cwl7QggULdPt++mkpVahQkcqVe5uyArdu3aKKFStRwYKFyMfHhxwdHSl37jzk5OREto6iKLRy5Qpq0aJlqo8FgcDb29vq+mhDFxcXysrcunWTSpQoQaVKleLr1Wg0ZCvAUpgc+M2Gh4fTX3/9lSHXJAhC2iJyhsgZWR2RMywjcoZgC4hyRcgSjBs3hl+SK1eupnffbUyvvfYaWyE6depMv/yy0sD68sUXn7N1BW6BX345gB4/fqzb/88//1CXLp2pWrUqvB/WlnPnzrFL3/Dhw+jFixc6qw6sH6a4efMmn6Nu3Tp8njZtWtPhw4cMXCvv3r1L3303SXcsU6gDvv4Cl8uAgEDy8MjBdQ4dOkhXr16lSZO+ozffLM1Wgz59vqBVq1bqXsRwgW3ZshW3SVBQEy6rAsb69euoX7/+VrUx3Bm//XYU3xfcaZs3/4D27t2r2w9XxGbNmrI1DxazpUuXGHwf2xYs+JHbEe3bqFEDWrt2jW4/2uHChfM0f/48Xfuactfdv38fNWkSRJUrV+RndffunSTXCstEx44duA4sixMmjKeIiAirrwXcv3+fBg36imrWrM7PEUL1mTN/6/b/+ecf1KpVS24LWDF/+GGugSXPmPPnz3Ob16tXT7dNvb+dO3forhf95fr163T27Fk+J87ds2cPevr0qVl33eQwdte9fPkyde3ahc9Xq1YNGj16FEVEhCc5/pIli6l+/bpcZ9y4sSxcq6CPvfdeIN8/+sSAAZb7kaX+gd8EBPATJ07wtaJsjv/7v4V8Pjy3ESOGU0yMocABi828eT9Qw4bv8LngynvggPWCRkhICD/3Bg3qs5X2ww+b0fbt2wzq4PrwzxRcpGvXrkk9evRgoRZ9Fn0J533nnXrc7/R/z/h97tix3eprEQQh6yByhsgZ+oicYYjIGSJnCGmEIgiZTEjIM6Vs2TLKggU/WqwXHx+vtGz5ofLJJx8r586dU/7++7TSqtVHSqdOHXV1mjVrqgwe/LVy9epV5fr1a8rOnTuUixcvKjEx0cqyZcsUf/+qyqNHD3kJDw8zeR7UX716lXL58mU+xuzZs5RKlSood+/e0V1vgwbvKPPm/aA7ljXgmt96q7Ry8uRJ3bbvv5+ttGjR3KDerVu3uN6FC+e53L59W2X58p+V2NhYpX//fsr06dN4e7dunyq7d++y6txoOxwH7XPw4EHl5s2byp49e5T9+/fprq1cubf4nq5du6Zs2LBeqVy5Iq9V3n23oVKzZnVl5coVyo0b15WFCxfwd/777z/ej3bA8SdP/k7Xvrdv3+Z7uXjxAte5e/euUrFieWXy5En8vS1bNit169bmOqGhoVznxo0bSpUqlZRly37i9kd7ffRRC2XYsCFWXwvOHRDQWOnYsYMSHHyC6+zYsV05deoU7z9x4jj3hY0bN3BboE0aN26kzJ07x2wb/vTTUuX995sYbFPvD9sPHPhLuXLlCrcz+mXnzp2U4OBgfo5BQQHKt9+O1n1v6NAhyhdffK4row9PnDjB4P5w/yo4h/qsw8PDlfr16yr9+vXlPnrkyGElIOBdPqb+8XF/OCd+C3jWaNO1a9fw/rNnzypvv11W2bZtq3Lnzm2+xp9/Xmb23pPrH/hNjBo1Umnfvh0/e5RNgWeA5//rr7/ys5o1a6ZSrVoVg98A2hnXvm3bNq4zbdpUpXz5ctwX9Ntc7VNHjx416D/3799XFi9exPvxbPHbwb2eOfO3QXtXrVpZmTp1Cp8Dy2+/7eTz4jeB3zrqq+2lsmrVSn42giDYFiJniJwhcobIGfrtLHKGkF7Yvg+dYPPAggNtbvHiJSzWO3LkCP3777+0c+fvVKBAAd42ceJEatbsA9belytXju7du0ddunRlt0FQrNhruu97eXmy1QqWHUu8+eabvKh88UVf1ubv2bOH2rf/mHLmhBuqA+XIkSPZY+kD6w+uSz+OFtawXLlyG9TLlSuXbh/49tsxbA2ABh+usN2796DNmzeTu7sblS1bjnr06M6ukkFB71Hfvv1Mnvvw4cPcRps3b2XLFChSpIhu/7JlS8nfvzr17NmLy6gDSxcsEs2bv0wCBo1627bt+POnn3ajZcuW0bFjR6l48eLcFtC6wx1ZbZdnz17GbYPVq1fxeQcNGsxlfA/PdNGi/zOwOLz//vv0yScddc9wyJChbAUYMWIUubq6Jnst27Zto2fPnnLsMp4XKFq0mO4csFjgO82aNde1BSx506dPo969PzfZhrAi5s1r+nl37tyFatWqzZ8//vgT+vrrr2jRosVUqVIl3gYXX7hhpwWwjkRHR9OECRO5rYlK0dChw6hPn89pwICBlDu3tj/BHXjYsOH8TNDv6taty7+hjz5qxb8TxKzXq1ef+zHcq0uXNm0ZtaZ/oI3d3NzI2dnZ4m/i559/5rZo2VLr8oz+ilwHuB8V9POuXT+l9957j8sDB37JFmF8d/jwEcm2T758+fgdoPLxxx3o4MGDtHPnTgO39mLFinFogL6lE21XvXoNvo8CBQomcYPPmzcvWyph9XJwEMdPQbAVRM4QOUPkDOsROcMyImcIlhDlipDpQOCxhv/+u8rxxarAA0qWfJ1f7nBhhdDTsWMnjh3esmUzv7waNw6gokWLpuh64PY4d+5c2r9/Pye/gwsnXsoYKF6VqKgoHqw++6xnir8Lt+WlS5cZuCP+8MMc3gZ3wgoVKtDMmbOobdvW9Pbbb1P9+u8kOcalS//wYKAKPMag/d55p4HBNghnSKaHeG0MnOB///ufbr9WgMxt4IaaHNrnZDiQlC9f3uhaL9Hly5do69atBtsx0Ny+fZtKliyZ7LXAbbt06dI6gccYnAOZ+OHyq398PGdko4dAYEx0dBS5uGgFLmP0ryV3bq3QWqrU/wwE2SdPnlBagDZ84403EwUeLRCGcf1wE1aFHvw21Oemva48LGCCmjVr8qAON2UIa7Vr16aGDRuZvO+U9I/kuHbtP2rduo3BtvLlK7CwCsLCwujhw4d8P8bnwjOzBlzPwoULOJnjgwcP2EUZC/5J0KdMmbcMynhX4H4CAwO4PSBU169f3yCO39XVjdsZLsYQ8gRBsA1EzrCMyBlaRM7QInKGZUTOECwhyhUh04FmF4MWXoipBYncmjR5n7XDSAiF2MYpU6ZRo0aNrD7GlClT2ALz1VeDWGByc3PlOFH9ONKU8vvvv/Ng+sEHzQy2Y4AyzsCvDo7q4GXM5MnfUYcOn7AAePz4Merbty8PgHXr1uOyKaFHtcKkFmja9UEusbTOao6Y51atWlOHDh2S7NMXeC1dC55ZcudAXzHVL8y1lY+PL12+rBUajHF21n+VahOs6Q+W6N/WCvdpheE1aa9BbR9Ykdau/ZX7y6FDh2jOnDkcC75q1ZoUJcDLisDKtXz5zzR48DcseHp4uNOkSZOS/H6NBTz0ra1bt7OFC22C/Aw41tKlP+n6WmhoKH9PBB5BsC1EzhA5Qx+RM9IGkTNEzhCSIv5GQqYDrX+tWrU48ZV+MjEVdV75EiVKsqucvmXn6tUrvF+1MgBYTWBZWrjw/6hRo3d5akSAFxe0zclx+vQpat68OQ+IsBRA+ICrpj7WHkvfVRcaeT8/vyTWFGj59a0NSGrn6enJFgFj8EKGdh9uwwCDWGysNjkaLF/x8aYFkP/97w3WrsPiYAq4c8LCog/KaEtrrQXWgPOcO3fWYNvff79M/gbKlCnN1kO41xovzs7WZbLH/cKqpD+dpD5wTb127ZrJc5hzw4SFCoJ5RgsvptoQFkL938qpUyf5us1ZDE0BoaxGjZrssrp+/Qbu45hFIz37B1zyjYV8/eR/6PdwicX9GJ9L/zduCdTFb61p0w/Y7b5w4SJ044bpfm8MhBn80wD35yVLfqK//z6ts8KBK1f+5X4gCIJtIXKGyBn6iJxhGZEzLCNyhmAJUa4IWYJhw0awENGuXRvOFo6XFGItoRn++OP2XKdGjRo8/do333xNFy5c4JfnkCFDqEqVqlS2bFl2iUVmbsRNIjP8yZMneYBV46IR74mBAoLDs2fP2MJjCgx8u3fv4szzGDi//vrrJFYTHCs4+AQLEjiWJW7evMF11fhPfWrWrMUv8yFDvuFzHTx4gL7/fjbH+BpPiQdX0vHjx9Po0aN1AzPcGCEs4ru7du0yiLPWp2rVqlS5chUaMKAfa8vh9vrXX/t12dE7depCR48e4Qz8EIwQt4vpABHjm5a0adOGbty4QVOnTmGhY9u2rUlihLt27UanT5/mZ4lngL6AjPspmSoTcbQQVvv2/YL7AbLvo1/huKBXr17s0g0rCgYy9LXt27fT7NmzzB6zWjV/7j9XrlyhzAQWU1i9kKkfAzJcXSdMmMCDvDkrpDGYvQG/LbQvfiuIrUcfL17ctNCUVv0DltANG9bzguNgKlDj9kQc8+LFi2jHjh3cR2bMmM7XacrCaM5CjX8cIPzguX777WirXKXxz9G6deu4TdFftm7dwkJQwYIFdXWCg4P5NysIgu0hcobIGSoiZ1hG5AzLiJwhWELCgoQsARJ9rV27jmNTp0yZTI8ePWLrS5kyZWjEiJE6d8Pvv5/D8b+dOn3CAz9iFocMGcb7kfwNccJDh37DLzlfX1+2CsEtE0AgQBzmV199yfV69eqt26fP118P5qnbOnT4mHx8fDghGWI09UFSMrxMg4ICOC7y3LkLZu9t/fr1HIds6mUJbfzcuT/Q2LFjqEOH9uwKCJdeHN8YDNBIFoapFFWQgA1CWefOHXkwxPSS5pg5cya7IiMJGgQ+uCL37z+Q96Gdp02bzoMQBrY8efJw2+gnmUsLEH87Y8Ysmjx5Eq1Y8QvHr2OKR7S3yhtvvMHafAggHTt+whacIkWKUmBgoNXngeVpwYKFfL+9e/dkgRoWyeHDtedB/C/afd68eTzAwrqCBHUtW35k9pjoC4gXxmCIhG6ZBfrIjz8u5On9EP+OgRnPHf3AWry9vWj37t3cp9B/IehPnjyF4+5NkVb9IygoiJMiIqEfhHhcd5s2bVnY108Mh6lMp06dzL9j/FMwZ85cg6SRlvjss8/o9u1b9Nln3cnNzZ1atWpFDRo0pLCwFxa/5+XlxQkPp0z5jvsLrMk4L547wD84sDZjOlNBEGwPkTNEzlAROcMyImdYRuQMwRIaTBlksYYgCILAINlZ9+7dOCO8h0eOzL4cIQOBoIbQgNGjv83sSxEEQRDsFJEzsi8iZ9gHEhYkCIJgJbB2DRw4kG7fvpPZlyJkMLBwm7L0CoIgCEJaIXJG9kXkDPtAPFcEQRAEQRAEQRAEQRBSgXiuCIIgCIIgCIIgCIIgpAJRrgiCIAiCIAiCIAiCIKQCUa4IgiAIgiAIgiAIgiCkAlGuCIIgCIIgCIIgCIIgpAJRrgiCIAiCIAiCIAiCIKQCUa4IgiAIgiAIgiAIgiCkAlGuCIIgCIIgCIIgCIIgpAJRrgiCIAiCIAiCIAiCIKQCUa4IgiAIgiAIgiAIgiDQq/P/z6ZeQcKYDYAAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -529,8 +528,7 @@ " \"sufficiency\": Utility(CURVES, weights={\"sufficient\": 0.7, \"accurate\": 0.3}),\n", " \"accuracy\": Utility(CURVES, weights={\"sufficient\": 0.3, \"accurate\": 0.7}),\n", "}\n", - "means = aggregate(results, [\"sufficient\", \"accurate\"], statistics=[Quantile(\"cost\", 0.7)])\n", - "means[\"description\"] = space.designs_of(means).map(describe)\n", + "means = summarize(results, statistics=[\"sufficient\", \"accurate\", Quantile(\"cost\", 0.7)])\n", "means = means.set_index(\"design\")\n", "\n", "fig, axes = plt.subplots(1, 2, figsize=(11, 4.5), sharey=True)\n", @@ -540,9 +538,7 @@ " judged[name][\"pareto\"] = pareto_front(judged[name], {\"utility\": \"max\", \"cost p70\": \"min\"}) # of the utility\n", " legend = \"lower right\" if ax is axes[0] else None\n", " groups = means.planes.clip(upper=3) # 3 or 4 planes share a color\n", - " plot_designs(\n", - " judged[name], \"cost p70\", \"utility\", by=groups, front=\"pareto\", names=PLANE_GROUPS, legend=legend, ax=ax\n", - " )\n", + " plot_designs(judged[name], \"cost p70\", \"utility\", by=groups, names=PLANE_GROUPS, legend=legend, ax=ax)\n", " ax.axvline(BUDGET, color=GRAY, lw=1, ls=\"--\")\n", " ax.set(xlabel=\"Cost at 70% confidence (millions of dollars)\", ylabel=\"Utility\", ylim=(0, 1.02))\n", " ax.set_title(f\"Weighing {name} most\")\n", @@ -564,10 +560,10 @@ "id": "ab147572", "metadata": { "execution": { - "iopub.execute_input": "2026-11-14T15:43:54.638453Z", - "iopub.status.busy": "2026-11-14T15:43:54.638453Z", - "iopub.status.idle": "2026-11-14T15:43:54.652143Z", - "shell.execute_reply": "2026-11-14T15:43:54.652143Z" + "iopub.execute_input": "2026-11-15T04:33:53.977109Z", + "iopub.status.busy": "2026-11-15T04:33:53.976977Z", + "iopub.status.idle": "2026-11-15T04:33:53.983429Z", + "shell.execute_reply": "2026-11-15T04:33:53.983029Z" } }, "outputs": [ @@ -830,7 +826,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.16" + "version": "3.14.10" } }, "nbformat": 4, diff --git a/docs/examples/tradespace/trade_space_example.py b/docs/examples/tradespace/trade_space_example.py index fdf454f6..d88b98c0 100644 --- a/docs/examples/tradespace/trade_space_example.py +++ b/docs/examples/tradespace/trade_space_example.py @@ -82,6 +82,11 @@ def count_samples(observations, duration=DURATION): return {"sufficient": 100 * (samples >= threshold).sum() / N_POINTS} +def describe(d): + """A short description of a design: its altitude, field of regard, and layout.""" + return f"{d.altitude / 1e3:.0f} km, {d.field_of_regard} deg FOR, {layout_of(d.layout).describe()}" + + CACHE_DIRECTORY = Path(tempfile.gettempdir()) / "tatc-trade-space" # the points of each replicate: a lattice in a random orientation, from its seed TARGETS = Targets( @@ -97,15 +102,11 @@ def count_samples(observations, duration=DURATION): replicates=N_REPLICATES, n_jobs=-1, store=ResultStore(CACHE_DIRECTORY / "results.sqlite"), + describe=describe, # a description column in the results ) OBJECTIVES = {"satellites": "min", "planes": "min", "sufficient": "max"} -def describe(d): - """A short description of a design: its altitude, field of regard, and layout.""" - return f"{d.altitude / 1e3:.0f} km, {d.field_of_regard} deg FOR, {layout_of(d.layout).describe()}" - - def planes_name(planes): """The name of a number of planes.""" return f"{planes:.0f} plane{'s' if planes > 1 else ''}" @@ -164,8 +165,8 @@ def sample_field(observations, design): ) COST_MODEL = CostModel( satellites={ - 30: SatelliteCost(development=40, first_unit=12, learning_rate=0.9, mass=60), - 60: SatelliteCost(development=60, first_unit=18, learning_rate=0.9, mass=90), + 30: SatelliteCost(development=40, first_unit=12, learning_rate=0.9), + 60: SatelliteCost(development=60, first_unit=18, learning_rate=0.9), }, launch=LaunchCost(per_launch=8), operations=OperationsCost(per_year=3, per_satellite_year=0.5), diff --git a/src/tatc/tradespace/__init__.py b/src/tatc/tradespace/__init__.py index f6d4435c..37b726c3 100644 --- a/src/tatc/tradespace/__init__.py +++ b/src/tatc/tradespace/__init__.py @@ -5,7 +5,7 @@ in replicates that draw its uncertain parameters (`Study`, or `ObservationStudy` for the observations, deployment, costs, and failures of constellations) into results (a row per replicate), judges designs by -criteria (`Criteria`) on summaries of the results (`aggregate`, a row per +criteria (`Criteria`) on summaries of the results (`summarize`, a row per design) and their Pareto efficiency (`pareto_front`), and settles the uncertainty of its replicates (`refine`, `confirm`), or finds efficient designs of spaces too large to enumerate (`screen`, `optimize_optuna`, @@ -94,12 +94,11 @@ Probability, Quantile, StandardDeviation, - StandardError, Statistic, ) from .store import ResultStore from .study import Study -from .summary import aggregate, pareto_probability, summarize +from .summary import pareto_probability, summarize from .utility import ExponentialUtility, LinearUtility, PiecewiseUtility, Utility __all__ = [ @@ -164,10 +163,8 @@ "Quantile", "Requirement", "StandardDeviation", - "StandardError", "Statistic", "Utility", - "aggregate", "exceedance", "hypervolume", "hypervolume_progress", diff --git a/src/tatc/tradespace/attribution.py b/src/tatc/tradespace/attribution.py index 5f0371ba..a282bb64 100644 --- a/src/tatc/tradespace/attribution.py +++ b/src/tatc/tradespace/attribution.py @@ -51,23 +51,23 @@ class Attribution: errors of the shares (`first se` and `total se`, by a bootstrap). Those of differences (see `differences`) are of a pair of designs (`design` and `other`).""" + designs: list[Design] = field(default_factory=list) + """list[Design]: The designs attributed (of differences, those of the + pairs).""" by: tuple[str, ...] = () """tuple[str, ...]: The columns that separate the records of an evaluation (see `attribute_variance`).""" - samples: dict[str, np.ndarray] = field(default_factory=dict, repr=False) + _samples: dict[str, np.ndarray] = field(default_factory=dict, repr=False) """dict[str, numpy.ndarray]: The variances that the parameter of each row of `shares` explains (`first` and `total`), and the variance of the metric (`variance`), in each resample of the bootstrap (a row per row of `shares`, and a column per resample, of the same replicates for every design), from which `summary` estimates the standard errors of shares over designs.""" - resamples: np.ndarray | None = field(default=None, repr=False) + _resamples: np.ndarray | None = field(default=None, repr=False) """numpy.ndarray | None: The rows of A, B, and the mixed replicates in each resample of the bootstrap (a row per resample), which `differences` resamples too.""" - designs: list[Design] = field(default_factory=list) - """list[Design]: The designs attributed (of differences, those of the - pairs).""" @property def summary(self) -> pd.DataFrame: @@ -107,8 +107,8 @@ def summary_of(self, share: str = "total") -> pd.DataFrame: usable = (frame[share].notna() & frame["variance"].notna()).to_numpy() explained = np.where(usable, frame[share] * frame["variance"], 0.0) variance = np.where(usable, frame["variance"], 0.0) - sampled = np.where(usable[:, None], self.samples[share], np.nan) - sampled_variance = np.where(usable[:, None], self.samples["variance"], np.nan) + sampled = np.where(usable[:, None], self._samples[share], np.nan) + sampled_variance = np.where(usable[:, None], self._samples["variance"], np.nan) records = [] with warnings.catch_warnings(): # parameters drawn in no design, or without variance @@ -183,7 +183,7 @@ def differences( ValueError: if a design of a pair is not attributed, or a pair is of a design with itself. """ - if "other" in self.shares.columns or self.resamples is None: + if "other" in self.shares.columns or self._resamples is None: raise ValueError("differences need an attribution of designs") designs = list(pd.unique(self.results["design"])) pairs = list(combinations(designs, 2)) if pairs is None else pairs @@ -198,7 +198,7 @@ def differences( raise ValueError(f"pairs of a design with itself: {same}") metrics = list(pd.unique(self.shares["metric"])) parameters = list(pd.unique(self.shares["parameter"])) - n = self.resamples.shape[1] + n = self._resamples.shape[1] tables = { key: _tables(self.results, key, metrics, parameters, self.by) for key in dict.fromkeys(key for pair in keyed for key in pair) @@ -230,16 +230,16 @@ def differences( parameters, metrics, self.by, - self.resamples, + self._resamples, ) paired = {key for pair in keyed for key in pair} return Attribution( results=differences, shares=shares, - by=self.by, - samples=samples, - resamples=self.resamples, designs=[design for design in self.designs if design.key in paired], + by=self.by, + _samples=samples, + _resamples=self._resamples, ) @@ -267,7 +267,7 @@ def _groups_of( if not groups: raise ValueError("no parameters to attribute variance to") paths = [path for group in groups.values() for path in group] - space.check_uncertain(paths) + space._check_uncertain(paths) # pylint: disable=protected-access repeated = sorted({path for path in paths if paths.count(path) > 1}) if repeated: raise ValueError(f"parameters in more than one group: {repeated}") @@ -422,7 +422,7 @@ def _shares( in `keys`, and of each group of `by`) of each group of parameters (see `attribute_variance`), with a bootstrap of the resamples of the rows of A, B, and the mixed replicates (`resamples x n`), whose samples it also - returns (see `Attribution.samples`). + returns (see `Attribution._samples`). """ n = resamples.shape[1] feasible = feasible_records(results)[0] @@ -604,8 +604,8 @@ def attribute_variance( return Attribution( results=results, shares=shares, - by=by, - samples=samples, - resamples=drawn, designs=unique, + by=by, + _samples=samples, + _resamples=drawn, ) diff --git a/src/tatc/tradespace/cache.py b/src/tatc/tradespace/cache.py index 79c835fb..2859ba0c 100644 --- a/src/tatc/tradespace/cache.py +++ b/src/tatc/tradespace/cache.py @@ -26,7 +26,7 @@ import pandas as pd from ..schemas import Satellite -from .fingerprint import _fingerprint_of, find_stale, get_definition, warn_stale +from .fingerprint import _find_stale, _fingerprint_of, get_definition, warn_stale from .hashing import canonical, digest from .memory import Forgetful from .store import _decode, _encode @@ -99,8 +99,8 @@ class SatelliteCache(Forgetful): calls, other than TAT-C's: change it whenever these change), and by the satellite, in a folder of each namespace (by a hash of it, with the namespace in `namespace.txt`, and a `context` that describes it in - `context.json`, see `contexts`), and in it a folder of each fingerprint - (with the definition in `definition.json`). + `context.json`), and in it a folder of each fingerprint (with the + definition in `definition.json`). A cache warns if its namespace has results only of the same function with other code (of the function, of TAT-C, or of Python: the same values @@ -118,9 +118,10 @@ class SatelliteCache(Forgetful): namespace (str): An identifier of the analysis (of what the fingerprint of the function cannot see). context (Any): A description of the namespace, such as the values - from which it is made, kept on disk beside its results (see - `contexts`): JSON data, or values that `ResultStore` encodes - (such as tuples and datetimes), or `None` for none. + from which it is made (as of the caches of `Observations`, which + find their namespaces by it), kept on disk beside its results: + JSON data, or values that `ResultStore` encodes (such as tuples + and datetimes), or `None` for none. """ _forgotten = ("_memory", "_unreadable") # (copies sent to parallel workers) @@ -136,8 +137,6 @@ def __init__( self.function = function self.directory = None if directory is None else Path(directory) self.namespace = namespace - self.context = context - """Any: The description of the namespace, if any.""" self.fingerprint = "" """str: The fingerprint of the function, which keys results on disk.""" self.hits = 0 @@ -163,18 +162,12 @@ def __init__( self._warn_other_definitions() @staticmethod - def contexts(directory: str | os.PathLike) -> dict[str, Any]: + def _contexts(directory: str | os.PathLike) -> dict[str, Any]: """ Gets the namespaces of the results in a directory (of the caches that - share it, see `SatelliteCache`) and their contexts, such as to find - the caches of a set of observations (see `Observations.prune`). - - Args: - directory (str | os.PathLike): The directory. - - Returns: - dict[str, Any]: the context of each namespace (`None` if it has - none, or if it cannot be read) + share it) and their contexts (`None` if one has none, or if it cannot + be read), such as to find the caches of a set of observations (see + `Observations.prune`). """ directory = Path(directory) if not directory.is_dir(): @@ -215,7 +208,7 @@ def __fingerprint__(self) -> dict: def _stale(self) -> dict[Path, int]: """ Gets the folders of the results of the namespace by the function with - other code (the same values but for code, see `find_stale`), the + other code (the same values but for code, see `_find_stale`), the latest first, and their numbers of results (including folders of definitions without results). """ @@ -226,7 +219,7 @@ def _stale(self) -> dict[Path, int]: ] folders.sort(key=lambda folder: folder.stat().st_mtime, reverse=True) others = {folder: _read_definition(folder) for folder in folders} - return find_stale( + return _find_stale( self._definition, others, lambda folder: sum(1 for _ in folder.glob("*.pkl")), @@ -315,15 +308,9 @@ def _store(self, key: str, result: Any) -> None: self._unreadable.discard(key) _write(path, pickle.dumps(result), replace=True) - def get(self, satellite: Satellite) -> Any: + def _get(self, satellite: Satellite) -> Any: """ Gets the result of a satellite, computing it if it is not cached. - - Args: - satellite (Satellite): The satellite. - - Returns: - Any: the result """ key = get_satellite_key(satellite) try: @@ -341,9 +328,10 @@ def get(self, satellite: Satellite) -> Any: def __call__(self, satellites: Satellite | Iterable[Satellite]) -> Any: """ - Gets the results of satellites, concatenated if they are data frames - (or the list of results otherwise), or an empty data frame if there are - no satellites. + Gets the results of satellites (or of a satellite), each computed if + it is not cached: concatenated if they are data frames (or the list + of results otherwise), or an empty data frame if there are no + satellites. Args: satellites (Satellite | Iterable[Satellite]): The satellites. @@ -353,7 +341,7 @@ def __call__(self, satellites: Satellite | Iterable[Satellite]) -> Any: """ if isinstance(satellites, Satellite): satellites = [satellites] - results = [self.get(satellite) for satellite in satellites] + results = [self._get(satellite) for satellite in satellites] if not results: # no satellites (such as if all fail): an empty frame return pd.DataFrame() diff --git a/src/tatc/tradespace/confirmation.py b/src/tatc/tradespace/confirmation.py index 4c42e65d..0e5b5afd 100644 --- a/src/tatc/tradespace/confirmation.py +++ b/src/tatc/tradespace/confirmation.py @@ -8,15 +8,15 @@ from __future__ import annotations from collections.abc import Mapping, Sequence -from dataclasses import dataclass, field +from dataclasses import dataclass import numpy as np import pandas as pd -from .criteria import Criteria +from .criteria import Criteria, _as_criteria from .space import Design, _designs from .study import Study -from .summary import aggregate +from .summary import _summarize from .tables import FEASIBLE, JUDGMENT, efficient_keys @@ -46,11 +46,11 @@ class Confirmation: `feasible`, the `violation` of the requirements, and whether the design meets them (`meets_requirements`) and is efficient among the confirmed designs that do (`pareto`), by the new replicates.""" - criteria: Criteria - """Criteria: The criteria of the confirmation.""" - designs: list[Design] = field(default_factory=list) + designs: list[Design] """list[Design]: The confirmed designs (every design evaluated with new replicates).""" + criteria: Criteria + """Criteria: The criteria of the confirmation.""" @property def optimism(self) -> pd.Series: @@ -112,7 +112,7 @@ def confirm( such as rows of a summary, or the `designs` of another step), or `None` for those efficient by the criteria over every replicate of the results (see - `aggregate` and `pareto_front`). + `summarize` and `pareto_front`). replicates (int | None): The number of new replicates, or `None` for the study's number. @@ -120,21 +120,21 @@ def confirm( Confirmation: the new results, the summary of each design, and the designs """ - criteria = Criteria.of(criteria) + criteria = _as_criteria(criteria) count = study.replicates if replicates is None else replicates if count < 1: raise ValueError("replicates must be at least 1") if designs is None: - designs = efficient_keys(aggregate(results, criteria, design_columns=[])) + designs = efficient_keys(_summarize(results, criteria, design_values=False)) designs = _designs(study.space, designs, results) keys = {design.key for design in designs} start = int(results["replicate"].max()) + 1 if len(results) > 0 else 0 fresh = study.run(designs, replicate_indices=range(start, start + count)) names = [name for name in criteria.names if name != FEASIBLE] columns = ["design", *criteria.by] - confirmed = aggregate(fresh, criteria) - selected = aggregate( - results[results["design"].isin(keys)], criteria, design_columns=[] + confirmed = _summarize(fresh, criteria) + selected = _summarize( + results[results["design"].isin(keys)], criteria, design_values=False )[[*columns, *names]] summary = confirmed.merge( selected.rename(columns={name: f"{name} selected" for name in names}), @@ -158,5 +158,5 @@ def confirm( ] ] return Confirmation( - results=fresh, summary=summary, criteria=criteria, designs=designs + results=fresh, summary=summary, designs=designs, criteria=criteria ) diff --git a/src/tatc/tradespace/cost.py b/src/tatc/tradespace/cost.py index 82a0ca29..7e66137a 100644 --- a/src/tatc/tradespace/cost.py +++ b/src/tatc/tradespace/cost.py @@ -65,7 +65,7 @@ def evaluate(satellites, design): import pandas as pd from .deployment import Deployment -from .events import per_type +from .events import _per_type from .mission import MissionHistory from .nodes import Uncertain from .space import DesignSpace @@ -93,7 +93,9 @@ class Triangular: 0.904 to 1.708 for modified ones, and 0.981 to 1.140 for existing ones (M. W. Maier, K. L. Yeakel, and E. B. Wendoloski, "Cost Variance Analysis in Constellation Architecture Studies," IEEE Systems Journal 17(2), - 2023, Table I). + 2023, Table I): `Triangular(0.827, 2.274)`. (The mode is given by name, + as the bounds of such tables are, unlike the arguments of + `Uncertain.triangular`, which are in order of value.) Args: low (float): The lowest growth. @@ -103,6 +105,7 @@ class Triangular: low: float high: float + _: dataclasses.KW_ONLY mode: float = 1.0 def __post_init__(self): @@ -234,9 +237,6 @@ class SatelliteCost: first_unit (float): The recurring cost of the first unit (besides that of its components). learning_rate (float): The learning rate, in (0, 1]. - mass (float | None): The mass (kg), for launches priced by mass - (and of a `MissionPlan`, limited in mass) if the deployment - does not give one (see `CostModel.estimate`). components (Sequence[Component]): The components, if any, of distinct names. block_size (int | None): The units of each block of production, or @@ -249,7 +249,6 @@ class SatelliteCost: development: float = 0.0 first_unit: float = 0.0 learning_rate: float = 1.0 - mass: float | None = None components: Sequence[Component] = () block_size: int | None = None redevelopment: float = 1.0 @@ -448,26 +447,23 @@ def annual(self) -> pd.DataFrame: table["total"] = table.sum(axis=1) return table - def metrics(self, prefix: str = "cost") -> dict[str, float]: + def metrics(self) -> dict[str, float]: """ Gets the cost as metrics of an evaluation (see `Study`): the total - (``), each element (` development`, ` - production`, ` launch`, and ` operations`), the - present value of the total (` present`), and the cost of its - most expensive year (` peak annual`). - - Args: - prefix (str): The name of the total, and prefix of the others. + (`cost`), each element (`cost development`, `cost production`, `cost + launch`, and `cost operations`), the present value of the total + (`cost present`), and the cost of its most expensive year (`cost peak + annual`). Returns: dict[str, float]: the metrics """ annual = self.annual() return { - prefix: self.total, - **{f"{prefix} {element}": getattr(self, element) for element in ELEMENTS}, - f"{prefix} present": self.present_value, - f"{prefix} peak annual": ( + "cost": self.total, + **{f"cost {element}": getattr(self, element) for element in ELEMENTS}, + "cost present": self.present_value, + "cost peak annual": ( float(annual["total"].max()) if len(annual) > 0 else 0.0 ), } @@ -564,7 +560,7 @@ def satellite_cost_of(self, kind: Any = None) -> SatelliteCost: return self.satellites if kind is None: raise ValueError("a model of several types of satellites needs a type") - return per_type(self.satellites, kind, "cost") + return _per_type(self.satellites, kind, "cost") def _types(self) -> list[tuple[Any, SatelliteCost]]: """Gets the types of satellites: each type, and its cost.""" @@ -685,8 +681,8 @@ def estimate( never deployed: its development is the cost of the option to deploy them. Launches priced by mass (see `LaunchCost.per_kg`) take the masses of the satellites of the deployment (see - `DeploymentSchedule.plan`), which also limit the satellites of a - launch, or else those of the cost model (`SatelliteCost.mass`). + `DeploymentSchedule.plan`, and `MissionPlan.masses`), which also + limit the satellites of a launch. The costs of a sustained constellation (see `DeploymentSchedule`), such as of an operational program over the period of a study, are @@ -735,11 +731,11 @@ def estimate( history = ( deployment.planned() if isinstance(deployment, Deployment) else deployment ) - masses = {kind: self._mass_of(history, kind) for kind in history.development} + masses = {kind: history.masses.get(kind) for kind in history.development} if self.launch.per_kg > 0 and any(mass is None for mass in masses.values()): raise ValueError( - "launches priced by mass require masses (of the deployment, see " - + "DeploymentSchedule.plan, or of the cost model, see SatelliteCost.mass)" + "launches priced by mass require the masses of the deployment " + + "(see DeploymentSchedule.plan and MissionPlan.masses)" ) # the costs of a sustained constellation are those incurred by the end until = history.end if history.schedule.sustained else math.inf @@ -846,14 +842,6 @@ def _add_production( ) return begun - def _mass_of(self, history: MissionHistory, kind: Any) -> float | None: - """ - Gets the mass of a type of satellite: that of the deployment (see - `DeploymentSchedule.plan`), or else of its cost (if any). - """ - mass = history.masses.get(kind) - return self.satellite_cost_of(kind).mass if mass is None else mass - def _add_launches( self, history: MissionHistory, @@ -915,7 +903,7 @@ def _get_factor( factor = factors[element] if isinstance(factor, Mapping) and kind is None: raise ValueError(f"growth of {element} by type of satellite needs types") - return per_type(factor, kind, f"growth of {element}") + return _per_type(factor, kind, f"growth of {element}") def risk_space(*models: CostModel) -> DesignSpace: diff --git a/src/tatc/tradespace/criteria.py b/src/tatc/tradespace/criteria.py index a04b4dae..5a8f9952 100644 --- a/src/tatc/tradespace/criteria.py +++ b/src/tatc/tradespace/criteria.py @@ -34,13 +34,13 @@ class Requirement: example, `Requirement("sufficient p10", ">=", 80)`, or `Requirement("feasible", ">=", 1)`, which requires every replicate of a design to be feasible (`feasible` is the share of its replicates that - are, see `aggregate`). + are, see `summarize`). A design that does not meet it violates it by the difference between the statistic and the value, relative to a `scale`: by default the magnitude of the value (or 1 if the value is 0), so that the violations of requirements in different units are comparable. Summaries add them (the - `violation` of a design, see `aggregate`), by which the designs that miss + `violation` of a design, see `summarize`), by which the designs that miss requirements are ranked (see `pareto_ranks` and `screen`), and the constraint-aware optimizers of `optimize_optuna` and `optimize_pymoo` keep each as a constraint of its own. @@ -146,7 +146,7 @@ class Across: statistics. A design is judged only if it has feasible results in every group of the results (in each group of the criteria's `by`). Statistics of the feasibility of replicates (such as `feasible`, the share of a - design's replicates that are feasible, see `aggregate`) are not + design's replicates that are feasible, see `summarize`) are not combined: they are over the evaluations of every group together. Combining the statistics of the groups (such as the worst of the means) @@ -184,23 +184,19 @@ def __post_init__(self): object.__setattr__(self, "rules", rules) object.__setattr__(self, "weights", weights) - def weights_of(self, groups: Sequence[Any]) -> np.ndarray: - """ - Gets the weights of the mean of groups, normalized. - - Args: - groups (Sequence[Any]): The groups (values of the column). - Returns: - numpy.ndarray: the weight of each group, which sum to 1 - """ - if self.weights is None: - return np.full(len(groups), 1.0 / max(len(groups), 1)) - missing = [group for group in groups if group not in self.weights] - if missing: - raise ValueError(f"groups of {self.column!r} without weights: {missing}") - weights = np.array([float(self.weights[group]) for group in groups]) - return weights / weights.sum() +def _weights_of(across: Across, groups: Sequence[Any]) -> np.ndarray: + """ + Gets the weights of the mean of groups (values of the column of a rule + across them), normalized to sum to 1. + """ + if across.weights is None: + return np.full(len(groups), 1.0 / max(len(groups), 1)) + missing = [group for group in groups if group not in across.weights] + if missing: + raise ValueError(f"groups of {across.column!r} without weights: {missing}") + weights = np.array([float(across.weights[group]) for group in groups]) + return weights / weights.sum() Tolerance = float | str @@ -252,7 +248,7 @@ class Criteria: requirements=[Requirement("cost p70", "<=", 150)], tolerances={"coverage": 1.0}, ) - summary = aggregate(results, criteria) + summary = summarize(results, criteria) front = summary[summary.pareto] Objectives and requirements name statistics: those of `statistics`, or @@ -263,7 +259,7 @@ class Criteria: Designs are judged by their feasible replicates. The share of a design's replicates that are feasible is the statistic `feasible` (see - `aggregate`), which requirements may name, such as + `summarize`), which requirements may name, such as `Requirement("feasible", ">=", 1)` of designs feasible in every replicate. Designs without a feasible replicate are not judged. @@ -272,8 +268,8 @@ class Criteria: column, or once with criteria `across` it (see `Across`), which combine their statistics across the groups: their worst, or their mean. - The functions that judge designs (`aggregate`, `summarize`, - `pareto_front`, `pareto_ranks`, `hypervolume`, `hypervolume_progress`, + The functions that judge designs (`summarize`, `pareto_front`, + `pareto_ranks`, `hypervolume`, `hypervolume_progress`, `pareto_probability`, `robustness`, `refine`, `confirm`, `screen`, and the searches of `optimize_optuna` and `optimize_pymoo`) take criteria, or a mapping of objectives to their directions, which are criteria of the @@ -286,7 +282,7 @@ class Criteria: by name, of objectives and requirements that are not means of the metrics of their names (a metric given as a string, or a `Utility`, is its mean), and others to compute with them (see - `aggregate`), or a sequence of them, named by their conventional + `summarize`), or a sequence of them, named by their conventional names (see `Statistic.name`, such as `cost p70` of `Quantile("cost", 0.7)`). requirements (Sequence[Requirement]): Requirements on statistics. @@ -309,12 +305,6 @@ class Criteria: tolerances: Mapping[str, Tolerance] = field(default_factory=dict) by: Sequence[str] | str = () across: Across | None = None - tolerance_array: np.ndarray = field( - init=False, repr=False, compare=False, metadata={"fingerprint": False} - ) - """numpy.ndarray: The tolerances of the objectives (zero if not given), in - their order: their values in their units (first row), and their shares - of the values of the objectives (second row).""" def __post_init__(self): if not isinstance(self.objectives, Mapping): @@ -333,13 +323,12 @@ def __post_init__(self): if not isinstance(requirement, Requirement): raise TypeError(f"{requirement!r} is not a Requirement") tolerances = dict(self.tolerances) - tolerance_array = _tolerance_array(objectives, tolerances) + _tolerance_array(objectives, tolerances) # checks them by = tuple(tables.names(self.by)) object.__setattr__(self, "objectives", objectives) object.__setattr__(self, "statistics", statistics) object.__setattr__(self, "requirements", requirements) object.__setattr__(self, "tolerances", tolerances) - object.__setattr__(self, "tolerance_array", tolerance_array) object.__setattr__(self, "by", by) if self.across is not None: if not isinstance(self.across, Across): @@ -351,7 +340,7 @@ def __post_init__(self): unknown = sorted(set(self.across.rules) - set(self.names)) if unknown: raise ValueError(f"rules of names that are not statistics: {unknown}") - _ = self.combiners # checks that each statistic has a worst, if needed + _combiners(self) # checks that each statistic has a worst, if needed @property def names(self) -> list[str]: @@ -367,144 +356,143 @@ def names(self) -> list[str]: ) ) - def statistic(self, name: str) -> Statistic: - """ - Gets the statistic of a name: that of `statistics`, or the mean of - the metric of the name. - - Args: - name (str): The name. - - Returns: - Statistic: the statistic - """ - return self.statistics[name] if name in self.statistics else Mean(name) - @property def metrics(self) -> list[str]: """list[str]: The metrics (columns of the results of a study) of the statistics.""" return sorted( - {column for name in self.names for column in self.statistic(name).columns} + {column for name in self.names for column in _statistic(self, name).columns} ) - @classmethod - def of(cls, criteria: Criteria | Mapping[str, str]) -> Criteria: - """ - Gets criteria given as criteria, or as a mapping of objectives to their - directions (the criteria of the means of the metrics of their names). - - Args: - criteria (Criteria | Mapping[str, str]): The criteria, or the - objectives and their directions (`"min"` or `"max"`). - Returns: - Criteria: the criteria +def _as_criteria(criteria: Criteria | Mapping[str, str]) -> Criteria: + """ + Gets criteria given as criteria, or as a mapping of objectives to their + directions (the criteria of the means of the metrics of their names). - Raises: - TypeError: if the criteria are neither. - """ - if isinstance(criteria, Criteria): - return criteria - if isinstance(criteria, Mapping): - return cls(criteria) - raise TypeError( - "criteria must be Criteria or a mapping of objectives to their directions" + Raises: + TypeError: if the criteria are neither (with a hint, for metrics, + to give them as the `statistics` of `summarize`). + """ + if isinstance(criteria, Criteria): + return criteria + if isinstance(criteria, Mapping): + return Criteria(criteria) + hint = "" + if isinstance(criteria, (str, Sequence)): + hint = ( + ": give the metrics (or statistics) to summarize as `statistics`, " + + f"such as summarize(results, statistics={tables.names(criteria)!r})" ) + raise TypeError( + "criteria must be Criteria or a mapping of objectives to their " + + f"directions, not {criteria!r}{hint}" + ) - @property - def resolved(self) -> dict[str, Statistic]: - """dict[str, Statistic]: The statistic of each name (see `names` and - `statistic`).""" - return {name: self.statistic(name) for name in self.names} - @property - def signs(self) -> np.ndarray: - """numpy.ndarray: The sign of each objective that makes it a cost (to - minimize): 1 for an objective to minimize, and -1 for one to - maximize.""" - return np.array( - [ - 1.0 if direction == "min" else -1.0 - for direction in self.objectives.values() - ] - ) +def _statistic(criteria: Criteria, name: str) -> Statistic: + """ + Gets the statistic of a name of criteria: that of their `statistics`, or + the mean of the metric of the name. + """ + return criteria.statistics[name] if name in criteria.statistics else Mean(name) - def costs(self, values: Mapping[str, Any]) -> np.ndarray: - """ - Gets the objectives as costs (to minimize, see `signs`), from the - values of their statistics (by name, such as the columns of a - summary): maximized objectives are negated. - Args: - values (Mapping[str, Any]): The values of the statistics of - designs, by name. +def _resolved(criteria: Criteria) -> dict[str, Statistic]: + """Gets the statistic of each name of criteria (see `Criteria.names`).""" + return {name: _statistic(criteria, name) for name in criteria.names} - Returns: - numpy.ndarray: the costs (a row per design, and a column per - objective, `NaN` where a value is missing) - """ - columns = [ - np.asarray(values[name], dtype=float) * sign - for name, sign in zip(self.objectives, self.signs) + +def _signs(criteria: Criteria) -> np.ndarray: + """ + Gets the sign of each objective of criteria that makes it a cost (to + minimize): 1 for an objective to minimize, and -1 for one to maximize. + """ + return np.array( + [ + 1.0 if direction == "min" else -1.0 + for direction in criteria.objectives.values() ] - count = len(columns[0]) if columns else 0 - return np.column_stack(columns) if count else np.empty((0, len(columns))) + ) - def violation(self, values: Mapping[str, Any], count: int) -> np.ndarray: - """ - Gets the total violation of the requirements by designs (the sum of - their violations, see `Requirement.violation`), from the values of - their statistics (by name, such as the columns of a summary). - Args: - values (Mapping[str, Any]): The values of the statistics of - designs, by name. - count (int): The number of designs. +def _tolerances(criteria: Criteria) -> np.ndarray: + """ + Gets the tolerances of the objectives of criteria (zero if not given), in + their order: their values in their units (first row), and their shares + of the values of the objectives (second row). + """ + return _tolerance_array(criteria.objectives, criteria.tolerances) - Returns: - numpy.ndarray: the violation of each design (0 if it meets every - requirement, and `NaN` where a statistic of a requirement is) - """ - total = np.zeros(count) - for requirement in self.requirements: - statistic = np.asarray(values[requirement.name], dtype=float) - total = total + requirement.violation(statistic) - return total - @property - def combiners(self) -> dict[str, str]: - """dict[str, str]: How each statistic is combined across the groups of - `across` (see `Across`), by name: by its largest (`"max"`) or smallest - (`"min"`) value, its worst, or by its `"mean"` (empty without - `across`).""" - across = self.across - if across is None: - return {} - worst: dict[str, set[str]] = {} - for name, direction in self.objectives.items(): - worst.setdefault(name, set()).add("max" if direction == "min" else "min") - for requirement in self.requirements: - sense = "min" if requirement.operator in (">=", ">") else "max" - worst.setdefault(requirement.name, set()).add(sense) - combiners = {} - for name in self.names: - rule = across.rules.get(name, across.rule) - if rule == "mean" or (name not in worst and name not in across.rules): - # statistics that are neither objectives nor required (such as - # others to compute with them) have no worst: their means - combiners[name] = "mean" - elif name not in worst: - raise ValueError( - f"statistic {name!r} has no worst across {across.column!r}: it " - + "is neither an objective nor required (combine it by its " - + "mean, see Across)" - ) - elif len(worst[name]) > 1: - raise ValueError( - f"the objective and requirements of statistic {name!r} disagree " - + "on its worst: give it another name (in the statistics) for each" - ) - else: - combiners[name] = next(iter(worst[name])) - return combiners +def _costs(criteria: Criteria, values: Mapping[str, Any]) -> np.ndarray: + """ + Gets the objectives of criteria as costs (to minimize, see `_signs`), + from the values of their statistics (by name, such as the columns of a + summary): maximized objectives are negated. The costs have a row per + design, and a column per objective (`NaN` where a value is missing). + """ + columns = [ + np.asarray(values[name], dtype=float) * sign + for name, sign in zip(criteria.objectives, _signs(criteria)) + ] + count = len(columns[0]) if columns else 0 + return np.column_stack(columns) if count else np.empty((0, len(columns))) + + +def _violation(criteria: Criteria, values: Mapping[str, Any], count: int) -> np.ndarray: + """ + Gets the total violation of the requirements of criteria by `count` + designs (the sum of their violations, see `Requirement.violation`), from + the values of their statistics (by name, such as the columns of a + summary): 0 if a design meets every requirement, and `NaN` where a + statistic of a requirement is. + """ + total = np.zeros(count) + for requirement in criteria.requirements: + statistic = np.asarray(values[requirement.name], dtype=float) + total = total + requirement.violation(statistic) + return total + + +def _combiners(criteria: Criteria) -> dict[str, str]: + """ + Gets how each statistic of criteria is combined across the groups of + their `across` (see `Across`), by name: by its largest (`"max"`) or + smallest (`"min"`) value, its worst, or by its `"mean"` (empty without + `across`). + + Raises: + ValueError: if the worst of a statistic is asked for but it has none, + or its objective and requirements disagree on it. + """ + across = criteria.across + if across is None: + return {} + worst: dict[str, set[str]] = {} + for name, direction in criteria.objectives.items(): + worst.setdefault(name, set()).add("max" if direction == "min" else "min") + for requirement in criteria.requirements: + sense = "min" if requirement.operator in (">=", ">") else "max" + worst.setdefault(requirement.name, set()).add(sense) + combiners = {} + for name in criteria.names: + rule = across.rules.get(name, across.rule) + if rule == "mean" or (name not in worst and name not in across.rules): + # statistics that are neither objectives nor required (such as + # others to compute with them) have no worst: their means + combiners[name] = "mean" + elif name not in worst: + raise ValueError( + f"statistic {name!r} has no worst across {across.column!r}: it " + + "is neither an objective nor required (combine it by its " + + "mean, see Across)" + ) + elif len(worst[name]) > 1: + raise ValueError( + f"the objective and requirements of statistic {name!r} disagree " + + "on its worst: give it another name (in the statistics) for each" + ) + else: + combiners[name] = next(iter(worst[name])) + return combiners diff --git a/src/tatc/tradespace/deployment.py b/src/tatc/tradespace/deployment.py index d6b0632f..9ebf2027 100644 --- a/src/tatc/tradespace/deployment.py +++ b/src/tatc/tradespace/deployment.py @@ -36,7 +36,6 @@ from __future__ import annotations -import math import numbers from collections.abc import Callable, Mapping, Sequence from dataclasses import dataclass, field @@ -49,16 +48,16 @@ from .constellations import layout_of from .events import ( Launch, - PerType, PlannedPlane, Production, _Manifest, - per_type, - per_type_values, + _per_type, + _per_type_values, + _split, ) from .failures import FailureModel, RestorationPolicy from .mission import Capability, Decision, MissionHistory, Phase -from .simulation import _Simulation, simulate_histories +from .simulation import _check_sampling, _Sampler, _Simulation from .values import Values @@ -172,9 +171,12 @@ class Deployment: capability: Capability | None = field(default=None, repr=False, compare=False) """Capability | None: The capability of the satellites, which the rules of stages may read at their decisions (see `Decision.capability`) in - every simulation of the deployment, as the evaluations of an - `ObservationStudy` with a `MissionPlan` give it.""" - _planned: tuple | None = field(default=None, repr=False, compare=False) + every simulation of the deployment (given to `DeploymentSchedule.plan`, + as the evaluations of an `ObservationStudy` with a `MissionPlan` give + it).""" + _planned: MissionHistory | None = field( + default=None, init=False, repr=False, compare=False + ) @property def begin(self) -> float: @@ -257,19 +259,16 @@ def simulate( def planned(self) -> MissionHistory: """ Gets the history of the mission without failures (see `simulate`), - simulated once (for its policy and capability): its deployment, with - the stages that their rules deploy and the spares of its policy, - whose costs a `CostModel` estimates (see `CostModel.estimate`). + simulated once: its deployment, with the stages that their rules + deploy and the spares of its policy, whose costs a `CostModel` + estimates (see `CostModel.estimate`). Returns: MissionHistory: the history """ - key = (self.policy, self.capability) - if self._planned is None or any( - a is not b for a, b in zip(self._planned[0], key) - ): - self._planned = (key, self.simulate()) - return self._planned[1] + if self._planned is None: + self._planned = self.simulate() + return self._planned def simulate_many( self, @@ -286,7 +285,7 @@ def simulate_many( `simulate`), history `k` drawn from the seed and `k`, so that, with common random numbers, the same history of the same replicate draws the same failures in every design. Without a seed, the one history - without failures. + without failures (of one history only). The failures of the histories are stratified by default (`"stratified"`: a Latin hypercube over the histories, in which each @@ -327,22 +326,35 @@ def simulate_many( Returns: list[MissionHistory]: the histories + + Raises: + ValueError: if the histories are fewer than 1 (or more than 1 + without a seed), the sampling is unknown, or a stress is not + positive. """ - if histories < 1: - raise ValueError("histories must be at least 1") + _check_sampling(histories, sampling, stress, launch_stress) if seed is None: + if histories > 1: + raise ValueError( + "histories of failures need a seed: without one, the one " + + "history without failures" + ) return [self.simulate(model, None)] - return simulate_histories( - self, - model or FailureModel(), - seed, - histories=histories, - sampling=sampling, - stress=stress, - launch_stress=launch_stress, - ) + model = model or FailureModel() + launch_stress = stress if launch_stress is None else launch_stress + return [ + _Simulation( + self, + model, + (seed, k), + _Sampler(seed, k, histories) if sampling == "stratified" else None, + stress, + launch_stress, + ).run() + for k in range(histories) + ] - def expected_metrics( + def _expected_metrics( self, model: FailureModel | None = None, seed: int = 0, @@ -357,15 +369,6 @@ def expected_metrics( phases: precise and cheap, as the expected values of control variates (see `summarize_histories`, and the `controls` of `Failures`). - - Args: - model (FailureModel | None): The failures, or `None` for none. - seed (int): The seed of the histories. - histories (int): The number of histories. - sampling (str): The sampling of their failures. - - Returns: - dict[str, float]: the mean of each measure """ simulated = self.simulate_many( model, seed, histories=histories, sampling=sampling @@ -464,9 +467,9 @@ class DeploymentSchedule: """ years: float = 1.0 - design_life: PerType | None = None - development_years: PerType = 0.0 - production_rate: PerType | None = None + design_life: float | Mapping[Any, float] | None = None + development_years: float | Mapping[Any, float] = 0.0 + production_rate: float | Mapping[Any, float] | None = None launch_interval: float = 0.0 launch_capacity: int | None = None launch_mass_capacity: float | Callable[[int, Any], float] | None = None @@ -477,7 +480,8 @@ def __post_init__(self): if self.years <= 0: raise ValueError("years must be positive") if any( - life is not None and life <= 0 for life in per_type_values(self.design_life) + life is not None and life <= 0 + for life in _per_type_values(self.design_life) ): raise ValueError("design_life must be positive") if self.launch_interval < 0: @@ -486,136 +490,12 @@ def __post_init__(self): raise ValueError("launch_capacity must be at least 1") if any( rate is not None and rate <= 0 - for rate in per_type_values(self.production_rate) + for rate in _per_type_values(self.production_rate) ): raise ValueError("production_rate must be positive") - if any(years < 0 for years in per_type_values(self.development_years)): + if any(years < 0 for years in _per_type_values(self.development_years)): raise ValueError("development_years must not be negative") - def design_life_of(self, kind: Any = None) -> float | None: - """ - Gets the design life of a type of satellite. - - Args: - kind (Any): The type of the satellites (see `plan`). - - Returns: - float | None: the design life (years), or `None` if they last - the mission - """ - return per_type(self.design_life, kind, "design life") - - def production_years(self, kind: Any, satellites: int) -> float: - """ - Gets the time to produce satellites of a type on its line. - - Args: - kind (Any): The type of the satellites. - satellites (int): The number of satellites. - - Returns: - float: the years (0 for production that takes no time) - """ - rate = per_type(self.production_rate, kind, "production rate") - return 0.0 if rate is None else satellites / rate - - def mass_capacity_of(self, plane: tuple[int, Any] | None = None) -> float | None: - """ - Gets the most mass (kg) of a launch to a plane, if limited. - - Args: - plane (tuple[int, Any] | None): The index and values of the plane, - for a capacity that is a function of the plane. - - Returns: - float | None: the capacity, or `None` if not limited - """ - capacity = self.launch_mass_capacity - if capacity is None or not callable(capacity): - return capacity - if plane is None: - raise ValueError("a launch capacity of each plane needs the plane") - return float(capacity(*plane)) - - def next_slot(self, booked: Sequence[float], ready: float) -> float: - """ - Gets the earliest time of a launch at or after a time that keeps the - launch interval from launches booked before (as plans and - simulations book every launch: of deployments, replacements, - restorations, and spares). - - Args: - booked (Sequence[float]): The times of the launches booked, in - order. - ready (float): The time when the launch is ready. - - Returns: - float: the time of the launch - """ - interval = self.launch_interval - time = ready - if interval > 0: - for other in booked: - if other - interval < time < other + interval: - time = other + interval - return time - - def per_launch( - self, mass: float | None = None, plane: tuple[int, Any] | None = None - ) -> float: - """ - Gets the most satellites of a launch (to a plane), by the capacity of - launches in number and in mass. - - Args: - mass (float | None): The mass (kg) of each satellite. - plane (tuple[int, Any] | None): The index and values of the plane, - for a capacity in mass that is a function of the plane. - - Returns: - float: the number of satellites (infinite if not limited) - - Raises: - ValueError: if a capacity in mass is not given the mass, or a - satellite exceeds it. - """ - capacity = math.inf if self.launch_capacity is None else self.launch_capacity - mass_capacity = self.mass_capacity_of(plane) - if mass_capacity is not None: - if mass is None: - raise ValueError("a launch capacity in mass requires masses") - fits = math.floor(mass_capacity / mass) - if fits < 1: - raise ValueError("a satellite exceeds the mass capacity of a launch") - capacity = min(capacity, fits) - return capacity - - def split( - self, - satellites: int, - mass: float | None = None, - plane: tuple[int, Any] | None = None, - ) -> list[int]: - """ - Gets the satellites of each launch of a plane: as few launches as - carry them (see `per_launch`, at least one), sharing them evenly. - - Args: - satellites (int): The number of satellites. - mass (float | None): The mass (kg) of each satellite. - plane (tuple[int, Any] | None): The index and values of the plane, - for a capacity in mass that is a function of the plane. - - Returns: - list[int]: the satellites of each launch - """ - capacity = self.per_launch(mass, plane) - count = max(1, math.ceil(satellites / capacity)) if capacity < math.inf else 1 - return [ - satellites // count + (1 if j < satellites % count else 0) - for j in range(count) - ] - def launches_of( self, satellites: int, @@ -623,7 +503,8 @@ def launches_of( plane: tuple[int, Any] | None = None, ) -> int: """ - Gets the launches of a plane of satellites (see `split`). + Gets the launches of a plane of satellites: as few as carry them (by + the capacity of launches in number and in mass, at least one). Args: satellites (int): The number of satellites. @@ -634,7 +515,7 @@ def launches_of( Returns: int: the number of launches """ - return len(self.split(satellites, mass, plane)) + return len(_split(self, satellites, mass, plane)) def plan( self, @@ -642,8 +523,9 @@ def plan( *, kind: Any = None, policy: RestorationPolicy | None = None, - masses: PerType | None = None, + masses: float | Mapping[Any, float] | None = None, stages: Sequence[Stage] = (), + capability: Capability | None = None, ) -> Deployment: """ Plans the deployment of a constellation: the layout (or layouts) of @@ -656,7 +538,8 @@ def plan( produced after the planes (see `RestorationPolicy`). The planes of `stages` are deployed only if (and when) their rules decide to, in a simulation of the mission (see `Stage` and `Deployment.simulate`), and - the others as planned. + the others as planned; their rules may read the `capability` of the + satellites operating at their decisions (see `Decision.capability`). Args: layout (Any): The layout (or layouts) of the satellites, or a @@ -671,6 +554,8 @@ def plan( of launches by mass, see `CostModel.estimate`). stages (Sequence[Stage]): The stages deployed later, if their rules decide to. + capability (Capability | None): The capability of the + satellites, in the order of the planes, if any. Returns: Deployment: the deployment @@ -680,6 +565,7 @@ def plan( the layouts, if no satellites are planned, or if the spares of the policy lack a type of the layouts. """ + # pylint: disable=too-many-arguments,too-many-locals policy = RestorationPolicy() if policy is None else policy stages = tuple(stages) staged = [plane for stage in stages for plane in stage.planes] @@ -690,15 +576,17 @@ def plan( fleets = dict(layout) else: fleets = {kind: layout} - deployment = Deployment(schedule=self, stages=stages, policy=policy) + deployment = Deployment( + schedule=self, stages=stages, policy=policy, capability=capability + ) produced = [] # the planes that are not staged, in their order for name, item in fleets.items(): - developed = float(per_type(self.development_years, name, "development")) + developed = float(_per_type(self.development_years, name, "development")) spares = policy.orbit_spares_of(name) policy.ground_spares_of(name) # (raises if it lacks the type) deployment.development[name] = developed deployment.masses[name] = ( - None if masses is None else per_type(masses, name, "mass") + None if masses is None else _per_type(masses, name, "mass") ) listed = [] for plane in layout_of(item).planes(): diff --git a/src/tatc/tradespace/dominance.py b/src/tatc/tradespace/dominance.py index 3126863f..34e04e6e 100644 --- a/src/tatc/tradespace/dominance.py +++ b/src/tatc/tradespace/dominance.py @@ -92,7 +92,7 @@ def dominated(costs: np.ndarray, tolerances: np.ndarray | None = None) -> np.nda is penalized by the tolerances: no worse in every cost, and better in at least one, by at least its tolerance (absolute, plus a share of the magnitude of the cost of the point it would dominate: the rows of - `tolerances`, see `Criteria.tolerance_array`). + `tolerances`, see `criteria._tolerances`). A point that is dominated with tolerances is also dominated by a point that is efficient without them: the penalty depends only on the point diff --git a/src/tatc/tradespace/events.py b/src/tatc/tradespace/events.py index abf00484..aea33be3 100644 --- a/src/tatc/tradespace/events.py +++ b/src/tatc/tradespace/events.py @@ -18,28 +18,17 @@ from typing import TYPE_CHECKING, Any, NamedTuple if TYPE_CHECKING: - from .deployment import Deployment + from .deployment import Deployment, DeploymentSchedule -PerType = float | Mapping[Any, float] +_PerType = float | Mapping[Any, float] """A value for every type of satellite, or for each (a mapping by type).""" -def per_type(value: Any, kind: Any, name: str) -> Any: +def _per_type(value: Any, kind: Any, name: str) -> Any: """ Gets the value of a type of satellite of a value for every type or a - mapping of each (see `PerType`). - - Args: - value (Any): The value for every type, or a mapping of each type to - its value. - kind (Any): The type of satellite. - name (str): The name of the value, for errors. - - Returns: - Any: the value of the type - - Raises: - ValueError: if the mapping lacks the type. + mapping of each (see `_PerType`), raising a `ValueError` if the mapping + lacks the type (`name` names the value in the error). """ if isinstance(value, Mapping): if kind not in value: @@ -48,19 +37,86 @@ def per_type(value: Any, kind: Any, name: str) -> Any: return value -def per_type_values(value: Any) -> list: +def _per_type_values(value: Any) -> list: """ Gets the values of every type of satellite of a value for every type or a - mapping of each (see `PerType`), such as to validate them. + mapping of each (see `_PerType`), such as to validate them. + """ + return list(value.values()) if isinstance(value, Mapping) else [value] - Args: - value (Any): The value for every type, or a mapping of each type to - its value. - Returns: - list: the values of the mapping, or the value +def _production_years(schedule: DeploymentSchedule, kind: Any, count: int) -> float: """ - return list(value.values()) if isinstance(value, Mapping) else [value] + Gets the time to produce satellites of a type on its line (0 for + production that takes no time). + """ + rate = _per_type(schedule.production_rate, kind, "production rate") + return 0.0 if rate is None else count / rate + + +def _next_slot( + schedule: DeploymentSchedule, booked: Sequence[float], ready: float +) -> float: + """ + Gets the earliest time of a launch at or after a time that keeps the + launch interval from the launches booked before (in order), as plans and + simulations book every launch: of deployments, replacements, + restorations, and spares. + """ + interval = schedule.launch_interval + time = ready + if interval > 0: + for other in booked: + if other - interval < time < other + interval: + time = other + interval + return time + + +def _per_launch( + schedule: DeploymentSchedule, + mass: float | None = None, + plane: tuple[int, Any] | None = None, +) -> float: + """ + Gets the most satellites of a launch (to a plane: its index and values, + for a capacity in mass that is a function of the plane), by the capacity + of launches in number and in mass (of satellites of a mass, kg), infinite + if not limited, raising a `ValueError` if a capacity in mass lacks the + mass (or the plane) or a satellite exceeds it. + """ + capacity = ( + math.inf if schedule.launch_capacity is None else schedule.launch_capacity + ) + mass_capacity = schedule.launch_mass_capacity + if callable(mass_capacity): + if plane is None: + raise ValueError("a launch capacity of each plane needs the plane") + mass_capacity = float(mass_capacity(*plane)) + if mass_capacity is not None: + if mass is None: + raise ValueError("a launch capacity in mass requires masses") + fits = math.floor(mass_capacity / mass) + if fits < 1: + raise ValueError("a satellite exceeds the mass capacity of a launch") + capacity = min(capacity, fits) + return capacity + + +def _split( + schedule: DeploymentSchedule, + satellites: int, + mass: float | None = None, + plane: tuple[int, Any] | None = None, +) -> list[int]: + """ + Gets the satellites of each launch of a plane: as few launches as carry + them (see `_per_launch`, at least one), sharing them evenly. + """ + capacity = _per_launch(schedule, mass, plane) + count = max(1, math.ceil(satellites / capacity)) if capacity < math.inf else 1 + return [ + satellites // count + (1 if j < satellites % count else 0) for j in range(count) + ] class PlannedPlane(NamedTuple): @@ -127,7 +183,7 @@ class _Manifest: plans (see `DeploymentSchedule.plan`) and simulations (of the stages they deploy, and of restorations) share: the production line of each type of satellite, the launches booked (which later ones keep the launch - interval from, see `DeploymentSchedule.next_slot`), and the production + interval from, see `_next_slot`), and the production added. Args: @@ -179,10 +235,10 @@ def plane(self, plane: int) -> tuple[int, Any]: return plane, values[plane] if plane < len(values) else None def capacity(self, plane: int) -> float: - """The most satellites of a launch to a plane (see `per_launch`).""" + """The most satellites of a launch to a plane (see `_per_launch`).""" kind = self.deployment.planes[plane].kind - return self.schedule.per_launch( - self.deployment.masses.get(kind), self.plane(plane) + return _per_launch( + self.schedule, self.deployment.masses.get(kind), self.plane(plane) ) def produce( @@ -193,7 +249,7 @@ def produce( before them), returning when they are ready. """ begin = max(self.lines[kind], earliest) - ready = begin + self.schedule.production_years(kind, count) + ready = begin + _production_years(self.schedule, kind, count) self.lines[kind] = ready self.production.append(Production(kind, begin, ready, count, purpose)) return ready @@ -201,14 +257,14 @@ def produce( def next_slot(self, ready: float) -> float: """ Gets the earliest launch at or after a time that keeps the launch - interval (see `DeploymentSchedule.next_slot`), without booking it. + interval (see `_next_slot`), without booking it. """ - return self.schedule.next_slot(self.booked, ready) + return _next_slot(self.schedule, self.booked, ready) def slot(self, ready: float) -> float: """ Books the earliest launch at or after a time that keeps the launch - interval (see `DeploymentSchedule.next_slot`), returning its time. + interval (see `_next_slot`), returning its time. """ time = self.next_slot(ready) bisect.insort(self.booked, time) @@ -218,12 +274,15 @@ def launch(self, plane: int, ready: float) -> list[Launch]: """ Launches the satellites of a plane (and its spares in orbit) when they are ready: in as many launches as they need (see - `DeploymentSchedule.split`), each at the next launch slot. + `_split`), each at the next launch slot. """ kind, size, spares = self.deployment.planes[plane] launches, first = [], 0 - for satellites in self.schedule.split( - size + spares, self.deployment.masses.get(kind), self.plane(plane) + for satellites in _split( + self.schedule, + size + spares, + self.deployment.masses.get(kind), + self.plane(plane), ): launches.append(Launch(self.slot(ready), plane, kind, first, satellites)) first += satellites @@ -271,7 +330,7 @@ def replace(self, launches: Sequence[Launch], end: float) -> list[Launch]: queue: list = [] order = itertools.count() for launch in launches: - life = schedule.design_life_of(launch.kind) + life = _per_type(schedule.design_life, launch.kind, "design life") built = self.deployment.planes[launch.plane].satellites count = min(launch.first + launch.satellites, built) - launch.first if life is not None and count > 0: @@ -281,10 +340,10 @@ def replace(self, launches: Sequence[Launch], end: float) -> list[Launch]: while queue: need, _, generation, item = heapq.heappop(queue) plane, kind, first, count, life = item - begin = need - schedule.production_years(kind, count) + begin = need - _production_years(schedule, kind, count) time = math.inf if need < end - 1e-9: - time = schedule.next_slot(self.booked, need) + time = _next_slot(schedule, self.booked, need) if time < end - 1e-9: bisect.insort(self.booked, time) replacements.append( @@ -295,7 +354,7 @@ def replace(self, launches: Sequence[Launch], end: float) -> list[Launch]: schedule.sustained and begin < end - + float(per_type(schedule.development_years, kind, "development")) + + float(_per_type(schedule.development_years, kind, "development")) - 1e-9 ): following = need + life # produced after the end, not launched diff --git a/src/tatc/tradespace/expectations.py b/src/tatc/tradespace/expectations.py index 99434d08..b132a262 100644 --- a/src/tatc/tradespace/expectations.py +++ b/src/tatc/tradespace/expectations.py @@ -16,7 +16,7 @@ import numpy as np from .failures import FailureModel -from .mission import PHASE_COLUMNS, Capability +from .mission import _PHASE_COLUMNS, Capability, _position_names if TYPE_CHECKING: from .deployment import Deployment @@ -181,8 +181,8 @@ def exact_expectations( of their design life) over its failures: the expectation of the mean of each metric over the phases of the mission (` mission`, as `summarize_phases` gives for one history) and of its availability - (`availability`), exactly rather than from samples of histories (as - `Deployment.expected_metrics` estimates the measures of missions). + (`availability`), exactly rather than from samples of histories (see + `Deployment.simulate_many`). Without restoration, the satellites fail independently (but for the satellites of a launch, which a failed launch loses together), so that @@ -238,7 +238,7 @@ def exact_expectations( "exact expectations need a deployment whose policy does not restore " + "failures (RestorationPolicy(restore=False)): simulate histories instead" ) - names = list(capability.position_names(deployment.planes).values()) + names = list(_position_names(deployment.planes, capability.names).values()) count, groups = _launch_groups(deployment, model, _times(deployment, steps)) levels = _missing_levels(groups, count, tolerance) if _sets(count, levels) > max_sets: @@ -270,7 +270,7 @@ def exact_expectations( for weight, members in weights: # the metrics of the set, as of a phase in which it operates for name, value in capability(names[k] for k in members).items(): - if name in PHASE_COLUMNS: + if name in _PHASE_COLUMNS: continue totals[f"{name} mission"] = totals.get( f"{name} mission", 0.0 diff --git a/src/tatc/tradespace/failures.py b/src/tatc/tradespace/failures.py index a1365cc7..ae117c72 100644 --- a/src/tatc/tradespace/failures.py +++ b/src/tatc/tradespace/failures.py @@ -27,7 +27,7 @@ import numpy as np -from .events import per_type, per_type_values +from .events import _per_type, _per_type_values from .nodes import Categorical from .space import DesignSpace from .values import Scope @@ -349,7 +349,7 @@ def life_of(self, kind: Any) -> Lifetime | None: Returns: Lifetime | None: the life, or `None` if it does not fail """ - return per_type(self.life, kind, "life") + return _per_type(self.life, kind, "life") @dataclass(frozen=True) @@ -423,7 +423,7 @@ def __post_init__(self): if getattr(self, name) < 0: raise ValueError(f"{name} must not be negative") for name in ("orbit_spares", "ground_spares"): - if any(value < 0 for value in per_type_values(getattr(self, name))): + if any(value < 0 for value in _per_type_values(getattr(self, name))): raise ValueError(f"{name} must not be negative") def orbit_spares_of(self, kind: Any) -> int: @@ -436,7 +436,7 @@ def orbit_spares_of(self, kind: Any) -> int: Returns: int: the number of spares """ - return int(per_type(self.orbit_spares, kind, "orbit spares")) + return int(_per_type(self.orbit_spares, kind, "orbit spares")) def ground_spares_of(self, kind: Any) -> int: """ @@ -448,7 +448,7 @@ def ground_spares_of(self, kind: Any) -> int: Returns: int: the number of spares """ - return int(per_type(self.ground_spares, kind, "ground spares")) + return int(_per_type(self.ground_spares, kind, "ground spares")) def _spares_restore(d: Scope) -> bool: @@ -484,12 +484,12 @@ def policy_space( deployment = SCHEDULE.plan(d.layout, policy=policy) history = deployment.simulate(FAILURE_MODEL, d.failure_seed) - as an `ObservationStudy` does with a mission plan that names the - fragment (see `MissionPlan.policy`), whose values configure the default - policy (give the fields of a base policy to the fragment, or a function - of the design that configures it):: + as an `ObservationStudy` with a mission plan does for a fragment named + `policy` (see `MissionPlan.policy`), whose values configure the default + policy (give the fields of a base policy to the fragment, or give the + plan a function of the design that configures it):: - PLAN = MissionPlan(SCHEDULE, COST_MODEL, policy="policy") + space = space.extend(policy=policy_space(orbit_spares=Integer(0, 1))) Spares without restoration would never be used, so a constraint excludes them (unless `require_restoration` is `False`). diff --git a/src/tatc/tradespace/fingerprint.py b/src/tatc/tradespace/fingerprint.py index 3f86cdd5..79266fdd 100644 --- a/src/tatc/tradespace/fingerprint.py +++ b/src/tatc/tradespace/fingerprint.py @@ -341,36 +341,12 @@ def describe(self, value: Any, depth: int = 0, seen: set | None = None) -> Any: self.note(type(value).__module__) return _type(value) - # the rules of descriptions (see `_RULES`) + def noted(self, module: Any, description: Any) -> Any: + """Notes a module (see `note`), and gives a description.""" + self.note(module) + return description - def plain(self, value: Any, depth: int, seen: set) -> Any: - """Describes `None`, a boolean, an integer, or a string as itself.""" - del depth, seen - return value - - def number(self, value: float, depth: int, seen: set) -> str: - """Describes a float by its representation (exactly).""" - del depth, seen - return repr(value) - - def scalar(self, value: np.generic, depth: int, seen: set) -> Any: - """Describes a numpy scalar as Python's.""" - return self.describe(value.item(), depth, seen) - - def binary(self, value: bytes, depth: int, seen: set) -> str: - """Describes bytes by their hash.""" - del depth, seen - return hashlib.sha1(value).hexdigest() - - def moment(self, value: date | time, depth: int, seen: set) -> str: - """Describes a date or time by its ISO format.""" - del depth, seen - return value.isoformat() - - def duration(self, value: timedelta, depth: int, seen: set) -> dict: - """Describes a duration by its seconds.""" - del depth, seen - return {"timedelta": value.total_seconds()} + # the rules of descriptions that are more than one expression (see `_RULES`) def dataclass(self, value: Any, depth: int, seen: set) -> dict: """ @@ -405,33 +381,6 @@ def fingerprinted(self, value: Any, depth: int, seen: set) -> dict: "fingerprint": self.describe(value.__fingerprint__(), depth + 1, seen), } - def model(self, value: BaseModel, depth: int, seen: set) -> dict: - """Describes a pydantic model by its data.""" - del depth, seen - self.note(type(value).__module__) - return {**_type(value), **value.model_dump(mode="json")} - - def array(self, value: np.ndarray, depth: int, seen: set) -> dict: - """Describes an array by its type, shape, and a hash of its data.""" - del depth, seen - if value.dtype == object: - return {**_type(value), "shape": list(value.shape)} - return { - "array": str(value.dtype), - "shape": list(value.shape), - "data": hashlib.sha1(np.ascontiguousarray(value).tobytes()).hexdigest(), - } - - def frame(self, value: pd.DataFrame | pd.Series, depth: int, seen: set) -> dict: - """Describes a data frame or series (see `_frame`).""" - del depth, seen - return _frame(value) - - def geometry(self, value: shapely.Geometry, depth: int, seen: set) -> dict: - """Describes a geometry by a hash of its well-known binary.""" - del depth, seen - return {**_type(value), "data": hashlib.sha1(value.wkb).hexdigest()} - def sequence(self, value: list | tuple, depth: int, seen: set) -> Any: """Describes a list or tuple by its items (or its length, if long).""" if len(value) > _MAX_ITEMS: @@ -623,18 +572,6 @@ def klass(self, cls: type, depth: int, seen: set) -> dict: "members": members, } - def named(self, value: Any, depth: int, seen: set) -> dict: - """Describes a class or built-in function by its name.""" - del depth, seen - self.note(getattr(value, "__module__", None)) - return {"name": _name(value)} - - def module(self, value: types.ModuleType, depth: int, seen: set) -> dict: - """Describes a module by its name.""" - del depth, seen - self.note(value.__name__) - return {"module": value.__name__} - def instance(self, value: Any, depth: int, seen: set) -> dict: """ Describes an object of a class of the study's own: its class (see @@ -663,20 +600,50 @@ def instance(self, value: Any, depth: int, seen: set) -> dict: } +def _array(value: np.ndarray) -> dict: + """Describes an array by its type, shape, and a hash of its data.""" + if value.dtype == object: + return {**_type(value), "shape": list(value.shape)} + return { + "array": str(value.dtype), + "shape": list(value.shape), + "data": hashlib.sha1(np.ascontiguousarray(value).tobytes()).hexdigest(), + } + + _RULES: tuple[tuple[tuple[type, ...] | Callable[[Any], bool], Callable], ...] = ( - # by content - ((type(None), bool, int, str), _Describer.plain), - ((float,), _Describer.number), - ((np.generic,), _Describer.scalar), - ((bytes,), _Describer.binary), - ((datetime, date, time), _Describer.moment), - ((timedelta,), _Describer.duration), + # by content: plain values as themselves (floats by their representation, + # exactly, and numpy scalars as Python's), bytes by their hash, dates and + # times by their ISO format, and durations by their seconds + ((type(None), bool, int, str), lambda _, value, *__: value), + ((float,), lambda _, value, *__: repr(value)), + ( + (np.generic,), + lambda describer, value, *rest: describer.describe(value.item(), *rest), + ), + ((bytes,), lambda _, value, *__: hashlib.sha1(value).hexdigest()), + ((datetime, date, time), lambda _, value, *__: value.isoformat()), + ((timedelta,), lambda _, value, *__: {"timedelta": value.total_seconds()}), (_has_fingerprint, _Describer.fingerprinted), (_is_dataclass, _Describer.dataclass), - ((BaseModel,), _Describer.model), - ((np.ndarray,), _Describer.array), - ((pd.DataFrame, pd.Series), _Describer.frame), - ((shapely.Geometry,), _Describer.geometry), + # pydantic models by their data, arrays and data frames by hashes of their + # data (see `_array` and `_frame`), and geometries by a hash of their + # well-known binary + ( + (BaseModel,), + lambda describer, value, *_: describer.noted( + type(value).__module__, {**_type(value), **value.model_dump(mode="json")} + ), + ), + ((np.ndarray,), lambda _, value, *__: _array(value)), + ((pd.DataFrame, pd.Series), lambda _, value, *__: _frame(value)), + ( + (shapely.Geometry,), + lambda _, value, *__: { + **_type(value), + "data": hashlib.sha1(value.wkb).hexdigest(), + }, + ), ((list, tuple), _Describer.sequence), ((set, frozenset), _Describer.collection), ((dict,), _Describer.mapping), @@ -689,9 +656,19 @@ def instance(self, value: Any, depth: int, seen: set) -> dict: ((types.FunctionType,), _Describer.function), (_is_own_class, _Describer.klass), (_is_own_object, _Describer.instance), - # by name - ((types.BuiltinFunctionType, type), _Describer.named), - ((types.ModuleType,), _Describer.module), + # by name: classes and built-in functions, and modules + ( + (types.BuiltinFunctionType, type), + lambda describer, value, *_: describer.noted( + getattr(value, "__module__", None), {"name": _name(value)} + ), + ), + ( + (types.ModuleType,), + lambda describer, value, *_: describer.noted( + value.__name__, {"module": value.__name__} + ), + ), ) """What values are described by (see the module): the first rule whose test (types, or a predicate) a value matches describes it, and a value that @@ -1070,25 +1047,7 @@ def _without_code(description: Any) -> Any: return description -def _with_other_code(definition: dict, others: Mapping[Any, dict | None]) -> list: - """ - Gets the keys of other definitions (such as of the contexts of a store - or the folders of a cache) that have the same values as a definition but - other code (of its functions, of TAT-C, or of Python, see - `_without_code`), in their order: results of the same study with other - code, which are not reused, as opposed to those of other studies (such - as variants of other settings), which share stores and caches freely. - Definitions that are `None` (unknown) are of no study. - """ - values = _without_code(definition.get("values", {})) - return [ - key - for key, other in others.items() - if other is not None and _without_code(other.get("values", {})) == values - ] - - -def find_stale( +def _find_stale( definition: dict, others: Mapping[Any, dict | None], count: Callable[[Any], int], @@ -1098,22 +1057,18 @@ def find_stale( other code (of its functions, of TAT-C, or of Python), which are not reused: the keys of the other definitions (such as the contexts of a store, or the folders of a cache) that have the same values but other - code (see `_with_other_code`), in their order, with their numbers of - results. The results of other studies (such as variants of other - settings) are not stale, as studies share stores and caches freely. - - Args: - definition (dict): The definition (see `get_definition`). - others (Mapping[Any, dict | None]): The other definitions, by key - (`None` for a definition that is unknown, of no study). - count (Callable[[Any], int]): A function of a key that counts its - results (0 for a definition kept without results). - - Returns: - dict[Any, int]: the numbers of results, by key (in the order of - `others`) + code (see `_without_code`), in their order, with their numbers of + results (by `count`, a function of a key, 0 for a definition kept + without results). The results of other studies (such as variants of + other settings) are not stale, as studies share stores and caches + freely, and definitions that are `None` (unknown) are of no study. """ - return {key: count(key) for key in _with_other_code(definition, others)} + values = _without_code(definition.get("values", {})) + return { + key: count(key) + for key, other in others.items() + if other is not None and _without_code(other.get("values", {})) == values + } def warn_stale( @@ -1126,13 +1081,13 @@ def warn_stale( ) -> bool: """ Warns (at the user's call) that the results of the same study (or - function) as a definition with other code (see `find_stale`) are not + function) as a definition with other code (see `_find_stale`) are not reused, if any are found, with the differences of the latest of their definitions from the definition (see `compare_definitions`). Args: found (Mapping[Any, int]): The numbers of stale results, by the key - of their definition, the latest first (see `find_stale`). + of their definition, the latest first (see `_find_stale`). definition (dict): The definition (see `get_definition`). definition_of (Callable[[Any], dict | None]): A function of a key that gives its definition. diff --git a/src/tatc/tradespace/histories.py b/src/tatc/tradespace/histories.py index 47375e76..d3079178 100644 --- a/src/tatc/tradespace/histories.py +++ b/src/tatc/tradespace/histories.py @@ -21,6 +21,7 @@ from .criteria import Requirement from .mission import Capability, MissionHistory, summarize_phases +from .statistics import Probability, Quantile, StandardDeviation, Statistic def evaluate_histories( @@ -75,42 +76,42 @@ def evaluate_histories( def summarize_histories( histories: pd.DataFrame, *, - quantiles: Mapping[str, float | Sequence[float]] | None = None, - requirements: Sequence[Requirement] = (), + statistics: Sequence[Statistic] = (), controls: Mapping[str, float] | None = None, - spread: bool = False, ) -> dict[str, float]: """ Summarizes histories of a mission (see `evaluate_histories`) as the metrics of an evaluation: the mean of each column over the histories - (by the same name), quantiles of columns over the histories (` - histories p`, such as `"accurate mission histories p10"` for the - 0.1 quantile, the risk of the mission), and the share of the histories - that meet each requirement on a column (`P( ) - histories`, such as `"P(accurate time <= 4) histories"`). The statistics - over the histories of a replicate (quantiles, probabilities, and - standard deviations) end in `histories`, apart from the statistics over - the replicates (such as a `Quantile` or a `Probability`, see - `Criteria`), which are taken of these. + (by the same name), and `statistics` of columns over the histories, as + those of `Criteria` are over the replicates, named after the histories: + a `Quantile` (` histories + p`, such as `"accurate mission histories p10"` for the 0.1 + quantile, the risk of the mission), a `Probability` (`P( + ) histories`, such as `"P(accurate time <= 4) + histories"`, the share of the histories that meet it), or a + `StandardDeviation` (` histories std`, as `allocate_histories` + needs of a pilot study). The statistics over the histories of a + replicate end in `histories`, apart from the statistics over the + replicates (see `Criteria`), which are taken of these. Missing values (`NaN`, such as the `restoration years` of a history without restorations) are left out of the statistics of their column, but infinite ones are not: the mean of the time until a history meets a requirement (` time`, see `evaluate_histories`) is infinite if a history never meets it, and its quantiles, or the share of the - histories that meet it by a time (a requirement on it, such as - `Requirement("accurate time", "<=", 4)`), summarize it. + histories that meet it by a time (such as `Probability("accurate time", + "<=", 4)`), summarize it. With `controls`, the means are estimated with control variates: columns whose expected values are known (such as the `availability` of a - mission, which simulations alone estimate precisely and cheaply, see - `Deployment.expected_metrics`), and which vary with the other columns - from history to history. The mean of each other column is corrected by - the deviation of the controls' means from their expected values, times - the regression of the column on the controls over the histories, - which removes the share of its variance that the controls explain (a - share of `rho ** 2` for a correlation `rho`): fewer histories give the - same precision. The quantiles and probabilities are not corrected. + mission, which simulations alone estimate precisely and cheaply), and + which vary with the other columns from history to history. The mean of + each other column is corrected by the deviation of the controls' means + from their expected values, times the regression of the column on the + controls over the histories, which removes the share of its variance + that the controls explain (a share of `rho ** 2` for a correlation + `rho`): fewer histories give the same precision. The other statistics + are not corrected. Histories of stressed failures (see `Deployment.simulate_many`) are weighted by their likelihood ratios (`weight`), for every statistic, and @@ -118,34 +119,33 @@ def summarize_histories( the sum of the weights over the sum of their squares) measures how much a few weights dominate. - The quantiles and probabilities are over the histories of a replicate, - whose statistics over the replicates (such as their mean, see - `aggregate`) combine the risk of the mission with the uncertainty of the - replicates' other parameters (such as their targets). + The statistics are over the histories of a replicate, whose statistics + over the replicates (such as their mean, see `summarize`) combine the + risk of the mission with the uncertainty of the replicates' other + parameters (such as their targets). Args: histories (pandas.DataFrame): A row per history. - quantiles (Mapping | None): The quantiles of columns, by column. - requirements (Sequence[Requirement]): Requirements on columns. + statistics (Sequence[Statistic]): Statistics of columns over the + histories: `Quantile`, `Probability`, or `StandardDeviation`. controls (Mapping[str, float] | None): The expected values of columns that are control variates, if any. - spread (bool): `True` to add the standard deviation of each column - over the histories (` histories std`), as for - `allocate_histories`. Returns: dict[str, float]: the summary Raises: - ValueError: if a quantile or requirement is of a column that the - histories do not have. + TypeError: if a statistic is not one of these. + ValueError: if a statistic is of a column that the histories do not + have. """ + statistics = _history_statistics(statistics) numeric = histories.select_dtypes("number") - named = [*(quantiles or {}), *(requirement.name for requirement in requirements)] + named = [statistic.column for statistic in statistics] unknown = sorted(set(named) - set(numeric.columns)) if unknown: raise ValueError( - "quantiles or requirements of columns that the histories do not have: " + "statistics of columns that the histories do not have: " + f"{unknown} (they have {sorted(numeric.columns)})" ) weights = np.ones(len(numeric)) @@ -159,31 +159,76 @@ def summarize_histories( summary["effective histories"] = float(weights.sum() ** 2 / np.sum(weights**2)) if controls: summary.update(_controlled_means(numeric, controls, weights)) - if spread: - for column in numeric.columns: - values = numeric[column].to_numpy(dtype=float) - known = np.isfinite(values) - mean = _weighted_mean(values, weights) - variance = _weighted_mean((values - mean) ** 2, weights) - count = known.sum() - summary[f"{column} histories std"] = ( - float(np.sqrt(variance * count / (count - 1))) - if count > 1 - else math.nan - ) - for column, values in (quantiles or {}).items(): - for q in [values] if isinstance(values, (int, float)) else values: - summary[f"{column} histories p{100 * q:g}"] = _weighted_quantile( - numeric[column].to_numpy(dtype=float), weights, q - ) - for requirement in requirements: - met = requirement.met(histories[requirement.name].to_numpy(dtype=float)) - summary[f"P({requirement}) histories"] = float( - np.sum(weights * met) / np.sum(weights) + for statistic in statistics: + values = numeric[statistic.column].to_numpy(dtype=float) + summary[_history_name(statistic)] = _weighted_statistic( + statistic, values, weights ) return summary +_HISTORY_STATISTICS = (Quantile, Probability, StandardDeviation) +"""The statistics of columns over histories (see `summarize_histories`).""" + + +def _history_statistics(statistics: Sequence[Statistic]) -> tuple[Statistic, ...]: + """ + Gets statistics over histories (see `summarize_histories`), raising a + `TypeError` if one is not a statistic of a column of a kind that + summarizes histories. + """ + if isinstance(statistics, Statistic): + statistics = [statistics] + statistics = tuple(statistics) + for statistic in statistics: + if type(statistic) not in _HISTORY_STATISTICS or not isinstance( + statistic.column, str + ): + raise TypeError( + "statistics over histories are a Quantile, Probability, or " + + f"StandardDeviation of a column, not {statistic!r}" + ) + return statistics + + +def _history_name(statistic: Statistic) -> str: + """ + Gets the name of a statistic of a column over the histories of a + mission (see `summarize_histories`): ` histories p` of a + `Quantile`, `P( ) histories` of a + `Probability`, and ` histories std` of a `StandardDeviation`. + """ + if isinstance(statistic, Quantile): + return f"{statistic.column} histories p{100 * statistic.q:g}" + if isinstance(statistic, Probability): + return f"{statistic.name} histories" + return f"{statistic.column} histories std" + + +def _weighted_statistic( + statistic: Statistic, values: np.ndarray, weights: np.ndarray +) -> float: + """ + Computes a statistic over histories (see `summarize_histories`) of their + values, by their weights, leaving out missing values (`NaN`). + """ + if isinstance(statistic, Quantile): + return _weighted_quantile(values, weights, statistic.q) + known = ~np.isnan(values) + if isinstance(statistic, Probability): + if not known.any() or weights[known].sum() <= 0: + return math.nan + requirement = Requirement( + statistic.column, statistic.operator, statistic.threshold + ) + met = requirement.met(values[known]) + return float(np.sum(weights[known] * met) / np.sum(weights[known])) + mean = _weighted_mean(values, weights) + variance = _weighted_mean((values - mean) ** 2, weights) + count = known.sum() + return float(np.sqrt(variance * count / (count - 1))) if count > 1 else math.nan + + def _weighted_mean(values: np.ndarray, weights: np.ndarray) -> float: """ The weighted mean of the known values (not `NaN`, but infinite ones), @@ -266,9 +311,10 @@ def allocate_histories( (each a sample of its uncertain parameters other than failures, such as its targets, whose observations are expensive to compute) and histories of the failures of its mission in each replicate (cheap, with a - `PhaseCache`), from a pilot study: the records of its replicates (see - `summarize_histories`, with `spread`), each the mean (``) and - standard deviation (` histories std`) of a metric over `histories` + `PhaseCache`), from a pilot study: the records of its replicates (with + the statistic `StandardDeviation(metric)` of `Failures`, see + `summarize_histories`), each the mean (``) and standard + deviation (` histories std`) of a metric over `histories` histories. The variance of a replicate's mean is `between + within / K` for `K` diff --git a/src/tatc/tradespace/mission.py b/src/tatc/tradespace/mission.py index 2bee82ff..98cf009b 100644 --- a/src/tatc/tradespace/mission.py +++ b/src/tatc/tradespace/mission.py @@ -27,7 +27,7 @@ from .criteria import Requirement from .events import Launch, PlannedPlane, Production from .memory import Forgetful -from .references import given_design +from .references import _given_design if TYPE_CHECKING: from .cost import CostEstimate, CostModel @@ -56,7 +56,7 @@ def duration(self) -> float: return self.end - self.start -PHASE_COLUMNS = ("start", "end", "duration", "satellites") +_PHASE_COLUMNS = ("start", "end", "duration", "satellites") """The columns of the evaluations of phases that are not metrics (see `evaluate_phases`).""" @@ -87,16 +87,12 @@ def _position_names( return dict(zip(positions, names)) -def _satellite_keys( - satellites: Sequence[Satellite | str] | Mapping[str, str], -) -> dict[str, str]: +def _satellite_keys(satellites: Sequence[Satellite | str]) -> dict[str, str]: """ Gets the keys of satellites in a cache of their metrics (see `PhaseCache`), by name: of their content (see `get_satellite_key`), or - their names, if given as names (or the keys given, by name). + their names, if given as names. """ - if isinstance(satellites, Mapping): - return dict(satellites) return { name: get_satellite_key(s) if isinstance(s, Satellite) else name for name, s in zip(_names(satellites), satellites) @@ -433,7 +429,7 @@ def evaluate_phases( pandas.DataFrame: a row per phase: its `start`, `end`, `duration`, number of `satellites`, and metrics """ - given = given_design(metric, design) + given = _given_design(metric, design) return _evaluate_phases(phases, observations, lambda subset, _: given(subset())) @@ -455,14 +451,15 @@ def summarize_phases( phases (pandas.DataFrame): The metrics of each phase (see `evaluate_phases`). metrics (Sequence[str] | None): The metrics, or `None` for every - column other than those of the phases (see `PHASE_COLUMNS`). + column other than those of the phases (`start`, `end`, + `duration`, and `satellites`). requirements (Sequence[Requirement]): Requirements on metrics. Returns: dict[str, float]: the summary, as metrics of an evaluation """ if metrics is None: - metrics = [column for column in phases.columns if column not in PHASE_COLUMNS] + metrics = [column for column in phases.columns if column not in _PHASE_COLUMNS] weights = phases["duration"].to_numpy(dtype=float) summary = {} for name in metrics: @@ -524,12 +521,13 @@ class PhaseCache(Forgetful): a replicate's sample of targets and the analysis period) and by the content of the satellites that operate (see `get_satellite_key`), so that the phases of missions with the same satellites (of other histories, - policies, or designs, in the same replicate) are evaluated once. + policies, or designs, in the same replicate) are evaluated once. The + capabilities of the satellites of missions share it (see `Capability`). The metric must depend only on the observations (of the one window of the observations, see `evaluate_phases`), not on the names of the satellites. A metric with a parameter named `design` is given the design - of the mission (see `evaluate`), on which it must depend only through + of the mission (see `Capability`), on which it must depend only through what the context identifies (such as a scenario). Copies sent to the parallel workers of a study start with an empty memory, which the evaluations of a chunk share (consecutive evaluations of the same @@ -550,51 +548,7 @@ def __init__(self, metric: Callable[..., Mapping[str, float]]): """int: The phases evaluated.""" self._memory: dict = {} - def evaluate( - self, - phases: Sequence[Phase], - satellites: Sequence[Satellite | str] | Mapping[str, str], - observations: pd.DataFrame, - *, - context: Any = None, - design: Any = None, - ) -> pd.DataFrame: - """ - Evaluates the phases of a mission (see `evaluate_phases`), taking - the metrics of the satellites of a phase from the cache if they are - in it. - - Args: - phases (Sequence[Phase]): The phases. - satellites (Sequence[Satellite | str] | Mapping[str, str]): The - satellites, which key the cache by their content (or by - their names, if given as names, or by the keys given of their - names, see `get_satellite_key`). - observations (pandas.DataFrame): The observations of every - satellite, with their names (`satellite`). - context (Any): A hashable identifier of the observations (such - as the seed of their targets and their period). - design (Design | None): The (realized) design of the mission, - for a metric with a parameter named `design`. - - Returns: - pandas.DataFrame: a row per phase: its `start`, `end`, - `duration`, number of `satellites`, and metrics - """ - keys = _satellite_keys(satellites) - - def cached(subset: Callable[[], pd.DataFrame], names: frozenset) -> dict: - del subset # the cache filters the observations, if needed - return self.metrics_of( - {name: keys[name] for name in names}, - observations, - context=context, - design=design, - ) - - return _evaluate_phases(phases, observations, cached) - - def metrics_of( + def _metrics_of( self, keys: Mapping[str, str], observations: pd.DataFrame, @@ -603,31 +557,17 @@ def metrics_of( design: Any = None, ) -> dict[str, float]: """ - Gets the metrics of satellites that operate together, from the cache - if they are in it (keyed by the context and the keys of the - satellites), or else of their observations (and kept). - - Args: - keys (Mapping[str, str]): The keys of the satellites in the cache - (such as of their content, see `get_satellite_key`), by - their names in the observations. - observations (pandas.DataFrame): The observations of every - satellite, with their names (`satellite`), filtered to those - of the satellites only if they are not in the cache. - context (Any): A hashable identifier of the observations (such - as the seed of their targets and their period). - design (Design | None): The (realized) design of the mission, - for a metric with a parameter named `design`. - - Returns: - dict[str, float]: the metrics + Gets the metrics of satellites that operate together, by their keys + in the cache (by their names in the observations), from the cache if + they are in it (keyed by the context and the keys), or else of their + observations (and kept), given the design if the metric takes one. """ key = (context, frozenset(keys.values())) if key in self._memory: self.hits += 1 else: self.misses += 1 - metric = given_design(self.metric, design) + metric = _given_design(self.metric, design) self._memory[key] = dict(metric(_subset(observations, frozenset(keys)))) return dict(self._memory[key]) @@ -714,22 +654,17 @@ def evaluate(self, phases: Sequence[Phase]) -> pd.DataFrame: Evaluates the phases of a mission of the satellites (see `evaluate_phases`): the metrics of the satellites that operate in each, each set evaluated once (by the cache, with the context and the - design, see `PhaseCache.evaluate`). + design, see `PhaseCache`). Args: - phases (Sequence[Phase]): The phases. + phases (Sequence[Phase]): The phases (of the satellites, see + `MissionHistory.phases`). Returns: pandas.DataFrame: a row per phase: its `start`, `end`, `duration`, number of `satellites`, and metrics """ - return self._cache.evaluate( - phases, - self._keys, - self.observations, - context=self.context, - design=self.design, - ) + return _evaluate_phases(phases, self.observations, lambda _, names: self(names)) def __call__(self, names: Iterable[str]) -> dict[str, float]: """ @@ -745,50 +680,25 @@ def __call__(self, names: Iterable[str]) -> dict[str, float]: unknown = names - set(self.names) if unknown: raise ValueError(f"satellites that are not given: {sorted(unknown)}") - return self._cache.metrics_of( + # pylint: disable-next=protected-access + return self._cache._metrics_of( {name: self._keys[name] for name in names}, self.observations, context=self.context, design=self.design, ) - def position_names( - self, planes: Sequence[PlannedPlane] - ) -> dict[tuple[int, int], str]: - """ - Gets the name of the satellite at each position of each plane of a - deployment (see `Deployment.planes`), without spares, as the phases of - its missions name them (see `MissionHistory.phases`). - - Args: - planes (Sequence[PlannedPlane]): The planes. - - Returns: - dict[tuple[int, int], str]: the names, by plane and position - - Raises: - ValueError: if the planes have other numbers of satellites. - """ - return _position_names(planes, self.names) - - def at( + def _at( self, planes: Sequence[PlannedPlane], positions: Iterable[tuple[int, int]], ) -> dict[str, float]: """ - Gets the metrics of the satellites at positions of the planes of a - deployment (see `Deployment.planes`). - - Args: - planes (Sequence[PlannedPlane]): The planes. - positions (Iterable[tuple[int, int]]): The plane and position of - each satellite. - - Returns: - dict[str, float]: the metrics + Gets the metrics of the satellites at positions (by plane and + position) of the planes of a deployment (see `Deployment.planes`), as + the phases of its missions name them (see `MissionHistory.phases`). """ - named = self.position_names(planes) + named = _position_names(planes, self.names) return self(named[plane, position] for plane, position in positions) @@ -799,12 +709,12 @@ class Mission: observation study plans it (see `MissionPlan.plan_mission` and `ObservationStudy.mission_of`): its planned deployment (with the policy that restores the failures of its satellites, and the capability of its - satellites), its cost model and growth, and the capability of its - satellites (their observations, and the cache of the metrics of their - phases), from which follow the metrics of its phases (`phases`, of the - history of the mission without failures, see `Deployment.planned`), its - cost estimate (`estimate`), and the histories of its failures - (`histories`, with `failures`). + satellites: their observations, and the cache of the metrics of their + phases), its cost model and growth, the failures of its satellites, and + the study's requirements on its phases, from which follow the metrics of + its phases (`phases`, of the history of the mission without failures, + see `Deployment.planned`), its cost estimate (`estimate`), and the + histories of its failures (`histories`). """ design: Design @@ -818,10 +728,19 @@ class Mission: drawn), if any.""" growth: Any """Any: The growth of the costs (see `CostModel.estimate`).""" - capability: Capability - """Capability: The capability of the satellites.""" failures: Failures | None = None """Failures | None: The failures of the satellites, if any.""" + requirements: tuple[Requirement, ...] | None = None + """tuple[Requirement, ...] | None: The requirements on the metrics of + its phases, whose times its evaluation and histories give (see + `summarize_phases`), or `None` if the phases of a mission without + failures are not summarized (with failures, they always are).""" + + @property + def capability(self) -> Capability: + """Capability: The capability of the satellites (that of the + deployment).""" + return self.deployment.capability def phases(self) -> pd.DataFrame: """ @@ -856,10 +775,10 @@ def estimate(self) -> CostEstimate: def histories(self) -> pd.DataFrame: """ Gets the histories of the failures of the mission, which the - evaluation of a study with failures summarizes (see - `Failures.evaluate` and `evaluate_histories`): a row per history, - with the mean of each metric over its phases, the measures of its - mission, and its costs. + evaluation of a study with failures summarizes (see `Failures` and + `evaluate_histories`): a row per history, with the mean of each + metric over its phases, the times until they meet the requirements + (see `requirements`), the measures of its mission, and its costs. Returns: pandas.DataFrame: a row per history @@ -869,45 +788,31 @@ def histories(self) -> pd.DataFrame: """ if self.failures is None: raise ValueError("the study has no failures") - return self.failures.evaluate(self) + # pylint: disable-next=protected-access + return self.failures._evaluate(self) - def metrics(self) -> dict[str, float]: + def _record(self) -> dict[str, float]: """ - Gets the metrics of the planned mission that its evaluation records: + Gets the metrics of the mission that its evaluation records: `deployed` (see `Deployment.deployed`, of the history without - failures), `stages deployed` (of a staged deployment, the stages that - its rules deploy without failures), and, without failures, its costs - (see `estimate` and `CostEstimate.metrics`). - - Returns: - dict[str, float]: the metrics + failures) and `stages deployed` (of a staged deployment, the stages + that its rules deploy without failures); and the summary of the + histories of its failures (see `Failures`), or else its costs (see + `estimate` and `CostEstimate.metrics`) and, with requirements (or + none, `()`), the summary of its phases (see `summarize_phases`). """ planned = self.deployment.planned() record = {"deployed": planned.deployed} if self.deployment.stages: record["stages deployed"] = planned.metrics()["stages deployed"] - if self.cost_model is not None and self.failures is None: + if self.failures is not None: + # pylint: disable-next=protected-access + record.update(self.failures._summarize(self)) + return record + if self.cost_model is not None: record.update(self.estimate().metrics()) + if self.requirements is not None: + record.update( + summarize_phases(self.phases(), requirements=self.requirements) + ) return record - - def summarize( - self, phases: Sequence[Requirement] | None = None - ) -> dict[str, float]: - """ - Summarizes the mission as metrics of its evaluation: the histories of - its failures (see `Failures.summarize`), or else, with requirements - on its phases (or none, `()`), the phases of the mission without - failures (see `phases` and `summarize_phases`). - - Args: - phases (Sequence[Requirement] | None): The requirements on the - phases, or `None` not to summarize them. - - Returns: - dict[str, float]: the summary (empty without failures or phases) - """ - if self.failures is not None: - return self.failures.summarize(self) - if phases is not None: - return summarize_phases(self.phases(), requirements=phases) - return {} diff --git a/src/tatc/tradespace/nodes.py b/src/tatc/tradespace/nodes.py index 5d0c9da3..85c9a05e 100644 --- a/src/tatc/tradespace/nodes.py +++ b/src/tatc/tradespace/nodes.py @@ -94,21 +94,6 @@ def from_unit(self, u: float) -> Any: ) return float(self.low + u * (self.high - self.low)) - def to_unit(self, value: Any) -> float: - """ - Maps a value of the domain to [0, 1] (the center of a level's part), - the inverse of `from_unit`. - """ - if self.levels is not None: - return (self.levels.index(value) + 0.5) / len(self.levels) - if self.high == self.low: - return 0.5 - if self.log: - return (math.log(value) - math.log(self.low)) / ( - math.log(self.high) - math.log(self.low) - ) - return (value - self.low) / (self.high - self.low) - def suggest(self, trial: Any, name: str) -> Any: """ Suggests a value of the domain with an Optuna trial. Optuna requires diff --git a/src/tatc/tradespace/observations.py b/src/tatc/tradespace/observations.py index aec56896..6e3c884a 100644 --- a/src/tatc/tradespace/observations.py +++ b/src/tatc/tradespace/observations.py @@ -31,7 +31,7 @@ from .memory import Forgetful from .mission import Capability, Mission, PhaseCache from .plans import Failures, MissionPlan -from .references import Reference, given_design, takes_design, value_of +from .references import Reference, _given_design, _takes_design, value_of from .space import Design, DesignSpace from .study import Study, _Case @@ -85,15 +85,10 @@ def __init__( object.__setattr__(self, "seed", seed) object.__setattr__(self, "_memory", {}) - def seed_of(self, design: Design | None) -> Any: + def _seed_of(self, design: Design | None) -> Any: """ - Gets the seed of the targets of a design (`None` if they are fixed). - - Args: - design (Design | None): The (realized) design. - - Returns: - Any: the seed + Gets the seed of the targets of a (realized) design (`None` if they + are fixed). """ if self.seed is None: return None @@ -103,20 +98,14 @@ def seed_of(self, design: Design | None) -> Any: ) return value_of(design, self.seed) - def of(self, design: Design | None = None) -> pd.DataFrame: + def _of(self, design: Design | None = None) -> pd.DataFrame: """ - Gets the targets of a design (of its replicate). - - Args: - design (Design | None): The (realized) design, or `None` for fixed - targets. - - Returns: - pandas.DataFrame: the targets + Gets the targets of a (realized) design, of its replicate (or `None` + for fixed targets, see `ObservationStudy.targets_of`). """ if isinstance(self.source, pd.DataFrame): return self.source - return self._of_seed(self.seed_of(design)) + return self._of_seed(self._seed_of(design)) def _of_seed(self, seed: Any) -> pd.DataFrame: """Gets the targets of a seed (generated, or kept in memory).""" @@ -208,13 +197,6 @@ def __post_init__(self): object.__setattr__(self, "targets", Targets(self.targets)) object.__setattr__(self, "_caches", {}) - @property - def end(self) -> datetime: - """datetime: The end of the period (of a fixed start, see `end_of`).""" - if not isinstance(self.start, datetime): - raise ValueError("the start is a value of the design: see end_of") - return self.start + self.duration - def start_of(self, design: Design | None = None) -> datetime: """ Gets the start of the period of a design (of its replicate). @@ -248,34 +230,24 @@ def end_of(self, design: Design | None = None) -> datetime: """ return self.start_of(design) + self.duration - def context_of(self, design: Design | None = None) -> tuple: + def _context_of(self, design: Design | None = None) -> tuple: """ - Gets a key of the observations of a design: the seed of its targets - and the period (such as the context of a `PhaseCache`). - - Args: - design (Design | None): The (realized) design. - - Returns: - tuple: the key + Gets a key of the observations of a (realized) design: the seed of + its targets and the period (such as the context of a `PhaseCache`). """ - return (self.targets.seed_of(design), self.start_of(design), self.duration) + # pylint: disable-next=protected-access + return (self.targets._seed_of(design), self.start_of(design), self.duration) - def cache_of(self, design: Design | None = None) -> SatelliteCache: + def _cache_of(self, design: Design | None = None) -> SatelliteCache: """ - Gets the cache of the observations of the targets of a design (by the - seed of its targets and its period), in a namespace of the targets' - seed and the period (and the `namespace`), so that the cache warns of - results of the analysis with other code (see `SatelliteCache`) of the - same targets and period. - - Args: - design (Design | None): The (realized) design. - - Returns: - SatelliteCache: the cache + Gets the cache of the observations of the targets of a (realized) + design (by the seed of its targets and its period), in a namespace + of the targets' seed and the period (and the `namespace`), so that + the cache warns of results of the analysis with other code (see + `SatelliteCache`) of the same targets and period. """ - return self._cache(self.targets.seed_of(design), self.start_of(design)) + # pylint: disable-next=protected-access + return self._cache(self.targets._seed_of(design), self.start_of(design)) def _namespace(self, seed: Any, start: datetime) -> str: """Gets the namespace of the cache of the targets of a seed and a start.""" @@ -287,8 +259,8 @@ def _namespace(self, seed: Any, start: datetime) -> str: def _cache(self, seed: Any, start: datetime) -> SatelliteCache: """ Gets the cache of the observations of the targets of a seed from a - start (see `cache_of`), with the seed and start as the context of its - namespace (see `SatelliteCache.contexts`), from which `prune` finds + start (see `_cache_of`), with the seed and start as the context of its + namespace (see `SatelliteCache._contexts`), from which `prune` finds it. Its function generates the targets only if it computes a result. """ if (seed, start) not in self._caches: @@ -324,7 +296,8 @@ def prune(self) -> int: if self.directory is None: return 0 removed = 0 - for namespace, context in SatelliteCache.contexts(self.directory).items(): + contexts = SatelliteCache._contexts # pylint: disable=protected-access + for namespace, context in contexts(self.directory).items(): if not isinstance(context, (tuple, list)) or len(context) != 2: continue # of other caches seed, start = context @@ -350,7 +323,7 @@ def __call__( Returns: pandas.DataFrame: the observations (empty without satellites) """ - return self.cache_of(design)(satellites) + return self._cache_of(design)(satellites) def _hashable(value: Any) -> Any: @@ -377,8 +350,9 @@ class _Evaluation: """ The evaluation of the satellites of a design (see `ObservationStudy`): the metrics of the observations of every satellite and, with a plan, of - the mission (see `Mission`): its deployment and costs, and either the - phases of its deployment or the histories of its failures. + the mission (see `Mission`): its deployment and costs, and the phases of + its deployment or the histories of its failures (with the requirements + on their phases). """ observations: Observations @@ -401,31 +375,32 @@ def __call__(self, satellites: Sequence[Satellite], design: Design) -> dict: if layout is not None: record["planes"] = count_planes(layout) if self.plan is None: - record.update(given_design(self.metrics, design)(observations)) + record.update(_given_design(self.metrics, design)(observations)) return record mission = self.mission_from(satellites, observations, design) - record.update(mission.metrics()) if "satellite" in observations.columns: # those of every satellite by the capability, whose cache the # phases of the mission (such as its last) share capability = mission.capability record.update(capability(capability.names)) else: - record.update(given_design(self.metrics, design)(observations)) - record.update(mission.summarize(self.phases)) + record.update(_given_design(self.metrics, design)(observations)) + # pylint: disable-next=protected-access + record.update(mission._record()) return record def context_of(self, design: Design) -> tuple: """ Gets the context of the metrics of the phases of a design in the - cache (see `PhaseCache`): its observations (see - `Observations.context_of`) and, if the metrics are given the design, + cache (see `PhaseCache`): its observations (the seed of its targets + and its period) and, if the metrics are given the design, its scenario and the values of its uncertain parameters, which such metrics may read (designs of a replicate share them, with common random numbers). """ - context = self.observations.context_of(design) - if takes_design(self.metrics): + # pylint: disable-next=protected-access + context = self.observations._context_of(design) + if _takes_design(self.metrics): context = (context, design.scenario, _uncertain_values(design)) return context @@ -448,7 +423,11 @@ def mission_from( design=design, ) return self.plan.plan_mission( - design, value_of(design, self.layout), capability, self.failures + design, + value_of(design, self.layout), + capability, + failures=self.failures, + requirements=self.phases, ) @@ -457,10 +436,8 @@ class ObservationStudy(Study): A trade study of the observations of constellations: each replicate of a design builds its satellites, observes the targets of the replicate (see `Observations`), and records the metrics of the observations and, with a - mission `plan`, of the mission (see `Mission`): its deployment and costs, - and either the `phases` of its deployment (see `evaluate_phases` and - `summarize_phases`, with requirements, if any) or the histories of its - `failures` (see `Failures`):: + mission `plan`, of its mission (see `Mission`): its deployment and costs, + the `phases` of its deployment, and the histories of its `failures`:: study = ObservationStudy( space, @@ -471,64 +448,20 @@ class ObservationStudy(Study): phases=True, ) - Its results have the columns of every study (see `Study.run`) and: - - * `satellites`, and `planes` (with a `layout`, by default the value - `layout` of a design space that has one): their numbers. - * the metrics of the observations of every satellite (by their names). - * with a plan: `deployed`, the years from the start of development to the - last launch of the first generation of the satellites in the history - of the mission without failures (see `Deployment.planned`), including - the stages that their rules deploy then (see `Stage`), infinite if the - deployment does not finish within the mission; with stages, `stages - deployed`, the number of stages that their rules deploy then (with - failures, the mean over the histories); and, with a cost model, the - costs of the deployment (`cost`, `cost development`, and so on, see - `CostEstimate.metrics`; with failures, the means of the costs of the - histories). - * with phases: ` mission`, the mean of each metric over the - phases of the mission as its satellites are deployed (from the first - launch), and ` time`, the time at which a phase first meets - each requirement on a metric (see `summarize_phases`), in years from - the start of development, as `deployed` (infinite if none does). - * with failures: the means over the histories of the failures of each - replicate of ` mission` (the mean over the phases of each - history), of the measures of the missions (`availability`, `failures`, - `restorations`, and so on, see `MissionHistory.metrics`), of their - costs, and of the times of each history that meets the requirements of - the `phases` of the failures (` time`); and the `quantiles` of - columns over the histories (` histories p`) and the - shares of the histories that meet `requirements` (`P() - histories`), see `summarize_histories`. - - Statistics over the replicates of these columns (see `Criteria`) judge - designs: such as the mean over the replicates of `accurate mission`, or a - quantile over them of `cost histories p70`. + Its results have the columns of every study (see `Study.run`), the + numbers of `satellites` and `planes`, the metrics of every satellite, + and those of the mission (see `Mission`): `deployed`, `stages deployed`, + and costs (see `CostEstimate.metrics`), the summary of its phases (see + `summarize_phases`), and that of the histories of its failures (see + `summarize_histories`), whose means replace the costs without failures. The metrics are a function of the observations of any set of satellites - (which may be empty), so that failures and phases evaluate them for the - satellites that operate in each phase, over the one window of the - observations (see `evaluate_phases` for what this assumes, and - `Observations` for an epoch drawn for each replicate). A metrics function - with a parameter named `design` is also given the realized design, such - as for the window of an epoch drawn for each replicate or for values that - scenarios set (see `Study`): the metrics of phases are cached by the - satellites that operate, the targets and window of the observations, the - scenario, and the values of the uncertain parameters of the replicate - (which the designs of a replicate share, with common random numbers), so - such a function must depend on the design only through these. As a - `Study`, it runs as any other (see `Study.run`), such as in parallel, - with a store of its records, and in searches (such as `refine`, - `confirm`, `screen`, and the optimizers). Its fingerprint (see - `Study.fingerprint`) describes its parts, including targets by their - content (or the recipe of generated targets), so that its store needs no - namespace but for what the fingerprint cannot see. - - The parts of the evaluation of a design are also given apart, for - analyses other than its metrics: its satellites, targets, and - observations (`satellites_of`, `targets_of`, and `observations_of`), and - its mission (`mission_of`): its planned deployment, the metrics of its - phases, its cost estimate, and the histories of its failures. + (which may be empty), evaluated for those of each phase over the one + window of the observations (see `evaluate_phases`). One that takes the + realized `design` must depend on it only through the scenario and the + uncertain values of the replicate, by which phases are cached. The parts + of an evaluation are also given apart (`satellites_of`, `targets_of`, + `observations_of`, and `mission_of`). Args: space (DesignSpace): The design space. @@ -539,23 +472,23 @@ class ObservationStudy(Study): design, if it has a parameter named `design`) that gives their metrics (a mapping). layout (Reference | None): The value of the design that is its - layout (see `value_of` and `layout_of`), which a `plan` - requires, or `None` for the value `layout` of a design space - that has one (and none otherwise). + layout (see `layout_of`), which a `plan` requires, or `None` for + the value `layout` of a design space that has one. plan (MissionPlan | None): The deployment, policy, and costs, if any. failures (Failures | None): The failures, if any, which require a plan. phases (Sequence[Requirement] | bool | None): `True` (or requirements - on the metrics) to summarize the phases of the deployment, which - require a plan (with failures, the requirements on the phases of - the histories are those of `Failures`). + on the metrics) to summarize the phases of the mission, which + require a plan: of the deployment, or of each history of the + failures (whose phases are always summarized). **options (Any): The settings of the study (see `Study`), such as `replicates`, `seed`, `n_jobs`, and `store`. Raises: + TypeError: if the requirements on phases are not Requirements. ValueError: if failures or phases are given without a plan, a plan - without a layout, failures with phases, or the quantiles or - requirements of failures are of costs without a cost model. + without a layout, or statistics of failures of costs without a + cost model. """ def __init__( @@ -574,28 +507,22 @@ def __init__( # the requirements on the phases, if they are summarized phases = None if phases is None or phases is False else phases phases = () if phases is True else None if phases is None else tuple(phases) + if phases is not None and not all(isinstance(r, Requirement) for r in phases): + raise TypeError("the requirements on phases are Requirements") if layout is None and "layout" in space.children: layout = "layout" if plan is None and (failures is not None or phases is not None): raise ValueError("failures and phases require a mission plan") if plan is not None and layout is None: raise ValueError("a mission plan requires a layout") - if failures is not None and phases is not None: - raise ValueError( - "failures summarize the phases of their histories: give the " - + "requirements on them to Failures (phases), not to the study" - ) if failures is not None and plan.cost_model is None: - named = [ - *(failures.quantiles or {}), - *(r.name for r in failures.requirements), - ] + named = [statistic.column for statistic in failures.statistics] costs = [ name for name in named if name == "cost" or name.startswith("cost ") ] if costs: raise ValueError( - f"quantiles or requirements of costs without a cost model: {costs}" + f"statistics of failures of costs without a cost model: {costs}" ) self.observations, self.metrics, self.layout = observations, metrics, layout self.plan, self.failures, self.phases = plan, failures, phases @@ -626,7 +553,7 @@ def _prepare( # process, so that it warns of results of other code here (once, see # `SatelliteCache`), rather than in a worker process realized = self._realized(design, replicate, shift, case) - self.observations.cache_of(realized) + self.observations._cache_of(realized) # pylint: disable=protected-access def satellites_of( self, design: Design, replicate: int = 0, scenario: str | None = None @@ -658,7 +585,9 @@ def targets_of( Returns: pandas.DataFrame: the targets """ - return self.observations.targets.of(self.realize(design, replicate, scenario)) + realized = self.realize(design, replicate, scenario) + # pylint: disable-next=protected-access + return self.observations.targets._of(realized) def observations_of( self, design: Design, replicate: int = 0, scenario: str | None = None @@ -691,7 +620,8 @@ def mission_of( metrics of its phases (`Mission.phases`, which a study with `phases` summarizes), its cost estimate (`Mission.estimate`, the costs of a study without failures), and the histories of its failures - (`Mission.histories`, a row per history, which a study with failures + (`Mission.histories`, a row per history, with the times until they + meet the study's requirements on phases, which a study with failures summarizes). The design is realized, built, and observed once for all of them. diff --git a/src/tatc/tradespace/optimization.py b/src/tatc/tradespace/optimization.py index 4d7699e1..3e7db5c4 100644 --- a/src/tatc/tradespace/optimization.py +++ b/src/tatc/tradespace/optimization.py @@ -1,8 +1,8 @@ """ Searches of design spaces for Pareto-efficient designs with optimizers: -Optuna (which searches the hierarchical design space directly, see -`DesignSpace.suggest`) and pymoo (which searches the unit hypercube that -encodes it, see `DesignSpace.decode`). Both are optional dependencies. +Optuna (which searches the hierarchical design space directly, suggesting +each decision in turn) and pymoo (which searches the unit hypercube that +encodes it, a dimension per decision). Both are optional dependencies. Designs are judged by criteria (see `Criteria`, without `by`): their objectives are statistics over their replicates of the metrics of their @@ -23,7 +23,7 @@ is (see `Study`). Designs are judged by their feasible replicates, as summaries judge them -(see `aggregate`): a design infeasible in some replicates is judged by the +(see `summarize`): a design infeasible in some replicates is judged by the others (a requirement on `feasible`, the share of its replicates that are feasible, such as `Requirement("feasible", ">=", 1)`, rejects it), and a design without a feasible replicate is infeasible, which the optimizers' @@ -47,10 +47,10 @@ import numpy as np import pandas as pd -from .criteria import Criteria, Requirement +from .criteria import Criteria, Requirement, _as_criteria, _signs from .space import Design, Infeasible from .study import Study -from .summary import aggregate +from .summary import _summarize from .tables import FEASIBLE, check_records, efficient_keys @@ -70,18 +70,18 @@ class Search: results: pd.DataFrame """pandas.DataFrame: The results of every evaluation (see `Study.run`).""" - criteria: Criteria - """Criteria: The criteria of the search.""" - summary: pd.DataFrame = field(default_factory=pd.DataFrame) + summary: pd.DataFrame """pandas.DataFrame: A row per design that the search found feasible (with a feasible replicate, in every scenario with criteria `across` scenarios, as designs are judged by their feasible replicates, see - `aggregate`): the summary of the criteria over its replicates, with + `summarize`): the summary of the criteria over its replicates, with whether it is efficient among these designs (`pareto`, with the tolerances of the criteria).""" - designs: list[Design] = field(default_factory=list) + designs: list[Design] """list[Design]: The efficient designs that the search found (`pareto` of `summary`), for the next step.""" + criteria: Criteria + """Criteria: The criteria of the search.""" evaluated: list[Design] = field(default_factory=list) """list[Design]: The designs evaluated, in the order of their evaluation.""" state: Any = None @@ -94,7 +94,7 @@ class Evaluations: The evaluations of designs for a search: the objectives of each design (by its key), the violations of its requirements, and the records of the study's evaluations. Designs are judged by their feasible replicates (see - `aggregate`), and a design without a feasible replicate is infeasible. + `summarize`), and a design without a feasible replicate is infeasible. Args: study (Study): The study that evaluates designs. @@ -104,7 +104,7 @@ class Evaluations: """ def __init__(self, study: Study, criteria: Criteria | Mapping[str, str]): - self.study, self.criteria = study, Criteria.of(criteria) + self.study, self.criteria = study, _as_criteria(criteria) if self.criteria.by: raise ValueError( "searches need one record per evaluation: give criteria without `by`" @@ -162,7 +162,7 @@ def evaluate(self, designs: list[Design]) -> list[tuple[float, ...] | None]: def _run(self, designs: list[Design]) -> None: """ Evaluates designs, recording their objectives and violations (of - their summary, see `aggregate`). + their summary, see `summarize`). """ self.designs.update((design.key, design) for design in designs) records = self.study.run(designs) @@ -182,7 +182,7 @@ def _run(self, designs: list[Design]) -> None: ) check_records(records, keys, hint, self.criteria.metrics) self._checked = self._checked or bool(records[FEASIBLE].any()) - summary = aggregate(records, self.criteria, design_columns=[]) + summary = _summarize(records, self.criteria, design_values=False) summary = summary.set_index("design") shares = records.groupby("design")[FEASIBLE].mean() for design in designs: @@ -212,7 +212,7 @@ def search(self, state: Any) -> Search: Search: the search """ results = self.results - summary = aggregate(results, self.criteria) + summary = _summarize(results, self.criteria) return Search( results=results, criteria=self.criteria, @@ -247,8 +247,8 @@ def worst(self) -> list[float]: def optimize_optuna( study: Study, criteria: Criteria | Mapping[str, str], - n_trials: int, *, + n_trials: int = 100, seed: int | None = 0, sampler: Any = None, optuna_study: Any = None, @@ -258,13 +258,13 @@ def optimize_optuna( ) -> Search: """ Searches a study's design space with Optuna: each trial suggests a design - (see `DesignSpace.suggest`) and is told the objectives of the criteria: + (each of its decisions in turn) and is told the objectives of the criteria: statistics (such as means) of its metrics over its replicates. With `constraints`, each trial records the violation of the constraints of its design (`trial.set_constraint`, under the name `"feasibility"`): 0 for a design with feasible replicates (by which it is judged, see - `aggregate`), the amount by which it violates a constraint of the design + `summarize`), the amount by which it violates a constraint of the design space (see `DesignSpace`), or, for a design without a feasible replicate, the share of its evaluations that the study finds infeasible (see `Evaluations.infeasibility`). Optuna's constraint-aware samplers (such @@ -373,7 +373,7 @@ def infeasible(trial: Any, violation: float) -> None: for _ in range(size): trial = optuna_study.ask() try: - design = study.space.suggest(trial) + design = study.space._suggest(trial) # pylint: disable=protected-access except Infeasible as error: trial.set_user_attr("error", str(error)) infeasible(trial, error.violation) @@ -418,8 +418,8 @@ def _constraint_names(requirements: Sequence[Requirement]) -> list[str]: def make_pymoo_problem(study: Study, criteria: Criteria | Mapping[str, str]) -> Any: """ Makes a pymoo problem of a study's design space: its variables are the - unit hypercube that encodes the design space (see `DesignSpace.decode` - and `DesignSpace.unit_paths`), its objectives are minimized (maximized + unit hypercube that encodes the design space (a dimension per decision, + whose levels divide it equally), its objectives are minimized (maximized objectives are negated), and its constraint (`G <= 0`) is violated by designs that violate a constraint of the design space (by the amount of the violation, see `DesignSpace`) or that have no feasible replicate (by @@ -461,14 +461,16 @@ def make_pymoo_problem(study: Study, criteria: Criteria | Mapping[str, str]) -> evaluations = Evaluations(study, criteria) n_requirements = len(evaluations.criteria.requirements) - signs = evaluations.criteria.signs - n_var = len(study.space.unit_paths()) + signs = _signs(evaluations.criteria) + space = study.space + decode = space._decode # pylint: disable=protected-access + n_var = len(space._unit_paths()) # pylint: disable=protected-access def key_of(individual: Any) -> str | None: """The key of the design of a proposal, or `None` if it violates a constraint of the design space.""" try: - return study.space.decode(individual.X).key + return decode(individual.X).key except Infeasible: return None @@ -513,7 +515,7 @@ def _evaluate(self, x, out, *args, **kwargs): violation = np.ones(len(np.atleast_2d(x))) for i, row in enumerate(np.atleast_2d(x)): try: - designs.append(study.space.decode(row)) + designs.append(decode(row)) except Infeasible as error: designs.append(None) violation[i] = max(error.violation, 1e-9) @@ -593,9 +595,9 @@ def _update(self, algorithm: Any) -> float: def optimize_pymoo( study: Study, criteria: Criteria | Mapping[str, str], + *, algorithm: Any = None, termination: Any = ("n_gen", 10), - *, seed: int | None = 0, distinct: bool = True, max_designs: int | None = None, diff --git a/src/tatc/tradespace/pareto.py b/src/tatc/tradespace/pareto.py index 3846e3d7..bf5250d9 100644 --- a/src/tatc/tradespace/pareto.py +++ b/src/tatc/tradespace/pareto.py @@ -4,7 +4,7 @@ designs of a search as it proceeds). Designs are judged by criteria (see `Criteria`): objectives (columns of a -data frame, such as the statistics of a summary of a study, see `aggregate`) +data frame, such as the statistics of a summary of a study, see `summarize`) to minimize or maximize, requirements that efficient designs meet, the tolerances of the objectives, and the groups in which designs are judged separately. A mapping of objectives to their directions (`"min"` or @@ -12,7 +12,7 @@ objective (`NaN`, such as a statistic of a metric that none of its feasible replicates gives) is not efficient, and dominates no other. The probability that a design is efficient, given the uncertainty of its replicates, is that -of `pareto_probability` (of the summaries of studies, see `aggregate`). +of `pareto_probability` (of the summaries of studies, see `summarize`). @author: Paul T. Grogan """ @@ -24,21 +24,28 @@ import numpy as np import pandas as pd -from .criteria import Criteria +from .criteria import ( + Criteria, + _as_criteria, + _costs, + _signs, + _tolerances, + _violation, +) from .dominance import dominated, efficient -from .summary import aggregate +from .summary import _summarize from .tables import check_summary, groups def _get_costs(frame: pd.DataFrame, criteria: Criteria) -> np.ndarray: """ Gets the objectives of criteria of a data frame (of their columns) as - costs (to minimize, see `Criteria.costs`). + costs (to minimize, see `Criteria._costs`). """ missing = [column for column in criteria.objectives if column not in frame] if missing: raise ValueError(f"no columns of the objectives {missing}") - return criteria.costs(frame) + return _costs(criteria, frame) def _get_violation(frame: pd.DataFrame, criteria: Criteria) -> np.ndarray: @@ -50,10 +57,10 @@ def _get_violation(frame: pd.DataFrame, criteria: Criteria) -> np.ndarray: missing = [r.name for r in criteria.requirements if r.name not in frame.columns] if missing: raise ValueError( - f"no columns of the statistics {missing} of requirements: aggregate " - + "the results with the criteria (see aggregate)" + f"no columns of the statistics {missing} of requirements: summarize " + + "the results with the criteria (see summarize)" ) - violation = criteria.violation(frame, len(frame)) + violation = _violation(criteria, frame, len(frame)) return np.where(np.isnan(violation), np.inf, violation) @@ -62,14 +69,14 @@ def pareto_front( ) -> pd.Series: """ Finds the Pareto-efficient (non-dominated) rows of a summary of designs - (a row per design, such as of `aggregate`, not the results of a study, + (a row per design, such as of `summarize`, not the results of a study, which have a row per replicate): those that meet the requirements of the criteria (by the columns of their statistics) and that no other row that meets them dominates, being no worse in every objective and better in at least one, in each group of the criteria's `by`. Rows with the same objectives are all efficient if any is, and a row with a missing objective (`NaN`) is not. Summaries of criteria give - whether each design is efficient already (`pareto`, see `aggregate`). + whether each design is efficient already (`pareto`, see `summarize`). With a tolerance of an objective (see `Criteria`), a row dominates another only if it would still dominate it if it were worse by the @@ -94,14 +101,14 @@ def pareto_front( ValueError: if the summary has several rows of a design (in a group of the criteria's `by`), as the results of a study do. """ - criteria = Criteria.of(criteria) + criteria = _as_criteria(criteria) check_summary(summary, criteria.by) front = np.zeros(len(summary), dtype=bool) for _, positions in groups(summary, criteria.by): group = summary.iloc[positions] meets = _get_violation(group, criteria) == 0 costs = _get_costs(group, criteria) - front[positions] = efficient(costs, meets, criteria.tolerance_array) + front[positions] = efficient(costs, meets, _tolerances(criteria)) return pd.Series(front, index=summary.index, name="pareto") @@ -130,9 +137,9 @@ def pareto_ranks( ValueError: if the summary has several rows of a design (in a group of the criteria's `by`), as the results of a study do. """ - criteria = Criteria.of(criteria) + criteria = _as_criteria(criteria) check_summary(summary, criteria.by) - tolerances = criteria.tolerance_array + tolerances = _tolerances(criteria) ranks = np.full(len(summary), -1, dtype=int) for _, positions in groups(summary, criteria.by): group = summary.iloc[positions] @@ -219,7 +226,7 @@ def hypervolume( results of a study do (see `hypervolume_progress` for those of a search). """ - criteria = Criteria.of(criteria) + criteria = _as_criteria(criteria) if criteria.by: raise ValueError( "a hypervolume is of the rows of one group: give criteria without `by`" @@ -230,7 +237,7 @@ def hypervolume( reference = [reference[column] for column in objectives] if len(reference) != len(objectives): raise ValueError("the reference point needs a value for each objective") - bound = criteria.signs * np.asarray(reference, dtype=float) + bound = _signs(criteria) * np.asarray(reference, dtype=float) if len(summary) == 0: return 0.0 summary = summary[_get_violation(summary, criteria) == 0] @@ -251,7 +258,7 @@ def hypervolume_progress( optimizer, see `optimize_optuna`) as it proceeds: of the first designs evaluated (in the order of their first records in the results of the search), judged by their statistics over their replicates (see - `aggregate`), in steps of `step` designs (and of all of them). + `summarize`), in steps of `step` designs (and of all of them). Args: results (pandas.DataFrame): The results of the search (see @@ -267,8 +274,9 @@ def hypervolume_progress( """ if step < 1: raise ValueError("step must be at least 1") - criteria = Criteria.of(criteria) - summary = aggregate(results, criteria).set_index("design") + criteria = _as_criteria(criteria) + summary = _summarize(results, criteria, design_values=False) + summary = summary.set_index("design") order = results["design"].drop_duplicates().tolist() counts = list(range(step, len(order) + 1, step)) if order and (not counts or counts[-1] != len(order)): diff --git a/src/tatc/tradespace/plans.py b/src/tatc/tradespace/plans.py index 66e447d6..63f0586e 100644 --- a/src/tatc/tradespace/plans.py +++ b/src/tatc/tradespace/plans.py @@ -15,7 +15,8 @@ from __future__ import annotations import dataclasses -from collections.abc import Callable, Mapping, Sequence +import numbers +from collections.abc import Mapping, Sequence from typing import Any import numpy as np @@ -26,12 +27,44 @@ from .deployment import DeploymentSchedule, Stage from .expectations import ExactExpectationsError, exact_expectations from .failures import FailureModel, RestorationPolicy -from .histories import evaluate_histories, summarize_histories -from .mission import Capability, Mission, MissionHistory -from .references import Reference, _number, configure, value_of -from .simulation import SAMPLINGS +from .histories import _history_statistics, evaluate_histories, summarize_histories +from .mission import Capability, Mission +from .references import Reference, configure, value_of +from .simulation import _check_sampling from .space import Design -from .values import ChoiceValues +from .statistics import Statistic +from .values import ChoiceValues, Values + +_NUMBERS = (numbers.Real, Mapping) +"""The values of fields of numbers: a number, or a mapping (such as of +each type of satellite to its number).""" + + +def _resolve(design: Design, value: Any, kinds: type | tuple[type, ...] = ()) -> Any: + """ + Gets the value of a field of a plan for a design: the value given, if it + is `None` or of the kinds of the field's values, or else the value of the + design that it refers to (see `value_of`). + """ + if value is None or isinstance(value, kinds): + return value + return value_of(design, value) + + +def _policy(value: Any) -> RestorationPolicy | None: + """ + Gets the policy that a value gives: a policy, or the default policy + configured from the values of a group (a mapping, or a choice of + groups, see `configure`), or else `None`. + """ + if isinstance(value, RestorationPolicy): + return value + if isinstance(value, ChoiceValues): + if value.value is not None and not isinstance(value.value, Values): + return None # a choice of other values + elif not isinstance(value, Mapping): + return None + return configure(RestorationPolicy(), value) @dataclasses.dataclass(frozen=True) @@ -39,38 +72,44 @@ class MissionPlan: """ The deployment of the satellites of each design (see `DeploymentSchedule.plan`), the policy that restores the failures of its - satellites (see `RestorationPolicy`), and its costs (see `CostModel`), - from the values of the design (see `value_of`). - - The schedule, the policy, and the cost model may be functions of the - (realized) design, which size them by its values with relationships of - the study's own (TAT-C includes none, see the module - `tatc.tradespace.cost`): for example, the costs of a type of satellite - from the mass of its payload, or the capacity of launches to the - design's altitude:: + satellites (see `RestorationPolicy`), and its costs (see `CostModel`). + + Each part is given as a value, or as a reference to a value of the + design (see `Reference`: its name or path, or a function of the realized + design that computes it), which the plan reads for each design: a part + that is not a value of its kind (a `DeploymentSchedule`, a `CostModel`, a + `RestorationPolicy`, a sequence of `Stage`, or numbers) is a reference. + The type of the satellites (`kind`) and the scores of cost risk + (`scores`) are always references. A function sizes a part by the values + of the design with relationships of the study's own (TAT-C includes + none, see the module `tatc.tradespace.cost`): for example, the costs of + a type of satellite from the mass of its payload, or the capacity of + launches to the design's altitude:: def schedule(d): return dataclasses.replace(SCHEDULE, launch_mass_capacity=capacity(d.altitude)) - PLAN = MissionPlan(schedule, COST_MODEL, kind="payload") + PLAN = MissionPlan(schedule, COST_MODEL, kind="payload", masses=lambda d: mass(d.payload)) The deployment of each design is planned with its policy (see `DeploymentSchedule.plan`), which gives its spares: in orbit in each plane (`RestorationPolicy.orbit_spares`) and on the ground, which are produced (and cost) whether or not the study has failures (see - `Failures`). A policy may be a decision of each design, - such as a group of `policy_space` whose values configure the default - policy (see `configure`), or a function of the design that gives its - policy (such as one that configures a base policy):: + `Failures`). By default, the policy of a design is its value `policy`, + if it has one that configures a policy (such as a group of + `policy_space`, whose values configure the default policy, see + `configure`), and otherwise the default policy, which restores failed + satellites by producing new ones. A policy may also be given, or a + reference to another value of the design (a policy, or a group that + configures one), or a function that gives each design's policy (such as + one that configures a base policy):: space = space.extend(policy=policy_space(orbit_spares=Integer(0, 1), procurement_years=0.5)) - PLAN = MissionPlan(SCHEDULE, COST_MODEL, policy="policy") + PLAN = MissionPlan(SCHEDULE, COST_MODEL) # the policy of each design: its values `policy` PLAN = MissionPlan(SCHEDULE, COST_MODEL, policy=lambda d: configure(BASE_POLICY, d.policy)) - Launches limited in mass take the masses of the satellites from the cost - model (`SatelliteCost.mass`, of each type), unless `masses` are given, - and launches priced by mass take the same masses (see - `CostModel.estimate`). + Launches limited in mass, or priced by mass (see `CostModel.estimate`), + take the masses of the satellites (`masses`). The growth of the costs of the components of the cost model (see `Component`) is drawn from scores that are values of the design (such as @@ -80,170 +119,97 @@ def schedule(d): PLAN = MissionPlan(SCHEDULE, COST_MODEL, kind="payload", scores="cost_risk") Args: - schedule (DeploymentSchedule | Callable): The schedule of the - deployment, or a function of the design that gives it. - cost_model (CostModel | Callable | None): The costs, a function of the - design that gives them, or `None`. + schedule (DeploymentSchedule | Reference): The schedule of the + deployment. + cost_model (CostModel | Reference | None): The costs, or `None`. kind (Reference | None): The type of the satellites (for schedules, - failures, and costs of several types), as a value of the design. - policy (RestorationPolicy | Reference): The policy for the failed - satellites of each design, and its spares (by default, failed - satellites are restored by producing new ones), or a value of - the design (see `value_of`) that is its policy, or the values of - a group (such as of `policy_space`) that configure the default - policy (see `configure`). + failures, and costs of several types). + policy (RestorationPolicy | Reference | None): The policy for the + failed satellites of each design, and its spares (or the values + of a group that configure the default policy), or `None` for the + design's value `policy`, if it has one that configures a policy, + and otherwise the default policy. growth (float | Reference | Mapping): The growth of the costs (see - `CostModel.estimate`): a factor, a value of the design, or a - mapping of each element (such as `"development"`) to a factor or - a value of the design, or to a mapping of each type of satellite - to one. - stages (Sequence[Stage] | Callable): The stages of the deployment - (see `Stage`), or a function of the (realized) design that gives - them, such as of a decision whether to stage it and of the values - its rules read. Their rules may also read the capability of the - satellites operating at a decision, by the study's metrics (see + `CostModel.estimate`): a factor, or a mapping of each element + (such as `"development"`) to a factor, or to a mapping of each + type of satellite to one (each a number or a reference). + stages (Sequence[Stage] | Reference): The stages of the deployment + (see `Stage`), such as a function of the design that gives them + by a decision whether to stage it and the values its rules read. + Their rules may also read the capability of the satellites + operating at a decision, by the study's metrics (see `Decision.capability`). masses (float | Mapping | Reference | None): The mass (kg) of the - satellites (or of each type, a mapping), or a value of the - design, for launches limited (or priced) in mass, or `None` for - the masses of the cost model. + satellites (or of each type, a mapping), for launches limited (or + priced) in mass, or `None`. scores (Reference | None): The scores from which the growth of the - components of the cost model is drawn (see `CostModel.draw`), as - a value of the design (such as a group of `risk_space`), or - `None` for the expected costs of the components. + components of the cost model is drawn (see `CostModel.draw`), + such as a group of `risk_space`, or `None` for the expected + costs of the components. """ - schedule: DeploymentSchedule | Callable[[Design], DeploymentSchedule] - cost_model: CostModel | Callable[[Design], CostModel | None] | None = None + schedule: DeploymentSchedule | Reference + cost_model: CostModel | Reference | None = None _: dataclasses.KW_ONLY kind: Reference | None = None - policy: RestorationPolicy | Reference = RestorationPolicy() - growth: float | Reference | Mapping[str, float | Reference | Mapping[Any, Any]] = ( - 1.0 - ) - stages: Sequence[Stage] | Callable[[Design], Sequence[Stage]] = () + policy: RestorationPolicy | Reference | None = None + growth: float | Reference | Mapping[str, Any] = 1.0 + stages: Sequence[Stage] | Reference = () masses: float | Mapping[Any, float] | Reference | None = None scores: Reference | None = None - def schedule_of(self, design: Design) -> DeploymentSchedule: + def _policy_of(self, design: Design) -> RestorationPolicy: """ - Gets the schedule of the deployment of a design. - - Args: - design (Design): The (realized) design. - - Returns: - DeploymentSchedule: the schedule - """ - if isinstance(self.schedule, DeploymentSchedule): - return self.schedule - return self.schedule(design) - - def policy_of(self, design: Design) -> RestorationPolicy: - """ - Gets the policy for the failed satellites of a design, and its spares. - - Args: - design (Design): The (realized) design. - - Returns: - RestorationPolicy: the policy + Gets the policy for the failed satellites of a design, and its + spares, raising a `TypeError` if the policy it refers to is not a + policy or a group that configures one. """ - if isinstance(self.policy, RestorationPolicy): - return self.policy - policy = value_of(design, self.policy) - if isinstance(policy, RestorationPolicy): - return policy - if isinstance(policy, (Mapping, ChoiceValues)): - return configure(RestorationPolicy(), policy) - raise TypeError( - "the policy of a design is a RestorationPolicy, or values that " - + f"configure one, not {policy!r}" - ) + if self.policy is None: + named = _policy(design["policy"]) if "policy" in design else None + return RestorationPolicy() if named is None else named + policy = _policy(_resolve(design, self.policy, RestorationPolicy)) + if policy is None: + raise TypeError( + "the policy of a design is a RestorationPolicy, or values that " + + f"configure one, not {value_of(design, self.policy)!r}" + ) + return policy - def cost_model_of(self, design: Design) -> CostModel | None: + def _cost_model_of(self, design: Design) -> CostModel | None: """ Gets the cost model of a design, with the growth of its components drawn from the design's scores (if any, see `CostModel.draw`). - - Args: - design (Design): The (realized) design. - - Returns: - CostModel | None: the cost model, if any """ - model = self.cost_model - if model is not None and not isinstance(model, CostModel): - model = model(design) + model = _resolve(design, self.cost_model, CostModel) if model is None or self.scores is None: return model return model.draw(value_of(design, self.scores)) - def masses_of(self, design: Design, cost_model: CostModel | None = None) -> Any: + def _growth_of(self, design: Design) -> Any: """ - Gets the masses of the satellites of a design, for launches limited in - mass: the given masses (or the value of the design they name), or - those of the types of satellites of its cost model, if any. - - Args: - design (Design): The (realized) design. - cost_model (CostModel | None): The design's cost model. - - Returns: - Any: a mass, a mapping of types to masses, or `None` + Gets the growth of the costs of a design: a factor, or a mapping of + each element to its factor (or to a mapping of each type of + satellite to its factor). """ - if self.masses is not None: - if isinstance(self.masses, (int, float, Mapping)): - return self.masses - return value_of(design, self.masses) - if cost_model is None: - return None - satellites = cost_model.satellites - if isinstance(satellites, Mapping): - masses = {kind: cost.mass for kind, cost in satellites.items()} - return None if all(m is None for m in masses.values()) else masses - return satellites.mass - - def stages_of(self, design: Design) -> tuple: - """ - Gets the stages of the deployment of a design. - - Args: - design (Design): The (realized) design. - - Returns: - tuple[Stage, ...]: the stages - """ - stages = self.stages(design) if callable(self.stages) else self.stages - return tuple(stages or ()) - - def growth_of(self, design: Design) -> Any: - """ - Gets the growth of the costs of a design. - - Args: - design (Design): The (realized) design. - - Returns: - Any: a factor, or a mapping of each element to its factor (or to - a mapping of each type of satellite to its factor) - """ - if not isinstance(self.growth, Mapping): - return _number(design, self.growth) - growth: dict[str, Any] = {} - for element, value in self.growth.items(): + growth = _resolve(design, self.growth, _NUMBERS) + if not isinstance(growth, Mapping): + return growth + resolved: dict[str, Any] = {} + for element, value in growth.items(): + value = _resolve(design, value, _NUMBERS) if isinstance(value, Mapping): - growth[element] = {k: _number(design, g) for k, g in value.items()} - else: - growth[element] = _number(design, value) - return growth + value = {k: _resolve(design, g, numbers.Real) for k, g in value.items()} + resolved[element] = value + return resolved def plan_mission( self, design: Design, layout: Any, capability: Capability, + *, failures: Failures | None = None, + requirements: Sequence[Requirement] | None = None, ) -> Mission: """ Plans the mission of a realized design: its deployment (with its @@ -256,22 +222,30 @@ def plan_mission( capability (Capability): The capability of its satellites. failures (Failures | None): The failures of its satellites, if any. + requirements (Sequence[Requirement] | None): The requirements on + the metrics of its phases (see `Mission.requirements`), or + `None` not to summarize the phases of a mission without + failures. Returns: Mission: the mission """ - policy = self.policy_of(design) - cost_model = self.cost_model_of(design) - deployment = self.schedule_of(design).plan( + stages = _resolve(design, self.stages, (list, tuple)) + deployment = _resolve(design, self.schedule, DeploymentSchedule).plan( layout, kind=value_of(design, self.kind), - policy=policy, - masses=self.masses_of(design, cost_model), - stages=self.stages_of(design), + policy=self._policy_of(design), + masses=_resolve(design, self.masses, _NUMBERS), + stages=tuple(stages or ()), + capability=capability, ) - deployment.capability = capability return Mission( - design, deployment, cost_model, self.growth_of(design), capability, failures + design, + deployment, + self._cost_model_of(design), + self._growth_of(design), + failures, + None if requirements is None else tuple(requirements), ) @@ -279,180 +253,134 @@ def plan_mission( class Failures: """ The failures of the satellites of each design: histories of its mission - (see `Deployment.simulate_many`), restored by the policy of its - deployment (see `MissionPlan.policy`: by default by producing new - satellites; with `RestorationPolicy(restore=False)`, not restored), - summarized over the + (see `Deployment.simulate_many`), drawn from a `seed` of each replicate + and restored by the policy of its deployment (see `MissionPlan.policy`: + by default by producing new satellites; with + `RestorationPolicy(restore=False)`, not restored), summarized over the histories (see `summarize_histories`): the mean of each metric over the - phases of the mission and the histories, `quantiles` and `requirements` - of them, and their costs. With requirements on the metrics of the - `phases`, each history also gives the time until a phase first meets - each (` time`, see `summarize_phases`), summarized over the - histories as the other columns: its quantiles, or the share of the - histories that meet it by a time (a requirement on it), say more than - its mean, which is infinite if a history never meets it. + phases of the mission and the histories (and the time until a phase + first meets each requirement of the study on its phases, see + `ObservationStudy`), `statistics` of them over the histories (such as a + `Quantile` of the cost), and their costs:: + + statistics = [Quantile("accurate mission", 0.1), Quantile("cost", 0.7)] + FAILURES = Failures(FAILURE_MODEL, seed="failure_seed", histories=20, statistics=statistics) + + The time until a history meets a requirement is infinite if it never + does, so that its mean is infinite if any history never meets it, and + its quantiles, or the share of the histories that meet it by a time (a + `Probability`), summarize it. Without restoration, the means of the metrics and the availability are the exact expectations over the failures (see `exact_expectations`) if - `exact`, if the histories have failures (with a `seed`), and if - exact expectations apply: if the deployment is not staged (see `Stage`, - whose rules make its launches depend on the history) and has at most - `MAX_SETS` (200,000) sets of satellites to enumerate, which is known - before they are enumerated; otherwise (such as for constellations of - about 20 satellites or more) they are the means of the histories. - - With a `stress`, the failures are drawn from stressed distributions for - importance sampling (see `Deployment.simulate_many`), each history - weighted by its likelihood ratio. With `controls`, the means over the - histories are estimated with control variates (see - `summarize_histories`): measures of the missions (see - `MissionHistory.metrics`, such as `availability`) whose expected values - are estimated from `control_histories` other histories of the replicate, - simulated without evaluating their phases (see - `Deployment.expected_metrics`). With `spread`, the summaries add the - standard deviation of each column over the histories (` - histories std`), as `allocate_histories` needs of a pilot study. + they apply: if the deployment is not staged (see `Stage`, whose rules + make its launches depend on the history) and has at most `MAX_SETS` + (200,000) sets of satellites to enumerate, which is known before they + are enumerated; otherwise (such as for constellations of about 20 + satellites or more) they are the means of the histories. + + With a `stress`, the failures of satellites and launches are drawn from + stressed distributions for importance sampling (see + `Deployment.simulate_many`), each history weighted by its likelihood + ratio. With `controls`, the means over the histories are estimated with + control variates (see `summarize_histories`): measures of the missions + (see `MissionHistory.metrics`, such as `availability`) whose expected + values are estimated from `control_histories` other histories of the + replicate, simulated without evaluating their phases. Args: model (FailureModel): The failures. + seed (Reference): The value of the design that seeds the failures of + its replicate (see `value_of`), such as of `Uncertain.seed`. histories (int): The histories of each replicate. - seed (Reference | None): The value of the design that seeds the - failures (see `value_of`, such as of `Uncertain.seed`), or - `None` for the one history without failures. sampling (str): The sampling of the histories (`"stratified"` or `"random"`, see `Deployment.simulate_many`). - phases (Sequence[Requirement]): Requirements on the metrics of the - phases of each history, whose times it gives (` time`). - quantiles (Mapping | None): Quantiles of the columns of the - histories (see `summarize_histories`). - requirements (Sequence[Requirement]): Requirements on the columns of - the histories (see `summarize_histories`), such as on a time. - exact (bool): `True` for exact expectations without restoration. - stress (float): The factor of the hazards of stressed failures (1 - for none). - launch_stress (float | None): The factor of the probability that a - launch fails, or `None` for the stress. + statistics (Sequence[Statistic]): Statistics of the columns of the + histories over the histories: `Quantile`, `Probability`, or + `StandardDeviation` (see `summarize_histories`). + stress (float): The factor of the hazards of stressed failures, and + of the probability that a launch fails (1 for none). controls (Sequence[str]): The measures of the missions that are control variates, if any. control_histories (int): The histories that estimate the expected values of the controls. - spread (bool): `True` to add the standard deviations of the columns - over the histories. Raises: + TypeError: if the statistics are not of these kinds. ValueError: if the numbers of histories are less than 1, the - sampling is unknown, or a stress is not positive. + sampling is unknown, or the stress is not positive. """ model: FailureModel _: dataclasses.KW_ONLY + seed: Reference histories: int = 1 - seed: Reference | None = None sampling: str = "stratified" - phases: Sequence[Requirement] = () - quantiles: Mapping[str, float | Sequence[float]] | None = None - requirements: Sequence[Requirement] = () - exact: bool = True + statistics: Sequence[Statistic] = () stress: float = 1.0 - launch_stress: float | None = None controls: Sequence[str] = () control_histories: int = 1000 - spread: bool = False def __post_init__(self): if isinstance(self.controls, str): raise TypeError("controls are a sequence of names of measures") object.__setattr__(self, "controls", tuple(self.controls)) - object.__setattr__(self, "phases", tuple(self.phases)) - object.__setattr__(self, "requirements", tuple(self.requirements)) - if not all( - isinstance(requirement, Requirement) - for requirement in (*self.phases, *self.requirements) - ): - raise TypeError("phases and requirements are sequences of Requirements") - if self.histories < 1 or self.control_histories < 1: - raise ValueError("histories and control_histories must be at least 1") - if self.sampling not in SAMPLINGS: - raise ValueError( - f"sampling must be one of {SAMPLINGS}, not {self.sampling!r}" - ) - if self.stress <= 0 or ( - self.launch_stress is not None and self.launch_stress <= 0 - ): - raise ValueError("stress and launch_stress must be positive") - - def seed_of(self, design: Design) -> Any: + object.__setattr__(self, "statistics", _history_statistics(self.statistics)) + if self.seed is None: + raise ValueError("failures need a seed: a value of the design") + if self.control_histories < 1: + raise ValueError("control_histories must be at least 1") + _check_sampling(self.histories, self.sampling, self.stress) + + def _seed_of(self, design: Design) -> Any: """ - Gets the seed of the failures of a (realized) design's replicate. - - Args: - design (Design): The (realized) design. - - Returns: - Any: the seed, or `None` for the one history without failures + Gets the seed of the failures of a (realized) design's replicate, + raising a `ValueError` if it is `None` (of a design that is not + realized). """ - return value_of(design, self.seed) + seed = value_of(design, self.seed) + if seed is None: + raise ValueError( + "the seed of the failures of a design is None: failures need " + + "a realized design (with a seed, such as of Uncertain.seed)" + ) + return seed - def simulate(self, mission: Mission) -> list[MissionHistory]: + def _evaluate(self, mission: Mission) -> pd.DataFrame: """ - Simulates the histories of a mission (see `Deployment.simulate_many`), - restored by the policy of its deployment. - - Args: - mission (Mission): The mission. - - Returns: - list[MissionHistory]: the histories + Evaluates the histories of a mission (see `evaluate_histories`): for + each, the mean of each metric over its phases, the times until they + meet the requirements of the mission, the measures of its mission, + and its costs. """ - return mission.deployment.simulate_many( + histories = mission.deployment.simulate_many( self.model, - self.seed_of(mission.design), + self._seed_of(mission.design), histories=self.histories, sampling=self.sampling, stress=self.stress, - launch_stress=self.launch_stress, ) - - def evaluate(self, mission: Mission) -> pd.DataFrame: - """ - Evaluates the histories of a mission (see `simulate` and - `evaluate_histories`): for each, the mean of each metric over its - phases, the times until they meet the requirements of the `phases`, - the measures of its mission, and its costs. - - Args: - mission (Mission): The mission. - - Returns: - pandas.DataFrame: a row per history - """ return evaluate_histories( - self.simulate(mission), + histories, mission.capability, cost_model=mission.cost_model, growth=mission.growth, - requirements=self.phases, + requirements=mission.requirements or (), ) - def summarize(self, mission: Mission) -> dict[str, float]: + def _summarize(self, mission: Mission) -> dict[str, float]: """ Summarizes the histories of a mission as the metrics of its - evaluation (see `evaluate` and `summarize_histories`): with the - controls (if any), and with exact expectations of its means if they - apply (see `Failures`). - - Args: - mission (Mission): The mission. - - Returns: - dict[str, float]: the summary + evaluation (see `summarize_histories`): with the controls (if any), + and with exact expectations of its means if they apply. """ - seed = self.seed_of(mission.design) + seed = self._seed_of(mission.design) controls = None - if self.controls and seed is not None: + if self.controls: # other histories of the replicate (by a seed of its seed) other = int(np.random.default_rng([int(seed), 7]).integers(2**31)) - expected = mission.deployment.expected_metrics( + # pylint: disable-next=protected-access + expected = mission.deployment._expected_metrics( self.model, other, histories=self.control_histories, @@ -466,24 +394,19 @@ def summarize(self, mission: Mission) -> dict[str, float]: ) controls = {name: expected[name] for name in self.controls} record = summarize_histories( - self.evaluate(mission), - quantiles=self.quantiles, - requirements=self.requirements, - controls=controls, - spread=self.spread, + self._evaluate(mission), statistics=self.statistics, controls=controls ) - if self.exact and seed is not None: - try: - exact = exact_expectations( - mission.deployment, self.model, mission.capability - ) - except ExactExpectationsError: - exact = {} # the means of the histories instead - record.update( - { - key: value - for key, value in exact.items() - if key.endswith(" mission") or key == "availability" - } + try: + exact = exact_expectations( + mission.deployment, self.model, mission.capability ) + except ExactExpectationsError: + exact = {} # the means of the histories instead + record.update( + { + key: value + for key, value in exact.items() + if key.endswith(" mission") or key == "availability" + } + ) return record diff --git a/src/tatc/tradespace/plotting.py b/src/tatc/tradespace/plotting.py index 311195e3..432958ed 100644 --- a/src/tatc/tradespace/plotting.py +++ b/src/tatc/tradespace/plotting.py @@ -22,8 +22,6 @@ import numpy as np import pandas as pd -from .criteria import Criteria -from .pareto import pareto_front from .tables import feasible_records COLORS = ( @@ -121,6 +119,9 @@ def style_axes(ax: Any, grid: str | None = "y") -> Any: return ax +_JITTER_SEED = 0 +"""The seed of the random shifts of `plot_designs` (see its `jitter`).""" + _OTHERS = object() """The group of the rows without a value of the column that groups them.""" @@ -151,6 +152,21 @@ def _name(names: Mapping[Any, str] | Callable[[Any], str] | None, value: Any) -> return names.get(value, str(value)) +def _front(frame: pd.DataFrame, front: str | Sequence[bool] | None) -> Any: + """ + Gets the efficient rows of a frame to ring (a boolean column, or values), + or `None` for none: without the column `"pareto"` (of a summary of + criteria), none. + """ + if front is None: + return None + if isinstance(front, str) and front not in frame.columns: + if front == "pareto": + return None + raise ValueError(f"the frame has no column {front!r} of efficient designs") + return _mask(frame, front, "front") + + def _distinct(values: pd.Series) -> list: """Gets the distinct values (of a column), sorted if they can be.""" distinct = list(pd.unique(values.dropna())) @@ -176,8 +192,8 @@ def plot_designs( y: str, *, by: str | Sequence | None = None, - front: str | Sequence[bool] | Criteria | Mapping[str, str] | None = None, - labels: str | Callable[[pd.Series], str] | None = None, + front: str | Sequence[bool] | None = "pareto", + annotate: str | Callable[[pd.Series], str] | None = None, names: Mapping[Any, str] | Callable[[Any], str] | None = None, highlight: str | Sequence[bool] | None = None, label: str | None = None, @@ -187,22 +203,22 @@ def plot_designs( colors: Sequence[str] | Mapping[Any, str] = COLORS, legend: str | None = "best", ax: Any = None, - seed: int = 0, ) -> Any: """ - Plots designs (such as a summary of a study, see `aggregate`) by two + Plots designs (such as a summary of a study, see `summarize`) by two metrics: a point per row, colored by the value of a column `by` (if - any), with the efficient designs (`front`) ringed and labeled. Rows + any), with the efficient designs (`front`, by default those of the + column `pareto` of a summary of criteria, if it has one) ringed. Rows without a value of `by` (`NaN`, such as of a variable of a branch that a design does not choose) are drawn in gray, named `others` (or "other") in the legend. With `highlight`, only some designs are colored, over the others in gray (such as the designs a search evaluated, over every design):: - plot_designs(summary, "satellites", "sufficient", front="pareto") + plot_designs(summary, "satellites", "sufficient", by="layout") plot_designs( summary, "cost", "accurate", highlight=summary.policy == "degrade", - label="degrade", others="other policies", front="pareto", + label="degrade", others="other policies", ) Args: @@ -212,12 +228,13 @@ def plot_designs( by (str | Sequence | None): A column whose values color the designs, values for the rows (such as of a column grouped, as `summary.planes.clip(upper=3)`), or `None`. - front (str | Sequence[bool] | Criteria | Mapping | None): The - efficient designs: a boolean column (such as `"pareto"` of a - summary of criteria) or values (one per row), criteria (see - `pareto_front`), or `None`. - labels (str | Callable | None): The labels of the efficient designs: - a column, a function of a row, or `None`. + front (str | Sequence[bool] | None): The efficient designs: a boolean + column (by default `"pareto"`, of a summary of criteria, which a + frame without the column does not ring) or values (one per row, + such as of `pareto_front`), or `None`. + annotate (str | Callable | None): The labels of the efficient + designs, written next to them: a column, a function of a row, or + `None`. names (Mapping | Callable | None): The names of the values of `by` in the legend (by default, the values). highlight (str | Sequence[bool] | None): The designs to color (a @@ -236,13 +253,16 @@ def plot_designs( in order (or by value). legend (str | None): The location of the legend, or `None` for none. ax (matplotlib.axes.Axes | None): The axes, or `None` for a new figure. - seed (int): The seed of the jitter. Returns: matplotlib.axes.Axes: the axes + + Raises: + ValueError: if `front` is a column (other than `"pareto"`) that the + frame lacks, or values of a length other than the frame's. """ ax = _axes(ax, (9, 4.5)) - shift = np.random.default_rng(seed).uniform(-jitter, jitter, len(frame)) + shift = np.random.default_rng(_JITTER_SEED).uniform(-jitter, jitter, len(frame)) xs = frame[x].to_numpy(dtype=float) + (shift if jitter else 0.0) ys = frame[y].to_numpy(dtype=float) shown = np.ones(len(frame), dtype=bool) @@ -287,27 +307,22 @@ def plot_designs( lw=0, label=None if named else (others or "other"), ) - if front is not None: - if isinstance(front, (Criteria, Mapping)): - efficient = np.asarray(pareto_front(frame, front), dtype=bool) - else: - efficient = _mask(frame, front, "front") + ringed = _front(frame, front) + if ringed is not None: ax.scatter( - xs[efficient], - ys[efficient], + xs[ringed], + ys[ringed], s=70, facecolor="none", edgecolor=INK, lw=1.5, label=front_label, ) - if labels is not None: - rows = frame[efficient] - for (_, row), point in zip( - rows.iterrows(), zip(xs[efficient], ys[efficient]) - ): + if annotate is not None: + rows = frame[ringed] + for (_, row), point in zip(rows.iterrows(), zip(xs[ringed], ys[ringed])): ax.annotate( - labels(row) if callable(labels) else str(row[labels]), + annotate(row) if callable(annotate) else str(row[annotate]), point, xytext=(8, -3), textcoords="offset points", @@ -316,7 +331,7 @@ def plot_designs( ) ax.set(xlabel=x, ylabel=y) style_axes(ax) - named = by is not None or front is not None or label is not None + named = by is not None or ringed is not None or label is not None if legend is not None and (named or others is not None): ax.legend(loc=legend, fontsize=8, frameon=False, markerscale=1.6) return ax diff --git a/src/tatc/tradespace/references.py b/src/tatc/tradespace/references.py index 04a649c4..4dc785ef 100644 --- a/src/tatc/tradespace/references.py +++ b/src/tatc/tradespace/references.py @@ -23,9 +23,8 @@ A function of a study's results (such as the evaluation function of a `Study`, or the metrics of an `ObservationStudy`) that takes a keyword named -`design` is given the realized design as it (see `takes_design` and -`given_design`), as for a function that depends on values of the design -other than those it is given. +`design` is given the realized design as it, as for a function that +depends on values of the design other than those it is given. @author: Paul T. Grogan """ @@ -132,17 +131,11 @@ def configure(base: Any, values: Any = None, **overrides: Any) -> Any: return dataclasses.replace(base, **changes, **overrides) -def takes_design(function: Callable[..., Any]) -> bool: +def _takes_design(function: Callable[..., Any]) -> bool: """ - Whether a function takes a keyword named `design`, by which the parts of - studies give it the realized design (see `given_design`). - - Args: - function (Callable): The function. - - Returns: - bool: `True` if the function has a parameter named `design` that - may be given by keyword + Whether a function takes a keyword named `design` (a parameter named + `design` that may be given by keyword), by which the parts of studies + give it the realized design (see `_given_design`). """ try: parameter = inspect.signature(function).parameters.get("design") @@ -154,19 +147,12 @@ def takes_design(function: Callable[..., Any]) -> bool: ) -def given_design(function: Callable[..., Any], design: Design) -> Callable[..., Any]: +def _given_design(function: Callable[..., Any], design: Design) -> Callable[..., Any]: """ - Gets a function of its other arguments: the function given the design - as its keyword `design`, if it takes one (see `takes_design`), or the - function itself:: - - outcome = given_design(evaluate, realized)(built) + Gets a function of its other arguments: the function given the + (realized) design as its keyword `design`, if it takes one (see + `_takes_design`), or the function itself:: - Args: - function (Callable): The function. - design (Design): The (realized) design. - - Returns: - Callable: the function of its other arguments + outcome = _given_design(evaluate, realized)(built) """ - return partial(function, design=design) if takes_design(function) else function + return partial(function, design=design) if _takes_design(function) else function diff --git a/src/tatc/tradespace/refinement.py b/src/tatc/tradespace/refinement.py index 541152f0..c23a2e65 100644 --- a/src/tatc/tradespace/refinement.py +++ b/src/tatc/tradespace/refinement.py @@ -14,7 +14,7 @@ import pandas as pd from .alerts import _warn -from .criteria import Criteria +from .criteria import Criteria, _as_criteria, _tolerances from .space import Design, _designs from .study import Study from .summary import pareto_probability @@ -36,7 +36,11 @@ class Refinement: every replicate after its last round (`pareto` of its `summary`), which a confirmation checks with new replicates (see `confirm`, which selects them by default): designs whose efficiency is still uncertain may be - efficient by more replicates too (see `uncertain`). + efficient by more replicates too, those that more replicates would + settle:: + + summary = refinement.summary + unsettled = summary[summary.uncertain & ~summary.indifferent] """ results: pd.DataFrame @@ -45,21 +49,26 @@ class Refinement: summary: pd.DataFrame """pandas.DataFrame: A row per design (and group of the criteria's `by`): the probability that it is efficient after the last round (see - `pareto_probability`, with the values of the design), and whether its - efficiency is `uncertain` (by the bounds of `refine`, or with fewer than - its least replicates) and, if so, whether it is `indifferent` (its - objectives are known to within the precision of their tolerances).""" + `pareto_probability`, with the values of the design), whether its + efficiency is `uncertain` (its probability is strictly between the + bounds of `refine`, or it has fewer feasible replicates than the least), + and whether an uncertain design is `indifferent` (its objectives are + known to within the precision of their tolerances, so that whether it is + within the tolerances of the front does not matter, and it is not + refined). Designs that more replicates would settle are those uncertain + but not indifferent.""" + designs: list[Design] + """list[Design]: The designs efficient after the last round (`pareto` of + `summary`, in any group of the criteria's `by`), for the next step.""" criteria: Criteria """Criteria: The criteria of the refinement.""" rounds: pd.DataFrame = field(default_factory=pd.DataFrame) """pandas.DataFrame: A row per round (`round`, from 0): the number of - designs whose efficiency is uncertain (`uncertain`), of these, those that - are indifferent (`indifferent`), the number to which replicates were - added (`refined`), and the evaluations added (`evaluations`, a design in - a replicate in each scenario of a study with scenarios).""" - designs: list[Design] = field(default_factory=list) - """list[Design]: The designs efficient after the last round (`pareto` of - `summary`, in any group of the criteria's `by`), for the next step.""" + designs whose efficiency is uncertain (`uncertain`, in any group), of + these, those that are indifferent wherever they are uncertain + (`indifferent`), the number to which replicates were added (`refined`), + and the evaluations added (`evaluations`, a design in a replicate in + each scenario of a study with scenarios).""" candidates: list[Design] = field(default_factory=list) """list[Design]: The designs that could be refined (those given to `refine`).""" @@ -73,22 +82,6 @@ def evaluations(self) -> int: return 0 return int(self.rounds["evaluations"].sum()) - @property - def uncertain(self) -> pd.DataFrame: - """pandas.DataFrame: The rows of `summary` whose efficiency is still - uncertain, and that more replicates would settle (those that are not - indifferent).""" - summary = self.summary - return summary[summary["uncertain"] & ~summary["indifferent"]] - - @property - def indifferent(self) -> pd.DataFrame: - """pandas.DataFrame: The rows of `summary` whose efficiency is - uncertain, but whose objectives are known to within the precision of - their tolerances, so that whether they are within the tolerances of - the front does not matter.""" - return self.summary[self.summary["indifferent"]] - def _precise( probability: pd.DataFrame, criteria: Criteria, precision: float | None @@ -105,7 +98,7 @@ def _precise( precise = np.zeros(len(probability), dtype=bool) if precision is None or not criteria.tolerances: return precise - tolerances = criteria.tolerance_array + tolerances = _tolerances(criteria) precise[:] = True for i, name in enumerate(criteria.objectives): if f"{name} se" not in probability: @@ -176,7 +169,7 @@ def refine( lack a tolerance is never indifferent. A warning is given if designs remain uncertain (but not indifferent) without a tolerance. - Designs are judged by their feasible replicates (see `aggregate`): a + Designs are judged by their feasible replicates (see `summarize`): a design has fewer than `min_replicates` if fewer of its replicates are feasible, and `max_replicates` limits all of its replicates. Designs without a feasible replicate are not refined (and a refinement of results @@ -224,7 +217,7 @@ def refine( Refinement: the results, the final probabilities, the rounds, the efficient designs, and the candidates """ - criteria = Criteria.of(criteria) + criteria = _as_criteria(criteria) low, high = bounds if not 0 <= low < high <= 1: raise ValueError("bounds must satisfy 0 <= low < high <= 1") @@ -302,9 +295,9 @@ def estimate(round_: int) -> pd.DataFrame: return Refinement( results=combined, summary=probability, + designs=_designs(study.space, selected, combined), criteria=criteria, rounds=pd.DataFrame(rounds), - designs=_designs(study.space, selected, combined), candidates=refined, ) diff --git a/src/tatc/tradespace/scenarios.py b/src/tatc/tradespace/scenarios.py index f595424b..12d76764 100644 --- a/src/tatc/tradespace/scenarios.py +++ b/src/tatc/tradespace/scenarios.py @@ -9,13 +9,13 @@ from __future__ import annotations import dataclasses -from collections.abc import Mapping, Sequence +from collections.abc import Mapping import numpy as np import pandas as pd -from .criteria import Criteria -from .summary import aggregate +from .criteria import Criteria, _as_criteria, _resolved, _signs, _tolerances +from .summary import _summarize from .tables import design_values, value_columns @@ -29,7 +29,7 @@ def _scales(criteria: Criteria, scale: Mapping[str, float] | None) -> np.ndarray unknown = sorted(set(scale) - set(objectives)) if unknown: raise ValueError(f"scales of names that are not objectives: {unknown}") - absolute = criteria.tolerance_array[0] + absolute = _tolerances(criteria)[0] values = np.array( [ float(scale[name]) if name in scale else (absolute[i] or 1.0) @@ -46,13 +46,12 @@ def robustness( criteria: Criteria | Mapping[str, str], *, scale: Mapping[str, float] | None = None, - design_columns: Sequence[str] | None = None, ) -> pd.DataFrame: """ Measures the robustness of designs across scenarios (see `Study`): how often each design is efficient, and how far it falls from the front of each scenario, from the results of a study in each scenario (judged by - the criteria in each scenario, see `aggregate` and `pareto_front`). The + the criteria in each scenario, see `summarize` and `pareto_front`). The scenarios are the groups of the column of the criteria's `by` (by default, `"scenario"`, as of a study with scenarios). @@ -93,25 +92,22 @@ def robustness( scale (Mapping[str, float] | None): The units of regret of objectives (by name): by default, the absolute tolerance of an objective (if it has one), or else 1 (its units). - design_columns (Sequence[str] | None): The columns of the values of - designs, or `None` for those that are the same in every feasible - record of a design (see `aggregate`). Returns: pandas.DataFrame: a row per design (`design`): the values of the - design (as a summary keeps them, see `aggregate`), each objective + design (as a summary keeps them, see `summarize`), each objective in each scenario (` `), or once - (``) if it is a value of the designs (a column of - `design_columns`, such as a number of satellites), its - `pareto_trace`, `max_regret`, and regret in each scenario - (` regret`) + (``) if it is a value of the designs (the same in + every feasible record of a design, such as a number of + satellites), its `pareto_trace`, `max_regret`, and regret in each + scenario (` regret`) Raises: ValueError: if the results have no scenarios, or the criteria group records by several columns or combine them across scenarios (see `Across`, by which searches find robust designs). """ - criteria = Criteria.of(criteria) + criteria = _as_criteria(criteria) if criteria.across is not None: raise ValueError( "robustness judges designs in each scenario: give criteria without " @@ -131,8 +127,8 @@ def robustness( judged = dataclasses.replace(criteria, by=(scenario,)) objectives = list(criteria.objectives) # each objective in units of its scale, larger being better - units = -criteria.signs / _scales(criteria, scale) - summary = aggregate(results, judged, design_columns=[]) + units = -_signs(criteria) / _scales(criteria, scale) + summary = _summarize(results, judged, design_values=False) efficient = summary["pareto"].to_numpy(dtype=bool) scenarios = list(pd.unique(results[scenario])) designs = list(pd.unique(results["design"])) @@ -158,8 +154,8 @@ def robustness( # the values of the designs (of their first records, as of a summary), and # the objectives that are values of the designs, which are the same in # every scenario - statistics = judged.resolved - every = value_columns(results, {}, (scenario,), design_columns) + statistics = _resolved(judged) + every = value_columns(results, {}, (scenario,), None) metrics = {column for s in statistics.values() for column in s.columns} columns = [c for c in every if c not in metrics and c not in statistics] collapsed = { diff --git a/src/tatc/tradespace/screening.py b/src/tatc/tradespace/screening.py index fe87cd1d..170ecf4b 100644 --- a/src/tatc/tradespace/screening.py +++ b/src/tatc/tradespace/screening.py @@ -15,11 +15,11 @@ import pandas as pd -from .criteria import Criteria +from .criteria import Criteria, _as_criteria from .pareto import pareto_ranks from .space import Design, _designs from .study import Study -from .summary import aggregate +from .summary import _summarize @dataclass @@ -36,30 +36,28 @@ class Screening: refinement = refine(full, criteria, screening.results, screening.designs) The results and summaries of every stage are kept as well (`history` and - `summaries`). + `summaries`, with the `stage` of each row). """ results: pd.DataFrame """pandas.DataFrame: The results of the last stage (see `Study.run`).""" + summary: pd.DataFrame + """pandas.DataFrame: The summary of the designs of the last stage (a row + of `summaries`).""" + designs: list[Design] + """list[Design]: The designs that survive every stage (those the last + stage analyzes), for the next step.""" criteria: Criteria """Criteria: The criteria of the last stage.""" history: pd.DataFrame = field(default_factory=pd.DataFrame) """pandas.DataFrame: The results of every stage, with the `stage` (0 for the first), such as for the cost of the screening.""" - summaries: list[pd.DataFrame] = field(default_factory=list) - """list[pandas.DataFrame]: For each stage, the summary of its designs - (see `aggregate`, with whether each is efficient by the stage's - analysis, `pareto`), with their Pareto rank (`pareto_rank`, see - `pareto_ranks`), whether they were `kept` for the next stage, and the - `stage`.""" - designs: list[Design] = field(default_factory=list) - """list[Design]: The designs that survive every stage (those the last - stage analyzes), for the next step.""" - - @property - def summary(self) -> pd.DataFrame: - """pandas.DataFrame: The summary of the last stage.""" - return self.summaries[-1] + summaries: pd.DataFrame = field(default_factory=pd.DataFrame) + """pandas.DataFrame: The summaries of the designs of every stage (see + `summarize`, with whether each is efficient by the stage's analysis, + `pareto`), with their Pareto rank (`pareto_rank`, see `pareto_ranks`), + whether they were `kept` for the next stage, and the `stage` (0 for the + first).""" def _per_stage(value, count: int, name: str) -> list: @@ -158,10 +156,10 @@ def screen( for amount in keeps: _check_keep(amount) if isinstance(criteria, (Criteria, Mapping)): - stages = [Criteria.of(criteria)] * len(studies) + stages = [_as_criteria(criteria)] * len(studies) else: stages = [ - Criteria.of(c) for c in _per_stage(criteria, len(studies), "criteria") + _as_criteria(c) for c in _per_stage(criteria, len(studies), "criteria") ] for criteria in stages: if criteria.by: @@ -175,7 +173,7 @@ def screen( criteria = stages[stage] results = study.run(current) frames.append(results.assign(stage=stage)) - summary = aggregate(results, criteria) + summary = _summarize(results, criteria) summary["pareto_rank"] = pareto_ranks(summary, criteria) if stage < transitions: amount = keeps[stage] @@ -194,8 +192,9 @@ def screen( summaries.append(summary.assign(stage=stage)) return Screening( results=results, + summary=summaries[-1], + designs=current, criteria=criteria, history=pd.concat(frames, ignore_index=True), - summaries=summaries, - designs=current, + summaries=pd.concat(summaries, ignore_index=True), ) diff --git a/src/tatc/tradespace/sensitivity.py b/src/tatc/tradespace/sensitivity.py index 8b90ccef..282c58e9 100644 --- a/src/tatc/tradespace/sensitivity.py +++ b/src/tatc/tradespace/sensitivity.py @@ -39,7 +39,7 @@ def main_effects( Args: summary (pandas.DataFrame): The designs, a row each, with their values (see `Design.flat`) and metrics (such as a summary of a - study, see `aggregate`). + study, see `summarize`). variable (str): The column of the variable. metric (str): The column of the metric. max_levels (int): The most levels of a numeric variable, beyond which @@ -94,7 +94,7 @@ def sensitivity( Args: summary (pandas.DataFrame): The designs, a row each, with their values (see `Design.flat`) and metrics (such as a summary of a - study, see `aggregate`, which keeps the values of the designs). + study, see `summarize`, which keeps the values of the designs). variables (str | Sequence[str]): The column (or columns) of the variables. metrics (str | Sequence[str]): The column (or columns) of the metrics. diff --git a/src/tatc/tradespace/simulation.py b/src/tatc/tradespace/simulation.py index d7f39424..24042dcf 100644 --- a/src/tatc/tradespace/simulation.py +++ b/src/tatc/tradespace/simulation.py @@ -3,8 +3,8 @@ deployment of a constellation with the failures of its satellites and launches, the restoration of failed satellites by its policy, and the decisions of the rules of its stages, into the history of the mission (see -`MissionHistory`); and many histories of a replicate, independent or -stratified (see `Deployment.simulate_many`). +`MissionHistory`); and the samplers of many histories of a replicate, +independent or stratified (see `Deployment.simulate_many`). @author: Paul T. Grogan """ @@ -139,57 +139,24 @@ def __call__(self, key: tuple, dimensions: int) -> np.ndarray: ) -SAMPLINGS = ("random", "stratified") +_SAMPLINGS = ("random", "stratified") """The samplings of the failures of histories (see `Deployment.simulate_many`).""" -def simulate_histories( - deployment: Deployment, - model: FailureModel, - seed: int, - *, - histories: int = 1, - sampling: str = "stratified", - stress: float = 1.0, - launch_stress: float | None = None, -) -> list[MissionHistory]: +def _check_sampling( + histories: int, sampling: str, stress: float, launch_stress: float | None = None +) -> None: """ - Simulates the histories of a mission in a replicate (see - `Deployment.simulate_many`), history `k` from the seed and `k`. - - Args: - deployment (Deployment): The deployment, with its policy. - model (FailureModel): The failures. - seed (int): The seed of the replicate. - histories (int): The number of histories. - sampling (str): `"stratified"` or `"random"`. - stress (float): The factor of the hazards of stressed failures. - launch_stress (float | None): The factor of the probability that a - launch fails, or `None` for the stress. - - Returns: - list[MissionHistory]: the histories - - Raises: - ValueError: if the sampling is unknown or a stress is not positive. + Checks the sampling of histories (see `Deployment.simulate_many`), + raising a `ValueError` if the histories are fewer than 1, the sampling is + unknown, or a stress is not positive. """ - # pylint: disable=too-many-arguments - if sampling not in SAMPLINGS: - raise ValueError(f"sampling must be one of {SAMPLINGS}, not {sampling!r}") + if histories < 1: + raise ValueError("histories must be at least 1") + if sampling not in _SAMPLINGS: + raise ValueError(f"sampling must be one of {_SAMPLINGS}, not {sampling!r}") if stress <= 0 or (launch_stress is not None and launch_stress <= 0): raise ValueError("stress must be positive") - launch_stress = stress if launch_stress is None else launch_stress - return [ - _Simulation( - deployment, - model, - (seed, k), - _Sampler(seed, k, histories) if sampling == "stratified" else None, - stress, - launch_stress, - ).run() - for k in range(histories) - ] class _Simulation: @@ -333,7 +300,8 @@ def _on_decide(self, time: float, index: int) -> None: ( None if capability is None - else partial(capability.at, self.deployment.planes, operating) + # pylint: disable-next=protected-access + else partial(capability._at, self.deployment.planes, operating) ), ) if not stage.rule(decision): diff --git a/src/tatc/tradespace/space.py b/src/tatc/tradespace/space.py index 9bc199d0..5ba49d31 100644 --- a/src/tatc/tradespace/space.py +++ b/src/tatc/tradespace/space.py @@ -39,10 +39,10 @@ Infeasible, Uncertain, _as_node, - _Domain, ) from .values import Scope, Values, generic_path from .walks import ( + _ABSENT, _Context, _decided, _flatten, @@ -50,9 +50,9 @@ _level_of, _node_at, _Odometer, - _unit_paths, _walk, ) +from .walks import _unit_paths as _paths_of_units STATUS_COLUMNS = ("design", "replicate", "scenario", "feasible", "error", "seconds") """tuple[str, ...]: The columns of the results of a study (see `Study.run`) @@ -291,9 +291,9 @@ def realize( _check_seed(seed) replicate = _check_replicate(replicate) shift = _check_shift(shift) - self.space.check_uncertain(shift) + self.space._check_uncertain(shift) # pylint: disable=protected-access overrides = dict(overrides or {}) - self.space.check_overrides(overrides) + self.space._check_overrides(overrides) # pylint: disable=protected-access tail = [] if common_random_numbers else [int(self.key, 16)] def draw(path: str, node: Uncertain) -> Any: @@ -431,11 +431,12 @@ def __init__( def __repr__(self) -> str: return f"DesignSpace({', '.join(self.children)})" - def _design(self, ctx: _Context) -> Design: + def _design(self, ctx: _Context, prescribed: Any = _ABSENT) -> Design: """ - Decides a design (with nominal uncertain parameters). + Decides a design (with nominal uncertain parameters), following the + prescribed decisions, if any. """ - values, decisions = _walk(self, "", Scope(), ctx) + values, decisions = _walk(self, "", Scope(), ctx, prescribed) return Design(self, decisions, values) def design( @@ -528,16 +529,15 @@ def designs_of( """ Rebuilds designs from the rows of a data frame of their values by path (see `Design.flat`): the results of a study (see `Study.run`), or a - summary that keeps the values of the designs (see `aggregate`). The + summary that keeps the values of the designs (see `summarize`). The designs are those of the rows, aligned with them (with the frame's index), so that functions of designs map over the rows, or those of `keys` (indexed by them). Each design is rebuilt once, from the first row of its key (`design`, a column or the name of the index), whose key it must have, if the frame has keys:: - summary["description"] = space.designs_of(summary).map(describe) front = space.designs_of(summary[summary.pareto]) - confirmation = confirm(study, criteria, results, front) + realized = [study.realize(design) for design in front] Args: frame (pandas.DataFrame): The rows. @@ -587,32 +587,59 @@ def _rebuilt(self, record: Mapping[str, Any], key: str | None = None) -> Design: ) return design - def enumerate(self) -> list[Design]: + def enumerate(self, designs: Iterable[Design] | None = None) -> list[Design]: """ Enumerates every feasible design (a full factorial design over the levels of the design variables, including those that exist only in - some designs), without duplicates. + some designs), without duplicates, or every feasible design that + extends given designs: designs of a design space that this one + extends (see `extend`), each with every combination of the levels of + the decisions it lacks, such as each policy for each of the efficient + designs of the space without policies:: + + failure_space = cost_space.extend(policy=POLICY) + with_policies = failure_space.enumerate(cost_space.designs_of(efficient)) + + Args: + designs (Iterable[Design] | None): The designs to extend, or + `None` for every design. Returns: - list[Design]: the designs, in the order of their decisions + list[Design]: the designs, in the order of their decisions (and of + the given designs) Raises: - ValueError: if a design variable is continuous. - """ - return list(self._iterate()) - - def _iterate(self) -> Iterator[Design]: - """ - Iterates over every feasible design (see `enumerate`). The items of - unordered repetitions are walked in only one of their orders, so - that their permutations are not walked. + ValueError: if a design variable is continuous, or the decisions + of a given design are not those of a design of this design + space (see `design`). + """ + if designs is None: + return list(self._iterate()) + found: dict[str, Design] = {} + for given in designs: + if not isinstance(given, Design): + raise TypeError(f"designs to extend, not {given!r}") + for design in self._iterate(given.decisions): + found.setdefault(design.key, design) + return list(found.values()) + + def _iterate(self, prescribed: Any = _ABSENT) -> Iterator[Design]: + """ + Iterates over every feasible design (see `enumerate`), or every one + with the prescribed decisions (of some of its nodes). The items of + unordered repetitions are walked in only one of their orders, so that + their permutations are not walked. """ odometer = _Odometer() - ctx = _Context(choose=odometer.choose, odometer=odometer) + ctx = _Context( + choose=odometer.choose, + odometer=odometer, + normalize=None if prescribed is _ABSENT else _level_of, + ) keys: set[str] = set() while True: try: - design = self._design(ctx) + design = self._design(ctx, prescribed) if design.key not in keys: keys.add(design.key) yield design @@ -688,23 +715,6 @@ def unit(path: str, i: int = i, stratified: bool = stratified) -> float: raise Infeasible(f"no feasible design in {max_tries} draws") return designs - def unit_paths(self) -> list[str]: - """ - Gets the paths of every decision of the design space, in the order - they are decided: its design variables, its choices, and the counts - of its repetitions, with the items of each repetition up to its - largest count. These are the dimensions of the unit hypercube that - encodes its designs (see `encode` and `decode`). - - Returns: - list[str]: the paths - - Raises: - ValueError: if the count of a repetition has an upper bound that - is not fixed. - """ - return _unit_paths(self, "") - def uncertain_paths(self) -> list[str]: """ Gets the paths of the uncertain parameters of the design space (see @@ -712,24 +722,21 @@ def uncertain_paths(self) -> list[str]: of any item of a repetition (so that the phases of every plane of a constellation are one path, such as `planes[*].phase`), and with the branches of choices (such as `layout.walker.phase_fraction`), - whether a design chooses them or not. + whether a design chooses them or not. These name the parameters of a + shift (see `Design.realize`) and the overrides of a scenario (see + `Study`). Returns: list[str]: the paths """ return _leaf_paths(self, "", Uncertain) - def check_uncertain(self, paths: Iterable[str]) -> None: + def _check_uncertain(self, paths: Iterable[str]) -> None: """ Checks that paths are of uncertain parameters of the design space (as of `uncertain_paths`, with `[*]` for the index of any item of a - repetition), such as those of a shift (see `Design.realize`). - - Args: - paths (Iterable[str]): The paths. - - Raises: - ValueError: if a path is not of an uncertain parameter. + repetition), such as those of a shift (see `Design.realize`), raising + a `ValueError` if one is not. """ unknown = [p for p in paths if not isinstance(_node_at(self, p), Uncertain)] if unknown: @@ -738,19 +745,12 @@ def check_uncertain(self, paths: Iterable[str]) -> None: + f"{sorted(unknown, key=str)} (it has {self.uncertain_paths()})" ) - def check_overrides(self, overrides: Iterable[str]) -> None: + def _check_overrides(self, overrides: Iterable[str]) -> None: """ - Checks that the paths of the overrides of a scenario (see - `Design.realize`) are of fixed values or uncertain parameters of the - design space (with `[*]` for the index of any item of a repetition). - - Args: - overrides (Iterable[str]): The overrides (a mapping by path), or - their paths. - - Raises: - ValueError: if a path is not of a fixed value or an uncertain - parameter. + Checks that the paths of the overrides of a scenario (a mapping by + path, or the paths, see `Design.realize`) are of fixed values or + uncertain parameters of the design space (with `[*]` for the index of + any item of a repetition), raising a `ValueError` if one is not. """ unknown = [ p @@ -764,70 +764,44 @@ def check_overrides(self, overrides: Iterable[str]) -> None: + f"{sorted(unknown, key=str)} (it has {known})" ) - def decode(self, unit: Sequence[float]) -> Design: + def _unit_paths(self) -> list[str]: """ - Decodes a design from a point of the unit hypercube (a value in - [0, 1] for each of `unit_paths`): each decision maps the value of its - path to a level (each level spans an equal part of [0, 1]) or to a - point of its interval. Values of the paths of inactive nodes (such as - the branches not chosen) are ignored. This encodes the design space - for optimizers of fixed numbers of continuous variables, such as - pymoo's. - - Args: - unit (Sequence[float]): The values, in the order of `unit_paths`. - - Returns: - Design: the design + Gets the paths of every decision of the design space, in the order + they are decided: its design variables, its choices, and the counts + of its repetitions, with the items of each repetition up to its + largest count. These are the dimensions of the unit hypercube that + encodes its designs for optimizers of fixed numbers of continuous + variables (see `_decode` and `make_pymoo_problem`), raising a + `ValueError` if the count of a repetition has an upper bound that is + not fixed. + """ + return _paths_of_units(self, "") - Raises: - Infeasible: if the design violates a constraint. + def _decode(self, unit: Sequence[float]) -> Design: """ - index = {path: i for i, path in enumerate(self.unit_paths())} + Decodes a design from a point of the unit hypercube (a value in + [0, 1] for each of `_unit_paths`): each decision maps the value of + its path to a level (each level spans an equal part of [0, 1]) or to + a point of its interval. Values of the paths of inactive nodes (such + as the branches not chosen) are ignored. Raises `Infeasible` if the + design violates a constraint. + """ + index = {path: i for i, path in enumerate(self._unit_paths())} if len(unit) != len(index): raise ValueError(f"expected {len(index)} values, not {len(unit)}") return self._design( _Context(choose=lambda path, domain: domain.from_unit(unit[index[path]])) ) - def encode(self, design: Design) -> np.ndarray: - """ - Encodes a design as a point of the unit hypercube (see `decode`): the - center of the part of [0, 1] of each decided level, and 0.5 for the - paths of inactive nodes. - - Args: - design (Design): The design. - - Returns: - numpy.ndarray: the values, in the order of `unit_paths` - """ - index = {path: i for i, path in enumerate(self.unit_paths())} - unit = np.full(len(index), 0.5) - - def record(path: str, domain: _Domain, value: Any) -> None: - unit[index[path]] = domain.to_unit(value) - - ctx = _Context(record=record, canonical=True) - _walk(self, "", Scope(), ctx, design.decisions) - return unit - - def suggest(self, trial: Any) -> Design: + def _suggest(self, trial: Any) -> Design: """ - Decides a design with an Optuna trial (define-by-run): each decision - is suggested by the trial, named by its path, with the kind of its - variable (`suggest_float`, with the step of a discrete `Real`; - `suggest_int`; or `suggest_categorical`, also for choices), so that - Optuna's samplers search the hierarchical design space directly. - - Args: - trial (optuna.trial.Trial): The trial. - - Returns: - Design: the design - - Raises: - Infeasible: if the design violates a constraint. + Decides a design with an Optuna trial (define-by-run, see + `optimize_optuna`): each decision is suggested by the trial, named by + its path, with the kind of its variable (`suggest_float`, with the + step of a discrete `Real`; `suggest_int`; or `suggest_categorical`, + also for choices), so that Optuna's samplers search the hierarchical + design space directly. Raises `Infeasible` if the design violates a + constraint. """ return self._design( _Context(choose=lambda path, domain: domain.suggest(trial, path)) @@ -921,6 +895,6 @@ def _designs( raise ValueError( f"the values of designs {missing[:5]} are not given: give the designs, " + "or their keys with the results of a study (or a summary that keeps " - + "the values of designs, see aggregate)" + + "the values of designs, see summarize)" ) from error return [design for design in found.values() if design is not None] diff --git a/src/tatc/tradespace/statistics.py b/src/tatc/tradespace/statistics.py index 8b3d38c6..a54559e4 100644 --- a/src/tatc/tradespace/statistics.py +++ b/src/tatc/tradespace/statistics.py @@ -58,7 +58,10 @@ def _named_statistics(statistics: Any) -> dict[str, Statistic]: if isinstance(statistics, Mapping): return {name: _as_statistic(name, value) for name, value in statistics.items()} if isinstance(statistics, (str, Statistic)) or _is_derived(statistics): - statistics = [statistics] + raise TypeError( + "statistics must be a sequence of statistics (or metrics) or a mapping " + + f"of names to them, not {statistics!r}: give [{statistics!r}]" + ) named: dict[str, Statistic] = {} for item in statistics: statistic = _as_statistic(str(item), item) @@ -77,7 +80,7 @@ class Statistic: The column `feasible` of the results is the feasibility of each replicate (1 if it is feasible, 0 if not), whose statistics are over every replicate of a design, feasible or not (its mean is the share of its - replicates that are feasible, see `aggregate`); the statistics of other + replicates that are feasible, see `summarize`); the statistics of other metrics are over the feasible replicates. Args: @@ -97,13 +100,13 @@ def metric(self) -> str: def name(self) -> str: """str: The conventional name of the statistic, by which criteria name the statistics given without names: such as `cost` (a mean), `cost - std`, `cost se` (as of `summarize`), `cost min`, `cost max`, `cost - p70` (a quantile), or `P(cost <= 150)`. The statistics within a + std`, `cost min`, `cost max`, `cost p70` (a quantile), or `P(cost <= + 150)`. The statistics within a replicate over the histories of a mission (see `summarize_histories`) are named apart from these, as ` histories p10`, ` histories std`, and `P() histories`, and a statistic other than the mean of a metric must not have the name of a column of - the results (see `aggregate`).""" + the results (see `summarize`).""" return self.metric @property @@ -180,42 +183,46 @@ def reduce(self, values: np.ndarray) -> np.ndarray: return _nan_reduce(np.nanmean, values) -class StandardDeviation(Statistic): +def _standard_deviation(values: np.ndarray) -> np.ndarray: """ - The (sample) standard deviation of a metric over the replicates, a - measure of how much a design's outcome depends on its uncertain - parameters (`NaN` with fewer than two replicates). + Computes the sample standard deviation of each design (row) over its + values in its replicates (columns), ignoring missing values (`NaN` with + fewer than two, or with an infinite value, such as of a time that is + never met). """ + counts = np.sum(~np.isnan(values), axis=1) + result = np.full(values.shape[0], np.nan) + valid = counts > 1 + if np.any(valid): + with np.errstate(invalid="ignore"): # inf - inf, of infinite values + result[valid] = np.nanstd(values[valid], axis=1, ddof=1) + return result - @property - def name(self) -> str: - return f"{self.metric} std" - def reduce(self, values: np.ndarray) -> np.ndarray: - counts = np.sum(~np.isnan(values), axis=1) - result = np.full(values.shape[0], np.nan) - valid = counts > 1 - if np.any(valid): - result[valid] = np.nanstd(values[valid], axis=1, ddof=1) - return result +def _standard_error(values: np.ndarray) -> np.ndarray: + """ + Computes the standard error of the mean of each design (row) from its + values in its replicates (columns): their standard deviation over the + square root of their number (`NaN` with fewer than two), as the spreads + of summaries give it (` se`, see `summarize`). + """ + counts = np.sum(~np.isnan(values), axis=1) + return _standard_deviation(values) / np.sqrt(np.maximum(counts, 1)) -class StandardError(Statistic): +class StandardDeviation(Statistic): """ - The standard error of the mean of a metric over the replicates: its - standard deviation over the square root of the number of replicates, a - measure of the uncertainty of the mean (`NaN` with fewer than two - replicates). + The (sample) standard deviation of a metric over the replicates, a + measure of how much a design's outcome depends on its uncertain + parameters (`NaN` with fewer than two replicates). """ @property def name(self) -> str: - return f"{self.metric} se" + return f"{self.metric} std" def reduce(self, values: np.ndarray) -> np.ndarray: - counts = np.sum(~np.isnan(values), axis=1) - deviation = StandardDeviation(self.column).reduce(values) - return deviation / np.sqrt(np.maximum(counts, 1)) + return _standard_deviation(values) class Minimum(Statistic): diff --git a/src/tatc/tradespace/store.py b/src/tatc/tradespace/store.py index d47f6a61..11fd9a5e 100644 --- a/src/tatc/tradespace/store.py +++ b/src/tatc/tradespace/store.py @@ -110,7 +110,7 @@ class ResultStore: Records are also keyed by a `context`: a study gives its fingerprint, which changes with its definition (see `Study.fingerprint` for what it describes), so that records computed with other definitions are not - reused. The store keeps the definition of each context (see `define`), + reused. The store keeps the definition of each context, from which a study explains why it does not reuse records (see `compare_definitions`). What a fingerprint cannot describe (such as data that the functions read from files, and the code of modules other than @@ -126,6 +126,12 @@ class ResultStore: as `{"$tag": data}`, so that they are read exactly as they were written (or pickled, as `{"$pickle": data}`, if JSON cannot hold them). + A study reads and writes the store (see `Study.run`), and removes the + records of its definitions with other code (see `Study.prune`); `len` + counts the records of the namespace, and `clear` removes them:: + + study = Study(space, build, evaluate, store=ResultStore("results.sqlite")) + Args: path (str | os.PathLike): The database file (created if needed). namespace (str): An identifier of what the fingerprints of the @@ -166,7 +172,7 @@ def __init__(self, path: str | os.PathLike, *, namespace: str = ""): def _connect(self) -> sqlite3.Connection: return sqlite3.connect(self.path, timeout=60) - def get( + def _get( self, keys: Iterable[tuple[str, int]], context: str = "", variant: str = "" ) -> dict[tuple[str, int], list[dict]]: """ @@ -202,7 +208,7 @@ def get( found[design, replicate] = _decode(json.loads(text)) return found - def put( + def _put( self, items: Iterable[tuple[str, int, list[dict]]], context: str = "", @@ -238,7 +244,7 @@ def put( rows, ) - def define(self, context: str, definition: dict) -> None: + def _define(self, context: str, definition: dict) -> None: """ Keeps the definition of a context (such as that of a study, see `Study.definition`), if it is not kept already. @@ -260,9 +266,9 @@ def define(self, context: str, definition: dict) -> None: ], ) - def definition(self, context: str) -> dict | None: + def _definition(self, context: str) -> dict | None: """ - Gets the definition of a context (see `define`). + Gets the definition of a context (see `_define`). Args: context (str): The context. @@ -277,10 +283,10 @@ def definition(self, context: str) -> dict | None: ).fetchone() return None if row is None else json.loads(row[0]) - def contexts(self) -> dict[str, int]: + def _contexts(self) -> dict[str, int]: """ Gets the contexts of the namespace: those of its stored evaluations - and of its kept definitions (see `define`, such as of a study whose + and of its kept definitions (see `_define`, such as of a study whose evaluations all failed), in the order they were defined (those not defined first). @@ -303,9 +309,9 @@ def contexts(self) -> dict[str, int]: return dict(rows) def __len__(self) -> int: - return sum(self.contexts().values()) + return sum(self._contexts().values()) - def remove(self, contexts: str | Iterable[str]) -> int: + def _remove(self, contexts: str | Iterable[str]) -> int: """ Removes the stored records (and definitions) of contexts of the namespace, such as those of earlier definitions of a study (see diff --git a/src/tatc/tradespace/study.py b/src/tatc/tradespace/study.py index 43c9c6a0..368ccf1e 100644 --- a/src/tatc/tradespace/study.py +++ b/src/tatc/tradespace/study.py @@ -18,16 +18,11 @@ from pydantic import ValidationError from .alerts import _warn -from .fingerprint import ( - _fingerprint_of, - describe, - find_stale, - get_definition, - warn_stale, -) +from .fingerprint import _find_stale, _fingerprint_of, get_definition, warn_stale +from .fingerprint import describe as describe_value from .hashing import canonical, digest from .nodes import Infeasible -from .references import given_design +from .references import _given_design from .space import ( STATUS_COLUMNS, Design, @@ -39,6 +34,9 @@ ) from .store import ResultStore +_DESCRIPTION = "description" +"""The column of the results of a study that describes designs (see `Study`).""" + _UNSTORED = "_unstored" """A key of the records of evaluations that are not stored: those that failed (with `errors="record"`) and designs that failed validation, which may be @@ -158,6 +156,15 @@ def evaluate(satellites, design): evaluated alone, and one without values shares the evaluations of the study without scenarios. + A study may `describe` its designs with a function of a design (not of + a replicate) that labels it for tables and plots, as the value + `description` of each design in the results (after its other values), + which summaries keep (see `summarize`). Labels are given by every run, + not stored, nor part of the fingerprint: a new function needs no new + evaluations:: + + study = Study(space, build, evaluate, describe=lambda d: str(layout_of(d.layout))) + Evaluations run in parallel with `n_jobs` worker processes (or an `executor` with the interface of `concurrent.futures.Executor`). They are sent to the workers in chunks of consecutive evaluations of the same @@ -207,6 +214,9 @@ def evaluate(satellites, design): scenarios (Mapping[str, Mapping[str, Any]] | None): The scenarios in which to evaluate designs, if any: the overrides of fixed values and uncertain parameters of each (by path), by name. + describe (Callable | None): A function of a design that gives a label + of it (`description`), if any, which a value of the design space + (or a metric) may then not be named as (a `ValueError`). """ def __init__( @@ -224,7 +234,9 @@ def __init__( store: ResultStore | None = None, errors: str = "raise", scenarios: Mapping[str, Mapping[str, Any]] | None = None, + describe: Callable[[Design], Any] | None = None, ): + # pylint: disable=too-many-arguments if errors not in ("raise", "record"): raise ValueError(f"errors must be 'raise' or 'record', not {errors!r}") if replicates < 1: @@ -234,6 +246,10 @@ def __init__( if chunks_per_job < 1: raise ValueError("chunks_per_job must be at least 1") _check_seed(seed) + if describe is not None and not callable(describe): + raise TypeError(f"describe is a function of a design, not {describe!r}") + if describe is not None and _DESCRIPTION in space.children: + raise ValueError(f"a value of the design space named {_DESCRIPTION!r}") self.space, self.build, self.evaluate = space, build, evaluate self.replicates, self.seed = replicates, seed self.common_random_numbers = common_random_numbers @@ -242,6 +258,7 @@ def __init__( self.store = store self.errors = errors self.scenarios = _check_scenarios(space, scenarios) + self.describe = describe def __getstate__(self) -> dict: # an executor is not sent to workers (which add evaluations to the store) @@ -288,7 +305,7 @@ def _evaluate( raise return [self._failure(base, error)] try: - outcome = given_design(self.evaluate, realized)(built) + outcome = _given_design(self.evaluate, realized)(built) except Infeasible as error: return [{**base, "feasible": False, "error": str(error)}] except Exception as error: # pylint: disable=broad-exception-caught @@ -309,7 +326,7 @@ def _evaluate( else: records = [dict(outcome)] for record in records: - _check_metrics(record, base) + _check_metrics(record, base, self.describe is not None) return [{**base, **record} for record in records] @staticmethod @@ -344,7 +361,8 @@ def _evaluate_and_store( ] else: kept = records - self.store.put([(design.key, replicate, kept)], context, variant) + # pylint: disable-next=protected-access + self.store._put([(design.key, replicate, kept)], context, variant) return records def _run_chunk( @@ -430,6 +448,7 @@ def _settings(self) -> dict[str, Any]: "store": self.store, "errors": self.errors, "scenarios": self.scenarios, + "describe": self.describe, } def realize( @@ -560,7 +579,8 @@ def prune(self) -> int: return 0 definition = self.definition context = _fingerprint_of(definition) - return self.store.remove(_stale_contexts(self.store, context, definition)) + stale = _stale_contexts(self.store, context, definition) + return self.store._remove(stale) # pylint: disable=protected-access @property def workers(self) -> int: @@ -616,18 +636,19 @@ def run( record of an evaluation), in the order of the designs (and scenarios) and replicates, with the design's key (`design`), the `replicate` (and the `scenario`, with scenarios), the - values of the design by path (see `Design.flat`), whether it + values of the design by path (see `Design.flat`), its + `description` (if the study describes its designs), whether it is `feasible` (and the `error` if not), the time to build and evaluate it (`seconds`), and the metrics (the status columns alone, without evaluations, see `STATUS_COLUMNS`). Raises: ValueError: if a replicate index or an offset of `shift` is not - a non-negative integer, or `shift` names a path that is not of - an uncertain parameter of the design space. + a non-negative integer, `shift` names a path that is not of + an uncertain parameter, or a metric names another column. """ shift = {name: offset for name, offset in _check_shift(shift).items() if offset} - self.space.check_uncertain(shift) + self.space._check_uncertain(shift) # pylint: disable=protected-access replicates = ( range(self.replicates) if replicate_indices is None @@ -664,15 +685,18 @@ def run( for record in records ] if not records: - return pd.DataFrame( + frame = pd.DataFrame( columns=[ column for column in STATUS_COLUMNS if column != "scenario" or self.scenarios ] ) - frame = pd.DataFrame.from_records(records) - _check_feasible(frame) + else: + frame = pd.DataFrame.from_records(records) + _check_feasible(frame) + if self.describe is not None: + _add_descriptions(frame, self.describe, unique) return frame def _stored( @@ -691,13 +715,13 @@ def _stored( context = _fingerprint_of(definition) stored = {} for k, case in enumerate(cases): - found = self.store.get( + found = self.store._get( # pylint: disable=protected-access ((d.key, r) for _, d, r, c in tasks if c == k), context, case.variant ) stored.update({(key, r, k): records for (key, r), records in found.items()}) if tasks and not stored: _warn_other_definitions(self.store, context, definition) - self.store.define(context, definition) + self.store._define(context, definition) # pylint: disable=protected-access outcomes = [ _Outcome(i, case, replicate, stored[design.key, replicate, case]) for i, design, replicate, case in tasks @@ -827,7 +851,7 @@ def _check_scenarios( raise TypeError(f"the name of a scenario must be a string, not {name!r}") if not isinstance(values, Mapping): raise TypeError(f"the values of scenario {name!r} must be a mapping") - space.check_overrides(values) + space._check_overrides(values) # pylint: disable=protected-access checked[name] = dict(values) return checked @@ -839,7 +863,7 @@ def _describe_overrides(values: Mapping[str, Any]) -> str: """ if not values: return "" - return canonical(describe(dict(values))) + return canonical(describe_value(dict(values))) def _variant_of(shift: Mapping[str, int], scenario: str = "") -> str: @@ -863,16 +887,16 @@ def _stale_contexts( """ Gets the contexts of a store's namespace (and their numbers of evaluations) of the same study with other code (its functions', TAT-C's, - or Python's, see `find_stale`), the latest first, including those whose + or Python's, see `_find_stale`), the latest first, including those whose definitions are kept without evaluations. """ - contexts = store.contexts() + contexts = store._contexts() # pylint: disable=protected-access others = { - other: store.definition(other) + other: store._definition(other) # pylint: disable=protected-access for other in reversed(contexts) if other != context } - return find_stale(definition, others, contexts.__getitem__) + return _find_stale(definition, others, contexts.__getitem__) def _warn_other_definitions(store: ResultStore, context: str, definition: dict) -> None: @@ -886,7 +910,7 @@ def _warn_other_definitions(store: ResultStore, context: str, definition: dict) warn_stale( _stale_contexts(store, context, definition), definition, - store.definition, + store._definition, # pylint: disable=protected-access lambda count: f"the store has {count} evaluations of namespace " + f"{store.namespace!r} by this study", "see Study.fingerprint; Study.prune removes them", @@ -912,30 +936,52 @@ def _same(value: Any, other: Any) -> bool: return False -def _check_metrics(metrics: dict, base: dict) -> None: +def _check_metrics(metrics: dict, base: dict, described: bool = False) -> None: """ Checks that the metrics of a record do not replace the columns of the results of a study: they must not be named as its status columns (see - `STATUS_COLUMNS`, also `scenario` in a study without scenarios) nor as - the marker of unstored records (see `_UNSTORED`), and a metric named as - a value of the design (a key of `base`) must equal it. + `STATUS_COLUMNS`, also `scenario` in a study without scenarios), as its + descriptions of designs (`description`, if `described`, see `Study`), nor + as the marker of unstored records (see `_UNSTORED`), and a metric named + as a value of the design (a key of `base`) must equal it. """ + columns = [*STATUS_COLUMNS, *([_DESCRIPTION] if described else [])] clashes = [ str(name) for name, value in metrics.items() - if name in STATUS_COLUMNS + if name in columns or name == _UNSTORED or (name in base and not _same(value, base[name])) ] if clashes: raise ValueError( f"metrics named as columns of the results of a study: {sorted(clashes)}; " - + f"rename them (the results have the columns {list(STATUS_COLUMNS)}, " + + f"rename them (the results have the columns {columns}, " + "and the values of each design, see Design.flat, which a metric of " + "the same name must equal)" ) +def _add_descriptions( + results: pd.DataFrame, describe: Callable[[Design], Any], designs: list[Design] +) -> None: + """ + Adds the descriptions of designs (see `Study`) to the results of a run, + before `feasible`, raising a `ValueError` if the results have a column of + their name (a metric stored by a study that did not describe designs). + """ + if _DESCRIPTION in results.columns: + raise ValueError( + f"metrics named {_DESCRIPTION!r}, as descriptions: rename them" + ) + labels = {design.key: describe(design) for design in designs} + results.insert( + results.columns.get_loc("feasible"), + _DESCRIPTION, + [labels[key] for key in results["design"]], + ) + + def _check_feasible(results: pd.DataFrame) -> None: """ Warns if none of several designs of the results of a study is feasible, diff --git a/src/tatc/tradespace/summary.py b/src/tatc/tradespace/summary.py index 03734578..aba2bc1c 100644 --- a/src/tatc/tradespace/summary.py +++ b/src/tatc/tradespace/summary.py @@ -1,8 +1,8 @@ """ Summaries of the results of trade studies: the statistics of each design over -its replicates (see `Statistic`), its judgment by criteria (see `Criteria`), -and the probability that it is efficient, given the uncertainty of its -replicates (by a bootstrap). +its replicates (see `Statistic`) and their spreads, its judgment by criteria +(see `Criteria`), and the probability that it is efficient, given the +uncertainty of its replicates (by a bootstrap). Designs are judged by their feasible replicates: the statistics of a metric are over the replicates in which a design is feasible, and the share of its @@ -22,14 +22,25 @@ import numpy as np import pandas as pd -from .criteria import Across, Criteria +from .criteria import ( + Across, + Criteria, + _as_criteria, + _combiners, + _costs, + _resolved, + _statistic, + _tolerances, + _violation, + _weights_of, +) from .dominance import efficient from .statistics import ( Mean, - StandardDeviation, - StandardError, Statistic, _named_statistics, + _standard_deviation, + _standard_error, ) from .tables import ( FEASIBLE, @@ -167,6 +178,9 @@ def _spread_of_mean( weighted sum of the values of a replicate, and the standard error of the weighted mean of the groups' means. """ + if len(parts) == 1: + # the spread of the replicates of one group + return _standard_deviation(parts[0]), _standard_error(parts[0]) # the variance of the weighted sum, and the squared standard error, from # terms whose magnitudes tell rounding from a variance totals = np.zeros((2, len(parts[0]))) @@ -190,11 +204,12 @@ class _Statistics: The statistics of the designs of the feasible results of a group (of the criteria's `by`), over every replicate or some of them (see `evaluate`), from the values of their metrics in each replicate: in each group of a - column, combined across the groups (see `Across`), if any. Designs - without feasible results in every group are left out. + column, combined across the groups (see `Across`), or, without criteria + across a column, in one group of every result. Designs without feasible + results in every group are left out. The statistics of the feasibility of replicates (`feasible`, see - `aggregate`) are over the replicates of the feasible and infeasible + `summarize`) are over the replicates of the feasible and infeasible records of the designs, and, across groups, over those of every group together (they are not combined). @@ -219,7 +234,6 @@ def __init__( ): self.statistics, self.criteria = statistics, criteria across = None if criteria is None else criteria.across - self.combiners = None if across is None else criteria.combiners infeasible = results.iloc[:0] if infeasible is None else infeasible columns = {c for statistic in statistics.values() for c in statistic.columns} metrics = sorted(columns - {FEASIBLE}) @@ -230,49 +244,37 @@ def __init__( if set(statistic.columns) == {FEASIBLE} } if across is None: - self.designs = pd.Index(results["design"].drop_duplicates()) - infeasible = infeasible[infeasible["design"].isin(self.designs)] - self.replicates = _replicates_of(results, infeasible) - values = matrices(results, metrics, self.designs, self.replicates)[2] - values[FEASIBLE] = _feasibility( - results, infeasible, self.designs, self.replicates - ) - self.matrices = [values] - self.counts = ( - results.groupby("design")["replicate"] - .nunique() - .reindex(self.designs) - .to_numpy() - ) - return - combined = [name for name in statistics if name not in self.pooled] - self.weights = ( - across.weights_of(levels) - if any(self.combiners.get(name, "mean") == "mean" for name in combined) - else None - ) - parts = [ - results[(results[across.column] == group).to_numpy()] for group in levels - ] - complete = set.intersection(*(set(part["design"]) for part in parts)) + # one group of every result, whose statistics are its own + column, self.combiners = None, {} + parts, failures = [results], [infeasible] + self.weights = np.ones(1) + else: + column, self.combiners = across.column, _combiners(criteria) + parts = [results[(results[column] == group).to_numpy()] for group in levels] + failures = [ + infeasible[(infeasible[column] == group).to_numpy()] for group in levels + ] + self.weights = _weights_of(across, levels) designs = results["design"].drop_duplicates() - self.designs = pd.Index(designs[designs.isin(complete)]) - infeasible = infeasible[infeasible["design"].isin(self.designs)] - self.replicates = _replicates_of(results, infeasible) + if len(parts) > 1: + # the designs with feasible results in every group + complete = set.intersection(*(set(part["design"]) for part in parts)) + designs = designs[designs.isin(complete)] + self.designs = pd.Index(designs) + failures = [failed[failed["design"].isin(self.designs)] for failed in failures] + self.replicates = _replicates_of(results, pd.concat(failures)) self.matrices = [] - for group, part in zip(levels, parts): + for part, failed in zip(parts, failures): values = matrices(part, metrics, self.designs, self.replicates)[2] - failed = infeasible[(infeasible[across.column] == group).to_numpy()] values[FEASIBLE] = _feasibility(part, failed, self.designs, self.replicates) self.matrices.append(values) - self.counts = ( - results.groupby(["design", across.column])["replicate"] - .nunique() - .groupby(level="design") - .min() - .reindex(self.designs) - .to_numpy() - ) + # the fewest replicates of a design in any group + counts = results.groupby(["design", *([] if column is None else [column])])[ + "replicate" + ].nunique() + if column is not None: + counts = counts.groupby(level="design").min() + self.counts = counts.reindex(self.designs).to_numpy() def _pooled(self, statistic: Statistic, columns: np.ndarray | None) -> np.ndarray: """ @@ -287,11 +289,11 @@ def _pooled(self, statistic: Statistic, columns: np.ndarray | None) -> np.ndarra ] return statistic.reduce(matrix) - def _violation(self, values: Mapping[str, np.ndarray]) -> np.ndarray: + def violation(self, values: Mapping[str, np.ndarray]) -> np.ndarray: """Gets the total violation of the requirements of the criteria.""" if self.criteria is None: return np.zeros(len(self.designs)) - return self.criteria.violation(values, len(self.designs)) + return _violation(self.criteria, values, len(self.designs)) def evaluate( self, columns: np.ndarray | None = None @@ -300,9 +302,6 @@ def evaluate( Computes the statistics of each design (of the replicates `columns` of the matrices, or all) and the total violation of the requirements. """ - if self.combiners is None: - values = _evaluate(self.statistics, self.matrices[0], columns) - return values, self._violation(values) combined = { name: statistic for name, statistic in self.statistics.items() @@ -314,6 +313,9 @@ def evaluate( if name in self.pooled: values[name] = self._pooled(statistic, columns) continue + if len(parts) == 1: + values[name] = parts[0][name] + continue stacked = np.vstack([part[name] for part in parts]) how = self.combiners.get(name, "mean") if how == "max": @@ -322,7 +324,7 @@ def evaluate( values[name] = stacked.min(axis=0) else: values[name] = self.weights @ stacked - return values, self._violation(values) + return values, self.violation(values) def judged(self, columns: np.ndarray) -> np.ndarray: """ @@ -351,18 +353,13 @@ def spread(self, name: str, statistic: Statistic) -> tuple[np.ndarray, np.ndarra (see `summarize`), and, across groups, those of the statistic of the groups that it combines into. """ - deviation = StandardDeviation(statistic.column) - error = StandardError(statistic.column) - if self.combiners is None: - values = statistic.values_of(self.matrices[0]) - return deviation.reduce(values), error.reduce(values) parts = [statistic.values_of(m) for m in self.matrices] how = self.combiners.get(name, "mean") if how in ("max", "min"): # the spread of the group of the worst value means = np.vstack([statistic.reduce(part) for part in parts]) - deviations = np.vstack([deviation.reduce(part) for part in parts]) - errors = np.vstack([error.reduce(part) for part in parts]) + deviations = np.vstack([_standard_deviation(part) for part in parts]) + errors = np.vstack([_standard_error(part) for part in parts]) filled = np.where( np.isnan(means), -np.inf if how == "max" else np.inf, means ) @@ -387,8 +384,9 @@ def _summary_groups( Iterates over the groups (of the columns `by`) of the feasible results of a study, for summaries of their designs: a data frame of the designs of each group (`design`, the values of `by`, and the values of the designs, - see `aggregate`), and their statistics (see `_Statistics`). Results - without a feasible record have no groups. + see `summarize`: those of `design_columns`, or, if `None`, those that are + the same in every feasible record of a design), and their statistics + (see `_Statistics`). Results without a feasible record have no groups. """ feasible, infeasible = feasible_records(results) if feasible.empty: @@ -409,49 +407,45 @@ def _summary_groups( def _criteria_of( - criteria: Criteria | Mapping[str, str] | Sequence[str] | str, - statistics: Mapping[str, Statistic | str] | Sequence[str] | None, + criteria: Criteria | Mapping[str, str] | None, + statistics: Mapping[str, Statistic | str] | Sequence | None, by: Sequence[str] | str, ) -> tuple[Criteria | None, dict[str, Statistic], tuple[str, ...]]: """ - Gets the criteria (if any) of the arguments of `aggregate`, the + Gets the criteria (if any) of the arguments of `summarize`, the statistics to compute (by name), and the columns that group records. """ by = tuple(names(by)) extra = _named_statistics(statistics) + if criteria is None: + if not extra: + raise ValueError( + "give criteria, or the statistics (or metrics, whose means they " + + "are) to summarize as `statistics`" + ) + return None, extra, by if isinstance(criteria, Mapping) and not set(criteria.values()) <= {"min", "max"}: raise ValueError( "a mapping of criteria gives the directions of objectives ('min' or " + "'max'): give statistics by name as `statistics`" ) - if isinstance(criteria, (Criteria, Mapping)): - if by and isinstance(criteria, Criteria): + judged = _as_criteria(criteria) + if by: + if isinstance(criteria, Criteria): raise ValueError( "criteria group records by their own `by`: give it to the criteria" ) - judged = Criteria.of(criteria) - if by: - judged = replace(judged, by=by) - if extra: - clashes = sorted( - name - for name in extra - if name in judged.names and judged.statistic(name) != extra[name] - ) - if clashes: - raise ValueError( - f"statistics that the criteria name otherwise: {clashes}" - ) - judged = replace(judged, statistics={**judged.statistics, **extra}) - return judged, judged.resolved, judged.by - metrics = names(criteria) - resolved: dict[str, Statistic] = {name: Mean(name) for name in metrics} - resolved.update(extra) - if not resolved: - raise ValueError( - "give criteria, the metrics whose means to compute, or statistics" + judged = replace(judged, by=by) + if extra: + clashes = sorted( + name + for name in extra + if name in judged.names and _statistic(judged, name) != extra[name] ) - return None, resolved, by + if clashes: + raise ValueError(f"statistics that the criteria name otherwise: {clashes}") + judged = replace(judged, statistics={**judged.statistics, **extra}) + return judged, _resolved(judged), judged.by def _with_feasibility(statistics: Mapping[str, Statistic]) -> dict[str, Statistic]: @@ -464,6 +458,46 @@ def _with_feasibility(statistics: Mapping[str, Statistic]) -> dict[str, Statisti return {**statistics, FEASIBLE: Mean(FEASIBLE)} +def _spreads(statistics: Mapping[str, Statistic]) -> dict[str, list[str]]: + """ + Gets the columns of the spreads of the means of metrics (a column, or a + metric computed from others, such as a `Utility`) among statistics (by + name): their standard deviations and standard errors (` std` and + ` se`), but those that statistics name. + """ + return { + name: [ + column + for column in (f"{name} std", f"{name} se") + if column not in statistics + ] + for name, statistic in statistics.items() + if type(statistic) is Mean and FEASIBLE not in statistic.columns + } + + +def _ordered( + statistics: Mapping[str, Statistic], added: Mapping[str, Sequence[str]] +) -> list[str]: + """Gets the columns of statistics, each followed by those `added` to it + (such as its spreads).""" + return [column for name in statistics for column in (name, *added.get(name, ()))] + + +def _with_spreads( + values: dict[str, np.ndarray], + table: _Statistics, + statistics: Mapping[str, Statistic], + spreads: Mapping[str, Sequence[str]], +) -> None: + """Adds the spreads of means (see `_spreads`) to the values of a group.""" + for name, columns in spreads.items(): + deviation, error = table.spread(name, statistics[name]) + for column, value in ((f"{name} std", deviation), (f"{name} se", error)): + if column in columns: + values[column] = value + + def _check_names( statistics: Mapping[str, Statistic], results: pd.DataFrame, @@ -510,7 +544,7 @@ def _judge( violations, requirements, front = JUDGMENT frame[violations] = violation frame[requirements] = meets - frame[front] = efficient(criteria.costs(values), meets, criteria.tolerance_array) + frame[front] = efficient(_costs(criteria, values), meets, _tolerances(criteria)) def _assemble( @@ -519,19 +553,17 @@ def _assemble( values: Mapping[str, np.ndarray], violation: np.ndarray, criteria: Criteria | None, - extra: Mapping[str, np.ndarray] | None = None, ) -> pd.DataFrame: """ Adds to the rows of the designs of a group (of `_summary_groups`) their - statistics, `extra` columns (if any), the number of their feasible - `replicates`, the share of their replicates that are feasible - (`feasible`), and their judgment by criteria (if any, see `_judge`). + statistics (and the other columns of `values`, in order), the number of + their feasible `replicates`, the share of their replicates that are + feasible (`feasible`), and their judgment by criteria (if any, see + `_judge`). """ for name, value in values.items(): if name != FEASIBLE: frame[name] = value - for name, value in (extra or {}).items(): - frame[name] = value frame["replicates"] = table.counts frame[FEASIBLE] = values[FEASIBLE] if criteria is not None: @@ -590,97 +622,100 @@ def _without_constant(summary: pd.DataFrame, columns: Sequence[str]) -> pd.DataF def _summarize( results: pd.DataFrame, - judged: Criteria | None, - resolved: Mapping[str, Statistic], - by: Sequence[str], - design_columns: Sequence[str] | None, - spread: Sequence[str] = (), + criteria: Criteria | Mapping[str, str] | None = None, + *, + statistics: Mapping[str, Statistic | str] | Sequence | None = None, + by: Sequence[str] | str = (), + spread: bool = False, + design_values: bool = True, ) -> pd.DataFrame: """ - Summarizes results by the statistics of their designs (see `aggregate`), - with the spread of the means of metrics (by name) of `spread` (see - `summarize`): after each mean without criteria, and after the - statistics with criteria. + Summarizes results by the statistics of their designs (see `summarize`), + as the steps of trade studies do: without spreads by default, and, + without `design_values`, without the values of the designs (only their + keys, `design`), which saves finding them. """ + judged, resolved, by = _criteria_of(criteria, statistics, by) statistics = _with_feasibility(resolved) - spreads = [ - f"{name} {suffix}" - for name in spread - for suffix in ("std", "se") - if f"{name} {suffix}" not in statistics - ] - _check_names(statistics, results, spreads) - order: list[str] = [] - for name in statistics: - order.append(name) - if judged is None: - order.extend(c for c in (f"{name} std", f"{name} se") if c in spreads) - if judged is not None: - order.extend(spreads) + spreads = _spreads(statistics) if spread else {} + added = [column for columns in spreads.values() for column in columns] + _check_names(statistics, results, added) + order = _ordered(statistics, spreads) frames = [] for frame, table in _summary_groups( - results, statistics, by, judged, design_columns + results, statistics, by, judged, None if design_values else [] ): values, violation = table.evaluate() - for name in spread: - deviation, error = table.spread(name, statistics[name]) - values.update( - { - column: value - for column, value in ( - (f"{name} std", deviation), - (f"{name} se", error), - ) - if column in spreads - } - ) + _with_spreads(values, table, statistics, spreads) ordered = {name: values[name] for name in order} frames.append(_assemble(frame, table, ordered, violation, judged)) summary = _summaries(frames, by, order, judged) - return _without_constant(summary, spreads) + return _without_constant(summary, added) -def aggregate( +def summarize( results: pd.DataFrame, - criteria: Criteria | Mapping[str, str] | Sequence[str] | str = (), + criteria: Criteria | Mapping[str, str] | None = None, *, statistics: Mapping[str, Statistic | str] | Sequence | None = None, by: Sequence[str] | str = (), - design_columns: Sequence[str] | None = None, + spread: bool = True, ) -> pd.DataFrame: """ - Aggregates the results of a study (see `Study.run`, a row per replicate) - into a summary of its designs (a row per design, and per group of the - columns `by`, such as a sensor): statistics over the feasible replicates - of each design, the number of these `replicates`, the share of its - replicates that are feasible (`feasible`), and the values of the design - (see `Design.flat`), from which `DesignSpace.designs_of` rebuilds the - designs. + Summarizes the results of a study (see `Study.run`, a row per replicate) + with a row per design (and per group of the columns `by`, such as a + sensor): statistics over the feasible replicates of each design, the + spread of each that is the mean of a metric (with `spread`), the number + of these `replicates`, the share of its replicates that are feasible + (`feasible`), and the values of the design (see `Design.flat`), from + which `DesignSpace.designs_of` rebuilds the designs. The statistics are those of criteria (see `Criteria`, or a mapping of objectives to their directions, which are the means of the metrics of - their names), or the means of metrics (a list of their names), and other - `statistics`, by name (a statistic, or a metric given as a string, whose - mean it is), or a list of statistics (or metrics), named by their - conventional names (see `Statistic.name`):: + their names), and other `statistics`: a sequence of statistics or + metrics (a metric given as a string, or a `Utility`, is its mean), + named by their conventional names (see `Statistic.name`), or a mapping + of names to them:: - aggregate(results, {"satellites": "min", "sufficient": "max"}) - aggregate(results, ["sufficient", "accurate"]) - aggregate(results, statistics=[Quantile("cost", 0.7)]) # cost p70 - aggregate(results, COST, statistics=["cost development"]) + summarize(results, {"satellites": "min", "sufficient": "max"}) + summarize(results, statistics=["sufficient", "accurate"]) + summarize(results, statistics=[Quantile("cost", 0.7)]) # cost p70 + summarize(results, COST, statistics=["cost development"]) A statistic of the name of a column of the results is the mean of the column: any other statistic of the name raises an error, as its values would be taken for those of the column. + The spread of a mean of a metric (a column, or a metric computed from + others, such as a `Utility`) follows it: the standard deviation + (` std`) and the standard error (` se`) between the + replicates. A spread that is zero for every design (of a metric that is + the same in every replicate of each design, such as a number of + satellites, or of designs with one replicate) is left out (but those of + a summary without designs). + With criteria, the summary also gives the `violation` of their requirements (the sum of the violations, see `Requirement`, 0 if the design meets them all), whether the design meets them (`meets_requirements`), and whether it is efficient among the designs that do (`pareto`, see `pareto_front`, in each group of the criteria's - `by`; a design with a missing objective, `NaN`, is not). Criteria - `across` a column combine the statistics of each design across its - groups (see `Across`), of which `replicates` is the fewest of any group. + `by`; a design with a missing objective, `NaN`, is not):: + + summary = summarize(results, criteria) + front = summary[summary.pareto] + + Criteria `across` the groups of a column (such as scenarios, see + `Across`) combine the statistics of each design across its groups, of + which `replicates` is the fewest of any group. The spread of a combined + statistic is that of the worst group's value (of the worst), or, of a + weighted mean, the standard deviation of the weighted sum of the values + of a replicate in each group and the standard error of the weighted mean + of the groups' means, from the covariances of the groups over the + replicates they share (the same replicate in every group, in which it + has the same uncertain parameters, see `Study`), so that what the groups + share cancels. Groups without shared replicates are independent: the + standard error is then the square root of the weighted sum of the + squared standard errors of the groups (by the squared weights). Designs are judged by their feasible replicates. `feasible` is a statistic over every replicate of a design (the mean of the feasibility @@ -699,98 +734,28 @@ def aggregate( Args: results (pandas.DataFrame): The results. - criteria (Criteria | Mapping[str, str] | Sequence[str] | str): The - criteria (or objectives and their directions), or the metrics - whose means to compute. + criteria (Criteria | Mapping[str, str] | None): The criteria, or the + objectives (metrics whose means they are) and their directions + (`"min"` or `"max"`), if any. statistics (Mapping[str, Statistic | str] | Sequence | None): Other - statistics, by name, or a sequence of statistics (or metrics, - whose means they are), named by their conventional names. + statistics: a sequence of statistics (or metrics, whose means + they are), named by their conventional names, or a mapping of + names to them. by (Sequence[str] | str): The columns that group records of an evaluation (those of the criteria, if they have any). - design_columns (Sequence[str] | None): The columns of the values of - designs, or `None` for those that are the same in every - replicate of a design (except the metrics). + spread (bool): `True` to give the spreads of means. Returns: pandas.DataFrame: a row per feasible design (and group) Raises: + TypeError: if the criteria are neither criteria nor a mapping of + directions (give metrics as `statistics`). ValueError: if a statistic other than the mean of a column has the column's name, or the results have several records of an evaluation (in a group). """ - judged, resolved, by = _criteria_of(criteria, statistics, by) - return _summarize(results, judged, resolved, by, design_columns) - - -def summarize( - results: pd.DataFrame, - criteria: Criteria | Mapping[str, str] | Sequence[str] | str = (), - *, - statistics: Mapping[str, Statistic | str] | Sequence | None = None, - by: Sequence[str] | str = (), - design_columns: Sequence[str] | None = None, -) -> pd.DataFrame: - """ - Summarizes the feasible results of a study over their replicates (see - `aggregate`), with the spread of the means of metrics: for each design - (and each group of the columns `by`, such as a sensor), the statistics - of criteria (or the means of a list of metrics) and of other - `statistics`, the standard deviation (` std`) and standard error - (` se`) between replicates of each that is the mean of a metric - (a column, or a metric computed from others, such as a `Utility`), the - number of feasible replicates (`replicates`), the share of the replicates - that are feasible (`feasible`), and the values of the design. Of criteria - (or a mapping of objectives to their directions), the summary is theirs - (see `aggregate`: the violation of their requirements, and whether each - design is efficient, `pareto`):: - - summary = summarize(results, {"satellites": "min", "sufficient": "max"}) - front = summary[summary.pareto] - summarize(results, ACCURACY, statistics=["sufficient"]) # and its mean - - The spread of a mean that is zero for every design (of a metric that is - the same in every replicate of each design, such as a number of - satellites, or a design with one replicate) is left out of the summary - (but that of a summary without designs). - - With criteria `across` the groups of a column (such as scenarios, see - `Across`), the spread is that of the statistic combined from the groups: - of the worst, the spread in the group of the worst value; of a weighted - mean, the standard deviation of the weighted sum of the values of a - replicate in each group, and the standard error of the weighted mean of - the groups' means, from the covariances of the groups over the - replicates they share (the same replicate in every group, in which it - has the same uncertain parameters, see `Study`), so that what the groups - share cancels. Groups without shared replicates are independent: the - standard error is then the square root of the weighted sum of the - squared standard errors of the groups (by the squared weights). These - are of the same kind as the standard errors of the bootstrap of - `pareto_probability`, of the combined statistic. - - Args: - results (pandas.DataFrame): The results (see `Study.run`). - criteria (Criteria | Mapping[str, str] | Sequence[str] | str): The - criteria (or objectives and their directions), or the metrics - whose means to summarize. - statistics (Mapping[str, Statistic | str] | Sequence | None): Other - statistics (see `aggregate`). - by (Sequence[str] | str): Other columns that group records of an - evaluation (those of criteria, if they have any). - design_columns (Sequence[str] | None): The columns of the values of - designs, or `None` for those that are the same in every - replicate of a design (except the metrics). - - Returns: - pandas.DataFrame: the summary, a row per feasible design (and group) - """ - judged, resolved, by = _criteria_of(criteria, statistics, by) - spread = [ - name - for name, statistic in resolved.items() - if type(statistic) is Mean and FEASIBLE not in statistic.columns - ] - return _summarize(results, judged, resolved, by, design_columns, spread) + return _summarize(results, criteria, statistics=statistics, by=by, spread=spread) def pareto_probability( @@ -799,7 +764,6 @@ def pareto_probability( *, n_resamples: int = 500, seed: int = 0, - design_columns: Sequence[str] | None = None, ) -> pd.DataFrame: """ Estimates the probability that each design is Pareto-efficient by @@ -829,7 +793,7 @@ def pareto_probability( which a design is infeasible are drawn too: the statistics of a resample are those of the drawn replicates in which the design is feasible, and the share of its replicates that are feasible (`feasible`, see - `aggregate`) is that of the drawn replicates. A design whose drawn + `summarize`) is that of the drawn replicates. A design whose drawn replicates are all infeasible (in a scenario, with criteria `across` scenarios) is not judged in the resample: it neither meets the requirements nor is efficient. @@ -843,22 +807,16 @@ def pareto_probability( (`"min"` or `"max"`). n_resamples (int): The number of resamples (at least 2). seed (int): The seed of the resamples. - design_columns (Sequence[str] | None): The columns of the values of - designs, or `None` for those that are the same in every - replicate of a design (see `aggregate`). Returns: pandas.DataFrame: a row per feasible design (and group), empty without one: the summary of the criteria over every replicate - (see `aggregate`: the values of the design, the statistics, the - standard error of each objective, ` se`, its standard - deviation over the resamples, left out if it is zero for every - design, as `summarize` leaves out spreads, the number of feasible - `replicates`, the share of the replicates that are `feasible`, - the `violation` of the requirements, whether the design meets - them, `meets_requirements`, and whether it is efficient among - those that do, `pareto`), the probability that it is efficient - (`pareto_probability`), and the probability that it meets the + (see `summarize`, with the spreads of means), in which each + objective that is not a mean (such as a quantile) is followed by + its standard error, its standard deviation over the resamples + (` se`, left out if it is zero for every design, as + `summarize` leaves out spreads), and the probability that the + design is efficient (`pareto_probability`) and that it meets the requirements (`requirements_probability`) Raises: @@ -866,22 +824,29 @@ def pareto_probability( column's name, or the results have several records of an evaluation (in a group). """ - criteria = Criteria.of(criteria) - statistics = _with_feasibility(criteria.resolved) - errors = [f"{name} se" for name in criteria.objectives] - _check_names(statistics, results, errors) - tolerances = criteria.tolerance_array + criteria = _as_criteria(criteria) + statistics = _with_feasibility(_resolved(criteria)) + spreads = _spreads(statistics) + # the standard errors of the objectives that are not means, by the bootstrap + booted = [ + name + for name in criteria.objectives + if name not in spreads and f"{name} se" not in statistics + ] + added = {**spreads, **{name: [f"{name} se"] for name in booted}} + columns = [column for spread in added.values() for column in spread] + _check_names(statistics, results, columns) + order = _ordered(statistics, added) + tolerances = _tolerances(criteria) rng = np.random.default_rng(seed) frames = [] - for frame, table in _summary_groups( - results, statistics, criteria.by, criteria, design_columns - ): + for frame, table in _summary_groups(results, statistics, criteria.by, criteria): values, violation = table.evaluate() counts = np.zeros(len(table.designs)) met = np.zeros(len(table.designs)) # the sums of the objectives (and of their squares) over the resamples - sums = {name: np.zeros(len(table.designs)) for name in criteria.objectives} - squares = {name: np.zeros(len(table.designs)) for name in criteria.objectives} + sums = {name: np.zeros(len(table.designs)) for name in booted} + squares = {name: np.zeros(len(table.designs)) for name in booted} for drawn in draw_resamples(len(table.replicates), n_resamples, rng): sample, sample_violation = table.evaluate(drawn) # designs without a drawn replicate keep the statistics of all of @@ -892,24 +857,27 @@ def pareto_probability( sample_violation[undrawn] = violation[undrawn] judged = table.judged(drawn) | undrawn meets = (sample_violation == 0) & judged - counts += efficient(criteria.costs(sample), meets, tolerances) + counts += efficient(_costs(criteria, sample), meets, tolerances) met += meets - for name in criteria.objectives: + for name in booted: sums[name] += sample[name] squares[name] += sample[name] ** 2 - bootstrap = { - error: _bootstrap_error(sums[name], squares[name], n_resamples) - for name, error in zip(criteria.objectives, errors) - } - _assemble(frame, table, values, violation, criteria, bootstrap) + computed = dict(values) + _with_spreads(computed, table, statistics, spreads) + for name in booted: + computed[f"{name} se"] = _bootstrap_error( + sums[name], squares[name], n_resamples + ) + ordered = {name: computed[name] for name in order} + _assemble(frame, table, ordered, violation, criteria) frame["pareto_probability"] = counts / n_resamples frame["requirements_probability"] = met / n_resamples frames.append(frame) summary = _summaries( frames, criteria.by, - [*statistics, *errors], + order, criteria, after=["pareto_probability", "requirements_probability"], ) - return _without_constant(summary, errors) + return _without_constant(summary, columns) diff --git a/src/tatc/tradespace/tables.py b/src/tatc/tradespace/tables.py index ce05dd38..0ae1a921 100644 --- a/src/tatc/tradespace/tables.py +++ b/src/tatc/tradespace/tables.py @@ -21,11 +21,11 @@ FEASIBLE = "feasible" """The column of the results of a study of whether each record is feasible, and the statistic (and column of summaries) of the share of a design's -replicates that are feasible (see `aggregate`).""" +replicates that are feasible (see `summarize`).""" JUDGMENT = ("violation", "meets_requirements", "pareto") """The columns of the judgment of designs by criteria in their summaries (see -`aggregate`).""" +`summarize`).""" SEPARATE = ( "give the columns that separate them as `by` (of the criteria), or combine " @@ -35,7 +35,7 @@ SUMMARIZE = ( "summarize the results of a study (a row per replicate) first, with a row " - + "per design (see aggregate), or select the rows of one group (such as those " + + "per design (see summarize), or select the rows of one group (such as those " + "of a scenario)" ) """How to give each design one row, rather than the results of a study (a @@ -331,7 +331,7 @@ def efficient_keys(summary: pd.DataFrame) -> list: `pareto` is true, in any group), each once, in order. Args: - summary (pandas.DataFrame): The summary (see `aggregate`). + summary (pandas.DataFrame): The summary (see `summarize`). Returns: list: the keys diff --git a/src/tatc/tradespace/utility.py b/src/tatc/tradespace/utility.py index 812a5976..4cd3116c 100644 --- a/src/tatc/tradespace/utility.py +++ b/src/tatc/tradespace/utility.py @@ -178,7 +178,7 @@ class Utility: a sample of points, see `attribute_variance`), the expected utility penalizes the noise rather than the design: judge the utility of the means instead (`utility(summary)`, of a summary of the means of the - metrics, see `aggregate`). + metrics, see `summarize`). Args: attributes (Mapping[str, Callable]): The single-attribute utility of diff --git a/src/tatc/tradespace/walks.py b/src/tatc/tradespace/walks.py index 255e1586..b9892d60 100644 --- a/src/tatc/tradespace/walks.py +++ b/src/tatc/tradespace/walks.py @@ -83,13 +83,12 @@ class _Context: decides a variable, `draw(path, node)` draws an uncertain parameter (or `None` for nominal values), `fix(path, node)` gives a fixed value (or `None` for its value), and `check` enables constraints. If given, - `record(path, domain, value)` is called with every decision, chosen or - prescribed, and `normalize(path, domain, value)` gives the value of the - domain that a prescribed decision is (such as its level, see - `_level_of`). With an `odometer` (of an enumeration), the items of - unordered repetitions are only walked in the order of their levels. A - walk of the decisions of a design (`canonical`), whose unordered items - are in order, does not sort them again. + `normalize(path, domain, value)` gives the value of the domain that a + prescribed decision is (such as its level, see `_level_of`). With an + `odometer` (of an enumeration), the items of unordered repetitions are + only walked in the order of their levels. A walk of the decisions of a + design (`canonical`), whose unordered items are in order, does not sort + them again. """ # pylint: disable=too-many-instance-attributes @@ -99,7 +98,6 @@ def __init__( choose: Callable[[str, _Domain], Any] | None = None, draw: Callable[[str, Uncertain], Any] | None = None, check: bool = True, - record: Callable[[str, _Domain, Any], None] | None = None, odometer: _Odometer | None = None, fix: Callable[[str, Fixed], Any] | None = None, normalize: Callable[[str, _Domain, Any], Any] | None = None, @@ -108,7 +106,7 @@ def __init__( # pylint: disable=too-many-arguments,too-many-positional-arguments self.choose, self.draw, self.check = choose, draw, check self.fix, self.normalize = fix, normalize - self.record, self.odometer = record, odometer + self.odometer = odometer self.canonical = canonical self.ranks: list[list[float]] = [] """The ranks of the decisions of the unordered items being walked @@ -125,8 +123,6 @@ def decide(self, path: str, domain: _Domain, prescribed: Any) -> Any: value = self.normalize(path, domain, prescribed) else: value = prescribed - if self.record is not None: - self.record(path, domain, value) if self.ranks: rank = _rank(domain, value) for ranks in self.ranks: @@ -168,12 +164,7 @@ def _walk( if prescribed is _FIRST: ctx, prescribed = ctx.first(), _ABSENT if isinstance(node, Variable): - if ( - prescribed is not _ABSENT - and ctx.record is None - and ctx.normalize is None - and not ctx.ranks - ): + if prescribed is not _ABSENT and ctx.normalize is None and not ctx.ranks: return prescribed, prescribed value = ctx.decide(path, node.domain(scope), prescribed) return value, value @@ -551,7 +542,7 @@ def _decided(values: Mapping[str, Any], path: str, domain: _Domain) -> Any: if _missing(value): raise ValueError( f"no value of {path}: rebuild designs from the results of a study, or " - + "from a summary that keeps the values of designs (see aggregate)" + + "from a summary that keeps the values of designs (see summarize)" ) return _level_of(path, domain, value) @@ -563,7 +554,7 @@ def _decided(values: Mapping[str, Any], path: str, domain: _Domain) -> Any: def _unit_paths(node: Node, path: str) -> list[str]: """ - Gets the paths of the decisions of a node (see `DesignSpace.unit_paths`). + Gets the paths of the decisions of a node (see `DesignSpace._unit_paths`). """ if isinstance(node, Variable): return [path] diff --git a/tests/tradespace/test_attribution.py b/tests/tradespace/test_attribution.py index 30366969..aade4f7b 100644 --- a/tests/tradespace/test_attribution.py +++ b/tests/tradespace/test_attribution.py @@ -152,7 +152,7 @@ def test_summary(self): first = a.summary_of("first") self.assertAlmostEqual(first.loc["s", "v"], 1.0) self.assertAlmostEqual(first.loc["s", "v se"], 0.0) - self.assertEqual(a.samples["total"].shape, (len(a.shares), 200)) + self.assertEqual(a._samples["total"].shape, (len(a.shares), 200)) with self.assertRaises(ValueError): a.summary_of("second") diff --git a/tests/tradespace/test_cache.py b/tests/tradespace/test_cache.py index 7a1bc282..b65e26f9 100644 --- a/tests/tradespace/test_cache.py +++ b/tests/tradespace/test_cache.py @@ -217,13 +217,18 @@ def test_contexts(self): namespace=namespace, context=context, ) - contexts = SatelliteCache.contexts(directory) + # pylint: disable-next=protected-access + contexts = SatelliteCache._contexts(directory) self.assertEqual(contexts, {"x": (3, EPOCH), "y": None, "z": {"seed": 1}}) # a context that cannot be read is none for path in Path(directory).rglob("context.json"): path.write_text("{") - self.assertEqual(set(SatelliteCache.contexts(directory).values()), {None}) - self.assertEqual(SatelliteCache.contexts(directory), {}) # removed + found = SatelliteCache._contexts( + directory + ) # pylint: disable=protected-access + self.assertEqual(set(found.values()), {None}) + found = SatelliteCache._contexts(directory) # pylint: disable=protected-access + self.assertEqual(found, {}) # removed with self.assertRaises(TypeError): SatelliteCache( # pylint: disable=too-many-function-args self.analysis, directory @@ -265,7 +270,7 @@ def test_disk_cache_in_parallel(self): def test_pickled_cache_is_empty(self): """Copies of a cache (as sent to workers) start without results.""" cache = SatelliteCache(_name) - cache.get(_satellite("a")) + cache(_satellite("a")) copy = pickle.loads(pickle.dumps(cache)) self.assertEqual(copy._memory, {}) # pylint: disable=protected-access cache.clear_memory() diff --git a/tests/tradespace/test_confirmation.py b/tests/tradespace/test_confirmation.py index 3ee19e21..5b8fb123 100644 --- a/tests/tradespace/test_confirmation.py +++ b/tests/tradespace/test_confirmation.py @@ -50,7 +50,7 @@ def setUp(self): self.study = _study() self.designs = self.study.space.enumerate() self.results = self.study.run(self.designs) - summary = summarize(self.results, list(OBJECTIVES), design_columns=[]) + summary = summarize(self.results, statistics=list(OBJECTIVES)) # the best looking designs of each cost best = summary.sort_values("value", ascending=False).groupby( summary.design.map({d.key: d.cost for d in self.designs}) @@ -90,7 +90,7 @@ def test_removes_optimism(self): def test_default_front(self): """Without designs, the front of the results is confirmed; designs may also be given by their keys or a data frame of them.""" - summary = summarize(self.results, list(OBJECTIVES), design_columns=[]) + summary = summarize(self.results, statistics=list(OBJECTIVES)) front = summary[pareto_front(summary, OBJECTIVES)] confirmation = confirm(self.study, OBJECTIVES, self.results) self.assertEqual(set(confirmation.summary.design), set(front.design)) @@ -134,6 +134,7 @@ def test_optimism_without_designs(self): empty = Confirmation( results=pd.DataFrame(), summary=pd.DataFrame({"cost optimism": [], "value optimism": []}), + designs=[], criteria=Criteria(OBJECTIVES), ) with warnings.catch_warnings(): diff --git a/tests/tradespace/test_cost.py b/tests/tradespace/test_cost.py index a9dcab84..0874738e 100644 --- a/tests/tradespace/test_cost.py +++ b/tests/tradespace/test_cost.py @@ -25,12 +25,12 @@ Study, Triangular, Uncertain, - aggregate, count_satellites, exceedance, planes_space, risk_space, sso_planes_space, + summarize, walker_space, ) from tatc.tradespace.constellations import plane_sizes @@ -108,7 +108,7 @@ class TestCostModel(unittest.TestCase): def setUp(self): self.satellite = SatelliteCost( - development=100, first_unit=10, learning_rate=0.9, mass=50 + development=100, first_unit=10, learning_rate=0.9 ) def test_elements(self): @@ -152,7 +152,7 @@ def test_rideshare(self): model = CostModel( self.satellite, launch=LaunchCost(per_satellite=2, per_kg=0.1) ) - estimate = model.estimate(DeploymentSchedule().plan(_walker(1, 4))) + estimate = model.estimate(DeploymentSchedule().plan(_walker(1, 4), masses=50)) self.assertEqual(estimate.launches, 1) # counted, though not priced per launch self.assertAlmostEqual(estimate.launch, 4 * (2 + 0.1 * 50)) with self.assertRaises(ValueError): @@ -186,24 +186,17 @@ def test_spares(self): self.assertEqual(estimate.total, model.estimate(deployment.planned()).total) def test_masses_of_the_deployment(self): - """Launches are priced by the masses that size them: those of the - deployment, or else of the cost model.""" + """Launches are priced by the masses of the deployment, which size + them.""" schedule = DeploymentSchedule(years=3, launch_mass_capacity=250) deployment = schedule.plan(_walker(1, 4), masses=100) self.assertEqual(len(deployment.launches), 2) by_kg = LaunchCost(per_kg=0.01) - # without masses of the cost model - priced = CostModel(SatelliteCost(first_unit=1), launch=by_kg).estimate( - deployment - ) - self.assertAlmostEqual(priced.launch, 4 * 100 * 0.01) - # the masses of the deployment take the place of the cost model's - other = CostModel(SatelliteCost(first_unit=1, mass=60), launch=by_kg) - self.assertAlmostEqual(other.estimate(deployment).launch, 4 * 100 * 0.01) + model = CostModel(SatelliteCost(first_unit=1), launch=by_kg) + self.assertAlmostEqual(model.estimate(deployment).launch, 4 * 100 * 0.01) unsized = DeploymentSchedule(years=3).plan(_walker(1, 4)) - self.assertAlmostEqual(other.estimate(unsized).launch, 4 * 60 * 0.01) with self.assertRaisesRegex(ValueError, "masses"): - CostModel(SatelliteCost(), launch=by_kg).estimate(unsized) + model.estimate(unsized) def test_types(self): """Types of satellites are developed once each, with their own curves.""" @@ -284,7 +277,7 @@ def evaluate(d): return {**cost.metrics(), "satellites": count_satellites(d.layout)} results = Study(space, lambda d: d, evaluate, replicates=20).run(designs) - summary = aggregate( + summary = summarize( results, statistics={"cost": "cost", "cost p70": Quantile("cost", 0.7)} ) # the 0.7 quantile of a growth skewed upward exceeds the mean @@ -452,6 +445,10 @@ def test_quantiles(self): Triangular(1.2, 1.5) # mode below the lowest growth with self.assertRaises(ValueError): Triangular(1.0, 1.0) + # the mode by name, unlike the order of Uncertain.triangular + self.assertAlmostEqual(Triangular(0.9, 1.6, mode=1.2).ppf(3 / 7), 1.2) + with self.assertRaises(TypeError): + Triangular(0.9, 1.0, 1.6) # pylint: disable=too-many-function-args class TestComponents(unittest.TestCase): diff --git a/tests/tradespace/test_criteria.py b/tests/tradespace/test_criteria.py index 41ce0790..f439e938 100644 --- a/tests/tradespace/test_criteria.py +++ b/tests/tradespace/test_criteria.py @@ -19,6 +19,16 @@ Requirement, pareto_front, ) +from tatc.tradespace.criteria import ( + _as_criteria, + _combiners, + _costs, + _resolved, + _signs, + _statistic, + _tolerances, + _violation, +) class TestRequirement(unittest.TestCase): @@ -83,10 +93,10 @@ def test_names(self): ) self.assertEqual(criteria.names, ["a", "b", "c"]) self.assertEqual(criteria.metrics, ["a", "x", "y"]) - self.assertEqual(criteria.statistic("a"), Mean("a")) - self.assertEqual(criteria.statistic("b"), Mean("y")) + self.assertEqual(_statistic(criteria, "a"), Mean("a")) + self.assertEqual(_statistic(criteria, "b"), Mean("y")) self.assertEqual( - criteria.resolved, {"a": Mean("a"), "b": Mean("y"), "c": Mean("x")} + _resolved(criteria), {"a": Mean("a"), "b": Mean("y"), "c": Mean("x")} ) self.assertEqual(criteria.by, ("sensor",)) @@ -124,10 +134,10 @@ def test_shorthand(self): pareto_front(frame, objectives), pareto_front(frame, Criteria(objectives)) ) criteria = Criteria(objectives) - self.assertIs(Criteria.of(criteria), criteria) - self.assertEqual(Criteria.of(objectives), criteria) + self.assertIs(_as_criteria(criteria), criteria) + self.assertEqual(_as_criteria(objectives), criteria) with self.assertRaises(TypeError): - Criteria.of(["cost"]) + _as_criteria(["cost"]) def test_costs_and_violation(self): """Objectives are costs (maximized ones negated), and the violations @@ -136,17 +146,17 @@ def test_costs_and_violation(self): {"cost": "min", "value": "max"}, requirements=[Requirement("cost", "<=", 2), Requirement("value", ">=", 4)], ) - np.testing.assert_array_equal(criteria.signs, [1.0, -1.0]) + np.testing.assert_array_equal(_signs(criteria), [1.0, -1.0]) values = {"cost": np.array([1.0, 3.0]), "value": np.array([5.0, np.nan])} np.testing.assert_array_equal( - criteria.costs(values), [[1.0, -5.0], [3.0, np.nan]] + _costs(criteria, values), [[1.0, -5.0], [3.0, np.nan]] ) - np.testing.assert_allclose(criteria.violation(values, 2), [0.0, np.nan]) + np.testing.assert_allclose(_violation(criteria, values, 2), [0.0, np.nan]) np.testing.assert_allclose( - criteria.violation({"cost": [3.0], "value": [2.0]}, 1), [0.5 + 0.5] + _violation(criteria, {"cost": [3.0], "value": [2.0]}, 1), [0.5 + 0.5] ) - self.assertEqual(criteria.costs({"cost": [], "value": []}).shape, (0, 2)) - np.testing.assert_array_equal(Criteria({"a": "min"}).violation({}, 3), 0.0) + self.assertEqual(_costs(criteria, {"cost": [], "value": []}).shape, (0, 2)) + np.testing.assert_array_equal(_violation(Criteria({"a": "min"}), {}, 3), 0.0) def test_tolerance_array(self): """Tolerances are values in the units of objectives, or shares of @@ -155,12 +165,12 @@ def test_tolerance_array(self): {"a": "min", "b": "max", "c": "min"}, tolerances={"c": "5%", "a": 2} ) np.testing.assert_array_equal( - criteria.tolerance_array, [[2.0, 0.0, 0.0], [0.0, 0.0, 0.05]] + _tolerances(criteria), [[2.0, 0.0, 0.0], [0.0, 0.0, 0.05]] ) # derived from the tolerances, which compare criteria changed = dataclasses.replace(criteria, tolerances={"b": 1}) np.testing.assert_array_equal( - changed.tolerance_array, [[0.0, 1.0, 0.0], [0.0, 0.0, 0.0]] + _tolerances(changed), [[0.0, 1.0, 0.0], [0.0, 0.0, 0.0]] ) self.assertEqual(criteria, dataclasses.replace(criteria)) self.assertNotEqual(criteria, changed) @@ -168,7 +178,7 @@ def test_tolerance_array(self): def test_combiners(self): """Statistics across groups are combined by their worst, or their mean.""" - self.assertEqual(Criteria({"a": "min"}).combiners, {}) + self.assertEqual(_combiners(Criteria({"a": "min"})), {}) criteria = Criteria( {"a": "min", "b": "max"}, statistics={"c": "x", "d": "y"}, @@ -176,7 +186,7 @@ def test_combiners(self): across=Across(rules={"b": "mean"}), ) self.assertEqual( - criteria.combiners, {"a": "max", "b": "mean", "c": "min", "d": "mean"} + _combiners(criteria), {"a": "max", "b": "mean", "c": "min", "d": "mean"} ) with self.assertRaisesRegex(ValueError, "no worst"): Criteria( diff --git a/tests/tradespace/test_deployment.py b/tests/tradespace/test_deployment.py index 9fd94812..e69d253e 100644 --- a/tests/tradespace/test_deployment.py +++ b/tests/tradespace/test_deployment.py @@ -253,8 +253,6 @@ def test_design_life_by_type(self): ] self.assertEqual(replacements, [("short", 3), ("short", 5)]) self.assertEqual(deployment.units, {"short": 6, "long": 2}) - self.assertEqual(schedule.design_life_of("short"), 2) - self.assertIsNone(schedule.design_life_of("long")) with self.assertRaises(ValueError): DeploymentSchedule(design_life={"short": 2}).plan(_walker(), kind="long") diff --git a/tests/tradespace/test_failures.py b/tests/tradespace/test_failures.py index b18a3cc3..be605a71 100644 --- a/tests/tradespace/test_failures.py +++ b/tests/tradespace/test_failures.py @@ -22,19 +22,22 @@ FailureModel, Integer, LaunchCost, + Mean, OperationsCost, Piecewise, - Requirement, + Probability, + Quantile, RestorationPolicy, SatelliteCost, Stage, + StandardDeviation, Study, Uncertain, Weibull, - aggregate, build_constellation, pareto_front, policy_space, + summarize, walker_space, ) from tatc.tradespace import expectations as expectations_module @@ -490,7 +493,7 @@ def evaluate(d): designs = space.enumerate() self.assertEqual(len(designs), 2 * 5) results = Study(space, lambda d: d, evaluate, replicates=30).run(designs) - summary = aggregate(results, ["cost", "availability"]) + summary = summarize(results, statistics=["cost", "availability"]) front = summary[pareto_front(summary, {"cost": "min", "availability": "max"})] policies = { ( @@ -556,27 +559,29 @@ def test_simulate_many(self): self.failures, 7, histories=10, sampling="random" ) self.assertEqual(degraded[3].failures[0], histories[3].failures[0]) - self.assertEqual( - len(deployment.simulate_many(self.failures, None, histories=10)), 1 - ) + # without a seed, the one history without failures + (unseeded,) = deployment.simulate_many(self.failures, None) + self.assertEqual(unseeded.failures, []) + with self.assertRaisesRegex(ValueError, "seed"): + deployment.simulate_many(self.failures, None, histories=10) self.assertIs(deployment.planned(), deployment.planned()) with self.assertRaises(ValueError): deployment.simulate_many(self.failures, 7, histories=0) # without a model of failures, as simulate, nothing fails unfailing = deployment.simulate_many(seed=7, histories=3) self.assertEqual([h.failures for h in unfailing], [[], [], []]) - self.assertEqual(deployment.expected_metrics(histories=3)["availability"], 1) + # pylint: disable-next=protected-access + self.assertEqual(deployment._expected_metrics(histories=3)["availability"], 1) def test_phase_cache(self): """A cache evaluates each set of satellites once, as without it.""" deployment = self.schedule.plan(self.layout) histories = deployment.simulate_many(self.failures, 7, histories=20) cache = PhaseCache(self._metric) + capability = Capability(self.satellites, self.observations, cache, context="r0") for history in histories: phases = history.phases(self.satellites) - cached = cache.evaluate( - phases, self.satellites, self.observations, context="r0" - ) + cached = capability.evaluate(phases) direct = evaluate_phases(phases, self.observations, self._metric) pd.testing.assert_frame_equal(cached, direct) self.assertGreater(cache.hits, cache.misses) @@ -589,16 +594,13 @@ def test_phase_cache(self): {s.name: r.name for s, r in zip(self.satellites, renamed)} ) misses = cache.misses - cache.evaluate( - histories[0].phases(renamed), renamed, observations, context="r0" + Capability(renamed, observations, cache, context="r0").evaluate( + histories[0].phases(renamed) ) self.assertEqual(cache.misses, misses) # other observations (another context) are evaluated again - cache.evaluate( - histories[0].phases(self.satellites), - self.satellites, - self.observations, - context="r1", + Capability(self.satellites, self.observations, cache, context="r1").evaluate( + histories[0].phases(self.satellites) ) self.assertGreater(cache.misses, misses) cache.clear() @@ -626,8 +628,12 @@ def test_evaluate_and_summarize(self): self.assertIn(column, missions.columns) summary = summarize_histories( missions, - quantiles={"share mission": [0.1, 0.5], "cost": 0.7}, - requirements=[Requirement("share mission", ">=", 60)], + statistics=[ + Quantile("share mission", 0.1), + Quantile("share mission", 0.5), + Quantile("cost", 0.7), + Probability("share mission", ">=", 60), + ], ) self.assertAlmostEqual( summary["share mission"], missions["share mission"].mean() @@ -727,10 +733,11 @@ def test_stratified_histories(self): def test_expected_metrics(self): """Expected measures of a mission from many histories.""" deployment = self.schedule.plan(self.layout) - expected = deployment.expected_metrics(self.failures, histories=200) + # pylint: disable=protected-access + expected = deployment._expected_metrics(self.failures, histories=200) self.assertTrue(0 < expected["availability"] < 1) self.assertEqual( - deployment.expected_metrics(FailureModel(), histories=10)["availability"], + deployment._expected_metrics(FailureModel(), histories=10)["availability"], 1.0, ) @@ -784,7 +791,9 @@ def _pilot(self, between, within, replicates=200, histories=20, seed=0): for _ in range(replicates): expected = rng.normal(50, between) missions = pd.DataFrame({"share": rng.normal(expected, within, histories)}) - rows.append(summarize_histories(missions, spread=True)) + rows.append( + summarize_histories(missions, statistics=[StandardDeviation("share")]) + ) return pd.DataFrame(rows) def test_recommendation(self): @@ -1027,7 +1036,7 @@ def test_rare_losses(self): [{**h.metrics(), "weight": h.weight} for h in histories] ) summary = summarize_histories( - rows, requirements=[Requirement("failures", ">=", 2)] + rows, statistics=[Probability("failures", ">=", 2)] ) values.append(summary["P(failures >= 2) histories"]) if stress > 1: @@ -1054,22 +1063,28 @@ def test_stressed_launches(self): ) def test_times_and_columns(self): - """Times that a history never meets are infinite in the summaries, and - quantiles and requirements need columns of the histories.""" + """Times that a history never meets are infinite in the summaries, + missing values are left out, and statistics need columns of the + histories, of the kinds that summarize histories.""" histories = pd.DataFrame({"accurate time": [2.0, 3.0, math.inf, np.nan]}) summary = summarize_histories( histories, - quantiles={"accurate time": [0.3, 0.9]}, - requirements=[Requirement("accurate time", "<=", 3)], + statistics=[ + Quantile("accurate time", 0.3), + Quantile("accurate time", 0.9), + Probability("accurate time", "<=", 3), + ], ) self.assertEqual(summary["accurate time"], math.inf) self.assertEqual(summary["accurate time histories p30"], 2.0) self.assertEqual(summary["accurate time histories p90"], math.inf) - self.assertEqual(summary["P(accurate time <= 3) histories"], 0.5) + self.assertEqual(summary["P(accurate time <= 3) histories"], 2 / 3) with self.assertRaisesRegex(ValueError, "other"): - summarize_histories(histories, quantiles={"other": 0.5}) + summarize_histories(histories, statistics=[Quantile("other", 0.5)]) with self.assertRaisesRegex(ValueError, "other"): - summarize_histories(histories, requirements=[Requirement("other", ">", 1)]) + summarize_histories(histories, statistics=[Probability("other", ">", 1)]) + with self.assertRaises(TypeError): + summarize_histories(histories, statistics=[Mean("accurate time")]) def test_weighted_summaries(self): """Weighted histories give weighted statistics.""" @@ -1078,9 +1093,11 @@ def test_weighted_summaries(self): ) summary = summarize_histories( missions, - quantiles={"value": 0.5}, - requirements=[Requirement("value", ">=", 3)], - spread=True, + statistics=[ + Quantile("value", 0.5), + Probability("value", ">=", 3), + StandardDeviation("value"), + ], ) self.assertAlmostEqual(summary["value"], (4 + 2 + 3 + 8) / 8) self.assertEqual(summary["value histories p50"], 1.0) # half the weight is at 1 diff --git a/tests/tradespace/test_fingerprint.py b/tests/tradespace/test_fingerprint.py index b5dd7b67..82935fc5 100644 --- a/tests/tradespace/test_fingerprint.py +++ b/tests/tradespace/test_fingerprint.py @@ -43,7 +43,6 @@ describe, get_definition, get_fingerprint, - find_stale, warn_stale, ) @@ -369,11 +368,12 @@ def test_versions(self): # of definitions definition = {"values": {"f": newer}} self.assertEqual( - fingerprint._with_other_code( + fingerprint._find_stale( definition, {"a": {"values": {"f": older}}, "b": None, "c": {"values": {}}}, + lambda key: 1, ), - ["a"], + {"a": 1}, ) def test_dataclasses(self): @@ -744,7 +744,8 @@ def test_stale(self): with their numbers of results.""" others = {"b": self.older, "c": self.other, "d": None, "a": self.older} counts = {"a": 0, "b": 3, "c": 5, "d": 1} - found = find_stale(self.newer, others, counts.__getitem__) + # pylint: disable-next=protected-access + found = fingerprint._find_stale(self.newer, others, counts.__getitem__) self.assertEqual(list(found.items()), [("b", 3), ("a", 0)]) def test_warn_stale(self): diff --git a/tests/tradespace/test_observations.py b/tests/tradespace/test_observations.py index 90e2991b..0f9c32f0 100644 --- a/tests/tradespace/test_observations.py +++ b/tests/tradespace/test_observations.py @@ -4,6 +4,8 @@ @author Paul T. Grogan """ +# pylint: disable=protected-access + import dataclasses import importlib.util import math @@ -31,17 +33,21 @@ Exponential, FailureModel, Failures, + Fixed, Integer, LaunchCost, MissionPlan, ObservationStudy, Observations, + Probability, + Quantile, Real, Requirement, RestorationPolicy, SatelliteCache, SatelliteCost, Stage, + StandardDeviation, Study, Targets, Triangular, @@ -112,27 +118,27 @@ def test_generated(self): """Targets generated from a seed of the design differ by replicate.""" design = SPACE.enumerate()[0] first, second = design.realize(0), design.realize(1) - targets = TARGETS.of(first) + targets = TARGETS._of(first) pd.testing.assert_frame_equal( targets, generate_points_fibonacci_lattice( count=N_POINTS, rotate=True, seed=first.points_seed ), ) - self.assertIs(TARGETS.of(first), targets) # kept in memory - self.assertFalse(TARGETS.of(second).equals(targets)) + self.assertIs(TARGETS._of(first), targets) # kept in memory + self.assertFalse(TARGETS._of(second).equals(targets)) self.assertEqual(pickle.loads(pickle.dumps(TARGETS))._memory, {}) with self.assertRaises(ValueError): - TARGETS.of() + TARGETS._of() def test_fixed(self): """Fixed targets are the same in every replicate.""" points = generate_points_fibonacci_lattice(count=5, rotate=True, seed=1) targets = Targets(points) - self.assertIs(targets.of(), points) - self.assertIsNone(targets.seed_of(None)) + self.assertIs(targets._of(), points) + self.assertIsNone(targets._seed_of(None)) same = Targets(generate_points_fibonacci_lattice, count=5, rotate=True) - self.assertTrue(same.of().equals(same.of())) + self.assertTrue(same._of().equals(same._of())) with self.assertRaises(ValueError): Targets(points, seed="points_seed") with self.assertRaises(TypeError): @@ -149,13 +155,13 @@ def test_matches_analysis(self): d = SPACE.enumerate()[3].realize(0) satellites = _build(d) observations = _observations()(satellites, d) - direct = collect_observations(TARGETS.of(d), satellites, START, START + HOURS) + direct = collect_observations(TARGETS._of(d), satellites, START, START + HOURS) columns = ["target_hash", "satellite", "epoch"] pd.testing.assert_frame_equal( observations.sort_values(columns, ignore_index=True)[direct.columns], direct.sort_values(columns, ignore_index=True), ) - self.assertEqual(_observations().context_of(d), (d.points_seed, START, HOURS)) + self.assertEqual(_observations()._context_of(d), (d.points_seed, START, HOURS)) def test_disk_cache(self): """Observations on disk are kept by the seed of the targets and the period.""" @@ -171,7 +177,7 @@ def test_disk_cache(self): self.assertTrue(all("targets of seed" in n for n in namespaces)) again = _observations(directory) again(_build(designs[0]), designs[0]) - self.assertEqual(again.cache_of(designs[0]).misses, 0) + self.assertEqual(again._cache_of(designs[0]).misses, 0) def test_targets_generated_when_needed(self): """Caches on disk of generated targets are keyed by their recipe and @@ -195,7 +201,7 @@ def test_targets_generated_when_needed(self): again(_build(designs[0])[:1], designs[0]) # from the results on disk generated.assert_not_called() self.assertEqual( - sorted(SatelliteCache.contexts(directory).values()), + sorted(SatelliteCache._contexts(directory).values()), sorted((d.points_seed, START) for d in designs), ) # the fingerprint of a cache follows the recipe of the targets (their @@ -204,14 +210,14 @@ def test_targets_generated_when_needed(self): def fingerprint(targets): return get_fingerprint( - Observations(targets, START, HOURS).cache_of(d).function + Observations(targets, START, HOURS)._cache_of(d).function ) fresh = Targets(_grid, 5, seed="points_seed") recipes = [fresh, Targets(_grid, 6, seed="points_seed"), TARGETS] prints = [fingerprint(targets) for targets in recipes] self.assertEqual(len(set(prints)), 3) - fresh.of(d) + fresh._of(d) self.assertEqual(fingerprint(fresh), prints[0]) def test_directory_not_in_fingerprint(self): @@ -241,7 +247,7 @@ def test_matches_study(self): def evaluate(satellites, design): deployment = SCHEDULE.plan(design.layout) observations = collect_observations( - TARGETS.of(design), satellites, START, START + HOURS + TARGETS._of(design), satellites, START, START + HOURS ) return { "satellites": len(satellites), @@ -297,17 +303,12 @@ def test_phases_and_failures(self): failures=failures, ).run(designs) self.assertTrue({"observed mission", "availability", "cost"} <= set(degraded)) - # the policy of each design + # the policy of each design: by default, its values `policy` trade = DesignSpace( **SPACE.children, policy=policy_space(orbit_spares=Integer(0, 1)) ) restored = ObservationStudy( - trade, - _build, - _observations(), - _metrics, - plan=dataclasses.replace(PLAN, policy="policy"), - failures=failures, + trade, _build, _observations(), _metrics, plan=PLAN, failures=failures ).run(trade.enumerate()[:4]) self.assertTrue(restored.feasible.all()) spares = restored.groupby("policy.orbit_spares")["cost production"].mean() @@ -369,7 +370,7 @@ def test_epoch(self): for epoch, d in realized.items(): self.assertEqual(observations.start_of(d), epoch) self.assertEqual(observations.end_of(d), epoch + HOURS) - self.assertEqual(observations.context_of(d)[1], epoch) + self.assertEqual(observations._context_of(d)[1], epoch) satellites = _build(d) fixed = Observations(TARGETS, epoch, HOURS)(satellites, d) pd.testing.assert_frame_equal(observations(satellites, d), fixed) @@ -379,11 +380,9 @@ def test_epoch(self): observations(satellites, realized[later]) ) ) - with self.assertRaises(ValueError): - _ = observations.end with self.assertRaises(ValueError): observations.start_of(None) - self.assertEqual(Observations(TARGETS, START, HOURS).end, START + HOURS) + self.assertEqual(Observations(TARGETS, START, HOURS).end_of(), START + HOURS) # a study with an epoch drawn for each replicate results = ObservationStudy( space, _build, observations, _metrics, layout="layout", replicates=4 @@ -392,14 +391,14 @@ def test_epoch(self): def test_sizing(self): """Plans size the schedule and costs of each design by its values, and - limit launches by the masses of the cost model.""" + limit launches by the masses of the plan.""" designs = [d for d in SPACE.enumerate() if d.layout.per_plane == 2] def cost_model(d): """Satellites that cost more to develop higher (an illustrative relationship).""" development = 10 * d.altitude / 600e3 return CostModel( - SatelliteCost(development=development, first_unit=2, mass=100), + SatelliteCost(development=development, first_unit=2), launch=LaunchCost(per_launch=1), ) @@ -413,7 +412,7 @@ def study(plan): SPACE, _build, _observations(), _metrics, layout="layout", plan=plan ) - results = study(MissionPlan(schedule, cost_model)).run(designs) + results = study(MissionPlan(schedule, cost_model, masses=100.0)).run(designs) by_altitude = results.groupby("altitude")[["cost development", "cost launch"]] means = by_altitude.mean() self.assertAlmostEqual( @@ -424,8 +423,9 @@ def study(plan): planes = results.groupby("altitude")["planes"].mean() self.assertAlmostEqual(means.loc[600e3, "cost launch"], planes[600e3]) self.assertAlmostEqual(means.loc[700e3, "cost launch"], 2 * planes[700e3]) - # given masses take the place of those of the cost model - light = study(MissionPlan(schedule, cost_model, masses=50.0)).run(designs) + # masses of each design (a reference to its values) + light = study(MissionPlan(schedule, cost_model, masses=lambda d: 50.0)) + light = light.run(designs) self.assertAlmostEqual( light.groupby("altitude")["cost launch"].mean()[700e3], planes[700e3] ) @@ -476,13 +476,13 @@ def study(plan): ) design = designs[0].realize(0) self.assertEqual( - plan.growth_of(design), {"development": {"a": design.growth, "b": 2}} + plan._growth_of(design), {"development": {"a": design.growth, "b": 2}} ) # scores of a group nested in another nested = SPACE.extend(risk=DesignSpace(cost_risk=risk_space(model))) design = nested.enumerate()[0].realize(3) plan = MissionPlan(SCHEDULE, model, scores="risk.cost_risk") - self.assertEqual(plan.cost_model_of(design), model.draw(design.risk.cost_risk)) + self.assertEqual(plan._cost_model_of(design), model.draw(design.risk.cost_risk)) def test_stages(self): """Plans stage the deployments of designs that decide to.""" @@ -516,7 +516,7 @@ def stages(design): self.assertTrue(np.isnan(staged.loc[False, "stages deployed"])) # no stages self.assertLess(staged.loc[True, "deployed"], staged.loc[False, "deployed"]) # failures without restoration: histories are sampled rather than exact - failures = Failures(FAILURES, histories=4, seed="failure_seed") + failures = Failures(FAILURES, seed="failure_seed", histories=4) options["plan"] = dataclasses.replace( plan, policy=RestorationPolicy(restore=False) ) @@ -603,6 +603,21 @@ def metric(observations, design): plain = study.replace(metrics=_metrics).evaluate self.assertEqual(plain.context_of(first), plain.context_of(other)) + def test_references(self): + """Every part of a plan may refer to a value of the design, by name or + by a function of the design.""" + space = SPACE.extend( + staging=Fixed((Stage(1, 1.0),)), schedule=Fixed(SCHEDULE), mass=Fixed(5.0) + ) + design = [d for d in space.enumerate() if d.layout.planes == 2][0] + plan = MissionPlan("schedule", lambda d: COSTS, stages="staging", masses="mass") + study = ObservationStudy(space, _build, _observations(), _metrics, plan=plan) + mission = study.mission_of(design) + self.assertEqual(mission.deployment.stages, (Stage(1, 1.0),)) + self.assertEqual(mission.deployment.masses, {None: 5.0}) + self.assertIs(mission.deployment.schedule, SCHEDULE) + self.assertEqual(mission.cost_model, COSTS) + def test_staging_recorded(self): """Studies record the stages that rules deploy (without failures), and when the first generation is deployed, with them.""" @@ -681,37 +696,45 @@ def study(policy): # a group of values that configures the default policy, or a base one space = SPACE.extend(policy=policy_space(restore=True, orbit_spares=1)) realized = space.enumerate()[0].realize(0) - named = dataclasses.replace(PLAN, policy="policy").policy_of(realized) + named = dataclasses.replace(PLAN, policy="policy")._policy_of(realized) self.assertEqual(named, RestorationPolicy(orbit_spares=1)) base = RestorationPolicy(drift_years=1.0) configured = dataclasses.replace( PLAN, policy=lambda d: configure(base, d.policy) - ).policy_of(realized) + )._policy_of(realized) self.assertEqual(configured, RestorationPolicy(orbit_spares=1, drift_years=1.0)) + # by default, the design's values `policy`, if they configure a policy + self.assertEqual(PLAN._policy_of(realized), RestorationPolicy(orbit_spares=1)) + other = SPACE.extend(policy=Categorical(["a", "b"])).enumerate()[0] + self.assertEqual(PLAN._policy_of(other.realize(0)), RestorationPolicy()) + self.assertEqual(PLAN._policy_of(designs[0].realize(0)), RestorationPolicy()) def test_failure_times(self): """Failures give each history the time until it meets requirements on its phases, summarized over the histories.""" failures = Failures( FAILURES, - histories=6, seed="failure_seed", - phases=[Requirement("observed", ">=", 50)], - quantiles={"observed time": 0.5}, - requirements=[Requirement("observed time", "<=", 1)], + histories=6, + statistics=[ + Quantile("observed time", 0.5), + Probability("observed time", "<=", 1), + ], ) - study = ObservationStudy( - SPACE, _build, _observations(), _metrics, plan=PLAN, failures=failures + phased = ObservationStudy( + SPACE, + _build, + _observations(), + _metrics, + plan=PLAN, + phases=[Requirement("observed", ">=", 50)], ) + study = phased.replace(failures=failures) # the requirements of the study design = SPACE.enumerate()[3] result = study.run([design]).iloc[0] histories = study.mission_of(design).histories() self.assertIn("observed time", histories) - summary = summarize_histories( - histories, - quantiles=failures.quantiles, - requirements=failures.requirements, - ) + summary = summarize_histories(histories, statistics=failures.statistics) for column in ( "observed time", "observed time histories p50", @@ -729,14 +752,23 @@ def test_failure_validation(self): for invalid in ( {"sampling": "antithetic"}, {"stress": 0.0}, - {"launch_stress": -1.0}, {"histories": 0}, + {"control_histories": 0}, + {"seed": None}, ): with self.subTest(invalid=invalid): with self.assertRaises(ValueError): - Failures(FAILURES, **invalid) + Failures(FAILURES, **{"seed": "failure_seed", **invalid}) + with self.assertRaises(TypeError): + Failures(FAILURES) # pylint: disable=missing-kwoa + with self.assertRaises(TypeError): + Failures( + FAILURES, seed="failure_seed", statistics=[Requirement("x", ">", 1)] + ) with self.assertRaises(TypeError): - Failures(FAILURES, phases=["observed >= 50"]) + ObservationStudy( + SPACE, _build, _observations(), _metrics, plan=PLAN, phases=["x"] + ) with self.assertRaisesRegex(ValueError, "cost model"): ObservationStudy( SPACE, @@ -744,7 +776,9 @@ def test_failure_validation(self): _observations(), _metrics, plan=MissionPlan(SCHEDULE), - failures=Failures(FAILURES, quantiles={"cost": 0.7}), + failures=Failures( + FAILURES, seed="failure_seed", statistics=[Quantile("cost", 0.7)] + ), ) # quantiles of other columns that the histories do not have study = ObservationStudy( @@ -753,7 +787,9 @@ def test_failure_validation(self): _observations(), _metrics, plan=PLAN, - failures=Failures(FAILURES, quantiles={"other": 0.5}), + failures=Failures( + FAILURES, seed="failure_seed", statistics=[Quantile("other", 0.5)] + ), ) with self.assertRaisesRegex(ValueError, "other"): study.run(SPACE.enumerate()[:1]) @@ -790,10 +826,7 @@ def test_invalid(self): _build, observations, _metrics, - layout="layout", - plan=PLAN, - failures=Failures(FAILURES), - phases=True, + failures=Failures(FAILURES, seed="failure_seed"), ) @unittest.skipUnless(HAS_JOBLIB, "requires joblib") @@ -843,7 +876,7 @@ def test_mission(self): self.assertEqual(mission.design.growth, realized.growth) deployment = mission.deployment self.assertEqual(deployment.planes, SCHEDULE.plan(realized.layout).planes) - self.assertIs(deployment.capability, mission.capability) + self.assertIs(mission.capability, deployment.capability) phases = mission.phases() self.assertAlmostEqual( summarize_phases(phases)["observed mission"], result["observed mission"] @@ -851,7 +884,7 @@ def test_mission(self): self.assertAlmostEqual(mission.estimate().total, result["cost"]) self.assertEqual(deployment.planned().deployed, result["deployed"]) self.assertIs(deployment.planned(), deployment.planned()) - self.assertIs(deployment.policy, PLAN.policy) + self.assertEqual(deployment.policy, RestorationPolicy()) with self.assertRaisesRegex(ValueError, "failures"): mission.histories() unplanned = self.study.replace(plan=None, phases=None) @@ -910,7 +943,7 @@ def analysis(source): others(satellites, realized) with self.assertWarnsRegex(UserWarning, "other code"): latest(satellites, realized) - stale = first.cache_of(realized).folder + stale = first._cache_of(realized).folder self.assertEqual(len(list(stale.glob("*.pkl"))), len(satellites)) # a study removes them too, and counts the evaluations it removes study = ObservationStudy(SPACE, _build, latest, _metrics) @@ -918,13 +951,15 @@ def analysis(source): self.assertEqual(list(stale.glob("*.pkl")), []) self.assertEqual(latest.prune(), 0) # the results of the other targets (another definition) are kept - kept = others.cache_of(realized).folder + kept = others._cache_of(realized).folder self.assertEqual(len(list(kept.glob("*.pkl"))), len(satellites)) self.assertEqual(Observations(TARGETS, START, HOURS).prune(), 0) def test_failure_options(self): """Failures sample stressed histories, with controls and spreads.""" - self.assertTrue(MissionPlan(SCHEDULE).policy.restore) # restored by default + realized = self.design.realize(0) + default = MissionPlan(SCHEDULE)._policy_of(realized) + self.assertTrue(default.restore) # restored by default study = ObservationStudy( SPACE, _build, @@ -934,12 +969,12 @@ def test_failure_options(self): plan=PLAN, failures=Failures( FAILURES, - histories=6, seed="failure_seed", + histories=6, stress=2.0, controls=["availability"], control_histories=50, - spread=True, + statistics=[StandardDeviation("observed mission")], ), ) result = study.run([self.design]).iloc[0] @@ -1001,19 +1036,3 @@ def test_exact_or_sampled(self): fallback = study.run([design]).iloc[0] for column in ("observed mission", "availability"): self.assertAlmostEqual(fallback[column], sampled[column].mean()) - - def test_exact_without_seed(self): - """Without a seed, the one history without failures is not replaced by - exact expectations over failures.""" - design = SPACE.enumerate()[3] - study = ObservationStudy( - SPACE, - _build, - _observations(), - _metrics, - plan=DEGRADE, - failures=Failures(FAILURES), - ) - result = study.run([design]).iloc[0] - self.assertEqual(result["availability"], 1.0) - self.assertEqual(result["failures"], 0.0) diff --git a/tests/tradespace/test_optimization.py b/tests/tradespace/test_optimization.py index d6b69fef..4cd95922 100644 --- a/tests/tradespace/test_optimization.py +++ b/tests/tradespace/test_optimization.py @@ -23,7 +23,6 @@ Requirement, Study, Uncertain, - aggregate, hypervolume, optimize_optuna, optimize_pymoo, @@ -35,6 +34,8 @@ _constraint_names, make_pymoo_problem, ) +from tatc.tradespace.values import Scope +from tatc.tradespace.walks import _Context, _walk HAS_OPTUNA = importlib.util.find_spec("optuna") is not None HAS_PYMOO = importlib.util.find_spec("pymoo") is not None @@ -43,6 +44,20 @@ REFERENCE = {"cost": 30, "value": 0} +def _encode(space, design): + """The center of each decided level's part of [0, 1], and 0.5 for inactive paths.""" + paths = space._unit_paths() + index = {path: i for i, path in enumerate(paths)} + unit = np.full(len(index), 0.5) + + def record(path, domain, value): + unit[index[path]] = (domain.levels.index(value) + 0.5) / len(domain.levels) + return value + + _walk(space, "", Scope(), _Context(normalize=record), design.decisions) + return unit + + def _space(): """Constellations of planes, or a single satellite of a quality.""" return DesignSpace( @@ -103,7 +118,7 @@ class TestEncoding(unittest.TestCase): def test_unit_paths(self): """Paths cover every decision, with repeated items up to the largest count.""" - paths = _space().unit_paths() + paths = _space()._unit_paths() self.assertEqual( paths[:3], [ @@ -119,7 +134,7 @@ def test_round_trip(self): """Every design decodes from its encoding.""" space = _space() for design in space.enumerate(): - self.assertEqual(space.decode(space.encode(design)).key, design.key) + self.assertEqual(space._decode(_encode(space, design)).key, design.key) def test_decode_random(self): """Random points decode to designs of the space (or infeasible ones).""" @@ -129,7 +144,7 @@ def test_decode_random(self): decoded = 0 for _ in range(200): try: - design = space.decode(rng.random(len(space.unit_paths()))) + design = space._decode(rng.random(len(space._unit_paths()))) except Infeasible: continue decoded += 1 @@ -143,7 +158,7 @@ def test_dynamic_count_bound(self): parts=Repeat(Integer(0, 1), count=Integer(1, lambda d: d.n)), ) with self.assertRaises(ValueError): - space.unit_paths() + space._unit_paths() class TestEvaluations(unittest.TestCase): @@ -177,9 +192,11 @@ def test_feasible_replicates(self): self.assertEqual( [evaluations.infeasibility[d.key] for d in designs], [0.0, 0.0, 1.0] ) - # the summary of a search is that of its results (see aggregate) + # the summary of a search is that of its results (see summarize) search = evaluations.search(None) - pd.testing.assert_frame_equal(search.summary, aggregate(results, {"f": "max"})) + pd.testing.assert_frame_equal( + search.summary, summarize(results, {"f": "max"}, spread=False) + ) self.assertEqual([d.key for d in search.designs], [designs[1].key]) self.assertEqual(len(search.evaluated), 3) # a requirement on the share of feasible replicates @@ -222,7 +239,7 @@ def test_constraint_names(self): def _exact_hypervolume(): - summary = summarize(_study().run(), list(OBJECTIVES)) + summary = summarize(_study().run(), statistics=list(OBJECTIVES)) return summary, hypervolume(summary, OBJECTIVES, REFERENCE) @@ -246,7 +263,7 @@ def test_suggest(self): "layout.planes.planes[1].size": 0.5, } ) - design = _space().suggest(trial) + design = _space()._suggest(trial) self.assertEqual( [(p.satellites, p.size) for p in design.layout.planes], [(1, 0.5), (3, 1.5)] ) @@ -269,7 +286,7 @@ def test_optimize(self): ) optuna_study, results = search.state, search.results self.assertEqual(len(optuna_study.trials), 150) - found = summarize(results, list(OBJECTIVES)) + found = summarize(results, statistics=list(OBJECTIVES)) self.assertLessEqual(found.design.nunique(), 150) self.assertGreater(hypervolume(found, OBJECTIVES, REFERENCE), 0.9 * exact) self.assertTrue(pareto_front(summary, OBJECTIVES).any()) @@ -298,7 +315,7 @@ def test_optimize(self): list(search.summary.design[search.summary.pareto]), ) self.assertEqual(search.criteria.objectives, OBJECTIVES) - found = summarize(results, list(OBJECTIVES)) + found = summarize(results, statistics=list(OBJECTIVES)) self.assertGreater(hypervolume(found, OBJECTIVES, REFERENCE), 0.9 * exact) self.assertFalse(results.feasible.all()) # some designs were too heavy # the summary of the feasible designs, and their front @@ -318,24 +335,25 @@ def test_duplicates(self): study = _study() problem = make_pymoo_problem(study, OBJECTIVES) single = study.space.design({"layout": ["single", {"quality": 2}]}) - x = study.space.encode(single) + x = _encode(study.space, single) # the same level of each variable, and other values of the branch not chosen same = x.copy() - same[study.space.unit_paths().index("layout.single.quality")] += 0.1 + same[study.space._unit_paths().index("layout.single.quality")] += 0.1 other = x.copy() - other[study.space.unit_paths().index("layout.planes.planes.count")] = 0.9 - too_many = study.space.encode( + other[study.space._unit_paths().index("layout.planes.planes.count")] = 0.9 + too_many = _encode( + study.space, study.space.design( {"layout": ["planes", {"planes": [{"satellites": 4, "size": 0.5}] * 2}]} - ) + ), ) - too_many[study.space.unit_paths().index("layout.planes.planes.count")] = 0.99 + too_many[study.space._unit_paths().index("layout.planes.planes.count")] = 0.99 for k in range(3): too_many[ - study.space.unit_paths().index(f"layout.planes.planes[{k}].satellites") + study.space._unit_paths().index(f"layout.planes.planes[{k}].satellites") ] = 0.99 with self.assertRaises(Infeasible): - study.space.decode(too_many) + study.space._decode(too_many) pop = Population.new("X", np.array([x, same, other, too_many, too_many])) kept = problem.duplicates.do(pop) self.assertEqual(len(kept), 3) # one of the same design, and both infeasible @@ -363,11 +381,18 @@ def test_algorithm_unchanged(self): algorithm = NSGA2(pop_size=8) own = algorithm.mating.eliminate_duplicates - optimize_pymoo(_study(), OBJECTIVES, algorithm, ("n_gen", 2), seed=1) + optimize_pymoo( + _study(), OBJECTIVES, algorithm=algorithm, termination=("n_gen", 2), seed=1 + ) self.assertIs(algorithm.mating.eliminate_duplicates, own) self.assertIs(algorithm.initialization.eliminate_duplicates, own) plain = optimize_pymoo( - _study(), OBJECTIVES, algorithm, ("n_gen", 2), seed=1, distinct=False + _study(), + OBJECTIVES, + algorithm=algorithm, + termination=("n_gen", 2), + seed=1, + distinct=False, ) self.assertGreater(len(plain.evaluated), 0) @@ -381,8 +406,8 @@ def test_max_designs(self): search = optimize_pymoo( _study(), OBJECTIVES, - NSGA2(pop_size=10), - ("n_gen", 50), + algorithm=NSGA2(pop_size=10), + termination=("n_gen", 50), seed=1, max_designs=25, ) @@ -394,8 +419,8 @@ def test_max_designs(self): short = optimize_pymoo( _study(), OBJECTIVES, - NSGA2(pop_size=10), - ("n_gen", 2), + algorithm=NSGA2(pop_size=10), + termination=("n_gen", 2), seed=1, max_designs=1000, ) @@ -473,15 +498,15 @@ def test_violations(self): light = space.design({"layout": ["single", {"quality": 2}]}) # three planes of four satellites: the first branch, the largest count # and number of satellites (the last of their levels) - paths = space.unit_paths() + paths = space._unit_paths() heavy = np.full(len(paths), 0.1) for i, path in enumerate(paths): if path.endswith("count") or path.endswith("satellites"): heavy[i] = 0.99 with self.assertRaises(Infeasible) as context: - space.decode(heavy) + space._decode(heavy) self.assertEqual(context.exception.violation, 4) - x = np.array([space.encode(light), heavy]) + x = np.array([_encode(space, light), heavy]) population = Evaluator().eval(problem, Population.new(X=x)) self.assertEqual(list(population.get("G")[:, 0]), [0, 4]) diff --git a/tests/tradespace/test_pareto.py b/tests/tradespace/test_pareto.py index 89737f62..a3f5d2dd 100644 --- a/tests/tradespace/test_pareto.py +++ b/tests/tradespace/test_pareto.py @@ -15,11 +15,11 @@ from tatc.tradespace import ( Criteria, Requirement, - aggregate, hypervolume, hypervolume_progress, pareto_front, pareto_ranks, + summarize, ) from tatc.tradespace.dominance import dominated @@ -193,7 +193,7 @@ def test_pareto(self): ignore_index=True, ) criteria = Criteria(self.objectives, by="size") - summary = aggregate(results, criteria) + summary = summarize(results, criteria) self.assertEqual( list(summary.pareto), list(pareto_front(summary.drop(columns="pareto"), criteria)), @@ -207,12 +207,12 @@ def test_pareto(self): def test_results_raise(self): """Results with a row per replicate are not summaries of designs.""" for function in (pareto_front, pareto_ranks): - with self.assertRaisesRegex(ValueError, "aggregate"): + with self.assertRaisesRegex(ValueError, "summarize"): function(self.results, self.objectives) - with self.assertRaisesRegex(ValueError, "aggregate"): + with self.assertRaisesRegex(ValueError, "summarize"): hypervolume(self.results, self.objectives, [2, 0]) indexed = self.results.set_index("design") - with self.assertRaisesRegex(ValueError, "aggregate"): + with self.assertRaisesRegex(ValueError, "summarize"): pareto_front(indexed, self.objectives) def test_groups_of_designs(self): diff --git a/tests/tradespace/test_plotting.py b/tests/tradespace/test_plotting.py index 48dc9826..4036cbcf 100644 --- a/tests/tradespace/test_plotting.py +++ b/tests/tradespace/test_plotting.py @@ -57,8 +57,7 @@ def test_designs(self): "satellites", "sufficient", by="planes", - front="pareto", - labels="design", + annotate="design", names=lambda planes: f"{planes} planes", jitter=0.2, ) @@ -75,10 +74,17 @@ def test_designs(self): # jitter shifts only the horizontal positions offsets = np.concatenate([c.get_offsets() for c in ax.collections[:2]]) self.assertTrue(np.all(np.abs(offsets[:, 0] - np.round(offsets[:, 0])) <= 0.2)) - # criteria find the front - ax = plot_designs(self.summary, "satellites", "sufficient", front=objectives) + # the front of the column `pareto` by default, or given rows + rows = pareto_front(self.summary, objectives) + plain = self.summary.drop(columns="pareto") + ax = plot_designs(plain, "satellites", "sufficient", front=rows) self.assertEqual(len(ax.collections[-1].get_offsets()), efficient) self.assertEqual(ax.get_xlabel(), "satellites") + # without the column, none + ax = plot_designs(plain, "satellites", "sufficient") + self.assertEqual(len(ax.collections), 1) + with self.assertRaisesRegex(ValueError, "efficient"): + plot_designs(self.summary, "satellites", "sufficient", front="best") def test_given_axes(self): """Plots draw on given axes.""" @@ -235,7 +241,7 @@ def test_missing_groups(self): self.assertEqual(labels, ["50.0", "60.0", "other", "Pareto-efficient"]) named = plot_designs(frame, "x", "y", by="inclination", others="sso") labels = [text.get_text() for text in named.get_legend().get_texts()] - self.assertEqual(labels[-1], "sso") + self.assertEqual(labels[-2:], ["sso", "Pareto-efficient"]) # with highlights, the designs in gray share their name both = plot_designs( frame, @@ -244,6 +250,7 @@ def test_missing_groups(self): by="inclination", highlight=[True, False, True, False], others="the rest", + front=None, ) labels = [text.get_text() for text in both.get_legend().get_texts()] self.assertEqual(labels, ["the rest", "50.0", "60.0"]) diff --git a/tests/tradespace/test_references.py b/tests/tradespace/test_references.py index 75ec23ff..79430893 100644 --- a/tests/tradespace/test_references.py +++ b/tests/tradespace/test_references.py @@ -5,6 +5,8 @@ @author Paul T. Grogan """ +# pylint: disable=protected-access + import dataclasses import unittest @@ -17,7 +19,7 @@ configure, value_of, ) -from tatc.tradespace.references import given_design, takes_design +from tatc.tradespace.references import _given_design, _takes_design SPACE = DesignSpace( altitude=Real(600e3, 700e3, step=100e3), @@ -108,22 +110,22 @@ def keyword(x, *, design=None): def only_position(x, design, /): return x, design - self.assertTrue(takes_design(positional)) - self.assertTrue(takes_design(keyword)) - self.assertFalse(takes_design(only_position)) - self.assertFalse(takes_design(lambda x: x)) - self.assertFalse(takes_design(lambda x, **kwargs: x)) - self.assertFalse(takes_design(len)) + self.assertTrue(_takes_design(positional)) + self.assertTrue(_takes_design(keyword)) + self.assertFalse(_takes_design(only_position)) + self.assertFalse(_takes_design(lambda x: x)) + self.assertFalse(_takes_design(lambda x, **kwargs: x)) + self.assertFalse(_takes_design(len)) def test_given_design(self): """A function that takes the design is given it; others are not.""" design = SPACE.enumerate()[0] self.assertEqual( - given_design(lambda x, design: (x, design.key), design)(1), + _given_design(lambda x, design: (x, design.key), design)(1), (1, design.key), ) def alone(x): return x - self.assertIs(given_design(alone, design), alone) + self.assertIs(_given_design(alone, design), alone) diff --git a/tests/tradespace/test_refinement.py b/tests/tradespace/test_refinement.py index dad0f1c6..8da7896e 100644 --- a/tests/tradespace/test_refinement.py +++ b/tests/tradespace/test_refinement.py @@ -107,7 +107,9 @@ def test_refines_uncertain_designs(self): uncertain_before = ( (before.pareto_probability > 0.05) & (before.pareto_probability < 0.95) ).sum() - self.assertLess(len(refinement.uncertain), uncertain_before) + summary = refinement.summary + unsettled = summary[summary.uncertain & ~summary.indifferent] + self.assertLess(len(unsettled), uncertain_before) # far fewer evaluations than uniform replication to the same depth uniform = replicates.max() * len(self.designs) self.assertLess(len(refinement.results), 0.6 * uniform) @@ -260,8 +262,9 @@ def refined(precision): refinement, precise = refined(0.1) self.assertGreaterEqual(precise, 20) self.assertLessEqual(precise, 30) - self.assertEqual(refinement.indifferent.design.tolist(), [designs[1].key]) - self.assertEqual(len(refinement.uncertain), 0) + summary = refinement.summary + self.assertEqual(summary.design[summary.indifferent].tolist(), [designs[1].key]) + self.assertFalse((summary.uncertain & ~summary.indifferent).any()) self.assertEqual(refinement.rounds.indifferent.iloc[-1], 1) with self.assertRaises(ValueError): refine(study, criteria, results, designs, precision=0) diff --git a/tests/tradespace/test_scenarios.py b/tests/tradespace/test_scenarios.py index 2244c74d..4a32f9e1 100644 --- a/tests/tradespace/test_scenarios.py +++ b/tests/tradespace/test_scenarios.py @@ -24,13 +24,13 @@ ResultStore, Study, Uncertain, - aggregate, attribute_variance, optimize_optuna, optimize_pymoo, pareto_front, pareto_probability, robustness, + summarize, ) from tatc.tradespace.optimization import Evaluations @@ -85,10 +85,10 @@ def test_results(self): pinned = by.xs("pinned", level="scenario") self.assertTrue((pinned.noise == 0.5).all()) # judged in each scenario - summary = aggregate(results, Criteria({"y": "max"}, by="scenario")) + summary = summarize(results, Criteria({"y": "max"}, by="scenario")) self.assertEqual(len(summary), 3 * 3) with self.assertRaises(ValueError): - aggregate(results, Criteria({"y": "max"})) + summarize(results, Criteria({"y": "max"})) def test_without_scenarios(self): """A study without scenarios has no column of them.""" @@ -306,8 +306,9 @@ def test_design_values(self): r = self._robustness(results=pd.DataFrame(rows)) self.assertEqual(list(r.columns[:3]), ["s1 perf", "s2 perf", "cost"]) np.testing.assert_allclose(r["s1 perf"], r["s2 perf"]) - # columns given as the values of designs - r = self._robustness(results=pd.DataFrame(rows), design_columns=[]) + # a cost that varies between replicates is not a value of the designs + varying = pd.DataFrame(rows).assign(cost=lambda f: f.cost + 0.1 * f.replicate) + r = self._robustness(results=varying) self.assertEqual( list(r.columns[:4]), ["s1 perf", "s2 perf", "s1 cost", "s2 cost"] ) @@ -339,7 +340,7 @@ class TestAcross(unittest.TestCase): """ def _summary(self, criteria, results=RESULTS): - summary = aggregate(results, criteria) + summary = summarize(results, criteria) summary["pareto"] = pareto_front(summary, criteria) return summary.set_index("design") @@ -365,7 +366,7 @@ def test_mean(self): self.assertEqual(list(summary.pareto), [True, True, False]) unweighted = Across("scenario", "mean", {"s1": 1}) with self.assertRaises(ValueError): - aggregate(RESULTS, Criteria(OBJECTIVES, across=unweighted)) + summarize(RESULTS, Criteria(OBJECTIVES, across=unweighted)) def test_requirements(self): """A requirement is met by the combined statistic: in every scenario, @@ -411,11 +412,11 @@ def test_agrees_with_scenarios(self): SPACE, lambda d: d, _evaluate, replicates=3, scenarios=SCENARIOS ).run() objectives = {"y": "max", "cost": "min"} - by_scenario = aggregate(results, Criteria(objectives, by="scenario")) + by_scenario = summarize(results, Criteria(objectives, by="scenario")) y = by_scenario.pivot(index="design", columns="scenario", values="y") for rule, expected in (("worst", y.min(axis=1)), ("mean", y.mean(axis=1))): criteria = Criteria(objectives, across=Across(rule=rule)) - summary = aggregate(results, criteria).set_index("design") + summary = summarize(results, criteria).set_index("design") np.testing.assert_allclose(summary.y, expected.loc[summary.index]) probability = pareto_probability( results, Criteria(objectives, across=Across()), n_resamples=20 @@ -444,8 +445,8 @@ def test_invalid(self): # a statistic without a direction is combined by its mean, unless a # rule asks for its worst, which it has none of extra = Criteria(OBJECTIVES, statistics={"extra": "perf"}, across=Across()) - summary = aggregate(RESULTS, extra).set_index("design") - means = aggregate(RESULTS, Criteria(OBJECTIVES, by="scenario")) + summary = summarize(RESULTS, extra).set_index("design") + means = summarize(RESULTS, Criteria(OBJECTIVES, by="scenario")) np.testing.assert_allclose( summary.extra, means.groupby("design", sort=False).perf.mean() ) @@ -463,7 +464,7 @@ def test_invalid(self): across=Across(), ) with self.assertRaises(ValueError): - aggregate( + summarize( RESULTS.drop(columns="scenario"), Criteria(OBJECTIVES, across=Across()) ) @@ -478,12 +479,12 @@ class TestSearchAcross(unittest.TestCase): """ def test_evaluations(self): - """A search judges each design across the scenarios, as aggregate does.""" + """A search judges each design across the scenarios, as summaries do.""" criteria = Criteria({"y": "max", "cost": "min"}, across=Across()) evaluations = Evaluations(_scenario_study(), criteria) designs = SPACE.enumerate() values = evaluations.evaluate(designs) - summary = aggregate(evaluations.results, criteria).set_index("design") + summary = summarize(evaluations.results, criteria).set_index("design") for design, (y, cost) in zip(designs, values): self.assertAlmostEqual(y, summary.loc[design.key, "y"]) self.assertAlmostEqual(cost, summary.loc[design.key, "cost"]) @@ -506,7 +507,11 @@ def test_pymoo(self): criteria = Criteria({"y": "max", "cost": "min"}, across=Across(rule="mean")) search = optimize_pymoo( - _scenario_study(), criteria, NSGA2(pop_size=4), ("n_gen", 2), seed=1 + _scenario_study(), + criteria, + algorithm=NSGA2(pop_size=4), + termination=("n_gen", 2), + seed=1, ) self.assertEqual(set(search.results.scenario), set(SCENARIOS)) self.assertGreater(len(search.designs), 0) diff --git a/tests/tradespace/test_screening.py b/tests/tradespace/test_screening.py index 5c4a5cb8..6128d750 100644 --- a/tests/tradespace/test_screening.py +++ b/tests/tradespace/test_screening.py @@ -59,7 +59,7 @@ class TestScreen(unittest.TestCase): def setUp(self): self.designs = _space().enumerate() - exact = summarize(_study(0, 1).run(self.designs), list(OBJECTIVES)) + exact = summarize(_study(0, 1).run(self.designs), statistics=list(OBJECTIVES)) self.front = set(exact.design[pareto_front(exact, OBJECTIVES)]) def test_keeps_whole_fronts(self): @@ -67,7 +67,7 @@ def test_keeps_whole_fronts(self): screening = screen( [_study(0.3, 1), _study(0, 1)], OBJECTIVES, self.designs, keep=20 ) - first = screening.summaries[0] + first = screening.summaries[screening.summaries.stage == 0] self.assertGreaterEqual(first.kept.sum(), 20) last_rank = first[first.kept].pareto_rank.max() self.assertTrue((first[first.pareto_rank <= last_rank].kept).all()) @@ -105,7 +105,7 @@ def test_three_stages(self): self.designs, keep=[0.5, 10], ) - counts = [len(summary) for summary in screening.summaries] + counts = screening.summaries.groupby("stage").size().tolist() self.assertEqual(counts[0], len(self.designs)) self.assertGreaterEqual(counts[1], 0.5 * counts[0]) self.assertGreaterEqual(counts[2], 10) @@ -192,7 +192,8 @@ def test_misses_ranked_last(self): space.enumerate(), keep=4, ) - first = screening.summaries[0].set_index("design") + summaries = screening.summaries + first = summaries[summaries.stage == 0].set_index("design") meets = first[first.meets_requirements] misses = first[~first.meets_requirements] self.assertGreater(misses.pareto_rank.min(), meets.pareto_rank.max()) diff --git a/tests/tradespace/test_sensitivity.py b/tests/tradespace/test_sensitivity.py index 9119f132..29015dab 100644 --- a/tests/tradespace/test_sensitivity.py +++ b/tests/tradespace/test_sensitivity.py @@ -81,9 +81,9 @@ def test_results_raise(self): results = pd.DataFrame( {"design": ["x", "x", "y", "y"], "a": [1, 1, 2, 2], "metric": [1, 2, 3, 4]} ) - with self.assertRaisesRegex(ValueError, "aggregate"): + with self.assertRaisesRegex(ValueError, "summarize"): sensitivity(results, ["a"], ["metric"]) - with self.assertRaisesRegex(ValueError, "aggregate") as context: + with self.assertRaisesRegex(ValueError, "summarize") as context: main_effects(results, "a", "metric") # summaries of designs in groups give a row of each design per group self.assertNotIn("Criteria", str(context.exception)) diff --git a/tests/tradespace/test_space.py b/tests/tradespace/test_space.py index 15660d3d..8f23abbe 100644 --- a/tests/tradespace/test_space.py +++ b/tests/tradespace/test_space.py @@ -523,6 +523,42 @@ def test_extend(self): with self.assertRaises(Infeasible): extended.design({"a": 3, "b": 0, "c": "x"}) + def test_enumerate_extensions(self): + """The extensions of designs are those of every combination of the + decisions they lack, in their order, without the infeasible ones.""" + space = DesignSpace(a=Integer(1, 3)) + extended = space.extend( + c=Categorical(["x", "y"]), + d=Repeat(Integer(0, 1), count=Integer(1, 2), ordered=False), + constraints=[lambda d: not (d.a == 3 and d.c == "y")], + ) + bases = space.enumerate() + extensions = extended.enumerate(bases[::-1]) + expected = [ + extended.design(base, c=c, d=d) + for base in bases[::-1] + for c in ("x", "y") + for d in ([0], [1], [0, 0], [0, 1], [1, 1]) + if not (base.a == 3 and c == "y") + ] + self.assertEqual([d.key for d in extensions], [d.key for d in expected]) + self.assertTrue(all(d.space is extended for d in extensions)) + # every design of the space, from the designs of its unextended space + self.assertEqual( + {d.key for d in extended.enumerate(bases)}, + {d.key for d in extended.enumerate()}, + ) + # a design of the space itself, and repeated designs, once + self.assertEqual(extended.enumerate([expected[0]] * 2), [expected[0]]) + self.assertEqual(extended.enumerate([]), []) + # decisions of other children, or of other levels + with self.assertRaisesRegex(ValueError, "no children"): + space.enumerate([expected[0]]) + with self.assertRaisesRegex(ValueError, "not a level"): + DesignSpace(a=Integer(5, 6)).enumerate(bases) + with self.assertRaises(TypeError): + extended.enumerate([{"a": 1}]) + def _layouts_space(): """A choice of a group of planes (a number) or a repetition of planes.""" @@ -645,7 +681,7 @@ def test_kinds(self): designs = categorical.enumerate() self.assertEqual(len(designs), 2 + 8) self.assertEqual( - categorical.unit_paths(), + categorical._unit_paths(), # pylint: disable=protected-access ["parts.count", "parts[0]", "parts[1]", "parts[2]"], ) rebuilt = categorical.designs_of( @@ -659,7 +695,7 @@ def test_kinds(self): ) self.assertEqual(len(derived.enumerate()), 2 + 4) with self.assertRaisesRegex(ValueError, "upper bound"): - derived.unit_paths() + derived._unit_paths() # pylint: disable=protected-access def test_invalid(self): """Counts of other nodes, or negative, are rejected at once.""" @@ -891,16 +927,17 @@ def test_scenario_name(self): def test_checks(self): """Paths of shifts and overrides are checked by the design space.""" + # pylint: disable=protected-access space = _planes_space() - space.check_uncertain(["planes[*].phase"]) - space.check_overrides({"planes[*].phase": 1.0}) - self.space.check_overrides({"limit": 1, "u": 0.5}) + space._check_uncertain(["planes[*].phase"]) + space._check_overrides({"planes[*].phase": 1.0}) + self.space._check_overrides({"limit": 1, "u": 0.5}) for paths in (["planes[0].phase"], ["per_plane"], ["planes[*]"], [1]): with self.subTest(paths=paths): with self.assertRaisesRegex(ValueError, "not uncertain"): - space.check_uncertain(paths) + space._check_uncertain(paths) with self.assertRaisesRegex(ValueError, "not fixed values"): - self.space.check_overrides({"n": 2}) + self.space._check_overrides({"n": 2}) def test_seed(self): """Seeds are non-negative integers.""" diff --git a/tests/tradespace/test_stages.py b/tests/tradespace/test_stages.py index 8b365d6f..0d469b3f 100644 --- a/tests/tradespace/test_stages.py +++ b/tests/tradespace/test_stages.py @@ -203,8 +203,11 @@ def rule(decision): ) return decision.capability["observing"] < 4 - deployment = SCHEDULE.plan(_layout(), stages=[Stage(2, [0.0, 0.5], rule)]) - deployment.capability = Capability(NAMES, OBSERVATIONS, _count) + capability = Capability(NAMES, OBSERVATIONS, _count) + deployment = SCHEDULE.plan( + _layout(), stages=[Stage(2, [0.0, 0.5], rule)], capability=capability + ) + self.assertIs(deployment.capability, capability) history = deployment.simulate() # the first plane alone at the first launch (the second is launched later) self.assertEqual(seen, [(0.0, 2, {"observing": 2.0})]) @@ -212,8 +215,9 @@ def rule(decision): # the planned history reads it too self.assertEqual(history.metrics()["stages deployed"], 1.0) self.assertEqual(deployment.planned().decided, [deployment.begin]) - later = SCHEDULE.plan(_layout(), stages=[Stage(2, 0.5, rule)]) - later.capability = deployment.capability + later = SCHEDULE.plan( + _layout(), stages=[Stage(2, 0.5, rule)], capability=capability + ) self.assertEqual(later.simulate().decided, [None]) # without a capability, a rule cannot read it unmeasured = SCHEDULE.plan(_layout(), stages=[Stage(2, 0.0, rule)]) @@ -231,6 +235,7 @@ def test_capability_of_failures(self): Stage(2, [0.5, 1.0, 1.5, 2.0], lambda d: d.satellites_operating < 4) ], ) + cache = PhaseCache(_count) measured = SCHEDULE.plan( _layout(), policy=policy, @@ -241,10 +246,7 @@ def test_capability_of_failures(self): lambda d: d.capability["observing"] < 4, ) ], - ) - cache = PhaseCache(_count) - measured.capability = Capability( - NAMES, OBSERVATIONS, cache, context="replicate" + capability=Capability(NAMES, OBSERVATIONS, cache, context="replicate"), ) expected = by_count.simulate_many(failures, seed=1, histories=20) histories = measured.simulate_many(failures, seed=1, histories=20) @@ -256,6 +258,7 @@ def test_capability_of_failures(self): def test_capability_reads(self): """A capability evaluates sets of satellites by name, or by position, only when read.""" + # pylint: disable=protected-access calls = [] def metric(observations): @@ -265,18 +268,19 @@ def metric(observations): capability = Capability(NAMES, OBSERVATIONS, metric) self.assertEqual(capability(["s0", "s3"]), {"observing": 2.0}) planes = SCHEDULE.plan(_layout()).planes - self.assertEqual(capability.at(planes, [(1, 0), (2, 1)]), {"observing": 2.0}) + self.assertEqual(capability._at(planes, [(1, 0), (2, 1)]), {"observing": 2.0}) self.assertEqual(capability(set()), {"observing": 0.0}) self.assertEqual(calls, [2, 2, 0]) # a rule that does not read it does not evaluate it - deployment = SCHEDULE.plan(_layout(), stages=[Stage(2, 0.0, lambda d: True)]) - deployment.capability = capability + deployment = SCHEDULE.plan( + _layout(), stages=[Stage(2, 0.0, lambda d: True)], capability=capability + ) deployment.simulate() self.assertEqual(len(calls), 3) with self.assertRaises(ValueError): capability(["s9"]) with self.assertRaises(ValueError): - Capability(NAMES[:4], OBSERVATIONS, metric).at(planes, [(0, 0)]) + Capability(NAMES[:4], OBSERVATIONS, metric)._at(planes, [(0, 0)]) # a cache keys satellites given by name by their names cache = PhaseCache(_count) cached = Capability(NAMES, OBSERVATIONS, cache) @@ -285,9 +289,9 @@ def metric(observations): self.assertEqual((cache.hits, cache.misses), (1, 1)) # which the cache gives by their keys (and the context) keys = {"s0": "s0", "s1": "s1"} - self.assertEqual(cache.metrics_of(keys, OBSERVATIONS), {"observing": 2.0}) + self.assertEqual(cache._metrics_of(keys, OBSERVATIONS), {"observing": 2.0}) self.assertEqual((cache.hits, cache.misses), (2, 1)) - cache.metrics_of(keys, OBSERVATIONS, context="other") + cache._metrics_of(keys, OBSERVATIONS, context="other") self.assertEqual((cache.hits, cache.misses), (2, 2)) def test_lead_and_launches(self): diff --git a/tests/tradespace/test_statistics.py b/tests/tradespace/test_statistics.py index 75472ed3..89314784 100644 --- a/tests/tradespace/test_statistics.py +++ b/tests/tradespace/test_statistics.py @@ -16,9 +16,9 @@ Probability, Quantile, StandardDeviation, - StandardError, Statistic, ) +from tatc.tradespace.statistics import _standard_error VALUES = np.array( [[1.0, 2.0, 3.0, np.nan], [4.0, np.nan, np.nan, np.nan], [np.nan] * 4] @@ -39,8 +39,9 @@ def test_reductions(self): np.testing.assert_allclose( StandardDeviation("x").reduce(VALUES), [1, np.nan, np.nan] ) + # the standard error of the mean, of the spreads of summaries np.testing.assert_allclose( - StandardError("x").reduce(VALUES), [1 / np.sqrt(3), np.nan, np.nan] + _standard_error(VALUES), [1 / np.sqrt(3), np.nan, np.nan] ) np.testing.assert_allclose( Probability("x", ">=", 2).reduce(VALUES), [2 / 3, 1, np.nan] @@ -87,7 +88,6 @@ def test_names(self): """Statistics are named by convention.""" self.assertEqual(Mean("cost").name, "cost") self.assertEqual(StandardDeviation("cost").name, "cost std") - self.assertEqual(StandardError("cost").name, "cost se") self.assertEqual(Minimum("cost").name, "cost min") self.assertEqual(Maximum("cost").name, "cost max") self.assertEqual(Quantile("cost", 0.7).name, "cost p70") diff --git a/tests/tradespace/test_store.py b/tests/tradespace/test_store.py index 4eefec7e..3df9d686 100644 --- a/tests/tradespace/test_store.py +++ b/tests/tradespace/test_store.py @@ -4,6 +4,8 @@ @author Paul T. Grogan """ +# pylint: disable=protected-access + import importlib.util import json import math @@ -73,14 +75,16 @@ def evaluate(d): def test_store_and_get(self): """Records are stored and retrieved by design and replicate.""" store = ResultStore(self.path, namespace="x") - store.put([("d1", 0, [{"value": 1}]), ("d1", 1, [{"value": 2}])]) + store._put([("d1", 0, [{"value": 1}]), ("d1", 1, [{"value": 2}])]) self.assertEqual(len(store), 2) - self.assertEqual(store.get([("d1", 1), ("d2", 0)]), {("d1", 1): [{"value": 2}]}) + self.assertEqual( + store._get([("d1", 1), ("d2", 0)]), {("d1", 1): [{"value": 2}]} + ) # records of another context are separate - store.put([("d1", 1, [{"value": 3}])], context="c") - self.assertEqual(store.get([("d1", 1)], "c"), {("d1", 1): [{"value": 3}]}) - self.assertEqual(store.get([("d1", 1)])[("d1", 1)], [{"value": 2}]) - self.assertEqual(store.contexts(), {"": 2, "c": 1}) + store._put([("d1", 1, [{"value": 3}])], context="c") + self.assertEqual(store._get([("d1", 1)], "c"), {("d1", 1): [{"value": 3}]}) + self.assertEqual(store._get([("d1", 1)])[("d1", 1)], [{"value": 2}]) + self.assertEqual(store._contexts(), {"": 2, "c": 1}) other = ResultStore(self.path, namespace="y") self.assertEqual(len(other), 0) store.clear() @@ -199,7 +203,7 @@ def study(evaluate): current = study(lambda d: {"value": d.a * d.a}) self.assertEqual(current.prune(), 8) self.assertEqual( - store.contexts(), + store._contexts(), {current.fingerprint: 8, other.fingerprint: 8, constant.fingerprint: 8}, ) self.assertEqual(current.prune(), 0) @@ -230,7 +234,7 @@ def study(evaluate, **kwargs): broken = study(lambda d: {"value": d.a / 0}, errors="record") with self.assertWarnsRegex(UserWarning, "none of the 4 designs"): broken.run() - self.assertEqual(store.contexts(), {broken.fingerprint: 0}) + self.assertEqual(store._contexts(), {broken.fingerprint: 0}) self.assertEqual(len(store), 0) # the same study with other code (of the same constants) fixed = study(lambda d: {"value": d.a * 0}) @@ -238,8 +242,8 @@ def study(evaluate, **kwargs): warnings.simplefilter("error") # no evaluations to warn of fixed.run() self.assertEqual(fixed.prune(), 0) - self.assertEqual(store.contexts(), {fixed.fingerprint: 4}) - self.assertIsNone(store.definition(broken.fingerprint)) + self.assertEqual(store._contexts(), {fixed.fingerprint: 4}) + self.assertIsNone(store._definition(broken.fingerprint)) def test_records_as_json(self): """Records are kept as JSON, and read as they were written.""" @@ -264,8 +268,8 @@ def test_records_as_json(self): "array": np.arange(3), } store = ResultStore(self.path, namespace="x") - store.put([("d1", 0, [record])]) - read = store.get([("d1", 0)])[("d1", 0)][0] + store._put([("d1", 0, [record])]) + read = store._get([("d1", 0)])[("d1", 0)][0] self.assertEqual(set(read), set(record)) self.assertTrue(math.isnan(read.pop("nan"))) np.testing.assert_array_equal(read.pop("array"), record["array"]) @@ -288,8 +292,8 @@ def test_definitions(self): store = ResultStore(self.path, namespace="study") study = self._study(store) study.run() - self.assertEqual(store.definition(study.fingerprint), study.definition) - self.assertIsNone(store.definition("other")) + self.assertEqual(store._definition(study.fingerprint), study.definition) + self.assertIsNone(store._definition("other")) reseeded = self._study(store, seed=1) reseeded.run() self.assertEqual( @@ -298,14 +302,14 @@ def test_definitions(self): ) # contexts in the order they were defined, the latest last self.assertEqual( - list(store.contexts()), [study.fingerprint, reseeded.fingerprint] + list(store._contexts()), [study.fingerprint, reseeded.fingerprint] ) # the records of a context are removed - self.assertEqual(store.remove(study.fingerprint), 12) - self.assertEqual(store.contexts(), {reseeded.fingerprint: 12}) - self.assertIsNone(store.definition(study.fingerprint)) + self.assertEqual(store._remove(study.fingerprint), 12) + self.assertEqual(store._contexts(), {reseeded.fingerprint: 12}) + self.assertIsNone(store._definition(study.fingerprint)) store.clear() - self.assertIsNone(store.definition(reseeded.fingerprint)) + self.assertIsNone(store._definition(reseeded.fingerprint)) def test_parallel_interruption(self): """Workers store each evaluation as it completes, before an error.""" @@ -324,7 +328,7 @@ def test_parallel_interruption(self): study.run() # the designs evaluated before the error in its chunk (1 to 4) are kept designs = study.space.enumerate() - stored = store.get(((d.key, 0) for d in designs), study.fingerprint) + stored = store._get(((d.key, 0) for d in designs), study.fingerprint) values = sorted(records[0]["value"] for records in stored.values()) self.assertEqual(values[:3], [1, 2, 3]) self.assertNotIn(4, values) @@ -332,13 +336,13 @@ def test_parallel_interruption(self): def test_variants(self): """Variants of replicates are kept apart from plain replicates.""" store = ResultStore(self.path, namespace="x") - store.put([("d1", 0, [{"value": 1}])]) - store.put([("d1", 0, [{"value": 2}])], variant='{"u": 5}') - self.assertEqual(store.get([("d1", 0)]), {("d1", 0): [{"value": 1}]}) + store._put([("d1", 0, [{"value": 1}])]) + store._put([("d1", 0, [{"value": 2}])], variant='{"u": 5}') + self.assertEqual(store._get([("d1", 0)]), {("d1", 0): [{"value": 1}]}) self.assertEqual( - store.get([("d1", 0)], variant='{"u": 5}'), {("d1", 0): [{"value": 2}]} + store._get([("d1", 0)], variant='{"u": 5}'), {("d1", 0): [{"value": 2}]} ) - self.assertEqual(store.get([("d1", 0)], variant='{"u": 6}'), {}) + self.assertEqual(store._get([("d1", 0)], variant='{"u": 6}'), {}) self.assertEqual(len(store), 2) def test_shifted_runs(self): @@ -377,8 +381,8 @@ def test_table_without_variants(self): "INSERT INTO results VALUES ('x', '', 'd1', 0, '[{\"value\": 1}]')" ) store = ResultStore(self.path, namespace="x") - self.assertEqual(store.get([("d1", 0)]), {("d1", 0): [{"value": 1}]}) - store.put([("d1", 0, [{"value": 2}])], variant="v") + self.assertEqual(store._get([("d1", 0)]), {("d1", 0): [{"value": 1}]}) + store._put([("d1", 0, [{"value": 2}])], variant="v") self.assertEqual(len(store), 2) self.assertEqual(len(ResultStore(self.path, namespace="x")), 2) @@ -395,5 +399,5 @@ def test_earlier_format(self): ) store = ResultStore(self.path, namespace="x") self.assertEqual(len(store), 0) - store.put([("d1", 0, [{"value": 1}])]) - self.assertEqual(store.get([("d1", 0)]), {("d1", 0): [{"value": 1}]}) + store._put([("d1", 0, [{"value": 1}])]) + self.assertEqual(store._get([("d1", 0)]), {("d1", 0): [{"value": 1}]}) diff --git a/tests/tradespace/test_study.py b/tests/tradespace/test_study.py index b86d2f2d..9485aabb 100644 --- a/tests/tradespace/test_study.py +++ b/tests/tradespace/test_study.py @@ -190,7 +190,7 @@ def test_executor(self): def test_summarize(self): """Summaries give the mean and spread of metrics over replicates.""" results = self._noise_study().run() - summary = summarize(results, ["score"]) + summary = summarize(results, statistics=["score"]) self.assertEqual(len(summary), 9) self.assertIn("planes", summary.columns) self.assertNotIn("noise", summary.columns) @@ -201,7 +201,7 @@ def test_summarize(self): self.assertAlmostEqual(summary["score se"][0], first.score.std() / np.sqrt(3)) self.assertNotIn("score sem", summary.columns) # a metric may also be a value of the design - overlap = summarize(results, ["score", "planes"], design_columns=["planes"]) + overlap = summarize(results, statistics=["score", "planes"]) self.assertEqual(list(overlap.columns).count("planes"), 1) def test_replace_and_frames(self): @@ -222,7 +222,7 @@ def test_replace_and_frames(self): with self.assertRaisesRegex(TypeError, "no arguments"): study.replace(replicate=3) # designs given by a data frame of their values (such as a summary) - summary = summarize(results, ["score"]) + summary = summarize(results, statistics=["score"]) best = summary.nlargest(2, "score") again = study.run(best) self.assertEqual(list(again.design.unique()), list(best.design)) @@ -239,7 +239,7 @@ def test_summarize_by(self): ).set_index("sensor"), replicates=2, ) - summary = summarize(study.run(), ["value"], by=["sensor"]) + summary = summarize(study.run(), statistics=["value"], by=["sensor"]) self.assertEqual(len(summary), 18) b = summary[(summary.sensor == "b") & (summary.planes == 3)] self.assertTrue((b.value == 6).all()) @@ -658,3 +658,109 @@ def build(d): with self.assertWarnsRegex(UserWarning, "none of the 2 designs") as context: study.run() self.assertEqual(Path(context.filename).resolve(), Path(__file__).resolve()) + + +class TestDescriptions(unittest.TestCase): + """ + Unit tests for the descriptions of designs in the results of studies. + """ + + def setUp(self): + self.space = DesignSpace( + planes=Integer(1, 2), + per_plane=Integer(1, 2), + noise=Uncertain.uniform(0, 1), + ) + self.calls = [] + + def describe(d): + self.calls.append(d.key) + return f"{d.planes} x {d.per_plane}" + + self.describe = describe + + def _study(self, **options): + return Study( + self.space, + lambda d: d, + lambda d: {"satellites": d.planes * d.per_plane, "score": d.noise}, + replicates=3, + describe=self.describe, + **options, + ) + + def test_column(self): + """A description of each design follows its values, given once per design + (of the design, not its replicates), and summaries keep it.""" + results = self._study().run() + columns = list(results.columns) + self.assertEqual(columns.index("description"), columns.index("feasible") - 1) + self.assertEqual(columns.index("description"), columns.index("noise") + 1) + labels = [f"{p} x {s}" for p in (1, 2) for s in (1, 2)] + self.assertEqual(list(results.description), [x for x in labels for _ in "abc"]) + self.assertEqual(len(self.calls), 4) + summary = summarize(results, {"satellites": "min", "score": "max"}) + self.assertEqual(list(summary.description), labels) + # without a function, no descriptions + self.assertNotIn("description", self._study().replace(describe=None).run()) + with self.assertRaises(TypeError): + self._study().replace(describe="planes") + + def test_not_stored(self): + """Descriptions are not stored, nor part of the fingerprint, so that + another function needs no new evaluations.""" + with tempfile.TemporaryDirectory() as directory: + store = ResultStore(Path(directory) / "results.sqlite") + study = self._study(store=store) + first = study.run() + other = study.replace(describe=lambda d: f"{d.planes} planes") + self.assertEqual(other.fingerprint, study.fingerprint) + progress = [] + again = other.run(progress=lambda done, total: progress.append(done)) + self.assertEqual(progress, []) # every evaluation from the store + self.assertEqual(list(again.description.unique()), ["1 planes", "2 planes"]) + pd.testing.assert_frame_equal( + again.drop(columns="description"), first.drop(columns="description") + ) + records = store._get( # pylint: disable=protected-access + [(key, 0) for key in first.design.unique()], study.fingerprint + ) + self.assertEqual(len(records), 4) + self.assertTrue( + all("description" not in r for rs in records.values() for r in rs) + ) + + def test_other_spaces_and_scenarios(self): + """Designs of another design space are described as designs of the + study's, in each scenario.""" + extended = self.space.extend(limit=Fixed(1)) + study = self._study().replace( + space=extended, scenarios={"a": {}, "b": {"limit": 2}} + ) + results = study.run(self.space.enumerate()[:2]) + self.assertEqual(list(results.description.unique()), ["1 x 1", "1 x 2"]) + self.assertEqual(len(self.calls), 2) + self.assertEqual(list(results.columns[:3]), ["design", "replicate", "scenario"]) + + def test_names(self): + """Metrics and values may not be named as the descriptions.""" + study = Study( + self.space, + lambda d: d, + lambda d: {"description": "a metric"}, + describe=self.describe, + ) + with self.assertRaisesRegex(ValueError, "description"): + study.run() + # but may without descriptions + self.assertIn("description", study.replace(describe=None).run()) + with self.assertRaisesRegex(ValueError, "named 'description'"): + self._study().replace(space=self.space.extend(description=Fixed("x"))) + + def test_no_designs(self): + """A run of no designs gives the column of descriptions.""" + results = self._study().run([]) + self.assertEqual( + list(results.columns), + ["design", "replicate", "description", "feasible", "error", "seconds"], + ) diff --git a/tests/tradespace/test_summary.py b/tests/tradespace/test_summary.py index 4c70d48c..2f02d3f5 100644 --- a/tests/tradespace/test_summary.py +++ b/tests/tradespace/test_summary.py @@ -1,6 +1,6 @@ """ Unit tests for summaries of the results of studies: the statistics of each -design over its replicates (`aggregate` and `summarize`), its judgment by +design over its replicates and their spreads (`summarize`), its judgment by criteria, and the probability that it is efficient (`pareto_probability`). @author Paul T. Grogan @@ -18,7 +18,7 @@ Probability, Quantile, Requirement, - aggregate, + StandardDeviation, pareto_probability, summarize, ) @@ -101,14 +101,14 @@ def _scenarios(values): ) -class TestAggregate(unittest.TestCase): +class TestSummary(unittest.TestCase): """ - Unit tests for aggregating results. + Unit tests for summaries of the statistics of designs. """ def test_statistics(self): - """Statistics and design values are aggregated, without violations.""" - frame = aggregate( + """Statistics and design values are summarized, without violations.""" + frame = summarize( _results(), statistics={ "value": "value", @@ -121,16 +121,33 @@ def test_statistics(self): self.assertEqual(frame.loc["c", "size"], "large") self.assertTrue((frame.replicates == 4).all()) self.assertNotIn("violation", frame.columns) - self.assertEqual(list(aggregate(_results(), ["value"]).value), [13, 17.5, 1]) + means = summarize(_results(), statistics=["value"]) + self.assertEqual(list(means.value), [13, 17.5, 1]) # a mapping of statistics by name is not one of objectives with self.assertRaisesRegex(ValueError, "statistics"): - aggregate(_results(), {"value": "value"}) + summarize(_results(), {"value": "value"}) with self.assertRaises(ValueError): - aggregate(_results()) + summarize(_results()) + + def test_forms(self): + """Criteria are criteria or a mapping of directions, and statistics a + sequence or a mapping: metrics are given as statistics.""" + for metrics in (["value"], "value"): + with self.subTest(metrics=metrics): + with self.assertRaisesRegex(TypeError, "statistics=\\['value'\\]"): + summarize(_results(), metrics) + for single in ("value", Quantile("value", 0.5)): + with self.subTest(single=single): + with self.assertRaisesRegex(TypeError, "sequence"): + summarize(_results(), statistics=single) + with self.assertRaisesRegex(TypeError, "sequence"): + Criteria({"value": "max"}, statistics=single) + with self.assertRaisesRegex(TypeError, "statistics"): + pareto_probability(_results(), ["value"]) def test_objectives(self): """A mapping of objectives are criteria of their means, with others.""" - frame = aggregate( + frame = summarize( _results(), {"value": "max"}, statistics={"value p25": Quantile("value", 0.25)}, @@ -140,14 +157,14 @@ def test_objectives(self): self.assertTrue(frame.meets_requirements.all()) # statistics that the criteria name otherwise with self.assertRaisesRegex(ValueError, "otherwise"): - aggregate( + summarize( _results(), {"value": "max"}, statistics={"value": Quantile("value", 1)} ) # a statistic the criteria name the same way is not a clash - same = aggregate(_results(), {"value": "max"}, statistics={"value": "value"}) + same = summarize(_results(), {"value": "max"}, statistics={"value": "value"}) self.assertEqual(list(same.value), [13, 17.5, 1]) # objectives grouped by a column - self.assertEqual(len(aggregate(_results(), {"value": "max"}, by="size")), 3) + self.assertEqual(len(summarize(_results(), {"value": "max"}, by="size")), 3) def test_criteria(self): """Criteria add the violations of their requirements, relative to them.""" @@ -159,7 +176,7 @@ def test_criteria(self): Requirement("cost", "<=", 1.5), ], ) - frame = aggregate(_results(), criteria).set_index("design") + frame = summarize(_results(), criteria, spread=False).set_index("design") self.assertEqual( list(frame.columns[-8:]), [ @@ -179,28 +196,28 @@ def test_criteria(self): # none meets the requirements, so that none is efficient self.assertEqual(list(frame.pareto), [False, False, False]) with self.assertRaises(ValueError): - aggregate(_results(), criteria, by=["size"]) + summarize(_results(), criteria, by=["size"]) def test_requirement_on_metric(self): """A requirement on a metric is on its mean.""" criteria = Criteria( {"value": "max"}, requirements=[Requirement("cost", "<=", 1)] ) - frame = aggregate(_results(), criteria) + frame = summarize(_results(), criteria) self.assertIn("cost", frame.columns) self.assertEqual(list(frame.meets_requirements), [False, False, True]) # a requirement on a metric that the results do not have missing = Criteria({"value": "max"}, requirements=[Requirement("w", ">=", 1)]) with self.assertRaises(ValueError): - aggregate(_results(), missing) + summarize(_results(), missing) def test_statistics_of_names(self): """Statistics given by names are the means of the metrics, and other statistics are named by convention.""" - summary = aggregate(_results(), {"value": "max"}, statistics=["cost"]) + summary = summarize(_results(), {"value": "max"}, statistics=["cost"]) self.assertEqual(list(summary.cost), [2.0, 2.0, 1.0]) self.assertEqual( - list(aggregate(_results(), statistics=[Quantile("value", 0.25)]).columns)[ + list(summarize(_results(), statistics=[Quantile("value", 0.25)]).columns)[ -3: ], ["value p25", "replicates", "feasible"], @@ -211,20 +228,20 @@ def test_names_of_columns(self): results = _results().assign(**{"P(value >= 10)": 0.5}) statistic = Probability("value", ">=", 10) criteria = Criteria({"P(value >= 10)": "max"}, statistics=[statistic]) - for function in (aggregate, summarize, pareto_probability): + for function in (summarize, pareto_probability): with self.subTest(function=function.__name__): with self.assertRaisesRegex(ValueError, "P\\(value >= 10\\)"): function(results, criteria) # the mean of the column, of its name - summary = aggregate(results, {"P(value >= 10)": "max"}) + summary = summarize(results, {"P(value >= 10)": "max"}) np.testing.assert_allclose(summary["P(value >= 10)"], 0.5) renamed = Criteria({"reliable": "max"}, statistics={"reliable": statistic}) np.testing.assert_allclose( - aggregate(results, renamed).reliable, [1.0, 0.5, 0.0] + summarize(results, renamed).reliable, [1.0, 0.5, 0.0] ) # nor do the columns that summaries add with self.assertRaisesRegex(ValueError, "value se"): - summarize(_results().assign(**{"value se": 1.0}), ["value"]) + summarize(_results().assign(**{"value se": 1.0}), statistics=["value"]) with self.assertRaisesRegex(ValueError, "value se"): pareto_probability(_results().assign(**{"value se": 1.0}), {"value": "max"}) @@ -232,15 +249,15 @@ def test_records_of_groups(self): """Several records of an evaluation need the columns that separate them.""" results = pd.concat([_results().assign(sensor=s) for s in ("x", "y")]) with self.assertRaisesRegex(ValueError, r"by.*\['sensor'\]"): - aggregate(results, ["value"]) + summarize(results, statistics=["value"]) with self.assertRaisesRegex(ValueError, "sensor"): pareto_probability(results, {"value": "max"}) - frame = aggregate(results, Criteria({"value": "max"}, by="sensor")) + frame = summarize(results, Criteria({"value": "max"}, by="sensor")) self.assertEqual(len(frame), 6) - self.assertEqual(len(summarize(results, ["value"], by="sensor")), 6) + self.assertEqual(len(summarize(results, statistics=["value"], by="sensor")), 6) -class TestSummarize(unittest.TestCase): +class TestSpreads(unittest.TestCase): """ Unit tests for summaries with the spread of the means of metrics. """ @@ -255,53 +272,68 @@ def test_summarize_criteria(self): for column in ("value std", "value se", "pareto"): self.assertIn(column, summary.columns) self.assertNotIn("value p25 se", summary.columns) + # without spreads + plain = summarize(_results(), criteria, spread=False) + self.assertNotIn("value std", plain.columns) + self.assertNotIn("value se", plain.columns) grouped = summarize(_results(), {"value": "max"}, by="size") self.assertEqual(len(grouped), 3) with self.assertRaises(ValueError): summarize(_results(), Criteria({"value": "max"}), by="size") + def test_infinite_values(self): + """The spread of a metric with infinite values is missing, without warnings.""" + results = _results().assign(time=np.inf) + results.loc[results.replicate == 0, "time"] = 4.0 + with warnings.catch_warnings(): + warnings.simplefilter("error") + summary = summarize(results, statistics=["time", StandardDeviation("time")]) + self.assertTrue(np.isinf(summary["time"]).all()) + self.assertTrue(summary["time std"].isna().all()) + def test_summarize_statistics(self): """Summaries take other statistics, with the spread of their means.""" results = _results().assign(cost=lambda f: f.cost + 0.1 * f.replicate) summary = summarize(results, {"value": "max"}, statistics=["cost"]) for column in ("value", "value se", "cost", "cost std", "cost se", "pareto"): self.assertIn(column, summary.columns) - # each mean followed by its spread, without criteria - self.assertEqual( - list(summarize(results, ["value", "cost"]).columns[-8:]), - [ - "value", - "value std", - "value se", - "cost", - "cost std", - "cost se", - "replicates", - "feasible", - ], - ) + # each mean followed by its spread, with criteria or without + followed = [ + "value", + "value std", + "value se", + "cost", + "cost std", + "cost se", + "replicates", + "feasible", + ] + alone = summarize(results, statistics=["value", "cost"]) + self.assertEqual(list(alone.columns[-8:]), followed) + judged = summarize(results, {"value": "max", "cost": "min"}) + self.assertEqual(list(judged.columns[-11:-3]), followed) def test_constant_spreads(self): """The spreads of metrics that are the same in every replicate of each design are left out.""" - summary = summarize(_results(), ["value", "cost"]) + summary = summarize(_results(), statistics=["value", "cost"]) self.assertNotIn("cost std", summary.columns) self.assertNotIn("cost se", summary.columns) spread = summary.set_index("design")[["value std", "value se"]] np.testing.assert_allclose(spread.loc["c"].to_numpy(dtype=float), 0.0) # of designs of one replicate, as of summaries without designs - single = summarize(_results()[_results().replicate == 0], ["value"]) + single = summarize(_results()[_results().replicate == 0], statistics=["value"]) self.assertNotIn("value se", single.columns) - empty = summarize(_results().iloc[:0], ["value"]) + empty = summarize(_results().iloc[:0], statistics=["value"]) self.assertIn("value se", empty.columns) - # as are the standard errors of the bootstrap + # as are those of the probabilities of efficiency probability = pareto_probability(_results(), {"cost": "min", "value": "max"}) self.assertNotIn("cost se", probability.columns) self.assertIn("value se", probability.columns) def test_spread_of_worst(self): """Across groups, the spread of the worst is that of its group, as - is the standard error of the bootstrap.""" + the probabilities of efficiency give it.""" results = _scenarios({"a": [10] * 8, "b": [5, 9] * 4}) worst = Criteria({"v": "max"}, across=Across()) summary = summarize(results, worst).iloc[0] @@ -309,11 +341,9 @@ def test_spread_of_worst(self): self.assertEqual(summary.v, 7.0) self.assertAlmostEqual(summary["v std"], b.std()) self.assertAlmostEqual(summary["v se"], b.std() / np.sqrt(8)) - bootstrap = pareto_probability(results, worst, n_resamples=2000) - # the bootstrap's standard deviation, of n rather than n - 1 replicates - self.assertAlmostEqual( - bootstrap["v se"].iloc[0], b.std(ddof=0) / np.sqrt(8), delta=0.05 - ) + probability = pareto_probability(results, worst, n_resamples=50).iloc[0] + self.assertAlmostEqual(probability["v std"], b.std()) + self.assertAlmostEqual(probability["v se"], b.std() / np.sqrt(8)) def test_spread_of_mean(self): """Across groups, the spread of a weighted mean is that of the @@ -331,10 +361,8 @@ def test_spread_of_mean(self): self.assertAlmostEqual(summary.v, combined.mean()) self.assertAlmostEqual(summary["v std"], combined.std()) self.assertAlmostEqual(summary["v se"], combined.std() / np.sqrt(30)) - bootstrap = pareto_probability(paired, mean, n_resamples=2000) - self.assertAlmostEqual( - bootstrap["v se"].iloc[0] / summary["v se"], 1.0, delta=0.1 - ) + probability = pareto_probability(paired, mean, n_resamples=50) + self.assertAlmostEqual(probability["v se"].iloc[0], summary["v se"]) # replicates that no other group shares: independent groups independent = paired.assign( replicate=paired.replicate + 100 * (paired.scenario == "s2") @@ -367,7 +395,7 @@ def test_feasible_share(self): """Designs are judged by their feasible replicates, of which `replicates` is the number and `feasible` the share; designs without a feasible replicate are left out.""" - summary = aggregate(_partly_infeasible(), {"cost": "min", "value": "max"}) + summary = summarize(_partly_infeasible(), {"cost": "min", "value": "max"}) summary = summary.set_index("design") self.assertEqual(list(summary.index), ["a", "b"]) self.assertEqual(summary.loc["b", "value"], 20) @@ -387,7 +415,7 @@ def test_requirement(self): {"cost": "min", "value": "max"}, requirements=[Requirement("feasible", ">=", 1)], ) - summary = aggregate(_partly_infeasible(), every).set_index("design") + summary = summarize(_partly_infeasible(), every).set_index("design") self.assertEqual(list(summary.feasible), [1.0, 0.5]) self.assertEqual(list(summary.meets_requirements), [True, False]) self.assertAlmostEqual(summary.loc["b", "violation"], 0.5) @@ -396,7 +424,7 @@ def test_requirement(self): {"cost": "min", "value": "max"}, requirements=[Requirement("feasible", ">=", 0.5)], ) - summary = aggregate(_partly_infeasible(), half) + summary = summarize(_partly_infeasible(), half) self.assertTrue(summary.meets_requirements.all()) # its spread is not summarized summary = summarize(_partly_infeasible(), every) @@ -416,7 +444,7 @@ def test_groups(self): ], ignore_index=True, ) - summary = aggregate(records, ["value"], by="sensor") + summary = summarize(records, statistics=["value"], by="sensor") summary = summary.set_index(["sensor", "design"]) self.assertEqual(summary.loc[("y", "b"), "value"], 21) self.assertEqual(summary.loc[("x", "b"), "feasible"], 0.5) @@ -440,7 +468,7 @@ def test_across(self): requirements=[Requirement("feasible", ">=", 0.7)], across=Across(rule=rule), ) - summary = aggregate(results, criteria).set_index("design") + summary = summarize(results, criteria).set_index("design") self.assertEqual(list(summary.index), ["a", "b"]) self.assertEqual(summary.loc["b", "feasible"], 0.75) self.assertEqual(summary.loc["b", "replicates"], 2) @@ -452,9 +480,9 @@ def test_no_feasible_design(self): infeasible = results[results.design == "c"].drop(columns=["cost", "value"]) criteria = Criteria({"cost": "min", "value": "max"}, by="size") for summary in ( - aggregate(infeasible, {"cost": "min", "value": "max"}), - aggregate(infeasible.assign(size=1), criteria), - aggregate(infeasible.iloc[:0], {"cost": "min", "value": "max"}), + summarize(infeasible, {"cost": "min", "value": "max"}), + summarize(infeasible.assign(size=1), criteria), + summarize(infeasible.iloc[:0], {"cost": "min", "value": "max"}), ): self.assertTrue(summary.empty) self.assertEqual( @@ -464,13 +492,13 @@ def test_no_feasible_design(self): # of the types of their columns, which select rows self.assertEqual(summary.pareto.dtype, bool) self.assertTrue(summary[summary.pareto].empty) - self.assertTrue(aggregate(infeasible, ["value"]).empty) + self.assertTrue(summarize(infeasible, statistics=["value"]).empty) across = Criteria({"cost": "min", "value": "max"}, across=Across(rule="mean")) scenarios = pd.concat( [_partly_infeasible("s1"), _partly_infeasible("s2")], ignore_index=True ) - self.assertEqual(len(aggregate(scenarios, across)), 2) - self.assertTrue(aggregate(scenarios.iloc[:0], across).empty) + self.assertEqual(len(summarize(scenarios, across)), 2) + self.assertTrue(summarize(scenarios.iloc[:0], across).empty) class TestParetoProbability(unittest.TestCase): @@ -528,10 +556,6 @@ def test_design_values(self): probability = pareto_probability(results, {"cost": "min", "value": "max"}) self.assertEqual(list(probability["size"]), ["small", "large"]) self.assertNotIn("seed", probability.columns) - bare = pareto_probability( - results, {"cost": "min", "value": "max"}, design_columns=[] - ) - self.assertNotIn("size", bare.columns) def test_quantile_objective(self): """A pessimistic objective prefers the design with less spread.""" @@ -581,7 +605,8 @@ def test_unequal_replicates(self): ) def test_standard_errors(self): - """The bootstrap gives the standard error of each objective.""" + """The standard error of an objective that is a mean is that of + summaries, and that of others that of the bootstrap.""" rng = np.random.default_rng(0) results = pd.DataFrame( [ @@ -597,14 +622,28 @@ def test_standard_errors(self): ] ) probability = pareto_probability( - results, {"x": "min", "y": "max"}, n_resamples=2000 + results, {"x": "min", "y": "max"}, n_resamples=50 ) # x is the same in every replicate of each design self.assertNotIn("x se", probability.columns) - expected = results.groupby("design").y.std(ddof=0) / np.sqrt(40) - np.testing.assert_allclose( - probability.set_index("design")["y se"], expected, rtol=0.15 - ) + summary = summarize(results, {"x": "min", "y": "max"}) + for column in ("y std", "y se"): + np.testing.assert_allclose(probability[column], summary[column]) + # the standard deviation of the 0.2 quantile over the resamples + quantile = Criteria( + {"x": "min", "y p20": "max"}, statistics=[Quantile("y", 0.2)] + ) + probability = pareto_probability(results, quantile, n_resamples=2000) + self.assertEqual( + list(probability.columns[1:5]), ["x", "y p20", "y p20 se", "replicates"] + ) + # about that of a normal distribution of a standard deviation of 2: + # sqrt(q (1 - q) / n) over the density at the quantile (of a sample) + z = -0.8416 + density = np.exp(-(z**2) / 2) / np.sqrt(2 * np.pi) / 2 + expected = np.sqrt(0.2 * 0.8 / 40) / density + ratio = probability["y p20 se"].to_numpy() / expected + self.assertTrue(((ratio > 0.4) & (ratio < 2.5)).all(), ratio) def test_resamples_share_replicates(self): """A bootstrap draws each replicate in every scenario at once.""" diff --git a/tests/tradespace/test_tables.py b/tests/tradespace/test_tables.py index c8b6c2dd..6232f135 100644 --- a/tests/tradespace/test_tables.py +++ b/tests/tradespace/test_tables.py @@ -70,7 +70,7 @@ def test_records(self): ) # columns of the evaluation, and metrics, do not separate them check_records(doubled, ["design", "replicate", "sensor"]) - with self.assertRaisesRegex(ValueError, "aggregate"): + with self.assertRaisesRegex(ValueError, "summarize"): check_summary(results) check_summary(results, by=["replicate"]) diff --git a/tests/tradespace/test_utility.py b/tests/tradespace/test_utility.py index 2d40fbe7..eb8e02aa 100644 --- a/tests/tradespace/test_utility.py +++ b/tests/tradespace/test_utility.py @@ -20,9 +20,7 @@ Quantile, Requirement, StandardDeviation, - StandardError, Utility, - aggregate, pareto_front, summarize, ) @@ -166,14 +164,14 @@ def test_expected_utility(self): which penalizes the spread of a risk-averse utility.""" criteria = Criteria({"utility": "max"}, statistics={"utility": self.utility}) self.assertEqual(criteria.metrics, ["a"]) - summary = aggregate(_results(), criteria).set_index("design") + summary = summarize(_results(), criteria).set_index("design") expected = (0 + 1) / 2 self.assertAlmostEqual(summary.loc["x", "utility"], expected) self.assertAlmostEqual( summary.loc["y", "utility"], float(ExponentialUtility(0, 1, 2)(0.5)) ) # the utility of the means is the same for both - means = aggregate(_results(), ["a"]).set_index("design") + means = summarize(_results(), statistics=["a"]).set_index("design") np.testing.assert_allclose(self.utility(means), self.utility(means).iloc[0]) def test_statistics(self): @@ -183,7 +181,7 @@ def test_statistics(self): "reliable": Probability(self.utility, ">=", 0.5), "expected": Mean(self.utility), } - summary = aggregate(_results(), statistics=statistics).set_index("design") + summary = summarize(_results(), statistics=statistics).set_index("design") self.assertEqual(summary.loc["x", "worst"], 0.0) self.assertEqual(summary.loc["x", "reliable"], 0.5) self.assertEqual(summary.loc["y", "reliable"], 1.0) @@ -201,15 +199,14 @@ def test_summarize(self): # the cost of each design is the same in every replicate for column in ("cost std", "cost se"): self.assertNotIn(column, summary.columns) - spread = aggregate( + # as of the statistic + spread = summarize( _results(), criteria, - statistics={ - "utility std": StandardDeviation(self.utility), - "utility se": StandardError(self.utility), - }, + statistics={"utility std": StandardDeviation(self.utility)}, + spread=False, ).set_index("design") - pd.testing.assert_series_equal(summary["utility se"], spread["utility se"]) + pd.testing.assert_series_equal(summary["utility std"], spread["utility std"]) self.assertEqual(summary.loc["y", "utility std"], 0.0) def test_utility_against_cost(self): @@ -221,13 +218,13 @@ def test_utility_against_cost(self): ) # a requirement on a statistic that the criteria do not name with self.assertRaises(ValueError): - aggregate(_results(), criteria) + summarize(_results(), criteria) criteria = Criteria( {"utility": "max", "cost": "min"}, statistics={"utility": self.utility, "worst": Quantile(self.utility, 0)}, requirements=[Requirement("worst", ">=", 0.1)], ) - summary = aggregate(_results(), criteria) + summary = summarize(_results(), criteria) front = summary[pareto_front(summary, criteria)] # x is cheaper, but misses the requirement on its worst replicate self.assertEqual(list(front.design), ["y"]) From 822cb6e46a965e3a2bd25eee6925fbd33cd2b0f4 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Sat, 14 Nov 2026 22:37:03 -0700 Subject: [PATCH 51/52] review the trade space a seventh time: fingerprint statistics by their attributes, count only the resamples in which a design is judged in the standard errors of pareto_probability (and refine designs whose standard error is unknown), keep infinite means under control variates, take statistics over histories of equal weights as over replicates, reject two requirements on the phases of one metric and design values policy that configure no policy, key the cache of phases by the satellites of each content, judge rows without a value of by as a group of their own, give the summaries of searches, screenings, and confirmations the spreads of means, take a fixed seed of targets, a single constraint of layout fragments, and references in per-type masses, list the values of designs for completion (with suggestions of misspelled names), give the direction error for misspelled directions in summarize, require a front to annotate designs, and enumerate at most 4,096 sets for exact expectations --- CHANGELOG.md | 1 + src/tatc/tradespace/confirmation.py | 28 +++++++--- src/tatc/tradespace/constellations.py | 34 ++++++++----- src/tatc/tradespace/expectations.py | 15 +++--- src/tatc/tradespace/fingerprint.py | 5 +- src/tatc/tradespace/histories.py | 37 +++++++++----- src/tatc/tradespace/mission.py | 21 ++++++-- src/tatc/tradespace/observations.py | 68 ++++++++++++++++++------- src/tatc/tradespace/optimization.py | 9 ++-- src/tatc/tradespace/plans.py | 68 ++++++++++++++++--------- src/tatc/tradespace/plotting.py | 12 +++-- src/tatc/tradespace/refinement.py | 5 +- src/tatc/tradespace/screening.py | 10 ++-- src/tatc/tradespace/space.py | 11 +++- src/tatc/tradespace/statistics.py | 12 +++++ src/tatc/tradespace/summary.py | 39 ++++++++++---- src/tatc/tradespace/tables.py | 5 +- src/tatc/tradespace/values.py | 21 +++++++- tests/tradespace/test_confirmation.py | 20 ++++++++ tests/tradespace/test_constellations.py | 38 ++++++++++++++ tests/tradespace/test_cost.py | 30 +++++++++++ tests/tradespace/test_deployment.py | 17 ++++--- tests/tradespace/test_failures.py | 62 +++++++++++++++++++++- tests/tradespace/test_observations.py | 50 +++++++++++++++++- tests/tradespace/test_optimization.py | 8 +-- tests/tradespace/test_pareto.py | 10 ++++ tests/tradespace/test_plotting.py | 13 +++++ tests/tradespace/test_refinement.py | 47 +++++++++++++++++ tests/tradespace/test_screening.py | 8 +++ tests/tradespace/test_space.py | 23 +++++++++ tests/tradespace/test_statistics.py | 25 +++++++++ tests/tradespace/test_summary.py | 47 ++++++++++++++++- 32 files changed, 669 insertions(+), 130 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index dac18f22..0b1f415d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -44,6 +44,7 @@ Added: - The mission of each design of an observation study (module `plans`): `MissionPlan.policy` gives the restoration policy of each design (by default, the design's value `policy` if it has one, and otherwise restoring failed satellites; a policy, a function, or a reference to values that configure it, such as those of `policy_space`), with its spares in orbit (`RestorationPolicy.orbit_spares`, launched with their planes) and on the ground, and `ObservationStudy.mission_of` gives the `Mission` of a design (its deployment, phases, cost estimate, and histories) as its evaluation plans it (`MissionPlan.plan_mission`). With failures, the requirements on the phases of a study (`phases`) give the time until each history meets them, and `Failures` checks its options when it is made. Exact expectations fall back to the means of the histories for missions with too many sets of satellites (`expectations.MAX_SETS`). Planned replacements keep the launch interval, spares in orbit that are never used are not replaced at the end of their design life, launches are priced by the masses of the deployment, the phases of a mission are cached by the uncertain values of its replicate, and studies of staged deployments record the `stages deployed`. A deployment is planned with its restoration policy (`DeploymentSchedule.plan(policy=...)`, `Deployment.policy`), whose spares its planned history (`Deployment.planned`), its simulations (`Deployment.simulate(model)`), and its costs share, the options of `DeploymentSchedule.plan` and `ObservationStudy` are keyword-only, `layout_of` is exported, a layout names its pattern (`pattern`), `Stage` takes numpy values, and the development of a staged type that is never deployed is the cost of its option. References to values of designs are in module `references`. - Fingerprints describe objects by what their `__fingerprint__()` returns (designs, and caches of satellites by their function and namespace), so that a study whose functions use them is evaluated again when they change. Decisions that name no child of a design space raise an error (also those of designs of another space, in a study's space), `errors="record"` records the errors of realizing a design, metrics may not be named `scenario`, replicates and shifts must not be negative, and a design space takes a single constraint. Module `references` reads designs: `configure` and `value_of` are exported, and functions given the design follow one convention (a parameter named `design`). `Design.uncertain_values()` gives the values of a design's uncertain parameters, and `Statistic` and the classes of the steps (`Refinement`, `Confirmation`, `Screening`, `Search`, `Attribution`) are exported. `summarize` gives the spread of the statistics it reports across scenarios (of the worst scenario, or of the weighted mean over the replicates that the scenarios share) and leaves out spreads that are zero for every design. Statistics may not take the names of columns of the results, and `summarize_histories` names the share of histories that meet a requirement `P() histories`. `refine` charges the evaluations of every scenario to its budget (`Refinement.rounds` gives its rounds), `pareto_probability` leaves out of a resample a design without a feasible replicate drawn, `main_effects` orders its bins, searches with pymoo leave the caller's algorithm unchanged, and Optuna's constraints of requirements have distinct names. `exceedance` gives the `shared_replicates` of two designs. A ground spare goes up at the next launch slot, the planes of a stage launch in the order they are ready, and `MissionHistory.deployed` is infinite for a deployment that outlasts the mission. `SatelliteCache` keeps a context with each namespace, `Observations` generates the targets of a replicate only to observe them, an `ObservationStudy` computes the metrics of all of a design's satellites once, exact expectations are faster (module `expectations`), and the options of `Study.run`, `designs_of`, `ResultStore`, `SatelliteCache`, and `Repeat` are keyword-only. - A `tradespace.Study` may describe its designs (`describe`, a `description` column of the results that summaries keep, outside the fingerprint), and `DesignSpace.enumerate(designs)` gives every design that extends designs of a space it extends (such as each design with each policy). `summarize` gives the statistics of designs with the spreads of their means (or without, `spread=False`) and takes criteria or a mapping of objectives, with metrics and other statistics in `statistics`; `pareto_probability` gives the standard errors of means as `summarize` does, and of other objectives by its bootstrap. `Failures` take statistics over the histories (`Quantile`, `Probability`, and `StandardDeviation`) and require a `seed`, a study's requirements on phases (`phases`) apply with or without failures, and each field of a `MissionPlan` is a value or a reference to the design (also `stages`), with the restoration policy of the design's value `policy` by default. The masses of satellites are given by the plan (`MissionPlan.masses`), `Triangular` takes its `mode` by keyword, the options of the optimizers are keyword-only (`optimize_optuna(n_trials=100)`), `plot_designs` rings the efficient designs (`pareto`) by default and labels designs with `annotate`, and the outcomes of steps give their `results`, `summary`, `designs`, and `criteria` first (`Screening.summaries` gives the summaries of every stage in one frame). The parts of criteria, design spaces, stores, missions, and observations that only the module uses are private, and `DesignSpace` neither encodes designs nor documents the internals of its optimizers. + - `tradespace.Targets` take a fixed seed (an integer) or a value of the design, the layout fragments a single constraint or several, and the per-type `masses` of a `MissionPlan` references to values of the design. Designs list their values for completion (`dir`) and suggest the names of misspelled ones. Fingerprints describe statistics by their attributes (such as the quantiles of `Failures`). Phases take at most one requirement on each metric, and a design's value `policy` that neither is nor configures a policy raises an error. The summaries of `Search`, `Screening`, and `Confirmation` give the spreads of means, as `summarize` does; rows without a value of `by` are judged as a group of their own; and `plot_designs` annotates only with a front. Statistics over histories of equal weights are those over replicates, control variates keep infinite means, and exact expectations enumerate at most 4,096 sets of satellites (`MAX_SETS`, about 12 satellites) before failures fall back to histories. - Trade space tutorial (`docs/examples/tradespace`): eight notebooks that follow one trade of constellations, each adding one idea to those before it: `EvaluateTradeSpace` (design space, study, and Pareto front), `ExplainTradeSpace` (sampling error, revisits, and sensitivity), `SearchTradeSpace` (hypervolume, screening, and optimizers), `RankUncertainDesigns` (probability of efficiency, refinement, confirmation, and requirements on statistics), `CompareScenarios` (scenarios, regret, and searches across scenarios), `TradeCostAndUtility` (costs with uncertain growth, budgets, and utility), `PlanDeployment` (phases and staging), and `PlanForFailures` (failures, restoration policies, and the attribution of variance). Each notebook defines what it introduces, and imports what earlier notebooks defined from `trade_space_example.py`. - The `RunOSSEMonsoon` example declares its constellation trade as a design space, caches the looks of each satellite, evaluates its replicates in parallel, and finds its Pareto-efficient designs. diff --git a/src/tatc/tradespace/confirmation.py b/src/tatc/tradespace/confirmation.py index 0e5b5afd..5b0ea953 100644 --- a/src/tatc/tradespace/confirmation.py +++ b/src/tatc/tradespace/confirmation.py @@ -37,9 +37,11 @@ class Confirmation: which do not include those that selected the designs.""" summary: pd.DataFrame """pandas.DataFrame: A row per design (and group): the values of the - design, the statistics of the criteria by the new replicates, those of - the replicates that selected the design (` selected`), the - optimism of the selection in each objective (` optimism`: by + design, the statistics of the criteria by the new replicates (each mean + followed by its spread, ` std` and ` se`, as + `summarize` gives them), those of the replicates that selected the + design (` selected`), the optimism of the selection in each + objective (` optimism`: by how much the selecting replicates made the design look better than the new replicates do, in its units, positive if they did), the number of new feasible `replicates`, the share of the new replicates that are @@ -132,7 +134,16 @@ def confirm( fresh = study.run(designs, replicate_indices=range(start, start + count)) names = [name for name in criteria.names if name != FEASIBLE] columns = ["design", *criteria.by] - confirmed = _summarize(fresh, criteria) + confirmed = _summarize(fresh, criteria, spread=True) + # the spreads of the means by the new replicates, after each statistic + spreads = { + name: [ + column + for column in (f"{name} std", f"{name} se") + if column in confirmed.columns and column not in names + ] + for name in names + } selected = _summarize( results[results["design"].isin(keys)], criteria, design_values=False )[[*columns, *names]] @@ -147,12 +158,17 @@ def confirm( summary[f"{name} selected"] - summary[name] ) status = ["replicates", FEASIBLE, *JUDGMENT] - values = [c for c in confirmed.columns if c not in {*columns, *names, *status}] + statistics = [ + column + for name in names + for column in (name, *spreads[name], f"{name} selected") + ] + values = [c for c in confirmed.columns if c not in {*columns, *statistics, *status}] summary = summary[ [ *columns, *values, - *(c for name in names for c in (name, f"{name} selected")), + *statistics, *(f"{name} optimism" for name in criteria.objectives), *status, ] diff --git a/src/tatc/tradespace/constellations.py b/src/tatc/tradespace/constellations.py index e77157c4..b6e4c0aa 100644 --- a/src/tatc/tradespace/constellations.py +++ b/src/tatc/tradespace/constellations.py @@ -69,7 +69,7 @@ def build(d): WalkerConstellation, ) from .nodes import Derived, Fixed, Integer, Real, Repeat, Uncertain -from .space import DesignSpace +from .space import DesignSpace, _as_constraints from .values import ChoiceValues, RepeatValues, Scope, Values WALKER = "walker" @@ -98,7 +98,7 @@ def walker_space( configuration: Any = "delta", phase_fraction: Any = 0.0, node_fraction: Any = 0.0, - constraints: Sequence[Callable[[Scope], Any]] = (), + constraints: Callable[[Scope], Any] | Sequence[Callable[[Scope], Any]] = (), ) -> DesignSpace: """ Gets a fragment of a design space of Walker constellations (see @@ -141,7 +141,8 @@ def walker_space( node_fraction (Any): The node of the lead satellite, as a fraction of `360 / planes` degrees (delta configuration) or 360 degrees (star configuration). - constraints (Sequence[Callable]): Constraints of the fragment. + constraints (Callable | Sequence[Callable]): A constraint, or the + constraints, of the fragment. Returns: DesignSpace: the fragment @@ -199,7 +200,7 @@ def sso_planes_space( repeat_ground_track: Any = True, ordered: bool = False, distinct: bool = True, - constraints: Sequence[Callable[[Scope], Any]] = (), + constraints: Callable[[Scope], Any] | Sequence[Callable[[Scope], Any]] = (), ) -> DesignSpace: """ Gets a fragment of a design space of planes of sun-synchronous orbits @@ -262,7 +263,8 @@ def sso_planes_space( ordered (bool): `True` if the planes are ordered (for example, if their values depend on their index). distinct (bool): `True` to require different crossing times. - constraints (Sequence[Callable]): Other constraints of the fragment. + constraints (Callable | Sequence[Callable]): Another constraint, + or other constraints, of the fragment. Returns: DesignSpace: the fragment @@ -282,7 +284,10 @@ def sso_planes_space( } if altitude is not None: children["altitude"] = altitude - constraints = ([_distinct_crossings] if distinct else []) + list(constraints) + constraints = [ + *([_distinct_crossings] if distinct else []), + *_as_constraints(constraints), + ] return DesignSpace(constraints=constraints, **children) @@ -297,7 +302,7 @@ def planes_space( altitude: Any = None, repeat_ground_track: Any = True, ordered: bool = False, - constraints: Sequence[Callable[[Scope], Any]] = (), + constraints: Callable[[Scope], Any] | Sequence[Callable[[Scope], Any]] = (), ) -> DesignSpace: """ Gets a fragment of a design space of planes of circular orbits (see @@ -335,7 +340,8 @@ def planes_space( repeat_ground_track (Any): Whether the satellites of a train follow the same ground track (or the same plane). ordered (bool): `True` if the planes are ordered. - constraints (Sequence[Callable]): Constraints of the fragment. + constraints (Callable | Sequence[Callable]): A constraint, or the + constraints, of the fragment. Returns: DesignSpace: the fragment @@ -408,7 +414,7 @@ def soc_space( altitude: Any = None, phase_fraction: Any = 0.0, node_fraction: Any = 0.0, - constraints: Sequence[Callable[[Scope], Any]] = (), + constraints: Callable[[Scope], Any] | Sequence[Callable[[Scope], Any]] = (), ) -> DesignSpace: """ Gets a fragment of a design space of streets-of-coverage constellations @@ -453,8 +459,9 @@ def soc_space( node_fraction (Any): The node of the lead satellite, as a fraction of `360 / planes` degrees (inclined orbits) or 360 degrees (polar orbits). - constraints (Sequence[Callable]): Constraints of the fragment (such - as a maximum of `planes * per_plane` satellites). + constraints (Callable | Sequence[Callable]): A constraint, or the + constraints, of the fragment (such as a maximum of + `planes * per_plane` satellites). Returns: DesignSpace: the fragment @@ -492,7 +499,7 @@ def mog_space( clockwise: Any = True, altitude: Any = None, phase_fraction: Any = 0.0, - constraints: Sequence[Callable[[Scope], Any]] = (), + constraints: Callable[[Scope], Any] | Sequence[Callable[[Scope], Any]] = (), ) -> DesignSpace: """ Gets a fragment of a design space of mutual orbiting groups (see @@ -522,7 +529,8 @@ def mog_space( altitude (Any): The altitude, if part of the layout. phase_fraction (Any): The phase of the reference orbit, as a fraction of 360 degrees. - constraints (Sequence[Callable]): Constraints of the fragment. + constraints (Callable | Sequence[Callable]): A constraint, or the + constraints, of the fragment. Returns: DesignSpace: the fragment diff --git a/src/tatc/tradespace/expectations.py b/src/tatc/tradespace/expectations.py index b132a262..ac864791 100644 --- a/src/tatc/tradespace/expectations.py +++ b/src/tatc/tradespace/expectations.py @@ -21,10 +21,11 @@ if TYPE_CHECKING: from .deployment import Deployment -MAX_SETS = 200_000 +MAX_SETS = 4_096 """The most sets of satellites that exact expectations enumerate by default (see `exact_expectations`), as those of the failures of a study do (see -`Failures`).""" +`Failures`): those of about 12 satellites, whose metrics they evaluate +(nearly every set) in about 35 times as many evaluations as 20 histories.""" class ExactExpectationsError(ValueError): @@ -201,10 +202,12 @@ def exact_expectations( Without sampling error, an expectation estimates the mean of many histories with none of their variance (see `Deployment.simulate_many`), - for missions of a few to a dozen or two satellites; for larger ones - (whose sets number more than `max_sets`, which is known before any is - enumerated), or with restoration (whose shared production and launches - make failures dependent), simulate histories. + for missions of a few to about a dozen satellites, but evaluates the + metrics of nearly every set (about `2 ** n` of `n` satellites, against + the few sets that histories evaluate); for larger ones (whose sets + number more than `max_sets`, which is known before any is enumerated), + or with restoration (whose shared production and launches make failures + dependent), simulate histories. Args: deployment (Deployment): The deployment, whose policy does not diff --git a/src/tatc/tradespace/fingerprint.py b/src/tatc/tradespace/fingerprint.py index 79266fdd..f9a274b3 100644 --- a/src/tatc/tradespace/fingerprint.py +++ b/src/tatc/tradespace/fingerprint.py @@ -22,9 +22,10 @@ - the nodes of design spaces, by their attributes; - objects that describe themselves by a method `__fingerprint__()`, by the value that it returns, which is described in their place: designs - (by their design space, decisions, replicate, and scenario) and caches + (by their design space, decisions, replicate, and scenario), caches of satellites (by their function and namespace, not their counts of - hits and misses, nor what they hold); + hits and misses, nor what they hold), and statistics (by their + attributes, such as their column and quantile); - partial functions (by their function and arguments), bound methods (by their function and object), and functions that decorators wrap (such as by `functools.lru_cache`, by the wrapped function). diff --git a/src/tatc/tradespace/histories.py b/src/tatc/tradespace/histories.py index d3079178..98d4bfac 100644 --- a/src/tatc/tradespace/histories.py +++ b/src/tatc/tradespace/histories.py @@ -100,7 +100,10 @@ def summarize_histories( requirement (` time`, see `evaluate_histories`) is infinite if a history never meets it, and its quantiles, or the share of the histories that meet it by a time (such as `Probability("accurate time", - "<=", 4)`), summarize it. + "<=", 4)`), summarize it. Histories of equal weights take each statistic + as over replicates (a linear quantile, and a standard deviation that is + `NaN` with an infinite value); weighted ones take the quantile of the + weighted distribution. With `controls`, the means are estimated with control variates: columns whose expected values are known (such as the `availability` of a @@ -111,7 +114,9 @@ def summarize_histories( controls over the histories, which removes the share of its variance that the controls explain (a share of `rho ** 2` for a correlation `rho`): fewer histories give the same precision. The other statistics - are not corrected. + are not corrected, nor are the means of columns with an infinite value + (such as the time until a requirement is met, if a history never meets + it), which stay infinite. Histories of stressed failures (see `Deployment.simulate_many`) are weighted by their likelihood ratios (`weight`), for every statistic, and @@ -210,23 +215,31 @@ def _weighted_statistic( ) -> float: """ Computes a statistic over histories (see `summarize_histories`) of their - values, by their weights, leaving out missing values (`NaN`). + values, by their weights, leaving out missing values (`NaN`): with equal + weights, the statistic as over replicates (see `Statistic.reduce`), and + otherwise weighted (a quantile of the weighted distribution, and a + standard deviation that is `NaN` with an infinite value). """ + known = ~np.isnan(values) + given = weights[known] + if len(given) == 0 or np.all(given == given[0]): + return float(statistic.reduce(values[None, :])[0]) if isinstance(statistic, Quantile): return _weighted_quantile(values, weights, statistic.q) - known = ~np.isnan(values) if isinstance(statistic, Probability): - if not known.any() or weights[known].sum() <= 0: + if weights[known].sum() <= 0: return math.nan requirement = Requirement( statistic.column, statistic.operator, statistic.threshold ) met = requirement.met(values[known]) return float(np.sum(weights[known] * met) / np.sum(weights[known])) + count = known.sum() + if count < 2 or np.isinf(values[known]).any(): + return math.nan mean = _weighted_mean(values, weights) variance = _weighted_mean((values - mean) ** 2, weights) - count = known.sum() - return float(np.sqrt(variance * count / (count - 1))) if count > 1 else math.nan + return float(np.sqrt(variance * count / (count - 1))) def _weighted_mean(values: np.ndarray, weights: np.ndarray) -> float: @@ -244,15 +257,12 @@ def _weighted_quantile(values: np.ndarray, weights: np.ndarray, q: float) -> flo """ The quantile of the known values (not `NaN`, but infinite ones), by their weights: the least value whose cumulative weight reaches the share - `q` of the total (as numpy's `inverted_cdf`), or numpy's linear quantile - of finite values without weights. + `q` of the total (as numpy's `inverted_cdf`). """ known = ~np.isnan(values) values, weights = values[known], weights[known] if len(values) == 0: return math.nan - if np.all(weights == weights[0]) and np.all(np.isfinite(values)): - return float(np.quantile(values, q)) order = np.argsort(values) cumulative = np.cumsum(weights[order]) / weights.sum() position = min(int(np.searchsorted(cumulative, q - 1e-12)), len(values) - 1) @@ -267,7 +277,8 @@ def _controlled_means( `summarize_histories`): each column's mean less the regression of the column on the controls applied to the deviations of the controls' means from their expected values, over the histories in which the column and - the controls are known. + the controls are known. A column with an infinite value keeps its plain + (infinite) mean. """ names = list(controls) missing = set(names) - set(numeric.columns) @@ -278,6 +289,8 @@ def _controlled_means( for column in numeric.columns: if column in controls: continue + if np.isinf(numeric[column].to_numpy(dtype=float)).any(): + continue # an infinite mean (such as of a time never met) is kept data = numeric[[column, *names]].to_numpy(dtype=float) known = np.all(np.isfinite(data), axis=1) data, w = data[known], weights[known] diff --git a/src/tatc/tradespace/mission.py b/src/tatc/tradespace/mission.py index 98cf009b..fe4c33d2 100644 --- a/src/tatc/tradespace/mission.py +++ b/src/tatc/tradespace/mission.py @@ -453,11 +453,22 @@ def summarize_phases( metrics (Sequence[str] | None): The metrics, or `None` for every column other than those of the phases (`start`, `end`, `duration`, and `satellites`). - requirements (Sequence[Requirement]): Requirements on metrics. + requirements (Sequence[Requirement]): Requirements on metrics, at + most one of each metric (whose time it names). Returns: dict[str, float]: the summary, as metrics of an evaluation + + Raises: + ValueError: if two requirements are of the same metric. """ + named = [requirement.name for requirement in requirements] + repeated = sorted({name for name in named if named.count(name) > 1}) + if repeated: + raise ValueError( + f"requirements on phases of the same metrics: {repeated} (the time " + + "until a phase meets a requirement is named by its metric)" + ) if metrics is None: metrics = [column for column in phases.columns if column not in _PHASE_COLUMNS] weights = phases["duration"].to_numpy(dtype=float) @@ -559,10 +570,12 @@ def _metrics_of( """ Gets the metrics of satellites that operate together, by their keys in the cache (by their names in the observations), from the cache if - they are in it (keyed by the context and the keys), or else of their - observations (and kept), given the design if the metric takes one. + they are in it (keyed by the context and the keys, with those of + satellites of the same content counted, as each observes), or else + of their observations (and kept), given the design if the metric + takes one. """ - key = (context, frozenset(keys.values())) + key = (context, tuple(sorted(keys.values()))) if key in self._memory: self.hits += 1 else: diff --git a/src/tatc/tradespace/observations.py b/src/tatc/tradespace/observations.py index 6e3c884a..092e43a7 100644 --- a/src/tatc/tradespace/observations.py +++ b/src/tatc/tradespace/observations.py @@ -14,6 +14,7 @@ from __future__ import annotations import dataclasses +import numbers import os import warnings from collections.abc import Callable, Mapping, Sequence @@ -31,7 +32,7 @@ from .memory import Forgetful from .mission import Capability, Mission, PhaseCache from .plans import Failures, MissionPlan -from .references import Reference, _given_design, _takes_design, value_of +from .references import Reference, _given_design, _number, _takes_design, value_of from .space import Design, DesignSpace from .study import Study, _Case @@ -43,35 +44,56 @@ class Targets(Forgetful): """ The targets of observations (such as points): fixed (a data frame), or - generated in each replicate by a function (such as + generated by a function (such as `tatc.generation.generate_points_fibonacci_lattice`) given the `arguments` - and `keywords`, and a seed that is a value of the design (as its keyword - `seed`, such as of `Uncertain.seed`), so that each replicate samples - other targets. Generated targets are kept in memory by seed. + and `keywords`, and a seed (as its keyword `seed`): a value of the design + (such as of `Uncertain.seed`), so that each replicate samples other + targets, or a fixed seed (an integer), so that every replicate samples + the same targets:: + + Targets(generate_points_fibonacci_lattice, count=100, rotate=True, seed="points_seed") + Targets(generate_points_fibonacci_lattice, count=100, rotate=True, seed=7) + + Generated targets are kept in memory by seed. Args: source (pandas.DataFrame | Callable): The targets, or a function that generates them. *arguments (Any): The arguments of the function. - seed (Reference | None): The value of the design that seeds the - function (see `value_of`), or `None` (to generate the same - targets). + seed (Reference | int | None): The value of the design that seeds + the function (see `value_of`), a fixed seed (an integer), or + `None` (to give the function no seed). **keywords (Any): The keyword arguments of the function. + + Raises: + TypeError: if the source is neither a data frame nor a function, or + the seed is neither a reference, an integer, nor `None`. + ValueError: if fixed targets are given arguments or a seed. """ source: Any arguments: tuple keywords: dict - seed: Reference | None + seed: Reference | int | None _forgotten = ("_memory",) # (copies sent to parallel workers) def __init__( self, source: Any, *arguments: Any, - seed: Reference | None = None, + seed: Reference | int | None = None, **keywords: Any, ): + if not ( + seed is None + or isinstance(seed, str) + or callable(seed) + or (isinstance(seed, numbers.Integral) and not isinstance(seed, bool)) + ): + raise TypeError( + "the seed of targets is a value of the design (its name or path, " + + f"or a function of the design), an integer, or None, not {seed!r}" + ) if isinstance(source, pd.DataFrame): if arguments or keywords or seed is not None: raise ValueError("fixed targets take no arguments or seed") @@ -87,16 +109,16 @@ def __init__( def _seed_of(self, design: Design | None) -> Any: """ - Gets the seed of the targets of a (realized) design (`None` if they - are fixed). + Gets the seed of the targets of a (realized) design: a value of the + design, the fixed seed, or `None` (without a seed). """ if self.seed is None: return None - if design is None: + if design is None and not isinstance(self.seed, numbers.Integral): raise ValueError( "targets generated from a seed of the design need a design" ) - return value_of(design, self.seed) + return _number(design, self.seed) def _of(self, design: Design | None = None) -> pd.DataFrame: """ @@ -478,17 +500,17 @@ class ObservationStudy(Study): failures (Failures | None): The failures, if any, which require a plan. phases (Sequence[Requirement] | bool | None): `True` (or requirements - on the metrics) to summarize the phases of the mission, which - require a plan: of the deployment, or of each history of the - failures (whose phases are always summarized). + on the metrics, at most one of each) to summarize the phases of + the mission, which require a plan: of the deployment, or of each + history of the failures (whose phases are always summarized). **options (Any): The settings of the study (see `Study`), such as `replicates`, `seed`, `n_jobs`, and `store`. Raises: TypeError: if the requirements on phases are not Requirements. ValueError: if failures or phases are given without a plan, a plan - without a layout, or statistics of failures of costs without a - cost model. + without a layout, several requirements on phases of a metric, or + statistics of failures of costs without a cost model. """ def __init__( @@ -509,6 +531,14 @@ def __init__( phases = () if phases is True else None if phases is None else tuple(phases) if phases is not None and not all(isinstance(r, Requirement) for r in phases): raise TypeError("the requirements on phases are Requirements") + named = [requirement.name for requirement in phases or ()] + repeated = sorted({name for name in named if named.count(name) > 1}) + if repeated: + raise ValueError( + f"several requirements on the phases of metrics {repeated}: give " + + "one requirement per metric, whose time until the phases meet it " + + "is the column ` time`" + ) if layout is None and "layout" in space.children: layout = "layout" if plan is None and (failures is not None or phases is not None): diff --git a/src/tatc/tradespace/optimization.py b/src/tatc/tradespace/optimization.py index 3e7db5c4..15c79dec 100644 --- a/src/tatc/tradespace/optimization.py +++ b/src/tatc/tradespace/optimization.py @@ -74,9 +74,10 @@ class Search: """pandas.DataFrame: A row per design that the search found feasible (with a feasible replicate, in every scenario with criteria `across` scenarios, as designs are judged by their feasible replicates, see - `summarize`): the summary of the criteria over its replicates, with - whether it is efficient among these designs (`pareto`, with the - tolerances of the criteria).""" + `summarize`): the summary of the criteria over its replicates (with the + spreads of means, as `summarize` gives them), with whether it is + efficient among these designs (`pareto`, with the tolerances of the + criteria).""" designs: list[Design] """list[Design]: The efficient designs that the search found (`pareto` of `summary`), for the next step.""" @@ -212,7 +213,7 @@ def search(self, state: Any) -> Search: Search: the search """ results = self.results - summary = _summarize(results, self.criteria) + summary = _summarize(results, self.criteria, spread=True) return Search( results=results, criteria=self.criteria, diff --git a/src/tatc/tradespace/plans.py b/src/tatc/tradespace/plans.py index 63f0586e..6c59a982 100644 --- a/src/tatc/tradespace/plans.py +++ b/src/tatc/tradespace/plans.py @@ -29,7 +29,7 @@ from .failures import FailureModel, RestorationPolicy from .histories import _history_statistics, evaluate_histories, summarize_histories from .mission import Capability, Mission -from .references import Reference, configure, value_of +from .references import Reference, _number, configure, value_of from .simulation import _check_sampling from .space import Design from .statistics import Statistic @@ -51,6 +51,18 @@ def _resolve(design: Design, value: Any, kinds: type | tuple[type, ...] = ()) -> return value_of(design, value) +def _numbers(design: Design, value: Any) -> Any: + """ + Gets the value of a field of numbers of a plan for a design (see + `_NUMBERS`): a number, or a mapping of each type of satellite to its + number, each given or a reference to a value of the design. + """ + value = _resolve(design, value, _NUMBERS) + if isinstance(value, Mapping): + return {kind: _number(design, number) for kind, number in value.items()} + return value + + def _policy(value: Any) -> RestorationPolicy | None: """ Gets the policy that a value gives: a policy, or the default policy @@ -96,11 +108,12 @@ def schedule(d): plane (`RestorationPolicy.orbit_spares`) and on the ground, which are produced (and cost) whether or not the study has failures (see `Failures`). By default, the policy of a design is its value `policy`, - if it has one that configures a policy (such as a group of - `policy_space`, whose values configure the default policy, see - `configure`), and otherwise the default policy, which restores failed - satellites by producing new ones. A policy may also be given, or a - reference to another value of the design (a policy, or a group that + if it has one (a policy, or a group that configures one, such as a group + of `policy_space`, whose values configure the default policy, see + `configure`; other values raise a `TypeError`), and otherwise the + default policy, which restores failed satellites by producing new ones. + A policy may also be given, or a reference to another value of the + design (a policy, or a group that configures one), or a function that gives each design's policy (such as one that configures a base policy):: @@ -127,8 +140,8 @@ def schedule(d): policy (RestorationPolicy | Reference | None): The policy for the failed satellites of each design, and its spares (or the values of a group that configure the default policy), or `None` for the - design's value `policy`, if it has one that configures a policy, - and otherwise the default policy. + design's value `policy`, if it has one (which must be a policy or + configure one), and otherwise the default policy. growth (float | Reference | Mapping): The growth of the costs (see `CostModel.estimate`): a factor, or a mapping of each element (such as `"development"`) to a factor, or to a mapping of each @@ -140,8 +153,8 @@ def schedule(d): operating at a decision, by the study's metrics (see `Decision.capability`). masses (float | Mapping | Reference | None): The mass (kg) of the - satellites (or of each type, a mapping), for launches limited (or - priced) in mass, or `None`. + satellites (or of each type, a mapping of each to a number or a + reference), for launches limited (or priced) in mass, or `None`. scores (Reference | None): The scores from which the growth of the components of the cost model is drawn (see `CostModel.draw`), such as a group of `risk_space`, or `None` for the expected @@ -161,12 +174,22 @@ def schedule(d): def _policy_of(self, design: Design) -> RestorationPolicy: """ Gets the policy for the failed satellites of a design, and its - spares, raising a `TypeError` if the policy it refers to is not a - policy or a group that configures one. + spares, raising a `TypeError` if the policy it refers to (or, by + default, its value `policy`, if not `None`) is not a policy or a + group that configures one. """ if self.policy is None: - named = _policy(design["policy"]) if "policy" in design else None - return RestorationPolicy() if named is None else named + value = design["policy"] if "policy" in design else None + if value is None: + return RestorationPolicy() + named = _policy(value) + if named is None: + raise TypeError( + "the value policy of a design is the default policy of a plan: " + + f"a RestorationPolicy, or values that configure one, not {value!r} " + + "(give the plan's policy= a function of the design that gives it)" + ) + return named policy = _policy(_resolve(design, self.policy, RestorationPolicy)) if policy is None: raise TypeError( @@ -194,13 +217,7 @@ def _growth_of(self, design: Design) -> Any: growth = _resolve(design, self.growth, _NUMBERS) if not isinstance(growth, Mapping): return growth - resolved: dict[str, Any] = {} - for element, value in growth.items(): - value = _resolve(design, value, _NUMBERS) - if isinstance(value, Mapping): - value = {k: _resolve(design, g, numbers.Real) for k, g in value.items()} - resolved[element] = value - return resolved + return {element: _numbers(design, value) for element, value in growth.items()} def plan_mission( self, @@ -235,7 +252,7 @@ def plan_mission( layout, kind=value_of(design, self.kind), policy=self._policy_of(design), - masses=_resolve(design, self.masses, _NUMBERS), + masses=_numbers(design, self.masses), stages=tuple(stages or ()), capability=capability, ) @@ -275,9 +292,10 @@ class Failures: the exact expectations over the failures (see `exact_expectations`) if they apply: if the deployment is not staged (see `Stage`, whose rules make its launches depend on the history) and has at most `MAX_SETS` - (200,000) sets of satellites to enumerate, which is known before they - are enumerated; otherwise (such as for constellations of about 20 - satellites or more) they are the means of the histories. + (4,096) sets of satellites to enumerate, which is known before they are + enumerated; otherwise (such as for constellations of more than about 12 + satellites, whose sets would cost far more evaluations than the + histories) they are the means of the histories. With a `stress`, the failures of satellites and launches are drawn from stressed distributions for importance sampling (see diff --git a/src/tatc/tradespace/plotting.py b/src/tatc/tradespace/plotting.py index 432958ed..eb88a4ae 100644 --- a/src/tatc/tradespace/plotting.py +++ b/src/tatc/tradespace/plotting.py @@ -234,7 +234,7 @@ def plot_designs( such as of `pareto_front`), or `None`. annotate (str | Callable | None): The labels of the efficient designs, written next to them: a column, a function of a row, or - `None`. + `None` (which needs a front). names (Mapping | Callable | None): The names of the values of `by` in the legend (by default, the values). highlight (str | Sequence[bool] | None): The designs to color (a @@ -259,8 +259,15 @@ def plot_designs( Raises: ValueError: if `front` is a column (other than `"pareto"`) that the - frame lacks, or values of a length other than the frame's. + frame lacks, or values of a length other than the frame's, or if + designs are annotated without a front. """ + ringed = _front(frame, front) + if annotate is not None and ringed is None: + raise ValueError( + "annotate labels the efficient designs: give a front (a column " + + "'pareto', such as of a summary of criteria, or values)" + ) ax = _axes(ax, (9, 4.5)) shift = np.random.default_rng(_JITTER_SEED).uniform(-jitter, jitter, len(frame)) xs = frame[x].to_numpy(dtype=float) + (shift if jitter else 0.0) @@ -307,7 +314,6 @@ def plot_designs( lw=0, label=None if named else (others or "other"), ) - ringed = _front(frame, front) if ringed is not None: ax.scatter( xs[ringed], diff --git a/src/tatc/tradespace/refinement.py b/src/tatc/tradespace/refinement.py index c23a2e65..075453bf 100644 --- a/src/tatc/tradespace/refinement.py +++ b/src/tatc/tradespace/refinement.py @@ -93,7 +93,7 @@ def _precise( design's value). Designs whose varying objectives lack a tolerance are not precise. An objective without a standard error (which `pareto_probability` leaves out where it is zero for every design) does - not vary. + not vary, and one whose standard error is unknown (`NaN`) is not precise. """ precise = np.zeros(len(probability), dtype=bool) if precision is None or not criteria.tolerances: @@ -106,7 +106,8 @@ def _precise( error = probability[f"{name} se"].to_numpy(dtype=float) value = np.abs(probability[name].to_numpy(dtype=float)) tolerance = tolerances[0, i] + tolerances[1, i] * value - varies = np.nan_to_num(error) > 0 + # an unknown (NaN) error may vary, and is not less than any precision + varies = ~(error == 0) precise &= ~varies | (error < precision * tolerance) return precise diff --git a/src/tatc/tradespace/screening.py b/src/tatc/tradespace/screening.py index 170ecf4b..b3596065 100644 --- a/src/tatc/tradespace/screening.py +++ b/src/tatc/tradespace/screening.py @@ -54,10 +54,10 @@ class Screening: the first), such as for the cost of the screening.""" summaries: pd.DataFrame = field(default_factory=pd.DataFrame) """pandas.DataFrame: The summaries of the designs of every stage (see - `summarize`, with whether each is efficient by the stage's analysis, - `pareto`), with their Pareto rank (`pareto_rank`, see `pareto_ranks`), - whether they were `kept` for the next stage, and the `stage` (0 for the - first).""" + `summarize`, with the spreads of means and whether each is efficient by + the stage's analysis, `pareto`), with their Pareto rank (`pareto_rank`, + see `pareto_ranks`), whether they were `kept` for the next stage, and the + `stage` (0 for the first).""" def _per_stage(value, count: int, name: str) -> list: @@ -173,7 +173,7 @@ def screen( criteria = stages[stage] results = study.run(current) frames.append(results.assign(stage=stage)) - summary = _summarize(results, criteria) + summary = _summarize(results, criteria, spread=True) summary["pareto_rank"] = pareto_ranks(summary, criteria) if stage < transitions: amount = keeps[stage] diff --git a/src/tatc/tradespace/space.py b/src/tatc/tradespace/space.py index 5ba49d31..2161dcf2 100644 --- a/src/tatc/tradespace/space.py +++ b/src/tatc/tradespace/space.py @@ -145,7 +145,16 @@ def values(self) -> Values: def __getattr__(self, name: str) -> Any: if name.startswith("_"): raise AttributeError(name) - return getattr(self.values, name) + try: + return getattr(self.values, name) + except AttributeError as error: + raise AttributeError( + f"the design has {error}", name=name, obj=self + ) from None + + def __dir__(self) -> list[str]: + # the values, for completion (and suggestions of misspelled names) + return sorted({*object.__dir__(self), *self._values}) def __getitem__(self, name: str) -> Any: return self.values[name] diff --git a/src/tatc/tradespace/statistics.py b/src/tatc/tradespace/statistics.py index a54559e4..e2114526 100644 --- a/src/tatc/tradespace/statistics.py +++ b/src/tatc/tradespace/statistics.py @@ -154,6 +154,18 @@ def __eq__(self, other: object) -> bool: def __hash__(self) -> int: return hash((type(self), tuple(sorted(vars(self).items())))) + def __fingerprint__(self) -> dict: + """ + Gets what identifies the statistic in a definition (see + `tatc.tradespace.fingerprint`), such as of the statistics of the + failures of a study (see `Failures`): its attributes (such as its + column, and its quantile or threshold). + + Returns: + dict: the attributes + """ + return dict(vars(self)) + def __repr__(self) -> str: return f"{type(self).__name__}({self.column!r})" diff --git a/src/tatc/tradespace/summary.py b/src/tatc/tradespace/summary.py index aba2bc1c..1fb7ab70 100644 --- a/src/tatc/tradespace/summary.py +++ b/src/tatc/tradespace/summary.py @@ -60,14 +60,20 @@ rounding of terms that cancel).""" -def _bootstrap_error(sums: np.ndarray, squares: np.ndarray, n: int) -> np.ndarray: +def _bootstrap_error( + sums: np.ndarray, squares: np.ndarray, n: np.ndarray +) -> np.ndarray: """ Gets the standard errors of statistics from the sums of their values (and - of their squares) over `n` resamples of a bootstrap: their standard - deviations over the resamples. + of their squares) over the resamples of a bootstrap in which each is + known (`n`, of each): their standard deviations over these resamples + (`NaN` with fewer than two). """ - mean = sums / n - return np.sqrt(np.maximum(squares - n * mean**2, 0.0) / max(n - 1, 1)) + n = np.asarray(n, dtype=float) + with np.errstate(invalid="ignore", divide="ignore"): + mean = sums / n + variance = np.maximum(squares - n * mean**2, 0.0) / (n - 1) + return np.where(n >= 2, np.sqrt(variance), np.nan) def _replicates_of(feasible: pd.DataFrame, infeasible: pd.DataFrame) -> pd.Index: @@ -424,7 +430,11 @@ def _criteria_of( + "are) to summarize as `statistics`" ) return None, extra, by - if isinstance(criteria, Mapping) and not set(criteria.values()) <= {"min", "max"}: + if isinstance(criteria, Mapping) and not all( + isinstance(value, str) for value in criteria.values() + ): + # statistics given as criteria (strings that are not directions, such + # as "minimize", are misspelled directions, which Criteria rejects) raise ValueError( "a mapping of criteria gives the directions of objectives ('min' or " + "'max'): give statistics by name as `statistics`" @@ -631,7 +641,8 @@ def _summarize( ) -> pd.DataFrame: """ Summarizes results by the statistics of their designs (see `summarize`), - as the steps of trade studies do: without spreads by default, and, + as the steps of trade studies judge designs: without spreads by default + (the summaries that steps give have them, as `summarize` does), and, without `design_values`, without the values of the designs (only their keys, `design`), which saves finding them. """ @@ -814,7 +825,8 @@ def pareto_probability( (see `summarize`, with the spreads of means), in which each objective that is not a mean (such as a quantile) is followed by its standard error, its standard deviation over the resamples - (` se`, left out if it is zero for every design, as + in which the design is judged (` se`, `NaN` with + fewer than two, and left out if it is zero for every design, as `summarize` leaves out spreads), and the probability that the design is efficient (`pareto_probability`) and that it meets the requirements (`requirements_probability`) @@ -845,8 +857,10 @@ def pareto_probability( counts = np.zeros(len(table.designs)) met = np.zeros(len(table.designs)) # the sums of the objectives (and of their squares) over the resamples + # in which they are known (in which each design is judged) sums = {name: np.zeros(len(table.designs)) for name in booted} squares = {name: np.zeros(len(table.designs)) for name in booted} + known = {name: np.zeros(len(table.designs)) for name in booted} for drawn in draw_resamples(len(table.replicates), n_resamples, rng): sample, sample_violation = table.evaluate(drawn) # designs without a drawn replicate keep the statistics of all of @@ -860,13 +874,16 @@ def pareto_probability( counts += efficient(_costs(criteria, sample), meets, tolerances) met += meets for name in booted: - sums[name] += sample[name] - squares[name] += sample[name] ** 2 + value = sample[name] + found = ~np.isnan(value) + sums[name] += np.where(found, value, 0.0) + squares[name] += np.where(found, value, 0.0) ** 2 + known[name] += found computed = dict(values) _with_spreads(computed, table, statistics, spreads) for name in booted: computed[f"{name} se"] = _bootstrap_error( - sums[name], squares[name], n_resamples + sums[name], squares[name], known[name] ) ordered = {name: computed[name] for name in order} _assemble(frame, table, ordered, violation, criteria) diff --git a/src/tatc/tradespace/tables.py b/src/tatc/tradespace/tables.py index 0ae1a921..5a8a6b9f 100644 --- a/src/tatc/tradespace/tables.py +++ b/src/tatc/tradespace/tables.py @@ -59,6 +59,8 @@ def groups(frame: pd.DataFrame, by: Sequence[str]) -> Iterator[tuple[tuple, Any] """ Iterates over the groups of a data frame by columns (or the frame, if none): the values of the columns, and the positions of the group's rows. + Rows without a value of a column (`NaN` or `None`) are a group of their + own, rather than left out. Args: frame (pandas.DataFrame): The data frame. @@ -77,7 +79,8 @@ def groups(frame: pd.DataFrame, by: Sequence[str]) -> Iterator[tuple[tuple, Any] missing = [column for column in by if column not in frame.columns] if missing: raise ValueError(f"no columns {missing} to group by") - for key, positions in frame.groupby(list(by), sort=False).indices.items(): + grouped = frame.groupby(list(by), sort=False, dropna=False) + for key, positions in grouped.indices.items(): yield (key if isinstance(key, tuple) else (key,)), positions diff --git a/src/tatc/tradespace/values.py b/src/tatc/tradespace/values.py index 49b0bc6b..8c396fa0 100644 --- a/src/tatc/tradespace/values.py +++ b/src/tatc/tradespace/values.py @@ -181,7 +181,14 @@ def __getattr__(self, name: str) -> Any: try: return self[name] except KeyError: - raise AttributeError(name) from None + raise AttributeError( + f"no value {name!r} (it has {list(self._values)})", name=name, obj=self + ) from None + + def __dir__(self) -> list[str]: + # the values, for completion (and suggestions of misspelled names) + index = ["index"] if self._index is not None else [] + return sorted({*object.__dir__(self), *self._values, *index}) def __iter__(self) -> Iterator[str]: return iter(self._values) @@ -237,9 +244,19 @@ def __getattr__(self, name: str) -> Any: if name == self._value.choice: return value raise AttributeError( - f"the choice chose {self.choice!r}, which has no value {name!r}" + f"the choice chose {self.choice!r}, which has no value {name!r}", + name=name, + obj=self, ) + def __dir__(self) -> list[str]: + # the values of the branch and its name, for completion (and + # suggestions of misspelled names) + value = self.value + branch = isinstance(value, (Values, ChoiceValues, RepeatValues)) + names = dir(value) if branch else [] + return sorted({*object.__dir__(self), *names, self._value.choice}) + def __getitem__(self, name: str) -> Any: return _resolve_path(self, name) diff --git a/tests/tradespace/test_confirmation.py b/tests/tradespace/test_confirmation.py index 5b8fb123..b7bb09fe 100644 --- a/tests/tradespace/test_confirmation.py +++ b/tests/tradespace/test_confirmation.py @@ -87,6 +87,26 @@ def test_removes_optimism(self): ) self.assertLess(abs(errors.mean()), 0.15) + def test_spreads(self): + """The summary gives the spreads of the means by the new replicates, + after each statistic, as summarize does.""" + confirmation = confirm( + self.study, OBJECTIVES, self.results, self.selected, replicates=20 + ) + summary = confirmation.summary + new = summarize(confirmation.results, OBJECTIVES).set_index("design") + np.testing.assert_allclose( + summary.set_index("design").loc[new.index, "value se"], new["value se"] + ) + # the cost, the same in every replicate, has no spread + self.assertNotIn("cost se", summary.columns) + columns = list(summary.columns) + self.assertEqual( + columns[columns.index("value") : columns.index("value") + 4], + ["value", "value std", "value se", "value selected"], + ) + self.assertLess(columns.index("variant"), columns.index("cost")) + def test_default_front(self): """Without designs, the front of the results is confirmed; designs may also be given by their keys or a data frame of them.""" diff --git a/tests/tradespace/test_constellations.py b/tests/tradespace/test_constellations.py index 425d7c6e..ca71b6e5 100644 --- a/tests/tradespace/test_constellations.py +++ b/tests/tradespace/test_constellations.py @@ -119,6 +119,44 @@ def test_defaults(self): DesignSpace(layout=sso_planes_space(altitude=500e3)).size(), 100 ) + def test_single_constraint(self): + """Fragments take a constraint, or a sequence of them.""" + + def at_most_two(d): + return count_satellites(d) <= 2 + + fragments = { + "walker": lambda c: walker_space( + inclination=60, + planes=Integer(1, 2), + per_plane=Integer(1, 2), + constraints=c, + ), + "sso": lambda c: sso_planes_space( + crossing=Real(6, 9, step=3), + planes=Integer(1, 2), + per_plane=Integer(1, 2), + constraints=c, + ), + "planes": lambda c: planes_space( + inclination=60, + planes=Integer(1, 2), + per_plane=Integer(1, 2), + constraints=c, + ), + } + for name, fragment in fragments.items(): + single = DesignSpace(layout=fragment(at_most_two)).enumerate() + listed = DesignSpace(layout=fragment([at_most_two])).enumerate() + self.assertEqual([d.key for d in single], [d.key for d in listed], name) + self.assertTrue(all(count_satellites(d.layout) <= 2 for d in single)) + self.assertLess(len(single), DesignSpace(layout=fragment(())).size()) + # the crossings of planes of sun-synchronous orbits are still distinct + planes = DesignSpace(layout=fragments["sso"](at_most_two)).enumerate() + for design in planes: + crossings = [plane.crossing for plane in design.layout.planes] + self.assertEqual(len(set(crossings)), len(crossings)) + class TestBuild(unittest.TestCase): """ diff --git a/tests/tradespace/test_cost.py b/tests/tradespace/test_cost.py index 0874738e..122359ec 100644 --- a/tests/tradespace/test_cost.py +++ b/tests/tradespace/test_cost.py @@ -9,6 +9,7 @@ import unittest import numpy as np +import pandas as pd from tatc.tradespace import ( Categorical, @@ -18,6 +19,7 @@ DesignSpace, Integer, LaunchCost, + MissionPlan, OperationsCost, Quantile, RestorationPolicy, @@ -34,6 +36,7 @@ walker_space, ) from tatc.tradespace.constellations import plane_sizes +from tatc.tradespace.mission import Capability def _design(**children): @@ -198,6 +201,33 @@ def test_masses_of_the_deployment(self): with self.assertRaisesRegex(ValueError, "masses"): model.estimate(unsized) + def test_masses_of_a_plan(self): + """The masses of a plan, and of each type, are numbers or references + to values of the design, as are the growths of each type.""" + design = _design( + layout=walker_space( + inclination=55.0, planes=1, per_plane=2, relative_spacing=0 + ), + payload=Categorical(["imager"]), + mass=Categorical([100.0]), + growth=Categorical([1.5]), + ) + capability = Capability(["a", "b"], pd.DataFrame({"satellite": []}), len) + model = CostModel( + {"imager": SatelliteCost(first_unit=1)}, launch=LaunchCost(per_kg=0.01) + ) + for masses in (100.0, "mass", {"imager": "mass"}, {"imager": lambda d: 100}): + plan = MissionPlan( + DeploymentSchedule(), + model, + kind="payload", + masses=masses, + growth={"launch": {"imager": "growth"}}, + ) + mission = plan.plan_mission(design, design.layout, capability) + self.assertEqual(mission.deployment.masses, {"imager": 100.0}) + self.assertAlmostEqual(mission.estimate().launch, 1.5 * 2 * 100 * 0.01) + def test_types(self): """Types of satellites are developed once each, with their own curves.""" small = SatelliteCost(development=10, first_unit=1) diff --git a/tests/tradespace/test_deployment.py b/tests/tradespace/test_deployment.py index e69d253e..eee17ef5 100644 --- a/tests/tradespace/test_deployment.py +++ b/tests/tradespace/test_deployment.py @@ -349,19 +349,24 @@ def metric(obs): self.assertEqual(list(capability.targets), [50, 25, 75, 100]) self.assertEqual(list(capability.satellites), [2, 1, 3, 4]) summary = summarize_phases( - capability, - requirements=[ - Requirement("targets", ">=", 75), - Requirement("targets", ">=", 200), - ], + capability, requirements=[Requirement("targets", ">=", 200)] ) expected = (50 * 0.5 + 25 * 0.5 + 75 * 1 + 100 * 2) / 4 self.assertAlmostEqual(summary["targets mission"], expected) - self.assertEqual(summary["targets time"], math.inf) # the last requirement + self.assertEqual(summary["targets time"], math.inf) # never met first = summarize_phases( capability, requirements=[Requirement("targets", ">=", 75)] ) self.assertEqual(first["targets time"], 3) + # two requirements of a metric would name the same time + with self.assertRaisesRegex(ValueError, "same metric"): + summarize_phases( + capability, + requirements=[ + Requirement("targets", ">=", 75), + Requirement("targets", ">=", 200), + ], + ) # phases of the same satellites are evaluated once repeated = evaluate_phases(phases + phases, observations, metric) self.assertEqual(len(repeated), 8) diff --git a/tests/tradespace/test_failures.py b/tests/tradespace/test_failures.py index be605a71..a04d3e2d 100644 --- a/tests/tradespace/test_failures.py +++ b/tests/tradespace/test_failures.py @@ -7,6 +7,7 @@ import math import unittest +import warnings from dataclasses import dataclass from unittest import mock @@ -606,6 +607,27 @@ def test_phase_cache(self): cache.clear() self.assertEqual((cache.hits, cache.misses), (0, 0)) + def test_phase_cache_of_identical_satellites(self): + """Satellites of the same content each count in the sets of a cache.""" + one = self.satellites[0] + twin = one.model_copy(update={"name": "twin"}) + observations = pd.DataFrame( + {"satellite": [one.name] * 3 + ["twin"] * 3, "target": [0, 1, 2] * 2} + ) + + def count(subset): + return {"observations": float(len(subset))} + + for sets in ( + [[one.name], [one.name, "twin"]], + [[one.name, "twin"], [one.name]], + ): + capability = Capability([one, twin], observations, PhaseCache(count)) + self.assertEqual( + [capability(names)["observations"] for names in sets], + [3.0 * len(names) for names in sets], + ) + def test_evaluate_and_summarize(self): """Histories are evaluated, priced, and summarized as one record.""" deployment = self.schedule.plan(self.layout) @@ -769,6 +791,43 @@ def test_control_variates(self): self.assertTrue(np.isfinite(summary["years"])) with self.assertRaises(ValueError): summarize_histories(missions, controls={"cost": 1.0}) + # a time that a history never meets keeps its infinite mean + availability = rng.uniform(0.6, 1.0, 20) + time = 3 + 2 * (1 - availability) + rng.normal(0, 0.05, 20) + time[availability < 0.65] = math.inf + missions = pd.DataFrame({"availability": availability, "share time": time}) + controlled = summarize_histories(missions, controls={"availability": 0.8}) + self.assertEqual(controlled["share time"], math.inf) + + def test_statistics_with_infinite_values(self): + """Statistics over histories of equal weights are those over + replicates, also of infinite values; weighted spreads of infinite + values are missing.""" + times = [float(t) for t in range(1, 21)] + statistics = [Quantile("time", 0.1), Quantile("time", 0.5)] + finite = summarize_histories( + pd.DataFrame({"time": times[:-1] + [1e9]}), statistics=statistics + ) + never = summarize_histories( + pd.DataFrame({"time": times[:-1] + [math.inf]}), statistics=statistics + ) + # a history that never meets it (the latest) moves no lower quantile + self.assertAlmostEqual(never["time histories p10"], 2.9) + for name in ("time histories p10", "time histories p50"): + self.assertAlmostEqual(never[name], finite[name]) + spread = [StandardDeviation("time")] + with warnings.catch_warnings(): + warnings.simplefilter("error") + plain = summarize_histories( + pd.DataFrame({"time": [1.0, 2.0, math.inf]}), statistics=spread + ) + weighted = summarize_histories( + pd.DataFrame({"time": [1.0, 2.0, math.inf], "weight": [0.5, 1.0, 1.5]}), + statistics=spread, + ) + self.assertTrue(math.isnan(plain["time histories std"])) + self.assertTrue(math.isnan(weighted["time histories std"])) + self.assertEqual(weighted["time"], math.inf) def _costs(replicate_seconds, history_seconds): @@ -1076,7 +1135,8 @@ def test_times_and_columns(self): ], ) self.assertEqual(summary["accurate time"], math.inf) - self.assertEqual(summary["accurate time histories p30"], 2.0) + # linear between the known values, as over replicates + self.assertAlmostEqual(summary["accurate time histories p30"], 2.6) self.assertEqual(summary["accurate time histories p90"], math.inf) self.assertEqual(summary["P(accurate time <= 3) histories"], 2 / 3) with self.assertRaisesRegex(ValueError, "other"): diff --git a/tests/tradespace/test_observations.py b/tests/tradespace/test_observations.py index 0f9c32f0..712eb03a 100644 --- a/tests/tradespace/test_observations.py +++ b/tests/tradespace/test_observations.py @@ -144,6 +144,35 @@ def test_fixed(self): with self.assertRaises(TypeError): Targets([1, 2]) + def test_fixed_seed(self): + """An integer seed generates the same targets in every replicate.""" + design = SPACE.enumerate()[0] + first, second = design.realize(0), design.realize(1) + targets = Targets( + generate_points_fibonacci_lattice, count=N_POINTS, rotate=True, seed=7 + ) + expected = generate_points_fibonacci_lattice( + count=N_POINTS, rotate=True, seed=7 + ) + pd.testing.assert_frame_equal(targets._of(first), expected) + self.assertIs(targets._of(second), targets._of(first)) + self.assertEqual(targets._seed_of(None), 7) + pd.testing.assert_frame_equal(targets._of(), expected) + # observations of a fixed seed need no design + observations = Observations(targets, START, HOURS) + satellites = _build(first) + pd.testing.assert_frame_equal( + observations(satellites), observations(satellites, second) + ) + + def test_invalid_seeds(self): + """A seed is a reference, an integer, or None.""" + for seed in (7.5, True, [1], timedelta(hours=1)): + with self.assertRaisesRegex(TypeError, "seed of targets"): + Targets(generate_points_fibonacci_lattice, count=5, seed=seed) + Targets(generate_points_fibonacci_lattice, count=5, seed=np.int64(3)) + Targets(generate_points_fibonacci_lattice, count=5, seed=lambda d: 3) + class TestObservations(unittest.TestCase): """ @@ -703,10 +732,14 @@ def study(policy): PLAN, policy=lambda d: configure(base, d.policy) )._policy_of(realized) self.assertEqual(configured, RestorationPolicy(orbit_spares=1, drift_years=1.0)) - # by default, the design's values `policy`, if they configure a policy + # by default, the design's values `policy`, which must configure a + # policy (others need a function that gives it), or else none self.assertEqual(PLAN._policy_of(realized), RestorationPolicy(orbit_spares=1)) other = SPACE.extend(policy=Categorical(["a", "b"])).enumerate()[0] - self.assertEqual(PLAN._policy_of(other.realize(0)), RestorationPolicy()) + with self.assertRaisesRegex(TypeError, "policy= a function"): + PLAN._policy_of(other.realize(0)) + unset = SPACE.extend(policy=Fixed(None)).enumerate()[0] + self.assertEqual(PLAN._policy_of(unset.realize(0)), RestorationPolicy()) self.assertEqual(PLAN._policy_of(designs[0].realize(0)), RestorationPolicy()) def test_failure_times(self): @@ -813,6 +846,19 @@ def test_invalid(self): observations = _observations() with self.assertRaises(ValueError): ObservationStudy(SPACE, _build, observations, _metrics, phases=True) + # one requirement on the phases of each metric + with self.assertRaisesRegex(ValueError, r"metrics \['observed'\]"): + ObservationStudy( + SPACE, + _build, + observations, + _metrics, + plan=PLAN, + phases=[ + Requirement("observed", ">=", 50), + Requirement("observed", ">=", 80), + ], + ) study = ObservationStudy(SPACE, _build, observations, _metrics, plan=PLAN) self.assertEqual(study.layout, "layout") shells = DesignSpace( diff --git a/tests/tradespace/test_optimization.py b/tests/tradespace/test_optimization.py index 4cd95922..3e3f8abf 100644 --- a/tests/tradespace/test_optimization.py +++ b/tests/tradespace/test_optimization.py @@ -192,11 +192,10 @@ def test_feasible_replicates(self): self.assertEqual( [evaluations.infeasibility[d.key] for d in designs], [0.0, 0.0, 1.0] ) - # the summary of a search is that of its results (see summarize) + # the summary of a search is that of its results (see summarize), + # with the spreads of means search = evaluations.search(None) - pd.testing.assert_frame_equal( - search.summary, summarize(results, {"f": "max"}, spread=False) - ) + pd.testing.assert_frame_equal(search.summary, summarize(results, {"f": "max"})) self.assertEqual([d.key for d in search.designs], [designs[1].key]) self.assertEqual(len(search.evaluated), 3) # a requirement on the share of feasible replicates @@ -321,6 +320,7 @@ def test_optimize(self): # the summary of the feasible designs, and their front summary = search.summary self.assertEqual(set(summary.design), set(results.design[results.feasible])) + self.assertIn("value se", summary.columns) # with the spreads of means np.testing.assert_array_equal( summary.pareto, pareto_front(summary, OBJECTIVES).to_numpy() ) diff --git a/tests/tradespace/test_pareto.py b/tests/tradespace/test_pareto.py index a3f5d2dd..6089b523 100644 --- a/tests/tradespace/test_pareto.py +++ b/tests/tradespace/test_pareto.py @@ -152,6 +152,16 @@ def test_requirements_and_groups(self): with self.assertRaises(ValueError): pareto_front(self.frame, criteria) # no column of the requirement + def test_missing_group(self): + """Rows without a value of a column of groups are a group of their own.""" + frame = pd.DataFrame( + {"cost": [1.0, 0.5, 2.0, 0.2], "sensor": ["x", None, "x", np.nan]} + ) + grouped = Criteria({"cost": "min"}, by="sensor") + # the rows without a sensor are judged together, not left out + self.assertEqual(list(pareto_front(frame, grouped)), [True, False, False, True]) + self.assertEqual(list(pareto_ranks(frame, grouped)), [0, 1, 1, 0]) + class TestRelativeTolerance(unittest.TestCase): """ diff --git a/tests/tradespace/test_plotting.py b/tests/tradespace/test_plotting.py index 4036cbcf..5a879bfa 100644 --- a/tests/tradespace/test_plotting.py +++ b/tests/tradespace/test_plotting.py @@ -85,6 +85,19 @@ def test_designs(self): self.assertEqual(len(ax.collections), 1) with self.assertRaisesRegex(ValueError, "efficient"): plot_designs(self.summary, "satellites", "sufficient", front="best") + # labels of the efficient designs need a front + figures = len(plt.get_fignums()) + for frame, front in ((plain, "pareto"), (self.summary, None)): + with self.subTest(front=front): + with self.assertRaisesRegex(ValueError, "annotate"): + plot_designs( + frame, + "satellites", + "sufficient", + front=front, + annotate="design", + ) + self.assertEqual(len(plt.get_fignums()), figures) # before drawing def test_given_axes(self): """Plots draw on given axes.""" diff --git a/tests/tradespace/test_refinement.py b/tests/tradespace/test_refinement.py index 8da7896e..c5c33328 100644 --- a/tests/tradespace/test_refinement.py +++ b/tests/tradespace/test_refinement.py @@ -24,6 +24,7 @@ refine, ) from tatc.tradespace.refinement import _precise +from tatc.tradespace.tables import draw_resamples OBJECTIVES = {"cost": "min", "value": "max"} @@ -350,6 +351,52 @@ def test_precise(self): _precise(probability.drop(columns="cost se"), criteria, 0.5), [True, False, True], ) + # an unknown standard error is not precise + unknown = probability.assign(**{"value se": [np.nan, 1.0, np.nan]}) + np.testing.assert_array_equal( + _precise(unknown, criteria, 0.5), [False, True, False] + ) + + def test_partly_infeasible_quantile(self): + """A design infeasible in most replicates, judged by a quantile, is + refined while its efficiency is uncertain, although some resamples + draw none of its feasible replicates.""" + space = DesignSpace( + variant=Integer(0, 1), + noise=Uncertain.normal(0, 1), + gate=Uncertain.uniform(0, 1), + ) + + def evaluate(d): + if d.variant == 0 and d.gate > 0.25: + raise Infeasible("rarely feasible") + return {"value": 5.0 + 0.3 * d.variant + 2 * d.noise} + + study = Study(space, lambda d: d, evaluate, replicates=20, seed=3) + results = study.run(space.enumerate()) + rare = results[results.variant == 0] + feasible = rare.replicate[rare.feasible].to_numpy() + self.assertEqual(len(feasible), 5) # as many as min_replicates + # resamples of the first round that draw none of them + drawn = draw_resamples(20, 1000, np.random.default_rng(0)) + self.assertGreater((~np.isin(drawn, feasible).any(axis=1)).sum(), 0) + criteria = Criteria( + {"value p50": "max"}, + statistics=[Quantile("value", 0.5)], + tolerances={"value p50": 0.5}, + ) + first = pareto_probability(results, criteria, n_resamples=1000, seed=0) + first = first.set_index("variant") + self.assertTrue(np.isfinite(first.loc[0, "value p50 se"])) + self.assertTrue(0.05 < first.loc[0, "pareto_probability"] < 0.95) + with warnings.catch_warnings(): + warnings.simplefilter("ignore", UserWarning) + refinement = refine( + study, criteria, results, step=5, max_rounds=1, n_resamples=1000 + ) + self.assertEqual(refinement.rounds.indifferent.iloc[0], 0) + added = refinement.results.iloc[len(results) :] + self.assertIn(0, set(added.variant)) # the rare design is refined class TestRefineInfeasible(unittest.TestCase): diff --git a/tests/tradespace/test_screening.py b/tests/tradespace/test_screening.py index 6128d750..e8202afa 100644 --- a/tests/tradespace/test_screening.py +++ b/tests/tradespace/test_screening.py @@ -80,6 +80,14 @@ def test_keeps_whole_fronts(self): self.assertEqual(len(screening.results), len(last)) self.assertNotIn("stage", screening.results.columns) self.assertEqual(screening.criteria.objectives, OBJECTIVES) + # the summaries of the stages are those of summarize, with spreads + noisy = screen( + [_study(0.3, 2), _study(0.3, 2)], OBJECTIVES, self.designs, keep=20 + ) + for column in ("value std", "value se"): + self.assertIn(column, noisy.summary.columns) + self.assertIn(column, noisy.summaries.columns) + self.assertNotIn("value se", screening.summary.columns) # without noise def test_finds_front(self): """A tolerance of the noise of the first stage keeps the efficient designs.""" diff --git a/tests/tradespace/test_space.py b/tests/tradespace/test_space.py index 8f23abbe..4b4694de 100644 --- a/tests/tradespace/test_space.py +++ b/tests/tradespace/test_space.py @@ -623,6 +623,29 @@ def test_items(self): self.assertEqual([plane.crossing for plane in planes[:1]], [planes[0].crossing]) self.assertEqual(planes, list(planes)) + def test_attribute_names(self): + """Designs and views list their values, and name those they lack.""" + names = dir(self.walker) + self.assertTrue({"layout", "realize", "key"} <= set(names)) + self.assertIn("planes", dir(self.walker.layout)) + self.assertIn("walker", dir(self.walker.layout)) + self.assertIn("count", dir(self.sso.layout.planes)) + self.assertIn("index", dir(self.sso.layout.planes[0])) + self.assertIn("crossing", dir(self.sso.layout.planes[0])) + with self.assertRaisesRegex(AttributeError, "no value 'layuot'") as raised: + self.walker.layuot # pylint: disable=pointless-statement + self.assertEqual(raised.exception.name, "layuot") + self.assertIs(raised.exception.obj, self.walker) + self.assertIn("it has ['altitude', 'layout']", str(raised.exception)) + with self.assertRaises(AttributeError) as raised: + self.walker.layout.plane # pylint: disable=pointless-statement + self.assertEqual(raised.exception.name, "plane") + with self.assertRaises(AttributeError) as raised: + self.sso.layout.planes[0].crosing # pylint: disable=pointless-statement + self.assertEqual(raised.exception.name, "crosing") + # getattr with a default, as of an optional value + self.assertIsNone(getattr(self.walker.layout, "altitude", None)) + def test_constraints(self): """The callables of a design space read values by paths too.""" space = DesignSpace( diff --git a/tests/tradespace/test_statistics.py b/tests/tradespace/test_statistics.py index 89314784..e9707112 100644 --- a/tests/tradespace/test_statistics.py +++ b/tests/tradespace/test_statistics.py @@ -18,6 +18,7 @@ StandardDeviation, Statistic, ) +from tatc.tradespace.fingerprint import get_fingerprint from tatc.tradespace.statistics import _standard_error VALUES = np.array( @@ -78,6 +79,30 @@ def test_equality(self): self.assertEqual(len({Mean("x"), Mean("x"), Mean("y")}), 2) self.assertIsInstance(Mean("x"), Statistic) + def test_fingerprints(self): + """Statistics are fingerprinted by their kind and parameters.""" + self.assertNotEqual( + get_fingerprint(Quantile("c", 0.7)), get_fingerprint(Quantile("c", 0.9)) + ) + self.assertNotEqual( + get_fingerprint(Probability("c", ">=", 50)), + get_fingerprint(Probability("c", ">=", 80)), + ) + self.assertNotEqual( + get_fingerprint(Probability("c", ">=", 50)), + get_fingerprint(Probability("c", "<=", 50)), + ) + self.assertNotEqual(get_fingerprint(Mean("c")), get_fingerprint(Mean("d"))) + self.assertNotEqual(get_fingerprint(Mean("c")), get_fingerprint(Maximum("c"))) + # equal statistics, equal fingerprints + self.assertEqual( + get_fingerprint(Quantile("c", 0.7)), get_fingerprint(Quantile("c", 0.7)) + ) + self.assertEqual( + get_fingerprint(Probability("c", ">=", 50)), + get_fingerprint(Probability("c", ">=", 50)), + ) + class TestNames(unittest.TestCase): """ diff --git a/tests/tradespace/test_summary.py b/tests/tradespace/test_summary.py index 2f02d3f5..cf21b2b9 100644 --- a/tests/tradespace/test_summary.py +++ b/tests/tradespace/test_summary.py @@ -125,7 +125,12 @@ def test_statistics(self): self.assertEqual(list(means.value), [13, 17.5, 1]) # a mapping of statistics by name is not one of objectives with self.assertRaisesRegex(ValueError, "statistics"): - summarize(_results(), {"value": "value"}) + summarize(_results(), {"value p25": Quantile("value", 0.25)}) + # a misspelled direction is one, which criteria reject + for direction in ("minimize", "value"): + with self.subTest(direction=direction): + with self.assertRaisesRegex(ValueError, "must be 'min' or 'max'"): + summarize(_results(), {"value": direction}) with self.assertRaises(ValueError): summarize(_results()) @@ -256,6 +261,19 @@ def test_records_of_groups(self): self.assertEqual(len(frame), 6) self.assertEqual(len(summarize(results, statistics=["value"], by="sensor")), 6) + def test_missing_group(self): + """Records without a value of a column of groups are a group of their + own, rather than left out.""" + results = _results().assign(sensor="x") + results.loc[results.design == "c", "sensor"] = None + frame = summarize(results, Criteria({"value": "max"}, by="sensor")) + self.assertEqual(sorted(frame.design), ["a", "b", "c"]) + # c is alone in its group, and so efficient + self.assertTrue(frame.set_index("design").loc["c", "pareto"]) + self.assertTrue(frame.set_index("design").loc["c", ["sensor"]].isna().all()) + means = summarize(results, statistics=["value"], by="sensor") + self.assertEqual(sorted(means.design), ["a", "b", "c"]) + class TestSpreads(unittest.TestCase): """ @@ -742,6 +760,33 @@ def test_infeasible_draws(self): ) self.assertEqual(probability.loc["steady", "requirements_probability"], 1.0) + def test_infeasible_draws_standard_error(self): + """The bootstrap standard error of an objective that is not a mean is + over the resamples in which a design is judged.""" + rng = np.random.default_rng(3) + results = pd.DataFrame( + [ + { + "design": design, + "replicate": r, + # d0 is feasible in 5 of 15 replicates + "feasible": design == "d1" or r % 3 == 0, + "value": 5.0 + rng.normal(), + } + for design in ("d0", "d1") + for r in range(15) + ] + ) + criteria = Criteria({"value p50": "max"}, statistics=[Quantile("value", 0.5)]) + probability = pareto_probability( + results, criteria, n_resamples=1000, seed=0 + ).set_index("design") + # some resamples draw none of d0's feasible replicates (about 2 in + # 1000), which do not judge it, rather than making its error unknown + errors = probability["value p50 se"] + self.assertTrue(np.isfinite(errors).all()) + self.assertGreater(errors["d0"], errors["d1"]) + def test_no_feasible_design(self): """Results without a feasible record have an empty summary.""" results = self._results([False] * 4) From 3da6e9ff07b1d00bfdc59989b9b94595f60f7483 Mon Sep 17 00:00:00 2001 From: Paul Grogan Date: Sat, 14 Nov 2026 22:57:18 -0700 Subject: [PATCH 52/52] skip the tests of highlights and shares without matplotlib --- tests/tradespace/test_plotting.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/tradespace/test_plotting.py b/tests/tradespace/test_plotting.py index 5a879bfa..81e7c4db 100644 --- a/tests/tradespace/test_plotting.py +++ b/tests/tradespace/test_plotting.py @@ -158,6 +158,7 @@ def test_exceedance(self): plot_exceedance(twice) +@unittest.skipIf(plt is None, "requires matplotlib") class TestHighlights(unittest.TestCase): """ Unit tests for plots of some designs over others. @@ -193,6 +194,7 @@ def test_highlight(self): plot_designs(summary, "x", "y", highlight=[True]) +@unittest.skipIf(plt is None, "requires matplotlib") class TestShares(unittest.TestCase): """ Unit tests for plots of shares, groups of values, and the style.